Merging upstream version 1.75.0+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

84 files changed, 5049 insertions, 0 deletions

diff --git a/vendor/derivative/tests/clippy-warning-clone-from.rs b/vendor/derivative/tests/clippy-warning-clone-from.rs
new file mode 100644
index 000000000..6811e1a4b
--- /dev/null
+++ b/vendor/derivative/tests/clippy-warning-clone-from.rs
@@ -0,0 +1,13 @@
+#![deny(clippy::all)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Clone(clone_from = "true"))]
+pub struct Foo {}
+
+fn main() {}
diff --git a/vendor/derivative/tests/compile-fail/derive-debug-unused.rs b/vendor/derivative/tests/compile-fail/derive-debug-unused.rs
new file mode 100644
index 000000000..91cc077c7
--- /dev/null
+++ b/vendor/derivative/tests/compile-fail/derive-debug-unused.rs
@@ -0,0 +1,19 @@
+#![deny(dead_code)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct Foo {
+    foo: u8,
+    #[derivative(Debug="ignore")]
+    bar: u8,
+}
+
+fn main() {
+    let _ = Foo { foo: 42, bar: 1 };
+}
\ No newline at end of file
diff --git a/vendor/derivative/tests/compile-fail/derive-debug-unused.stderr b/vendor/derivative/tests/compile-fail/derive-debug-unused.stderr
new file mode 100644
index 000000000..a56c9a2c6
--- /dev/null
+++ b/vendor/derivative/tests/compile-fail/derive-debug-unused.stderr
@@ -0,0 +1,11 @@
+error: field is never used: `bar`
+  --> $DIR/derive-debug-unused.rs:14:5
+   |
+14 |     bar: u8,
+   |     ^^^^^^^
+   |
+note: lint level defined here
+  --> $DIR/derive-debug-unused.rs:1:9
+   |
+1  | #![deny(dead_code)]
+   |         ^^^^^^^^^
diff --git a/vendor/derivative/tests/compile-fail/derive-debug.rs b/vendor/derivative/tests/compile-fail/derive-debug.rs
new file mode 100644
index 000000000..82822a853
--- /dev/null
+++ b/vendor/derivative/tests/compile-fail/derive-debug.rs
@@ -0,0 +1,15 @@
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct Foo<T, U> {
+    foo: T,
+    #[derivative(Debug(format_with="std::fmt::Debug::fmt"))]
+    bar: U,
+}
+
+fn main() {}
\ No newline at end of file
diff --git a/vendor/derivative/tests/compile-fail/derive-debug.stderr b/vendor/derivative/tests/compile-fail/derive-debug.stderr
new file mode 100644
index 000000000..9bca7161e
--- /dev/null
+++ b/vendor/derivative/tests/compile-fail/derive-debug.stderr
@@ -0,0 +1,9 @@
+error[E0277]: `U` doesn't implement `std::fmt::Debug`
+  --> $DIR/derive-debug.rs:11:36
+   |
+11 |     #[derivative(Debug(format_with="std::fmt::Debug::fmt"))]
+   |                                    ^^^^^^^^^^^^^^^^^^^^^^ `U` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug`
+   |
+   = help: the trait `std::fmt::Debug` is not implemented for `U`
+   = help: consider adding a `where U: std::fmt::Debug` bound
+   = note: required by `std::fmt::Debug::fmt`
diff --git a/vendor/derivative/tests/compile-fail/derive-partial-ord.rs b/vendor/derivative/tests/compile-fail/derive-partial-ord.rs
new file mode 100644
index 000000000..619788be7
--- /dev/null
+++ b/vendor/derivative/tests/compile-fail/derive-partial-ord.rs
@@ -0,0 +1,11 @@
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative, PartialEq)]
+#[derivative(PartialOrd)]
+enum Option {
+    Some,
+    None,
+}
+
+fn main() {}
diff --git a/vendor/derivative/tests/compile-fail/derive-partial-ord.stderr b/vendor/derivative/tests/compile-fail/derive-partial-ord.stderr
new file mode 100644
index 000000000..5786998cd
--- /dev/null
+++ b/vendor/derivative/tests/compile-fail/derive-partial-ord.stderr
@@ -0,0 +1,5 @@
+error: can't use `#[derivative(PartialOrd)]` on an enumeration without `feature_allow_slow_enum`; see the documentation for more details
+ --> $DIR/derive-partial-ord.rs:5:1
+  |
+5 | #[derivative(PartialOrd)]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/vendor/derivative/tests/compile-fail/invalid-attribute.rs b/vendor/derivative/tests/compile-fail/invalid-attribute.rs
new file mode 100644
index 000000000..b03412356
--- /dev/null
+++ b/vendor/derivative/tests/compile-fail/invalid-attribute.rs
@@ -0,0 +1,23 @@
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Clone = not_a_string)]
+struct Foo1;
+
+#[derive(Derivative)]
+#[derivative(Clone = 1+2)]
+struct Foo2;
+
+#[derive(Derivative)]
+#[derivative(Default(new = "True"))]
+struct Foo3;
+
+#[derive(Derivative)]
+#[derivative(Debug(bound))]
+struct Foo4;
+
+fn main() {}
\ No newline at end of file
diff --git a/vendor/derivative/tests/compile-fail/invalid-attribute.stderr b/vendor/derivative/tests/compile-fail/invalid-attribute.stderr
new file mode 100644
index 000000000..e3e0bb7b6
--- /dev/null
+++ b/vendor/derivative/tests/compile-fail/invalid-attribute.stderr
@@ -0,0 +1,23 @@
+error: invalid attribute: expected literal
+ --> $DIR/invalid-attribute.rs:8:22
+  |
+8 | #[derivative(Clone = not_a_string)]
+  |                      ^^^^^^^^^^^^
+
+error: invalid attribute: expected `,`
+  --> $DIR/invalid-attribute.rs:12:23
+   |
+12 | #[derivative(Clone = 1+2)]
+   |                       ^
+
+error: expected `"true"` or `"false"` for `new`, got `True`
+  --> $DIR/invalid-attribute.rs:16:28
+   |
+16 | #[derivative(Default(new = "True"))]
+   |                            ^^^^^^
+
+error: expected named value
+  --> $DIR/invalid-attribute.rs:20:20
+   |
+20 | #[derivative(Debug(bound))]
+   |                    ^^^^^
diff --git a/vendor/derivative/tests/compile-fail/unknown-attribute.rs b/vendor/derivative/tests/compile-fail/unknown-attribute.rs
new file mode 100644
index 000000000..31cdaf431
--- /dev/null
+++ b/vendor/derivative/tests/compile-fail/unknown-attribute.rs
@@ -0,0 +1,15 @@
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Clone = "does_not_exist")]
+struct Foo;
+
+#[derive(Derivative)]
+#[derivative(Clone(does_not_exist = "true"))]
+struct Bar;
+
+fn main() {}
\ No newline at end of file
diff --git a/vendor/derivative/tests/compile-fail/unknown-attribute.stderr b/vendor/derivative/tests/compile-fail/unknown-attribute.stderr
new file mode 100644
index 000000000..5383a2f4a
--- /dev/null
+++ b/vendor/derivative/tests/compile-fail/unknown-attribute.stderr
@@ -0,0 +1,11 @@
+error: Unknown attribute `does_not_exist` for trait `Clone`
+ --> $DIR/unknown-attribute.rs:8:22
+  |
+8 | #[derivative(Clone = "does_not_exist")]
+  |                      ^^^^^^^^^^^^^^^^
+
+error: Unknown attribute `does_not_exist` for trait `Clone`
+  --> $DIR/unknown-attribute.rs:12:20
+   |
+12 | #[derivative(Clone(does_not_exist = "true"))]
+   |                    ^^^^^^^^^^^^^^
diff --git a/vendor/derivative/tests/compile-fail/unknown-derive.rs b/vendor/derivative/tests/compile-fail/unknown-derive.rs
new file mode 100644
index 000000000..0a9a689ae
--- /dev/null
+++ b/vendor/derivative/tests/compile-fail/unknown-derive.rs
@@ -0,0 +1,22 @@
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(DoesNotExist1)]
+struct Foo;
+
+#[derive(Derivative)]
+#[derivative(DoesNotExist2(with_some="argument"))]
+struct Bar;
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct Baz {
+    #[derivative(DoesNotExist3)]
+    _baz: (),
+}
+
+fn main() {}
\ No newline at end of file
diff --git a/vendor/derivative/tests/compile-fail/unknown-derive.stderr b/vendor/derivative/tests/compile-fail/unknown-derive.stderr
new file mode 100644
index 000000000..2d83f1834
--- /dev/null
+++ b/vendor/derivative/tests/compile-fail/unknown-derive.stderr
@@ -0,0 +1,17 @@
+error: deriving `DoesNotExist1` is not supported by derivative
+ --> $DIR/unknown-derive.rs:8:14
+  |
+8 | #[derivative(DoesNotExist1)]
+  |              ^^^^^^^^^^^^^
+
+error: deriving `DoesNotExist2` is not supported by derivative
+  --> $DIR/unknown-derive.rs:12:14
+   |
+12 | #[derivative(DoesNotExist2(with_some="argument"))]
+   |              ^^^^^^^^^^^^^
+
+error: deriving `DoesNotExist3` is not supported by derivative
+  --> $DIR/unknown-derive.rs:18:18
+   |
+18 |     #[derivative(DoesNotExist3)]
+   |                  ^^^^^^^^^^^^^
diff --git a/vendor/derivative/tests/compile-test.rs b/vendor/derivative/tests/compile-test.rs
new file mode 100644
index 000000000..361332a1c
--- /dev/null
+++ b/vendor/derivative/tests/compile-test.rs
@@ -0,0 +1,9 @@
+extern crate trybuild;
+
+#[test]
+#[ignore]
+fn compile_test() {
+    let t = trybuild::TestCases::new();
+    let pattern = std::env::var("DERIVATIVE_TEST_FILTER").unwrap_or_else(|_| String::from("*.rs"));
+    t.compile_fail(format!("tests/compile-fail/{}", pattern));
+}
diff --git a/vendor/derivative/tests/derive-clone-generics.rs b/vendor/derivative/tests/derive-clone-generics.rs
new file mode 100644
index 000000000..96919f9b3
--- /dev/null
+++ b/vendor/derivative/tests/derive-clone-generics.rs
@@ -0,0 +1,29 @@
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+use std::marker::PhantomData;
+
+struct NoClone;
+
+#[derive(Derivative)]
+#[derivative(Clone, PartialEq)]
+struct PhantomField<T> {
+    foo: PhantomData<T>,
+}
+
+#[derive(Derivative)]
+#[derivative(Clone, PartialEq)]
+struct PhantomTuple<T> {
+    foo: PhantomData<(T,)>,
+}
+
+#[test]
+fn main() {
+    let phantom_field = PhantomField::<NoClone> { foo: Default::default() };
+    let phantom_tuple = PhantomTuple::<NoClone> { foo: Default::default() };
+    assert!(phantom_field == phantom_field.clone());
+    assert!(phantom_tuple == phantom_tuple.clone());
+}
diff --git a/vendor/derivative/tests/derive-clone.rs b/vendor/derivative/tests/derive-clone.rs
new file mode 100755
index 000000000..9120d3ee3
--- /dev/null
+++ b/vendor/derivative/tests/derive-clone.rs
@@ -0,0 +1,66 @@
+#![allow(clippy::blacklisted_name, clippy::redundant_clone, clippy::trivially_copy_pass_by_ref)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Debug, Derivative, PartialEq)]
+#[derivative(Clone)]
+struct Foo {
+    foo: u8,
+    #[derivative(Clone(clone_with="seventh"))]
+    bar: u8,
+}
+
+fn seventh(a: &u8) -> u8 {
+    a/7
+}
+
+#[derive(Debug, PartialEq)]
+struct EvilCloneFrom(u8);
+
+impl Clone for EvilCloneFrom {
+    fn clone(&self) -> Self {
+        EvilCloneFrom(self.0)
+    }
+
+    fn clone_from(&mut self, _: &Self) {
+        self.0 = 42;
+    }
+}
+
+#[derive(Derivative)]
+#[derivative(Clone(clone_from="true"))]
+struct StructWithCloneFrom(EvilCloneFrom);
+
+#[derive(Debug, Derivative, PartialEq)]
+#[derivative(Clone(clone_from="true"))]
+enum EnumWithCloneFrom {
+    Evil(EvilCloneFrom),
+    Good(u32),
+    None
+}
+
+#[test]
+fn main() {
+    let foo = Foo { foo: 31, bar: 42 };
+    assert_eq!(Foo { foo: 31, bar: 6 }, foo.clone());
+
+    let mut foo = StructWithCloneFrom(EvilCloneFrom(27));
+    foo.clone_from(&StructWithCloneFrom(EvilCloneFrom(0)));
+    assert_eq!((foo.0).0, 42);
+
+    let mut foo = EnumWithCloneFrom::Evil(EvilCloneFrom(27));
+    foo.clone_from(&EnumWithCloneFrom::Evil(EvilCloneFrom(0)));
+    assert_eq!(foo, EnumWithCloneFrom::Evil(EvilCloneFrom(42)));
+
+    let mut foo = EnumWithCloneFrom::Evil(EvilCloneFrom(27));
+    foo.clone_from(&EnumWithCloneFrom::None);
+    assert_eq!(foo, EnumWithCloneFrom::None);
+
+    let mut foo = EnumWithCloneFrom::Good(27);
+    foo.clone_from(&EnumWithCloneFrom::None);
+    assert_eq!(foo, EnumWithCloneFrom::None);
+}
diff --git a/vendor/derivative/tests/derive-debug-bounds.rs b/vendor/derivative/tests/derive-debug-bounds.rs
new file mode 100644
index 000000000..c572a508f
--- /dev/null
+++ b/vendor/derivative/tests/derive-debug-bounds.rs
@@ -0,0 +1,83 @@
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+use std::fmt::{Formatter, Result as FmtResult};
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct Foo<T, U> {
+    foo: T,
+    #[derivative(Debug(format_with="MyDebug::my_fmt", bound="U: MyDebug"))]
+    bar: U,
+}
+
+#[derive(Derivative)]
+#[derivative(Debug(bound="T: std::fmt::Debug, U: MyDebug"))]
+struct Foo2<T, U> {
+    foo: T,
+    #[derivative(Debug(format_with="MyDebug::my_fmt"))]
+    bar: U,
+}
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct Bar<T, U> (
+    T,
+    #[derivative(Debug(format_with="MyDebug::my_fmt", bound="U: MyDebug"))]
+    U,
+);
+
+#[derive(Derivative)]
+#[derivative(Debug(bound="T: std::fmt::Debug, U: MyDebug"))]
+struct Bar2<T, U> (
+    T,
+    #[derivative(Debug(format_with="MyDebug::my_fmt"))]
+    U,
+);
+
+struct NoDebug;
+
+struct GenericNeedsNoDebug<T>(T);
+impl<T> std::fmt::Debug for GenericNeedsNoDebug<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> FmtResult {
+        f.write_str("GenericNeedsNoDebug")
+    }
+}
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct TestUnneededBound<T>( // Test that we don't add T: Debug
+    #[derivative(Debug(bound=""))] GenericNeedsNoDebug<T>,
+);
+
+trait MyDebug {
+    fn my_fmt(&self, f: &mut Formatter) -> FmtResult {
+        f.write_str("MyDebug")
+    }
+}
+
+impl MyDebug for i32 { }
+impl<'a, T> MyDebug for &'a T { }
+
+
+trait ToDebug {
+    fn to_show(&self) -> String;
+}
+
+impl<T: std::fmt::Debug> ToDebug for T {
+    fn to_show(&self) -> String {
+        format!("{:?}", self)
+    }
+}
+
+#[test]
+fn main() {
+    assert_eq!(Foo { foo: 42, bar: 0 }.to_show(), "Foo { foo: 42, bar: MyDebug }".to_string());
+    assert_eq!(Foo2 { foo: 42, bar: 0 }.to_show(), "Foo2 { foo: 42, bar: MyDebug }".to_string());
+    assert_eq!(Bar(42, 0).to_show(), "Bar(42, MyDebug)".to_string());
+    assert_eq!(Bar2(42, 0).to_show(), "Bar2(42, MyDebug)".to_string());
+    assert_eq!(TestUnneededBound(GenericNeedsNoDebug(NoDebug)).to_show(), "TestUnneededBound(GenericNeedsNoDebug)".to_string());
+}
diff --git a/vendor/derivative/tests/derive-debug-generics.rs b/vendor/derivative/tests/derive-debug-generics.rs
new file mode 100644
index 000000000..97104c1d2
--- /dev/null
+++ b/vendor/derivative/tests/derive-debug-generics.rs
@@ -0,0 +1,93 @@
+#![allow(dead_code)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+use std::marker::PhantomData;
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct Foo<T, U> {
+    foo: T,
+    #[derivative(Debug="ignore")]
+    bar: U,
+}
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct Bar<T, U> (
+    T,
+    #[derivative(Debug="ignore")]
+    U,
+);
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+enum C<T, U> {
+    V1(T),
+    V2(#[derivative(Debug="ignore")] U),
+    V3(String),
+}
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+enum D<U> {
+    V1 {
+        #[derivative(Debug="ignore")]
+        a: U
+    }
+}
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct F<U>(#[derivative(Debug="ignore")] U);
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct G<U>(isize, #[derivative(Debug="ignore")] U);
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct J<U>(#[derivative(Debug="ignore")] U);
+
+struct NoDebug;
+
+trait ToDebug {
+    fn to_show(&self) -> String;
+}
+
+impl<T: std::fmt::Debug> ToDebug for T {
+    fn to_show(&self) -> String {
+        format!("{:?}", self)
+    }
+}
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct PhantomField<T> {
+    foo: PhantomData<T>,
+}
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct PhantomTuple<T> {
+    foo: PhantomData<(T,)>,
+}
+
+#[test]
+fn main() {
+    assert_eq!(Foo { foo: 42, bar: NoDebug }.to_show(), "Foo { foo: 42 }".to_string());
+    assert_eq!(Bar(42, NoDebug).to_show(), "Bar(42)".to_string());
+    assert_eq!(C::V1::<i32, NoDebug>(12).to_show(), "V1(12)".to_string());
+    assert_eq!(C::V2::<i32, NoDebug>(NoDebug).to_show(), "V2".to_string());
+    assert_eq!(C::V3::<i32, NoDebug>("foo".to_string()).to_show(), "V3(\"foo\")".to_string());
+    assert_eq!(D::V1 { a: NoDebug }.to_show(), "V1".to_string());
+    assert_eq!(F(NoDebug).to_show(), "F".to_string());
+    assert_eq!(G(42, NoDebug).to_show(), "G(42)".to_string());
+    assert_eq!(J(NoDebug).to_show(), "J".to_string());
+    assert_eq!(&format!("{:?}", PhantomField::<NoDebug> { foo: Default::default() }), "PhantomField { foo: PhantomData }");
+    assert_eq!(&format!("{:?}", PhantomTuple::<NoDebug> { foo: Default::default() }), "PhantomTuple { foo: PhantomData }");
+}
diff --git a/vendor/derivative/tests/derive-debug-packed.rs b/vendor/derivative/tests/derive-debug-packed.rs
new file mode 100644
index 000000000..08ece8fea
--- /dev/null
+++ b/vendor/derivative/tests/derive-debug-packed.rs
@@ -0,0 +1,74 @@
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+#[repr(C, packed)]
+struct Foo {
+    foo: u8,
+    #[derivative(Debug="ignore")]
+    bar: u8,
+}
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+#[repr(C, packed)]
+struct Bar (
+    u8,
+    #[derivative(Debug="ignore")]
+    u8,
+);
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+#[repr(C, packed)]
+struct F(#[derivative(Debug="ignore")] isize);
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+#[repr(C, packed)]
+struct G(isize, #[derivative(Debug="ignore")] isize);
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+#[repr(C, packed)]
+struct J(#[derivative(Debug="ignore")] NoDebug);
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+#[repr(C, packed)]
+struct K(isize, #[derivative(Debug="ignore")] NoDebug);
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+#[repr(C, packed)]
+struct L {
+    #[derivative(Debug="ignore")]
+    foo: NoDebug
+}
+
+struct NoDebug;
+
+trait ToDebug {
+    fn to_show(&self) -> String;
+}
+
+impl<T: std::fmt::Debug> ToDebug for T {
+    fn to_show(&self) -> String {
+        format!("{:?}", self)
+    }
+}
+
+#[test]
+fn main() {
+    assert_eq!(Foo { foo: 42, bar: 1 }.to_show(), "Foo { foo: 42 }".to_string());
+    assert_eq!(Bar(42, 1).to_show(), "Bar(42)".to_string());
+    assert_eq!(F(42).to_show(), "F".to_string());
+    assert_eq!(G(42, 0).to_show(), "G(42)".to_string());
+    assert_eq!(J(NoDebug).to_show(), "J".to_string());
+    assert_eq!(K(42, NoDebug).to_show(), "K(42)".to_string());
+    assert_eq!(L{ foo: NoDebug }.to_show(), "L".to_string());
+}
diff --git a/vendor/derivative/tests/derive-debug-transparent.rs b/vendor/derivative/tests/derive-debug-transparent.rs
new file mode 100644
index 000000000..fcbc587f8
--- /dev/null
+++ b/vendor/derivative/tests/derive-debug-transparent.rs
@@ -0,0 +1,39 @@
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Debug="transparent")]
+struct A(isize);
+
+#[derive(Derivative)]
+#[derivative(Debug="transparent")]
+struct B([isize; 1]);
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+enum C {
+    Foo(u8),
+    #[derivative(Debug="transparent")]
+    Bar(u8),
+}
+
+trait ToDebug {
+    fn to_show(&self) -> String;
+}
+
+impl<T: std::fmt::Debug> ToDebug for T {
+    fn to_show(&self) -> String {
+        format!("{:?}", self)
+    }
+}
+
+#[test]
+fn main() {
+    assert_eq!(A(42).to_show(), "42".to_string());
+    assert_eq!(B([42]).to_show(), "[42]".to_string());
+    assert_eq!(C::Foo(42).to_show(), "Foo(42)".to_string());
+    assert_eq!(C::Bar(42).to_show(), "42".to_string());
+}
diff --git a/vendor/derivative/tests/derive-debug.rs b/vendor/derivative/tests/derive-debug.rs
new file mode 100644
index 000000000..1c218bbeb
--- /dev/null
+++ b/vendor/derivative/tests/derive-debug.rs
@@ -0,0 +1,77 @@
+#![allow(dead_code)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct Foo {
+    foo: u8,
+    #[derivative(Debug="ignore")]
+    bar: u8,
+}
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct Bar (
+    u8,
+    #[derivative(Debug="ignore")]
+    u8,
+);
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+enum C {
+    V1(isize),
+    V2(#[derivative(Debug="ignore")] i32),
+    V3(String),
+}
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+enum D {
+    V1 {
+        #[derivative(Debug="ignore")]
+        a: isize
+    }
+}
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct F(#[derivative(Debug="ignore")] isize);
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct G(isize, #[derivative(Debug="ignore")] isize);
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct J(#[derivative(Debug="ignore")] NoDebug);
+
+struct NoDebug;
+
+trait ToDebug {
+    fn to_show(&self) -> String;
+}
+
+impl<T: std::fmt::Debug> ToDebug for T {
+    fn to_show(&self) -> String {
+        format!("{:?}", self)
+    }
+}
+
+#[test]
+fn main() {
+    assert_eq!(Foo { foo: 42, bar: 1 }.to_show(), "Foo { foo: 42 }".to_string());
+    assert_eq!(Bar(42, 1).to_show(), "Bar(42)".to_string());
+    assert_eq!(C::V1(12).to_show(), "V1(12)".to_string());
+    assert_eq!(C::V2(12).to_show(), "V2".to_string());
+    assert_eq!(C::V3("foo".to_string()).to_show(), "V3(\"foo\")".to_string());
+    assert_eq!(D::V1 { a: 42 }.to_show(), "V1".to_string());
+    assert_eq!(F(42).to_show(), "F".to_string());
+    assert_eq!(G(42, 0).to_show(), "G(42)".to_string());
+    assert_eq!(J(NoDebug).to_show(), "J".to_string());
+}
diff --git a/vendor/derivative/tests/derive-default-bounds.rs b/vendor/derivative/tests/derive-default-bounds.rs
new file mode 100755
index 000000000..fda2efc98
--- /dev/null
+++ b/vendor/derivative/tests/derive-default-bounds.rs
@@ -0,0 +1,42 @@
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Debug, Derivative, PartialEq)]
+#[derivative(Default="new")]
+struct Foo<T, U> {
+    foo: T,
+    #[derivative(Default(value="min()", bound="U: std::ops::Not<Output=U>, U: Default"))]
+    bar: U,
+}
+
+#[derive(Debug, Derivative, PartialEq)]
+#[derivative(Default(bound="T: Default, U: std::ops::Not<Output=U>, U: Default", new="true"))]
+struct Bar<T, U> {
+    foo: T,
+    #[derivative(Default(value="min()"))]
+    bar: U,
+}
+
+fn min<T: Default + std::ops::Not<Output=T>>() -> T {
+    !T::default()
+}
+
+#[derive(Debug, Derivative, PartialEq)]
+#[derivative(Default(bound=""))]
+struct WithOption<T> {
+    foo: Option<T>,
+}
+
+struct NonDefault;
+
+#[test]
+fn main() {
+    assert_eq!(Foo::default(), Foo { foo: 0u8, bar: 0xffu8 });
+    assert_eq!(Bar::default(), Bar { foo: 0u8, bar: 0xffu8 });
+    assert_eq!(Foo::new(), Foo { foo: 0u8, bar: 0xffu8 });
+    assert_eq!(Bar::new(), Bar { foo: 0u8, bar: 0xffu8 });
+    WithOption::<NonDefault>::default();
+}
diff --git a/vendor/derivative/tests/derive-default.rs b/vendor/derivative/tests/derive-default.rs
new file mode 100644
index 000000000..34e0806b8
--- /dev/null
+++ b/vendor/derivative/tests/derive-default.rs
@@ -0,0 +1,78 @@
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Debug, Derivative, PartialEq)]
+#[derivative(Default="new")]
+struct Foo {
+    foo: u8,
+    #[derivative(Default(value="42"))]
+    bar: u8,
+}
+
+#[derive(Debug, Derivative, PartialEq)]
+#[derivative(Default(new="true"))]
+struct Bar (
+    u8,
+    #[derivative(Default(value="42"))]
+    u8,
+);
+
+#[derive(Debug, PartialEq)]
+struct B1(u8, u8);
+#[derive(Debug, PartialEq)]
+struct B2{a:u8, b:u8}
+
+#[derive(Debug, Derivative, PartialEq)]
+#[derivative(Default(new="true"))]
+struct Baz (
+    #[derivative(Default(value="[1,2]"))]
+    [u8;2],
+    #[derivative(Default(value="[3;2]"))]
+    [u8;2],
+    #[derivative(Default(value="(4,5)"))]
+    (u8, u8),
+    #[derivative(Default(value="B1(6,7)"))]
+    B1,
+    #[derivative(Default(value="B2{a:8,b:9}"))]
+    B2,
+);
+
+#[derive(Debug, Derivative, PartialEq)]
+#[derivative(Default)]
+enum Enum1 {
+    #[allow(dead_code)]
+    A,
+    #[derivative(Default)]
+    B,
+}
+
+#[derive(Debug, Derivative, PartialEq)]
+#[derivative(Default)]
+enum Enum2 {
+    #[derivative(Default)]
+    A,
+    #[allow(dead_code)]
+    B,
+}
+
+#[derive(Debug, Derivative, PartialEq)]
+#[derivative(Default)]
+struct A(#[derivative(Default(value="NoDefault"))] NoDefault);
+
+#[derive(Debug, PartialEq)]
+struct NoDefault;
+
+#[test]
+fn main() {
+    assert_eq!(Foo::default(), Foo { foo: 0, bar: 42 });
+    assert_eq!(Foo::new(), Foo { foo: 0, bar: 42 });
+    assert_eq!(Bar::default(), Bar(0, 42));
+    assert_eq!(Bar::new(), Bar(0, 42));
+    assert_eq!(Baz::new(), Baz([1,2], [3,3], (4,5), B1(6,7), B2{a:8,b:9}));
+    assert_eq!(A::default(), A(NoDefault));
+    assert_eq!(Enum1::default(), Enum1::B);
+    assert_eq!(Enum2::default(), Enum2::A);
+}
diff --git a/vendor/derivative/tests/derive-eq-packed.rs b/vendor/derivative/tests/derive-eq-packed.rs
new file mode 100644
index 000000000..6e495c274
--- /dev/null
+++ b/vendor/derivative/tests/derive-eq-packed.rs
@@ -0,0 +1,61 @@
+#![allow(clippy::eq_op)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative, PartialEq)]
+#[derivative(Eq)]
+#[repr(C, packed)]
+struct Foo {
+    foo: u8
+}
+
+#[derive(Derivative)]
+#[derivative(Eq)]
+#[repr(C, packed)]
+struct WithPtr<T: ?Sized> {
+    #[derivative(Eq(bound=""))]
+    foo: *const T
+}
+
+impl<T: ?Sized> PartialEq for WithPtr<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.foo == other.foo
+    }
+}
+
+#[derive(Derivative)]
+#[derivative(PartialEq, Eq)]
+#[repr(C, packed)]
+struct Generic<T>(T);
+
+trait SomeTrait {}
+#[derive(Clone, Copy, PartialEq, Eq)]
+struct SomeType {
+    #[allow(dead_code)]
+    foo: u8
+}
+impl SomeTrait for SomeType {}
+
+fn assert_eq<T: Eq>(_: T) {}
+
+#[test]
+fn main() {
+    assert!(Foo { foo: 7 } == Foo { foo: 7 });
+    assert!(Foo { foo: 7 } != Foo { foo: 42 });
+
+    assert_eq(Foo { foo: 7 });
+
+    let ptr1: *const dyn SomeTrait = &SomeType { foo: 0 };
+    let ptr2: *const dyn SomeTrait = &SomeType { foo: 1 };
+    assert!(WithPtr { foo: ptr1 } == WithPtr { foo: ptr1 });
+    assert!(WithPtr { foo: ptr1 } != WithPtr { foo: ptr2 });
+
+    assert_eq(WithPtr { foo: ptr1 });
+
+    assert!(Generic(SomeType { foo: 0 }) == Generic(SomeType { foo: 0 }));
+    assert_eq(Generic(SomeType { foo: 0 }));
+}
diff --git a/vendor/derivative/tests/derive-eq.rs b/vendor/derivative/tests/derive-eq.rs
new file mode 100644
index 000000000..c52a5d3b3
--- /dev/null
+++ b/vendor/derivative/tests/derive-eq.rs
@@ -0,0 +1,50 @@
+#![allow(clippy::eq_op)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative, PartialEq)]
+#[derivative(Eq)]
+struct Foo {
+    foo: u8
+}
+
+#[derive(Derivative)]
+#[derivative(Eq)]
+struct WithPtr<T: ?Sized> {
+    #[derivative(Eq(bound=""))]
+    foo: *const T
+}
+
+impl<T: ?Sized> PartialEq for WithPtr<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.foo == other.foo
+    }
+}
+
+trait SomeTrait {}
+struct SomeType {
+    #[allow(dead_code)]
+    foo: u8
+}
+impl SomeTrait for SomeType {}
+
+fn assert_eq<T: Eq>(_: T) {}
+
+#[test]
+fn main() {
+    assert!(Foo { foo: 7 } == Foo { foo: 7 });
+    assert!(Foo { foo: 7 } != Foo { foo: 42 });
+
+    assert_eq(Foo { foo: 7 });
+
+    let ptr1: *const dyn SomeTrait = &SomeType { foo: 0 };
+    let ptr2: *const dyn SomeTrait = &SomeType { foo: 1 };
+    assert!(WithPtr { foo: ptr1 } == WithPtr { foo: ptr1 });
+    assert!(WithPtr { foo: ptr1 } != WithPtr { foo: ptr2 });
+
+    assert_eq(WithPtr { foo: ptr1 });
+}
diff --git a/vendor/derivative/tests/derive-hash.rs b/vendor/derivative/tests/derive-hash.rs
new file mode 100755
index 000000000..e7d057aed
--- /dev/null
+++ b/vendor/derivative/tests/derive-hash.rs
@@ -0,0 +1,134 @@
+//! This tests that we compute the same hash as `derive(Hash)`.
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+macro_rules! define {
+    ($kw:tt $($rest:tt)*) => {
+        #[derive(Derivative)]
+        #[derivative(Hash)]
+        $kw Ours $($rest)*
+
+        #[derive(Hash)]
+        $kw Theirs $($rest)*
+    }
+}
+
+struct FakeHasher<'a>(&'a mut Vec<u8>);
+impl<'a> ::std::hash::Hasher for FakeHasher<'a> {
+    fn finish(&self) -> u64 {
+        unimplemented!()
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.0.extend(bytes);
+    }
+}
+
+fn fake_hash<E: ::std::hash::Hash>(e: E) -> Vec<u8> {
+    let mut v = Vec::new();
+    e.hash(&mut FakeHasher(&mut v));
+    v
+}
+
+#[test]
+fn main() {
+    {
+        define! {
+            struct;
+        }
+
+        assert_eq!(fake_hash(Ours), fake_hash(Theirs));
+    }
+
+    {
+        define! {
+            struct {
+                foo: u8
+            }
+        }
+
+        assert_eq!(fake_hash(Ours { foo: 0 }), fake_hash(Theirs { foo: 0 }));
+        assert_eq!(fake_hash(Ours { foo: 42 }), fake_hash(Theirs { foo: 42 }));
+    }
+
+    {
+        define! {
+            struct<'a> {
+                foo: u8,
+                bar: &'a str,
+            }
+        }
+
+        assert_eq!(fake_hash(Ours { foo: 0, bar: "bar" }), fake_hash(Theirs { foo: 0, bar: "bar" }));
+        assert_eq!(fake_hash(Ours { foo: 42, bar: "bar" }), fake_hash(Theirs { foo: 42, bar: "bar" }));
+    }
+
+    {
+        define! {
+            struct<'a> (u8, &'a str);
+        }
+
+        assert_eq!(fake_hash(Ours ( 0, "bar" )), fake_hash(Theirs ( 0, "bar" )));
+        assert_eq!(fake_hash(Ours ( 42, "bar" )), fake_hash(Theirs ( 42, "bar" )));
+    }
+
+    {
+        define! {
+            enum {
+                A, B, C
+            }
+        }
+
+        assert_eq!(fake_hash(Ours::A), fake_hash(Theirs::A));
+        assert_eq!(fake_hash(Ours::B), fake_hash(Theirs::B));
+        assert_eq!(fake_hash(Ours::C), fake_hash(Theirs::C));
+    }
+
+    {
+        define! {
+            enum {
+                A, B = 42, C
+            }
+        }
+
+        assert_eq!(fake_hash(Ours::A), fake_hash(Theirs::A));
+        assert_eq!(fake_hash(Ours::B), fake_hash(Theirs::B));
+        assert_eq!(fake_hash(Ours::C), fake_hash(Theirs::C));
+    }
+
+    {
+        define! {
+            enum {
+                A, B = 42, C=1
+            }
+        }
+
+        assert_eq!(fake_hash(Ours::A), fake_hash(Theirs::A));
+        assert_eq!(fake_hash(Ours::B), fake_hash(Theirs::B));
+        assert_eq!(fake_hash(Ours::C), fake_hash(Theirs::C));
+    }
+
+    {
+        #[derive(Derivative)]
+        #[derivative(Hash)]
+        struct Ours<'a> {
+            foo: u8,
+            #[derivative(Hash="ignore")]
+            bar: &'a str,
+            baz: i64,
+        }
+
+        #[derive(Hash)]
+        struct Theirs {
+            foo: u8,
+            baz: i64,
+        }
+
+        assert_eq!(fake_hash(Ours { foo: 0, bar: "bar", baz: 312 }), fake_hash(Theirs { foo: 0, baz: 312 }));
+        assert_eq!(fake_hash(Ours { foo: 42, bar: "bar", baz: 312 }), fake_hash(Theirs { foo: 42, baz: 312 }));
+    }
+}
diff --git a/vendor/derivative/tests/derive-ord-packed.rs b/vendor/derivative/tests/derive-ord-packed.rs
new file mode 100644
index 000000000..7b4cad711
--- /dev/null
+++ b/vendor/derivative/tests/derive-ord-packed.rs
@@ -0,0 +1,264 @@
+#![allow(renamed_and_removed_lints)] // clippy::cyclomatic_complexity → clippy::cognitive_complexity
+#![allow(clippy::cyclomatic_complexity)]
+#![allow(clippy::cognitive_complexity)]
+#![allow(clippy::trivially_copy_pass_by_ref)]
+#![allow(clippy::unknown_clippy_lints)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(PartialEq, Eq, Derivative)]
+#[derivative(PartialOrd, Ord)]
+#[repr(C, packed)]
+struct Foo {
+    foo: u8,
+}
+
+#[derive(Derivative)]
+#[derivative(PartialEq, PartialOrd, Ord, Eq)]
+#[repr(C, packed)]
+struct WithPtr<T: ?Sized> {
+    #[derivative(PartialEq(bound = ""))]
+    #[derivative(PartialOrd(bound = ""))]
+    #[derivative(Ord(bound = ""))]
+    #[derivative(Eq(bound = ""))]
+    foo: *const T,
+}
+
+#[derive(PartialEq, Eq, Derivative)]
+#[derivative(PartialOrd, Ord)]
+#[repr(C, packed)]
+struct Empty;
+
+#[derive(PartialEq, Eq, Derivative)]
+#[derivative(PartialOrd, Ord)]
+#[repr(C, packed)]
+struct AllIgnored {
+    #[derivative(PartialOrd = "ignore")]
+    #[derivative(Ord = "ignore")]
+    foo: u8,
+}
+
+#[derive(PartialEq, Eq, Derivative)]
+#[derivative(PartialOrd, Ord)]
+#[repr(C, packed)]
+struct OneIgnored {
+    #[derivative(PartialOrd = "ignore")]
+    #[derivative(Ord = "ignore")]
+    foo: u8,
+    bar: u8,
+}
+
+#[derive(PartialEq, Eq, Derivative)]
+#[derivative(PartialOrd, Ord)]
+#[repr(C, packed)]
+struct Tenth(
+    #[derivative(
+        PartialOrd(compare_with = "partial_cmp_tenth"),
+        Ord(compare_with = "cmp_tenth")
+    )]
+    u8,
+);
+
+fn partial_cmp_tenth(lhs: &u8, rhs: &u8) -> std::option::Option<std::cmp::Ordering> {
+    if *lhs == 0 {
+        None
+    } else {
+        Some((lhs / 10).cmp(&(rhs / 10)))
+    }
+}
+fn cmp_tenth(lhs: &u8, rhs: &u8) -> std::cmp::Ordering {
+    (lhs / 10).cmp(&(rhs / 10))
+}
+
+#[derive(Derivative)]
+#[derivative(PartialOrd, Ord, PartialEq, Eq)]
+#[repr(C, packed)]
+struct Generic<T>(
+    #[derivative(
+        PartialEq = "ignore",
+        PartialOrd(compare_with = "dummy_partial_cmp", bound = ""),
+        Ord(compare_with = "dummy_cmp", bound = "")
+    )]
+    T,
+);
+
+fn dummy_partial_cmp<T>(_: &T, _: &T) -> std::option::Option<std::cmp::Ordering> {
+    Some(std::cmp::Ordering::Less)
+}
+fn dummy_cmp<T>(_: &T, _: &T) -> std::cmp::Ordering {
+    std::cmp::Ordering::Less
+}
+
+struct NonPartialOrd;
+
+#[derive(Derivative)]
+#[derivative(PartialEq, PartialOrd, Ord, Eq)]
+#[repr(C, packed)]
+struct GenericIgnore<T> {
+    f: u32,
+    #[derivative(PartialEq = "ignore")]
+    #[derivative(PartialOrd = "ignore")]
+    #[derivative(Ord = "ignore")]
+    t: T,
+}
+
+trait SomeTrait {}
+
+#[derive(Clone, Copy)]
+struct SomeType {
+    #[allow(dead_code)]
+    foo: u8,
+}
+impl SomeTrait for SomeType {}
+
+#[test]
+fn main() {
+    use std::cmp::Ordering;
+
+    assert_eq!(
+        Foo { foo: 7 }.partial_cmp(&Foo { foo: 42 }),
+        Some(Ordering::Less)
+    );
+    assert_eq!(
+        Foo { foo: 42 }.partial_cmp(&Foo { foo: 42 }),
+        Some(Ordering::Equal)
+    );
+    assert_eq!(
+        Foo { foo: 42 }.partial_cmp(&Foo { foo: 7 }),
+        Some(Ordering::Greater)
+    );
+    assert_eq!(Foo { foo: 7 }.cmp(&Foo { foo: 42 }), Ordering::Less);
+    assert_eq!(Foo { foo: 42 }.cmp(&Foo { foo: 42 }), Ordering::Equal);
+    assert_eq!(Foo { foo: 42 }.cmp(&Foo { foo: 7 }), Ordering::Greater);
+
+    let pointers: [*const dyn SomeTrait; 2] = [&SomeType { foo: 1 }, &SomeType { foo: 0 }];
+    let ptr1: *const dyn SomeTrait = pointers[0];
+    let ptr2: *const dyn SomeTrait = pointers[1];
+    let (ptr1, ptr2) = (std::cmp::min(ptr1, ptr2), std::cmp::max(ptr1, ptr2));
+    assert_eq!(
+        WithPtr { foo: ptr1 }.partial_cmp(&WithPtr { foo: ptr1 }),
+        Some(Ordering::Equal)
+    );
+    assert_eq!(
+        WithPtr { foo: ptr1 }.cmp(&WithPtr { foo: ptr1 }),
+        Ordering::Equal
+    );
+    assert_eq!(
+        WithPtr { foo: ptr1 }.partial_cmp(&WithPtr { foo: ptr2 }),
+        Some(Ordering::Less)
+    );
+    assert_eq!(
+        WithPtr { foo: ptr1 }.cmp(&WithPtr { foo: ptr2 }),
+        Ordering::Less
+    );
+
+    assert_eq!(Empty.partial_cmp(&Empty), Some(Ordering::Equal));
+    assert_eq!(
+        AllIgnored { foo: 0 }.partial_cmp(&AllIgnored { foo: 42 }),
+        Some(Ordering::Equal)
+    );
+    assert_eq!(
+        OneIgnored { foo: 0, bar: 6 }.partial_cmp(&OneIgnored { foo: 42, bar: 7 }),
+        Some(Ordering::Less)
+    );
+    assert_eq!(
+        OneIgnored { foo: 0, bar: 6 }.partial_cmp(&OneIgnored { foo: 42, bar: 6 }),
+        Some(Ordering::Equal)
+    );
+    assert_eq!(
+        OneIgnored { foo: 0, bar: 7 }.partial_cmp(&OneIgnored { foo: 42, bar: 6 }),
+        Some(Ordering::Greater)
+    );
+    assert_eq!(Empty.cmp(&Empty), Ordering::Equal);
+    assert_eq!(
+        AllIgnored { foo: 0 }.cmp(&AllIgnored { foo: 42 }),
+        Ordering::Equal
+    );
+    assert_eq!(
+        OneIgnored { foo: 0, bar: 6 }.cmp(&OneIgnored { foo: 42, bar: 7 }),
+        Ordering::Less
+    );
+    assert_eq!(
+        OneIgnored { foo: 0, bar: 6 }.cmp(&OneIgnored { foo: 42, bar: 6 }),
+        Ordering::Equal
+    );
+    assert_eq!(
+        OneIgnored { foo: 0, bar: 7 }.cmp(&OneIgnored { foo: 42, bar: 6 }),
+        Ordering::Greater
+    );
+
+    assert_eq!(
+        Option::None::<u8>.partial_cmp(&Option::Some(7)),
+        Some(Ordering::Less)
+    );
+    assert_eq!(
+        Option::Some(6).partial_cmp(&Option::Some(7)),
+        Some(Ordering::Less)
+    );
+    assert_eq!(
+        Option::Some(42).partial_cmp(&Option::Some(42)),
+        Some(Ordering::Equal)
+    );
+    assert_eq!(
+        Option::None::<u8>.partial_cmp(&Option::None::<u8>),
+        Some(Ordering::Equal)
+    );
+    assert_eq!(
+        Option::Some(7).partial_cmp(&Option::Some(6)),
+        Some(Ordering::Greater)
+    );
+    assert_eq!(
+        Option::Some(7).partial_cmp(&Option::None::<u8>),
+        Some(Ordering::Greater)
+    );
+    assert_eq!(Option::None::<u8>.cmp(&Option::Some(7)), Ordering::Less);
+    assert_eq!(Option::Some(6).cmp(&Option::Some(7)), Ordering::Less);
+    assert_eq!(Option::Some(42).cmp(&Option::Some(42)), Ordering::Equal);
+    assert_eq!(Option::None::<u8>.cmp(&Option::None::<u8>), Ordering::Equal);
+    assert_eq!(Option::Some(7).cmp(&Option::Some(6)), Ordering::Greater);
+    assert_eq!(Option::Some(7).cmp(&Option::None::<u8>), Ordering::Greater);
+
+    assert_eq!(Tenth(0).partial_cmp(&Tenth(67)), None);
+    assert_eq!(Tenth(42).partial_cmp(&Tenth(67)), Some(Ordering::Less));
+    assert_eq!(Tenth(60).partial_cmp(&Tenth(67)), Some(Ordering::Equal));
+    assert_eq!(Tenth(100).partial_cmp(&Tenth(67)), Some(Ordering::Greater));
+    assert_eq!(Tenth(42).cmp(&Tenth(67)), Ordering::Less);
+    assert_eq!(Tenth(60).cmp(&Tenth(67)), Ordering::Equal);
+    assert_eq!(Tenth(100).cmp(&Tenth(67)), Ordering::Greater);
+
+    assert_eq!(
+        Generic(SomeType { foo: 0 }).partial_cmp(&Generic(SomeType { foo: 0 })),
+        Some(Ordering::Less)
+    );
+    assert_eq!(
+        Generic(SomeType { foo: 0 }).cmp(&Generic(SomeType { foo: 0 })),
+        Ordering::Less
+    );
+
+    assert_eq!(
+        GenericIgnore {
+            f: 123,
+            t: NonPartialOrd
+        }
+        .cmp(&GenericIgnore {
+            f: 123,
+            t: NonPartialOrd
+        }),
+        Ordering::Equal
+    );
+    assert_eq!(
+        GenericIgnore {
+            f: 123,
+            t: NonPartialOrd
+        }
+        .partial_cmp(&GenericIgnore {
+            f: 123,
+            t: NonPartialOrd
+        }),
+        Some(Ordering::Equal)
+    );
+}
diff --git a/vendor/derivative/tests/derive-ord.rs b/vendor/derivative/tests/derive-ord.rs
new file mode 100644
index 000000000..cb55a19e8
--- /dev/null
+++ b/vendor/derivative/tests/derive-ord.rs
@@ -0,0 +1,266 @@
+#![allow(renamed_and_removed_lints)] // clippy::cyclomatic_complexity → clippy::cognitive_complexity
+#![allow(clippy::cyclomatic_complexity)]
+#![allow(clippy::cognitive_complexity)]
+#![allow(clippy::trivially_copy_pass_by_ref)]
+#![allow(clippy::unknown_clippy_lints)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+use std::marker::PhantomData;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(PartialEq, Eq, Derivative)]
+#[derivative(PartialOrd, Ord)]
+struct Foo {
+    foo: u8,
+}
+
+#[derive(PartialEq, Eq, Derivative)]
+#[derivative(
+    PartialOrd = "feature_allow_slow_enum",
+    Ord = "feature_allow_slow_enum"
+)]
+enum Option<T> {
+    None,
+    Some(T),
+}
+
+#[derive(Derivative)]
+#[derivative(PartialEq, PartialOrd, Ord, Eq)]
+struct WithPtr<T: ?Sized> {
+    #[derivative(PartialEq(bound = ""))]
+    #[derivative(PartialOrd(bound = ""))]
+    #[derivative(Ord(bound = ""))]
+    #[derivative(Eq(bound = ""))]
+    foo: *const T,
+}
+
+#[derive(PartialEq, Eq, Derivative)]
+#[derivative(PartialOrd, Ord)]
+struct Empty;
+
+#[derive(PartialEq, Eq, Derivative)]
+#[derivative(PartialOrd, Ord)]
+struct AllIgnored {
+    #[derivative(PartialOrd = "ignore")]
+    #[derivative(Ord = "ignore")]
+    foo: u8,
+}
+
+#[derive(PartialEq, Eq, Derivative)]
+#[derivative(PartialOrd, Ord)]
+struct OneIgnored {
+    #[derivative(PartialOrd = "ignore")]
+    #[derivative(Ord = "ignore")]
+    foo: u8,
+    bar: u8,
+}
+
+#[derive(PartialEq, Eq, Derivative)]
+#[derivative(PartialOrd, Ord)]
+struct Tenth(
+    #[derivative(
+        PartialOrd(compare_with = "partial_cmp_tenth"),
+        Ord(compare_with = "cmp_tenth")
+    )]
+    u8,
+);
+
+fn partial_cmp_tenth(lhs: &u8, rhs: &u8) -> std::option::Option<std::cmp::Ordering> {
+    if *lhs == 0 {
+        None
+    } else {
+        Some((lhs / 10).cmp(&(rhs / 10)))
+    }
+}
+fn cmp_tenth(lhs: &u8, rhs: &u8) -> std::cmp::Ordering {
+    (lhs / 10).cmp(&(rhs / 10))
+}
+
+#[derive(Derivative)]
+#[derivative(PartialOrd, Ord, PartialEq, Eq)]
+struct Generic<T>(
+    #[derivative(
+        PartialEq = "ignore",
+        PartialOrd(compare_with = "dummy_partial_cmp", bound = ""),
+        Ord(compare_with = "dummy_cmp", bound = "")
+    )]
+    T,
+);
+
+fn dummy_partial_cmp<T>(_: &T, _: &T) -> std::option::Option<std::cmp::Ordering> {
+    Some(std::cmp::Ordering::Less)
+}
+fn dummy_cmp<T>(_: &T, _: &T) -> std::cmp::Ordering {
+    std::cmp::Ordering::Less
+}
+
+struct NonPartialOrd;
+
+#[derive(Derivative)]
+#[derivative(PartialEq, PartialOrd, Ord, Eq)]
+struct GenericIgnore<T> {
+    f: u32,
+    #[derivative(PartialEq = "ignore")]
+    #[derivative(PartialOrd = "ignore")]
+    #[derivative(Ord = "ignore")]
+    t: PhantomData<T>,
+}
+
+trait SomeTrait {}
+struct SomeType {
+    #[allow(dead_code)]
+    foo: u8,
+}
+impl SomeTrait for SomeType {}
+
+#[test]
+fn main() {
+    use std::cmp::Ordering;
+
+    assert_eq!(
+        Foo { foo: 7 }.partial_cmp(&Foo { foo: 42 }),
+        Some(Ordering::Less)
+    );
+    assert_eq!(
+        Foo { foo: 42 }.partial_cmp(&Foo { foo: 42 }),
+        Some(Ordering::Equal)
+    );
+    assert_eq!(
+        Foo { foo: 42 }.partial_cmp(&Foo { foo: 7 }),
+        Some(Ordering::Greater)
+    );
+    assert_eq!(Foo { foo: 7 }.cmp(&Foo { foo: 42 }), Ordering::Less);
+    assert_eq!(Foo { foo: 42 }.cmp(&Foo { foo: 42 }), Ordering::Equal);
+    assert_eq!(Foo { foo: 42 }.cmp(&Foo { foo: 7 }), Ordering::Greater);
+
+    let pointers: [*const dyn SomeTrait; 2] = [&SomeType { foo: 1 }, &SomeType { foo: 0 }];
+    let ptr1: *const dyn SomeTrait = pointers[0];
+    let ptr2: *const dyn SomeTrait = pointers[1];
+    let (ptr1, ptr2) = (std::cmp::min(ptr1, ptr2), std::cmp::max(ptr1, ptr2));
+    assert_eq!(
+        WithPtr { foo: ptr1 }.partial_cmp(&WithPtr { foo: ptr1 }),
+        Some(Ordering::Equal)
+    );
+    assert_eq!(
+        WithPtr { foo: ptr1 }.cmp(&WithPtr { foo: ptr1 }),
+        Ordering::Equal
+    );
+    assert_eq!(
+        WithPtr { foo: ptr1 }.partial_cmp(&WithPtr { foo: ptr2 }),
+        Some(Ordering::Less)
+    );
+    assert_eq!(
+        WithPtr { foo: ptr1 }.cmp(&WithPtr { foo: ptr2 }),
+        Ordering::Less
+    );
+
+    assert_eq!(Empty.partial_cmp(&Empty), Some(Ordering::Equal));
+    assert_eq!(
+        AllIgnored { foo: 0 }.partial_cmp(&AllIgnored { foo: 42 }),
+        Some(Ordering::Equal)
+    );
+    assert_eq!(
+        OneIgnored { foo: 0, bar: 6 }.partial_cmp(&OneIgnored { foo: 42, bar: 7 }),
+        Some(Ordering::Less)
+    );
+    assert_eq!(
+        OneIgnored { foo: 0, bar: 6 }.partial_cmp(&OneIgnored { foo: 42, bar: 6 }),
+        Some(Ordering::Equal)
+    );
+    assert_eq!(
+        OneIgnored { foo: 0, bar: 7 }.partial_cmp(&OneIgnored { foo: 42, bar: 6 }),
+        Some(Ordering::Greater)
+    );
+    assert_eq!(Empty.cmp(&Empty), Ordering::Equal);
+    assert_eq!(
+        AllIgnored { foo: 0 }.cmp(&AllIgnored { foo: 42 }),
+        Ordering::Equal
+    );
+    assert_eq!(
+        OneIgnored { foo: 0, bar: 6 }.cmp(&OneIgnored { foo: 42, bar: 7 }),
+        Ordering::Less
+    );
+    assert_eq!(
+        OneIgnored { foo: 0, bar: 6 }.cmp(&OneIgnored { foo: 42, bar: 6 }),
+        Ordering::Equal
+    );
+    assert_eq!(
+        OneIgnored { foo: 0, bar: 7 }.cmp(&OneIgnored { foo: 42, bar: 6 }),
+        Ordering::Greater
+    );
+
+    assert_eq!(
+        Option::None::<u8>.partial_cmp(&Option::Some(7)),
+        Some(Ordering::Less)
+    );
+    assert_eq!(
+        Option::Some(6).partial_cmp(&Option::Some(7)),
+        Some(Ordering::Less)
+    );
+    assert_eq!(
+        Option::Some(42).partial_cmp(&Option::Some(42)),
+        Some(Ordering::Equal)
+    );
+    assert_eq!(
+        Option::None::<u8>.partial_cmp(&Option::None::<u8>),
+        Some(Ordering::Equal)
+    );
+    assert_eq!(
+        Option::Some(7).partial_cmp(&Option::Some(6)),
+        Some(Ordering::Greater)
+    );
+    assert_eq!(
+        Option::Some(7).partial_cmp(&Option::None::<u8>),
+        Some(Ordering::Greater)
+    );
+    assert_eq!(Option::None::<u8>.cmp(&Option::Some(7)), Ordering::Less);
+    assert_eq!(Option::Some(6).cmp(&Option::Some(7)), Ordering::Less);
+    assert_eq!(Option::Some(42).cmp(&Option::Some(42)), Ordering::Equal);
+    assert_eq!(Option::None::<u8>.cmp(&Option::None::<u8>), Ordering::Equal);
+    assert_eq!(Option::Some(7).cmp(&Option::Some(6)), Ordering::Greater);
+    assert_eq!(Option::Some(7).cmp(&Option::None::<u8>), Ordering::Greater);
+
+    assert_eq!(Tenth(0).partial_cmp(&Tenth(67)), None);
+    assert_eq!(Tenth(42).partial_cmp(&Tenth(67)), Some(Ordering::Less));
+    assert_eq!(Tenth(60).partial_cmp(&Tenth(67)), Some(Ordering::Equal));
+    assert_eq!(Tenth(100).partial_cmp(&Tenth(67)), Some(Ordering::Greater));
+    assert_eq!(Tenth(42).cmp(&Tenth(67)), Ordering::Less);
+    assert_eq!(Tenth(60).cmp(&Tenth(67)), Ordering::Equal);
+    assert_eq!(Tenth(100).cmp(&Tenth(67)), Ordering::Greater);
+
+    assert_eq!(
+        Generic(SomeType { foo: 0 }).partial_cmp(&Generic(SomeType { foo: 0 })),
+        Some(Ordering::Less)
+    );
+    assert_eq!(
+        Generic(SomeType { foo: 0 }).cmp(&Generic(SomeType { foo: 0 })),
+        Ordering::Less
+    );
+
+    assert_eq!(
+        GenericIgnore {
+            f: 123,
+            t: PhantomData::<NonPartialOrd>::default()
+        }
+        .cmp(&GenericIgnore {
+            f: 123,
+            t: PhantomData::<NonPartialOrd>::default()
+        }),
+        Ordering::Equal
+    );
+    assert_eq!(
+        GenericIgnore {
+            f: 123,
+            t: PhantomData::<NonPartialOrd>::default()
+        }
+        .partial_cmp(&GenericIgnore {
+            f: 123,
+            t: PhantomData::<NonPartialOrd>::default()
+        }),
+        Some(Ordering::Equal)
+    );
+}
diff --git a/vendor/derivative/tests/derive-partial-eq-packed.rs b/vendor/derivative/tests/derive-partial-eq-packed.rs
new file mode 100644
index 000000000..e3bce6c78
--- /dev/null
+++ b/vendor/derivative/tests/derive-partial-eq-packed.rs
@@ -0,0 +1,120 @@
+#![allow(clippy::eq_op, clippy::trivially_copy_pass_by_ref)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(PartialEq)]
+#[repr(C, packed)]
+struct Foo {
+    foo: u8,
+}
+
+#[derive(Derivative)]
+#[derivative(PartialEq)]
+#[repr(C, packed)]
+struct WithPtr<T: ?Sized> {
+    #[derivative(PartialEq(bound = ""))]
+    foo: *const T,
+}
+
+#[derive(Derivative)]
+#[derivative(PartialEq)]
+#[repr(C, packed)]
+struct Empty;
+
+#[derive(Derivative)]
+#[derivative(PartialEq)]
+#[repr(C, packed)]
+struct AllIgnored {
+    #[derivative(PartialEq = "ignore")]
+    foo: u8,
+}
+
+#[derive(Derivative)]
+#[derivative(PartialEq)]
+#[repr(C, packed)]
+struct OneIgnored {
+    #[derivative(PartialEq = "ignore")]
+    foo: u8,
+    bar: u8,
+}
+
+#[derive(Derivative)]
+#[derivative(PartialEq)]
+#[repr(C, packed)]
+struct Parity(#[derivative(PartialEq(compare_with = "same_parity"))] u8);
+
+fn same_parity(lhs: &u8, rhs: &u8) -> bool {
+    lhs % 2 == rhs % 2
+}
+
+#[derive(Derivative)]
+#[derivative(PartialEq)]
+#[repr(C, packed)]
+struct Generic<T>(#[derivative(PartialEq(compare_with = "dummy_cmp", bound = ""))] T);
+
+fn dummy_cmp<T>(_: &T, _: &T) -> bool {
+    true
+}
+
+struct NonPartialEq;
+
+#[derive(Derivative)]
+#[derivative(PartialEq, Eq)]
+#[repr(C, packed)]
+struct GenericIgnore<T> {
+    f: u32,
+    #[derivative(PartialEq = "ignore")]
+    t: T,
+}
+
+trait SomeTrait {}
+
+#[derive(Copy, Clone)]
+struct SomeType {
+    #[allow(dead_code)]
+    foo: u8,
+}
+impl SomeTrait for SomeType {}
+
+#[test]
+fn main() {
+    assert!(Foo { foo: 7 } == Foo { foo: 7 });
+    assert!(Foo { foo: 7 } != Foo { foo: 42 });
+
+    let ptr1: *const dyn SomeTrait = &SomeType { foo: 0 };
+    let ptr2: *const dyn SomeTrait = &SomeType { foo: 1 };
+    assert!(WithPtr { foo: ptr1 } == WithPtr { foo: ptr1 });
+    assert!(WithPtr { foo: ptr1 } != WithPtr { foo: ptr2 });
+
+    assert!(Empty == Empty);
+    assert!(AllIgnored { foo: 0 } == AllIgnored { foo: 42 });
+    assert!(OneIgnored { foo: 0, bar: 6 } == OneIgnored { foo: 42, bar: 6 });
+    assert!(OneIgnored { foo: 0, bar: 6 } != OneIgnored { foo: 42, bar: 7 });
+
+    assert!(Option::Some(42) == Option::Some(42));
+    assert!(Option::Some(0) != Option::Some(42));
+    assert!(Option::Some(42) != Option::None);
+    assert!(Option::None != Option::Some(42));
+    assert!(Option::None::<u8> == Option::None::<u8>);
+
+    assert!(Parity(3) == Parity(7));
+    assert!(Parity(2) == Parity(42));
+    assert!(Parity(3) != Parity(42));
+    assert!(Parity(2) != Parity(7));
+
+    assert!(Generic(SomeType { foo: 0 }) == Generic(SomeType { foo: 0 }));
+    assert!(
+        GenericIgnore {
+            f: 123,
+            t: NonPartialEq
+        } == GenericIgnore {
+            f: 123,
+            t: NonPartialEq
+        }
+    );
+}
diff --git a/vendor/derivative/tests/derive-partial-eq.rs b/vendor/derivative/tests/derive-partial-eq.rs
new file mode 100644
index 000000000..d9e67f38d
--- /dev/null
+++ b/vendor/derivative/tests/derive-partial-eq.rs
@@ -0,0 +1,148 @@
+#![allow(clippy::eq_op, clippy::trivially_copy_pass_by_ref, dead_code)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+use std::marker::PhantomData;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(PartialEq)]
+struct Foo {
+    foo: u8,
+}
+
+/// Test for backward compatibility.
+#[derive(Derivative)]
+#[derivative(PartialEq = "feature_allow_slow_enum")]
+#[allow(unused)]
+enum AllowsFeature<T> {
+    Some(T),
+    None,
+}
+
+#[derive(Derivative)]
+#[derivative(PartialEq)]
+enum Option<T> {
+    Some(T),
+    None,
+}
+
+#[derive(Derivative)]
+#[derivative(PartialEq)]
+enum SimpleEnum {
+    Some,
+    None,
+}
+
+#[derive(Derivative)]
+#[derivative(PartialEq)]
+enum UnitEnum {
+    Single,
+}
+
+#[derive(Derivative)]
+#[derivative(PartialEq)]
+struct WithPtr<T: ?Sized> {
+    #[derivative(PartialEq(bound = ""))]
+    foo: *const T,
+}
+
+#[derive(Derivative)]
+#[derivative(PartialEq)]
+struct Empty;
+
+#[derive(Derivative)]
+#[derivative(PartialEq)]
+struct AllIgnored {
+    #[derivative(PartialEq = "ignore")]
+    foo: u8,
+}
+
+#[derive(Derivative)]
+#[derivative(PartialEq)]
+struct OneIgnored {
+    #[derivative(PartialEq = "ignore")]
+    foo: u8,
+    bar: u8,
+}
+
+#[derive(Derivative)]
+#[derivative(PartialEq)]
+struct Parity(#[derivative(PartialEq(compare_with = "same_parity"))] u8);
+
+fn same_parity(lhs: &u8, rhs: &u8) -> bool {
+    lhs % 2 == rhs % 2
+}
+
+#[derive(Derivative)]
+#[derivative(PartialEq)]
+struct Generic<T>(#[derivative(PartialEq(compare_with = "dummy_cmp", bound = ""))] T);
+
+fn dummy_cmp<T>(_: &T, _: &T) -> bool {
+    true
+}
+
+struct NonPartialEq;
+
+#[derive(Derivative)]
+#[derivative(PartialEq, Eq)]
+struct GenericIgnore<T> {
+    f: u32,
+    #[derivative(PartialEq = "ignore")]
+    t: PhantomData<T>,
+}
+
+trait SomeTrait {}
+struct SomeType {
+    #[allow(dead_code)]
+    foo: u8,
+}
+impl SomeTrait for SomeType {}
+
+#[test]
+fn main() {
+    assert!(Foo { foo: 7 } == Foo { foo: 7 });
+    assert!(Foo { foo: 7 } != Foo { foo: 42 });
+
+    let ptr1: *const dyn SomeTrait = &SomeType { foo: 0 };
+    let ptr2: *const dyn SomeTrait = &SomeType { foo: 1 };
+    assert!(WithPtr { foo: ptr1 } == WithPtr { foo: ptr1 });
+    assert!(WithPtr { foo: ptr1 } != WithPtr { foo: ptr2 });
+
+    assert!(Empty == Empty);
+    assert!(AllIgnored { foo: 0 } == AllIgnored { foo: 42 });
+    assert!(OneIgnored { foo: 0, bar: 6 } == OneIgnored { foo: 42, bar: 6 });
+    assert!(OneIgnored { foo: 0, bar: 6 } != OneIgnored { foo: 42, bar: 7 });
+
+    assert!(Option::Some(42) == Option::Some(42));
+    assert!(Option::Some(0) != Option::Some(42));
+    assert!(Option::Some(42) != Option::None);
+    assert!(Option::None != Option::Some(42));
+    assert!(Option::None::<u8> == Option::None::<u8>);
+
+    assert!(SimpleEnum::Some == SimpleEnum::Some);
+    assert!(SimpleEnum::None == SimpleEnum::None);
+    assert!(SimpleEnum::Some != SimpleEnum::None);
+    assert!(SimpleEnum::None != SimpleEnum::Some);
+
+    assert!(UnitEnum::Single == UnitEnum::Single);
+
+    assert!(Parity(3) == Parity(7));
+    assert!(Parity(2) == Parity(42));
+    assert!(Parity(3) != Parity(42));
+    assert!(Parity(2) != Parity(7));
+
+    assert!(Generic(SomeType { foo: 0 }) == Generic(SomeType { foo: 0 }));
+    assert!(
+        GenericIgnore {
+            f: 123,
+            t: PhantomData::<NonPartialEq>::default()
+        } == GenericIgnore {
+            f: 123,
+            t: PhantomData::<NonPartialEq>::default()
+        }
+    );
+}
diff --git a/vendor/derivative/tests/issue-37-turbofish.rs b/vendor/derivative/tests/issue-37-turbofish.rs
new file mode 100644
index 000000000..4e634b8c1
--- /dev/null
+++ b/vendor/derivative/tests/issue-37-turbofish.rs
@@ -0,0 +1,12 @@
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub struct A {
+    #[derivative(Debug(format_with = "std::fmt::Debug::fmt"))]
+    v: u64,
+}
diff --git a/vendor/derivative/tests/issue-55.rs b/vendor/derivative/tests/issue-55.rs
new file mode 100644
index 000000000..7b98142f5
--- /dev/null
+++ b/vendor/derivative/tests/issue-55.rs
@@ -0,0 +1,21 @@
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+trait Foo {}
+
+fn fmt<T>(_: &T, _: &mut std::fmt::Formatter) -> std::fmt::Result {
+    unimplemented!()
+}
+
+#[derive(Debug)]
+struct Qux<'a, T: Foo>(&'a T);
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct _Bar<'a, T: Foo>(#[derivative(Debug(format_with="fmt"))] Qux<'a, T>);
+
+fn main() {
+}
\ No newline at end of file
diff --git a/vendor/derivative/tests/issue-57.rs b/vendor/derivative/tests/issue-57.rs
new file mode 100644
index 000000000..e3dc6502c
--- /dev/null
+++ b/vendor/derivative/tests/issue-57.rs
@@ -0,0 +1,19 @@
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+macro_rules! gen {
+    ($name:ident) => {
+        #[derive(Derivative)]
+        #[derivative(Debug)]
+        pub struct $name {
+            a: i32
+        }
+    };
+}
+
+gen!(Test);
+
+fn main() {}
\ No newline at end of file
diff --git a/vendor/derivative/tests/issue-58.rs b/vendor/derivative/tests/issue-58.rs
new file mode 100644
index 000000000..313ffd5c2
--- /dev/null
+++ b/vendor/derivative/tests/issue-58.rs
@@ -0,0 +1,18 @@
+#![deny(clippy::all)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Default, Derivative)]
+#[derivative(Debug)]
+pub struct Foo {
+    foo: u8,
+}
+
+fn main() {
+    let foo1 = Foo::default();
+    println!("foo = {:?}", foo1);
+}
diff --git a/vendor/derivative/tests/issue-67.rs b/vendor/derivative/tests/issue-67.rs
new file mode 100644
index 000000000..27af67fb5
--- /dev/null
+++ b/vendor/derivative/tests/issue-67.rs
@@ -0,0 +1,11 @@
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Hash)]
+enum _Enumeration<T> {
+    _Variant(T),
+}
\ No newline at end of file
diff --git a/vendor/derivative/tests/issue-82.rs b/vendor/derivative/tests/issue-82.rs
new file mode 100644
index 000000000..69913d494
--- /dev/null
+++ b/vendor/derivative/tests/issue-82.rs
@@ -0,0 +1,13 @@
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Copy, Clone, Derivative)]
+#[derivative(Debug)]
+#[repr(C, packed)]
+struct Test {
+    a: u8,
+    b: u32,
+}
\ No newline at end of file
diff --git a/vendor/derivative/tests/rustc-class-implement-traits.rs b/vendor/derivative/tests/rustc-class-implement-traits.rs
new file mode 100644
index 000000000..3e4574dfc
--- /dev/null
+++ b/vendor/derivative/tests/rustc-class-implement-traits.rs
@@ -0,0 +1,80 @@
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![allow(non_camel_case_types)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+trait noisy {
+    fn speak(&mut self);
+}
+
+#[derive(Derivative)]
+#[derivative(Clone)]
+struct cat {
+    meows : usize,
+
+    how_hungry : isize,
+    name : String,
+}
+
+impl cat {
+    fn meow(&mut self) {
+        println!("Meow");
+        self.meows += 1_usize;
+        if self.meows % 5_usize == 0_usize {
+            self.how_hungry += 1;
+        }
+    }
+}
+
+impl cat {
+    pub fn eat(&mut self) -> bool {
+        if self.how_hungry > 0 {
+            println!("OM NOM NOM");
+            self.how_hungry -= 2;
+            true
+        } else {
+            println!("Not hungry!");
+            false
+        }
+    }
+}
+
+impl noisy for cat {
+    fn speak(&mut self) { self.meow(); }
+}
+
+fn cat(in_x : usize, in_y : isize, in_name: String) -> cat {
+    cat {
+        meows: in_x,
+        how_hungry: in_y,
+        name: in_name,
+    }
+}
+
+
+fn make_speak<C:noisy>(mut c: C) {
+    c.speak();
+}
+
+#[test]
+fn main() {
+    let mut nyan = cat(0_usize, 2, "nyan".to_string());
+    nyan.eat();
+    assert!((!nyan.eat()));
+    for _ in 1_usize..10_usize {
+        make_speak(nyan.clone());
+    }
+}
diff --git a/vendor/derivative/tests/rustc-deriving-bounds.rs b/vendor/derivative/tests/rustc-deriving-bounds.rs
new file mode 100644
index 000000000..7be0c57e7
--- /dev/null
+++ b/vendor/derivative/tests/rustc-deriving-bounds.rs
@@ -0,0 +1,24 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Copy, Clone)]
+struct Test;
+
+#[test]
+fn main() {
+    let _ = Test;
+}
diff --git a/vendor/derivative/tests/rustc-deriving-clone-array.rs b/vendor/derivative/tests/rustc-deriving-clone-array.rs
new file mode 100644
index 000000000..446eb49cf
--- /dev/null
+++ b/vendor/derivative/tests/rustc-deriving-clone-array.rs
@@ -0,0 +1,27 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// test for issue #30244
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Copy, Clone)]
+#[allow(dead_code)]
+struct Array {
+    arr: [[u8; 256]; 4]
+}
+
+#[test]
+fn main() {}
diff --git a/vendor/derivative/tests/rustc-deriving-clone-enum.rs b/vendor/derivative/tests/rustc-deriving-clone-enum.rs
new file mode 100644
index 000000000..0464d970f
--- /dev/null
+++ b/vendor/derivative/tests/rustc-deriving-clone-enum.rs
@@ -0,0 +1,32 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// pretty-expanded FIXME #23616
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Clone)]
+enum E {
+    A,
+    B(()),
+    C,
+}
+
+#[test]
+fn main() {
+    let _ = E::A.clone();
+    let _ = E::B(()).clone();
+    let _ = E::C.clone();
+}
diff --git a/vendor/derivative/tests/rustc-deriving-clone-generic-enum.rs b/vendor/derivative/tests/rustc-deriving-clone-generic-enum.rs
new file mode 100644
index 000000000..58b9b1e28
--- /dev/null
+++ b/vendor/derivative/tests/rustc-deriving-clone-generic-enum.rs
@@ -0,0 +1,31 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// pretty-expanded FIXME #23616
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Clone)]
+#[allow(dead_code)]
+enum E<T,U> {
+    A(T),
+    B(T,U),
+    C
+}
+
+#[test]
+fn main() {
+    let _ = E::A::<isize, isize>(1).clone();
+}
diff --git a/vendor/derivative/tests/rustc-deriving-clone-generic-tuple-struct.rs b/vendor/derivative/tests/rustc-deriving-clone-generic-tuple-struct.rs
new file mode 100644
index 000000000..e1cc22454
--- /dev/null
+++ b/vendor/derivative/tests/rustc-deriving-clone-generic-tuple-struct.rs
@@ -0,0 +1,26 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// pretty-expanded FIXME #23616
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Clone)]
+struct S<T>(T, ());
+
+#[test]
+fn main() {
+    let _ = S(1, ()).clone();
+}
diff --git a/vendor/derivative/tests/rustc-deriving-clone-struct.rs b/vendor/derivative/tests/rustc-deriving-clone-struct.rs
new file mode 100644
index 000000000..2e0440518
--- /dev/null
+++ b/vendor/derivative/tests/rustc-deriving-clone-struct.rs
@@ -0,0 +1,47 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// pretty-expanded FIXME #23616
+
+#![allow(clippy::redundant_clone)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Default, Derivative)]
+#[derivative(Clone)]
+struct S {
+    _int: isize,
+    _i8: i8,
+    _i16: i16,
+    _i32: i32,
+    _i64: i64,
+
+    _uint: usize,
+    _u8: u8,
+    _u16: u16,
+    _u32: u32,
+    _u64: u64,
+
+    _f32: f32,
+    _f64: f64,
+
+    _bool: bool,
+    _char: char,
+    _nil: ()
+}
+
+#[test]
+fn main() {
+    let _ = S::default().clone();
+}
diff --git a/vendor/derivative/tests/rustc-deriving-clone-tuple-struct.rs b/vendor/derivative/tests/rustc-deriving-clone-tuple-struct.rs
new file mode 100644
index 000000000..f5815d633
--- /dev/null
+++ b/vendor/derivative/tests/rustc-deriving-clone-tuple-struct.rs
@@ -0,0 +1,24 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// pretty-expanded FIXME #23616
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Clone)]
+struct S((), ());
+
+#[test]
+fn main() {}
diff --git a/vendor/derivative/tests/rustc-deriving-cmp-generic-enum.rs b/vendor/derivative/tests/rustc-deriving-cmp-generic-enum.rs
new file mode 100644
index 000000000..d7bbe3998
--- /dev/null
+++ b/vendor/derivative/tests/rustc-deriving-cmp-generic-enum.rs
@@ -0,0 +1,68 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// no-pretty-expanded FIXME #15189
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(
+    PartialEq = "feature_allow_slow_enum",
+    Eq,
+    PartialOrd = "feature_allow_slow_enum",
+    Ord = "feature_allow_slow_enum"
+)]
+enum E<T> {
+    V0,
+    V1(T),
+    V2(T, T),
+}
+
+#[test]
+fn main() {
+    let e0 = E::V0;
+    let e11 = E::V1(1);
+    let e12 = E::V1(2);
+    let e21 = E::V2(1, 1);
+    let e22 = E::V2(1, 2);
+
+    // in order for both PartialOrd and Ord
+    let es = [e0, e11, e12, e21, e22];
+
+    for (i, e1) in es.iter().enumerate() {
+        for (j, e2) in es.iter().enumerate() {
+            let ord = i.cmp(&j);
+
+            let eq = i == j;
+            let lt = i < j;
+            let le = i <= j;
+            let gt = i > j;
+            let ge = i >= j;
+
+            // PartialEq
+            assert_eq!(*e1 == *e2, eq);
+            assert_eq!(*e1 != *e2, !eq);
+
+            // PartialOrd
+            assert_eq!(*e1 < *e2, lt);
+            assert_eq!(*e1 > *e2, gt);
+
+            assert_eq!(*e1 <= *e2, le);
+            assert_eq!(*e1 >= *e2, ge);
+
+            // Ord
+            assert_eq!(e1.cmp(e2), ord);
+        }
+    }
+}
diff --git a/vendor/derivative/tests/rustc-deriving-cmp-generic-struct-enum.rs b/vendor/derivative/tests/rustc-deriving-cmp-generic-struct-enum.rs
new file mode 100644
index 000000000..780ef3a79
--- /dev/null
+++ b/vendor/derivative/tests/rustc-deriving-cmp-generic-struct-enum.rs
@@ -0,0 +1,66 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// no-pretty-expanded FIXME #15189
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(
+    PartialEq = "feature_allow_slow_enum",
+    Eq,
+    PartialOrd = "feature_allow_slow_enum",
+    Ord = "feature_allow_slow_enum"
+)]
+enum ES<T> {
+    ES1 { x: T },
+    ES2 { x: T, y: T },
+}
+
+
+pub fn main() {
+    let (es11, es12, es21, es22) = (
+        ES::ES1 { x: 1 },
+        ES::ES1 { x: 2 },
+        ES::ES2 { x: 1, y: 1 },
+        ES::ES2 { x: 1, y: 2 },
+    );
+
+    // in order for both PartialOrd and Ord
+    let ess = [es11, es12, es21, es22];
+
+    for (i, es1) in ess.iter().enumerate() {
+        for (j, es2) in ess.iter().enumerate() {
+            let ord = i.cmp(&j);
+
+            let eq = i == j;
+            let (lt, le) = (i < j, i <= j);
+            let (gt, ge) = (i > j, i >= j);
+
+            // PartialEq
+            assert_eq!(*es1 == *es2, eq);
+            assert_eq!(*es1 != *es2, !eq);
+
+            // PartialOrd
+            assert_eq!(*es1 < *es2, lt);
+            assert_eq!(*es1 > *es2, gt);
+
+            assert_eq!(*es1 <= *es2, le);
+            assert_eq!(*es1 >= *es2, ge);
+
+            // Ord
+            assert_eq!(es1.cmp(es2), ord);
+        }
+    }
+}
diff --git a/vendor/derivative/tests/rustc-deriving-cmp-generic-struct.rs b/vendor/derivative/tests/rustc-deriving-cmp-generic-struct.rs
new file mode 100644
index 000000000..2c387282e
--- /dev/null
+++ b/vendor/derivative/tests/rustc-deriving-cmp-generic-struct.rs
@@ -0,0 +1,58 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// no-pretty-expanded FIXME #15189
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(PartialEq, Eq, PartialOrd, Ord)]
+struct S<T> {
+    x: T,
+    y: T,
+}
+
+pub fn main() {
+    let s1 = S { x: 1, y: 1 };
+    let s2 = S { x: 1, y: 2 };
+
+    // in order for both PartialOrd and Ord
+    let ss = [s1, s2];
+
+    for (i, s1) in ss.iter().enumerate() {
+        for (j, s2) in ss.iter().enumerate() {
+            let ord = i.cmp(&j);
+
+            let eq = i == j;
+            let lt = i < j;
+            let le = i <= j;
+            let gt = i > j;
+            let ge = i >= j;
+
+            // PartialEq
+            assert_eq!(*s1 == *s2, eq);
+            assert_eq!(*s1 != *s2, !eq);
+
+            // PartialOrd
+            assert_eq!(*s1 < *s2, lt);
+            assert_eq!(*s1 > *s2, gt);
+
+            assert_eq!(*s1 <= *s2, le);
+            assert_eq!(*s1 >= *s2, ge);
+
+            // Ord
+            assert_eq!(s1.cmp(s2), ord);
+        }
+    }
+}
diff --git a/vendor/derivative/tests/rustc-deriving-cmp-generic-tuple-struct.rs b/vendor/derivative/tests/rustc-deriving-cmp-generic-tuple-struct.rs
new file mode 100644
index 000000000..ffcb177ef
--- /dev/null
+++ b/vendor/derivative/tests/rustc-deriving-cmp-generic-tuple-struct.rs
@@ -0,0 +1,55 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// no-pretty-expanded FIXME #15189
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(PartialEq, Eq, PartialOrd, Ord)]
+struct TS<T>(T, T);
+
+pub fn main() {
+    let ts1 = TS(1, 1);
+    let ts2 = TS(1, 2);
+
+    // in order for both PartialOrd and Ord
+    let tss = [ts1, ts2];
+
+    for (i, ts1) in tss.iter().enumerate() {
+        for (j, ts2) in tss.iter().enumerate() {
+            let ord = i.cmp(&j);
+
+            let eq = i == j;
+            let lt = i < j;
+            let le = i <= j;
+            let gt = i > j;
+            let ge = i >= j;
+
+            // PartialEq
+            assert_eq!(*ts1 == *ts2, eq);
+            assert_eq!(*ts1 != *ts2, !eq);
+
+            // PartialOrd
+            assert_eq!(*ts1 < *ts2, lt);
+            assert_eq!(*ts1 > *ts2, gt);
+
+            assert_eq!(*ts1 <= *ts2, le);
+            assert_eq!(*ts1 >= *ts2, ge);
+
+            // Ord
+            assert_eq!(ts1.cmp(ts2), ord);
+        }
+    }
+}
diff --git a/vendor/derivative/tests/rustc-deriving-copyclone.rs b/vendor/derivative/tests/rustc-deriving-copyclone.rs
new file mode 100644
index 000000000..873263386
--- /dev/null
+++ b/vendor/derivative/tests/rustc-deriving-copyclone.rs
@@ -0,0 +1,61 @@
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Test that #[derive(Copy, Clone)] produces a shallow copy
+//! even when a member violates RFC 1521
+
+#![allow(clippy::clone_on_copy)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+use std::sync::atomic::{AtomicBool, Ordering};
+
+/// A struct that pretends to be Copy, but actually does something
+/// in its Clone impl
+#[derive(Copy)]
+struct Liar;
+
+/// Static cooperating with the rogue Clone impl
+static CLONED: AtomicBool = AtomicBool::new(false);
+
+impl Clone for Liar {
+    fn clone(&self) -> Self {
+        // this makes Clone vs Copy observable
+        CLONED.store(true, Ordering::SeqCst);
+
+        *self
+    }
+}
+
+/// This struct is actually Copy... at least, it thinks it is!
+#[derive(Copy, Clone)]
+struct TheirTheir(Liar);
+
+#[derive(Derivative)]
+#[derivative(Copy, Clone)]
+struct OurOur1(Liar);
+#[derive(Derivative)]
+#[derivative(Clone, Copy)]
+struct OurOur2(Liar);
+
+#[test]
+fn main() {
+    let _ = TheirTheir(Liar).clone();
+    assert!(!CLONED.load(Ordering::SeqCst), "TheirTheir");
+
+    let _ = OurOur1(Liar).clone();
+    assert!(!CLONED.load(Ordering::SeqCst), "OurOur1");
+    let _ = OurOur2(Liar).clone();
+    assert!(!CLONED.load(Ordering::SeqCst), "OurOur2");
+}
diff --git a/vendor/derivative/tests/rustc-deriving-default-box.rs b/vendor/derivative/tests/rustc-deriving-default-box.rs
new file mode 100644
index 000000000..adcdd9261
--- /dev/null
+++ b/vendor/derivative/tests/rustc-deriving-default-box.rs
@@ -0,0 +1,30 @@
+// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+use std::default::Default;
+
+#[derive(Derivative)]
+#[derivative(Default)]
+struct A {
+    foo: Box<[bool]>,
+}
+
+#[test]
+fn main() {
+    let a: A = Default::default();
+    let b: Box<[_]> = Box::<[bool; 0]>::new([]);
+    assert_eq!(a.foo, b);
+}
diff --git a/vendor/derivative/tests/rustc-deriving-enum-single-variant.rs b/vendor/derivative/tests/rustc-deriving-enum-single-variant.rs
new file mode 100644
index 000000000..70b647c88
--- /dev/null
+++ b/vendor/derivative/tests/rustc-deriving-enum-single-variant.rs
@@ -0,0 +1,30 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// pretty-expanded FIXME #23616
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+pub type TaskId = isize;
+
+#[derive(Derivative)]
+#[derivative(PartialEq="feature_allow_slow_enum")]
+pub enum Task {
+    TaskHandle(TaskId)
+}
+
+#[test]
+fn main() {
+    let _ = Task::TaskHandle(42);
+}
diff --git a/vendor/derivative/tests/rustc-deriving-hash.rs b/vendor/derivative/tests/rustc-deriving-hash.rs
new file mode 100644
index 000000000..bae6e8c8e
--- /dev/null
+++ b/vendor/derivative/tests/rustc-deriving-hash.rs
@@ -0,0 +1,83 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![allow(non_camel_case_types)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+use std::hash::{Hash, Hasher};
+use std::collections::hash_map::DefaultHasher;
+
+#[derive(Derivative)]
+#[derivative(Hash)]
+struct Person {
+    id: u16,
+    name: String,
+    phone: u64,
+}
+
+// test for hygiene name collisions
+#[derive(Derivative)]
+#[derivative(Hash)] struct __H__H;
+#[derive(Derivative)]
+#[allow(dead_code)] #[derivative(Hash)] struct Collision<__H> ( __H );
+// TODO(rustc) #[derivative(Hash)] enum Collision<__H> { __H { __H__H: __H } }
+
+#[derive(Derivative)]
+#[derivative(Hash)]
+enum E { A=1, B }
+
+fn hash<T: Hash>(t: &T) -> u64 {
+    let mut s = DefaultHasher::new();
+    t.hash(&mut s);
+    s.finish()
+}
+
+struct FakeHasher<'a>(&'a mut Vec<u8>);
+impl<'a> Hasher for FakeHasher<'a> {
+    fn finish(&self) -> u64 {
+        unimplemented!()
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.0.extend(bytes);
+    }
+}
+
+fn fake_hash(v: &mut Vec<u8>, e: E) {
+    e.hash(&mut FakeHasher(v));
+}
+
+#[test]
+fn main() {
+    let person1 = Person {
+        id: 5,
+        name: "Janet".to_string(),
+        phone: 555_666_777,
+    };
+    let person2 = Person {
+        id: 5,
+        name: "Bob".to_string(),
+        phone: 555_666_777,
+    };
+    assert_eq!(hash(&person1), hash(&person1));
+    assert!(hash(&person1) != hash(&person2));
+
+    // test #21714
+    let mut va = vec![];
+    let mut vb = vec![];
+    fake_hash(&mut va, E::A);
+    fake_hash(&mut vb, E::B);
+    assert!(va != vb);
+}
diff --git a/vendor/derivative/tests/rustc-deriving-in-fn.rs b/vendor/derivative/tests/rustc-deriving-in-fn.rs
new file mode 100644
index 000000000..7d38e749d
--- /dev/null
+++ b/vendor/derivative/tests/rustc-deriving-in-fn.rs
@@ -0,0 +1,27 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[test]
+fn main() {
+    #[derive(Derivative)]
+    #[derivative(Debug)]
+    struct Foo {
+        foo: isize,
+    }
+
+    let f = Foo { foo: 10 };
+    format!("{:?}", f);
+}
diff --git a/vendor/derivative/tests/rustc-deriving-meta-multiple.rs b/vendor/derivative/tests/rustc-deriving-meta-multiple.rs
new file mode 100644
index 000000000..beb41d696
--- /dev/null
+++ b/vendor/derivative/tests/rustc-deriving-meta-multiple.rs
@@ -0,0 +1,42 @@
+// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// pretty-expanded FIXME #23616
+
+#![allow(clippy::eq_op, clippy::redundant_clone)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+use std::hash::Hash;
+
+// testing multiple separate deriving attributes
+#[derive(Derivative)]
+#[derivative(PartialEq)]
+#[derivative(Clone)]
+#[derivative(Hash)]
+struct Foo {
+    bar: usize,
+    baz: isize
+}
+
+fn hash<T: Hash>(_t: &T) {}
+
+#[test]
+fn main() {
+    let a = Foo {bar: 4, baz: -3};
+
+    let _ = a == a;    // check for PartialEq impl w/o testing its correctness
+    let _ = a.clone(); // check for Clone impl w/o testing its correctness
+    hash(&a);  // check for Hash impl w/o testing its correctness
+}
diff --git a/vendor/derivative/tests/rustc-deriving-meta.rs b/vendor/derivative/tests/rustc-deriving-meta.rs
new file mode 100644
index 000000000..9281e3e05
--- /dev/null
+++ b/vendor/derivative/tests/rustc-deriving-meta.rs
@@ -0,0 +1,39 @@
+// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// pretty-expanded FIXME #23616
+
+#![allow(clippy::eq_op, clippy::redundant_clone)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+use std::hash::Hash;
+
+#[derive(Derivative)]
+#[derivative(PartialEq, Clone, Hash)]
+struct Foo {
+    bar: usize,
+    baz: isize
+}
+
+fn hash<T: Hash>(_t: &T) {}
+
+#[test]
+fn main() {
+    let a = Foo {bar: 4, baz: -3};
+
+    let _ = a == a;    // check for PartialEq impl w/o testing its correctness
+    let _ = a.clone(); // check for Clone impl w/o testing its correctness
+    hash(&a);  // check for Hash impl w/o testing its correctness
+}
diff --git a/vendor/derivative/tests/rustc-deriving-show-2.rs b/vendor/derivative/tests/rustc-deriving-show-2.rs
new file mode 100644
index 000000000..f4c173cb4
--- /dev/null
+++ b/vendor/derivative/tests/rustc-deriving-show-2.rs
@@ -0,0 +1,75 @@
+#![allow(dead_code)]
+#![deny(unused_variables)] // We used to generate warning: unused variable: `f`
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+use std::fmt;
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+enum A {}
+#[derive(Derivative)]
+#[derivative(Debug)]
+enum B { V1, V2, V3 }
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+enum C { V1(isize), V2(B), V3(String) }
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+enum D { V1{ a: isize } }
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct E;
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct F(isize);
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct G(isize, isize);
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct H { a: isize }
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct I { a: isize, b: isize }
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct J(Custom);
+
+struct Custom;
+impl fmt::Debug for Custom {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "yay")
+    }
+}
+
+trait ToDebug {
+    fn to_show(&self) -> String;
+}
+
+impl<T: fmt::Debug> ToDebug for T {
+    fn to_show(&self) -> String {
+        format!("{:?}", self)
+    }
+}
+
+#[test]
+fn main() {
+    assert_eq!(B::V1.to_show(), "V1".to_string());
+    assert_eq!(B::V2.to_show(), "V2".to_string());
+    assert_eq!(C::V1(3).to_show(), "V1(3)".to_string());
+    assert_eq!(C::V2(B::V2).to_show(), "V2(V2)".to_string());
+    assert_eq!(D::V1{ a: 2 }.to_show(), "V1 { a: 2 }".to_string());
+    assert_eq!(E.to_show(), "E".to_string());
+    assert_eq!(F(3).to_show(), "F(3)".to_string());
+    assert_eq!(G(3, 4).to_show(), "G(3, 4)".to_string());
+    assert_eq!(I{ a: 2, b: 4 }.to_show(), "I { a: 2, b: 4 }".to_string());
+    assert_eq!(J(Custom).to_show(), "J(yay)".to_string());
+}
diff --git a/vendor/derivative/tests/rustc-deriving-show.rs b/vendor/derivative/tests/rustc-deriving-show.rs
new file mode 100644
index 000000000..525d6020e
--- /dev/null
+++ b/vendor/derivative/tests/rustc-deriving-show.rs
@@ -0,0 +1,51 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct Unit;
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct Tuple(isize, usize);
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct Struct { x: isize, y: usize }
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+enum Enum {
+    Nullary,
+    Variant(isize, usize),
+    StructVariant { x: isize, y : usize }
+}
+
+macro_rules! t {
+    ($x:expr, $expected:expr) => {
+        assert_eq!(format!("{:?}", $x), $expected.to_string())
+    }
+}
+
+#[test]
+fn main() {
+    t!(Unit, "Unit");
+    t!(Tuple(1, 2), "Tuple(1, 2)");
+    t!(Struct { x: 1, y: 2 }, "Struct { x: 1, y: 2 }");
+    t!(Enum::Nullary, "Nullary");
+    t!(Enum::Variant(1, 2), "Variant(1, 2)");
+    t!(Enum::StructVariant { x: 1, y: 2 }, "StructVariant { x: 1, y: 2 }");
+}
diff --git a/vendor/derivative/tests/rustc-deriving-via-extension-hash-enum.rs b/vendor/derivative/tests/rustc-deriving-via-extension-hash-enum.rs
new file mode 100644
index 000000000..c5348587d
--- /dev/null
+++ b/vendor/derivative/tests/rustc-deriving-via-extension-hash-enum.rs
@@ -0,0 +1,36 @@
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Hash)]
+#[allow(dead_code)]
+enum Foo {
+    Bar(isize, char),
+    Baz(char, isize)
+}
+
+#[derive(Derivative)]
+#[derivative(Hash)]
+#[allow(dead_code)]
+enum A {
+    B,
+    C,
+    D,
+    E
+}
+
+#[test]
+fn main(){}
diff --git a/vendor/derivative/tests/rustc-deriving-via-extension-hash-struct.rs b/vendor/derivative/tests/rustc-deriving-via-extension-hash-struct.rs
new file mode 100644
index 000000000..c653154c5
--- /dev/null
+++ b/vendor/derivative/tests/rustc-deriving-via-extension-hash-struct.rs
@@ -0,0 +1,34 @@
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// pretty-expanded FIXME #23616
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+use std::collections::hash_map::DefaultHasher;
+
+#[derive(Derivative)]
+#[derivative(Hash)]
+struct Foo {
+    x: isize,
+    y: isize,
+    z: isize
+}
+
+#[test]
+fn main() {
+    use std::hash::Hash;
+    let mut hasher = DefaultHasher::new();
+    Foo { x: 0, y: 0, z: 0 }.hash(&mut hasher);
+}
diff --git a/vendor/derivative/tests/rustc-deriving-via-extension-type-params.rs b/vendor/derivative/tests/rustc-deriving-via-extension-type-params.rs
new file mode 100644
index 000000000..9fb62ce1c
--- /dev/null
+++ b/vendor/derivative/tests/rustc-deriving-via-extension-type-params.rs
@@ -0,0 +1,33 @@
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(PartialEq, Hash, Debug)]
+struct Foo<T> {
+    x: isize,
+    y: T,
+    z: isize
+}
+
+#[test]
+fn main() {
+    let a = Foo { x: 1, y: 2.0f64, z: 3 };
+    let b = Foo { x: 1, y: 2.0f64, z: 3 };
+    assert_eq!(a, b);
+    assert!(!(a != b));
+    assert!(a.eq(&b));
+    assert!(!a.ne(&b));
+}
diff --git a/vendor/derivative/tests/rustc-expr-copy.rs b/vendor/derivative/tests/rustc-expr-copy.rs
new file mode 100644
index 000000000..ab3ae912e
--- /dev/null
+++ b/vendor/derivative/tests/rustc-expr-copy.rs
@@ -0,0 +1,35 @@
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+
+fn f(arg: &mut A) {
+    arg.a = 100;
+}
+
+#[derive(Derivative)]
+#[derivative(Copy, Clone)]
+struct A { a: isize }
+
+#[test]
+fn main() {
+    let mut x = A {a: 10};
+    f(&mut x);
+    assert_eq!(x.a, 100);
+    x.a = 20;
+    let mut y = x;
+    f(&mut y);
+    assert_eq!(x.a, 20);
+}
diff --git a/vendor/derivative/tests/rustc-exterior.rs b/vendor/derivative/tests/rustc-exterior.rs
new file mode 100644
index 000000000..ec59daa0e
--- /dev/null
+++ b/vendor/derivative/tests/rustc-exterior.rs
@@ -0,0 +1,41 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+use std::cell::Cell;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Copy, Clone)]
+struct Point {x: isize, y: isize, z: isize}
+
+fn f(p: &Cell<Point>) {
+    assert_eq!(p.get().z, 12);
+    p.set(Point {x: 10, y: 11, z: 13});
+    assert_eq!(p.get().z, 13);
+}
+
+#[test]
+fn main() {
+    let a: Point = Point {x: 10, y: 11, z: 12};
+    let b: &Cell<Point> = &Cell::new(a);
+    assert_eq!(b.get().z, 12);
+    f(b);
+    assert_eq!(a.x, 10);
+    assert_eq!(a.y, 11);
+    assert_eq!(a.z, 12);
+    assert_eq!(b.get().x, 10);
+    assert_eq!(b.get().y, 11);
+    assert_eq!(b.get().z, 13);
+}
diff --git a/vendor/derivative/tests/rustc-issue-12860.rs b/vendor/derivative/tests/rustc-issue-12860.rs
new file mode 100644
index 000000000..b4d878ce2
--- /dev/null
+++ b/vendor/derivative/tests/rustc-issue-12860.rs
@@ -0,0 +1,69 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![allow(clippy::derive_hash_xor_eq)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+use std::collections::HashSet;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Hash)]
+#[derive(Copy, Clone, PartialEq, Eq)]
+struct XYZ {
+    x: isize,
+    y: isize,
+    z: isize
+}
+
+#[test]
+fn main() {
+    let mut connected = HashSet::new();
+    let mut border = HashSet::new();
+
+    let middle = XYZ{x: 0, y: 0, z: 0};
+    border.insert(middle);
+
+    while !border.is_empty() && connected.len() < 10000 {
+        let choice = *(border.iter().next().unwrap());
+        border.remove(&choice);
+        connected.insert(choice);
+
+        let cxp = XYZ{x: choice.x + 1, y: choice.y, z: choice.z};
+        let cxm = XYZ{x: choice.x - 1, y: choice.y, z: choice.z};
+        let cyp = XYZ{x: choice.x, y: choice.y + 1, z: choice.z};
+        let cym = XYZ{x: choice.x, y: choice.y - 1, z: choice.z};
+        let czp = XYZ{x: choice.x, y: choice.y, z: choice.z + 1};
+        let czm = XYZ{x: choice.x, y: choice.y, z: choice.z - 1};
+
+        if !connected.contains(&cxp) {
+            border.insert(cxp);
+        }
+        if  !connected.contains(&cxm){
+            border.insert(cxm);
+        }
+        if !connected.contains(&cyp){
+            border.insert(cyp);
+        }
+        if !connected.contains(&cym) {
+            border.insert(cym);
+        }
+        if !connected.contains(&czp){
+            border.insert(czp);
+        }
+        if !connected.contains(&czm) {
+            border.insert(czm);
+        }
+    }
+}
diff --git a/vendor/derivative/tests/rustc-issue-13434.rs b/vendor/derivative/tests/rustc-issue-13434.rs
new file mode 100644
index 000000000..f2ccab5e8
--- /dev/null
+++ b/vendor/derivative/tests/rustc-issue-13434.rs
@@ -0,0 +1,38 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct MyStruct;
+
+trait Repro {
+  fn repro(self, s: MyStruct) -> String;
+}
+
+impl<F> Repro for F where F: FnOnce(MyStruct) -> String {
+  fn repro(self, s: MyStruct) -> String {
+    self(s)
+  }
+}
+
+fn do_stuff<R: Repro>(r: R) -> String {
+  r.repro(MyStruct)
+}
+
+#[test]
+fn main() {
+  assert_eq!("MyStruct".to_string(), do_stuff(|s: MyStruct| format!("{:?}", s)));
+}
diff --git a/vendor/derivative/tests/rustc-issue-16530.rs b/vendor/derivative/tests/rustc-issue-16530.rs
new file mode 100644
index 000000000..3cf55c671
--- /dev/null
+++ b/vendor/derivative/tests/rustc-issue-16530.rs
@@ -0,0 +1,32 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![allow(deprecated)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+use std::hash::{SipHasher, Hasher, Hash};
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Hash)]
+struct Empty;
+
+#[test]
+fn main() {
+    let mut s1 = SipHasher::new_with_keys(0, 0);
+    Empty.hash(&mut s1);
+    let mut s2 = SipHasher::new_with_keys(0, 0);
+    Empty.hash(&mut s2);
+    assert_eq!(s1.finish(), s2.finish());
+}
diff --git a/vendor/derivative/tests/rustc-issue-19037.rs b/vendor/derivative/tests/rustc-issue-19037.rs
new file mode 100644
index 000000000..06f461ab1
--- /dev/null
+++ b/vendor/derivative/tests/rustc-issue-19037.rs
@@ -0,0 +1,38 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// pretty-expanded FIXME #23616
+
+#![allow(dead_code)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+struct Str([u8]);
+
+#[derive(Derivative)]
+#[derivative(Clone)]
+struct CharSplits<'a, Sep> {
+    string: &'a Str,
+    sep: Sep,
+    allow_trailing_empty: bool,
+    only_ascii: bool,
+    finished: bool,
+}
+
+fn clone(s: &Str) -> &Str {
+    Clone::clone(&s)
+}
+
+#[test]
+fn main() {}
diff --git a/vendor/derivative/tests/rustc-issue-19102.rs b/vendor/derivative/tests/rustc-issue-19102.rs
new file mode 100644
index 000000000..8530b843a
--- /dev/null
+++ b/vendor/derivative/tests/rustc-issue-19102.rs
@@ -0,0 +1,26 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![deny(unused_qualifications)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(PartialEq="feature_allow_slow_enum")]
+pub enum A {
+    B,
+}
+
+#[test]
+fn main() {}
diff --git a/vendor/derivative/tests/rustc-issue-19135.rs b/vendor/derivative/tests/rustc-issue-19135.rs
new file mode 100644
index 000000000..a73625c97
--- /dev/null
+++ b/vendor/derivative/tests/rustc-issue-19135.rs
@@ -0,0 +1,30 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+use std::marker::PhantomData;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct LifetimeStruct<'a>(PhantomData<&'a ()>);
+
+#[test]
+fn main() {
+    takes_hrtb_closure(|lts| println!("{:?}", lts));
+}
+
+fn takes_hrtb_closure<F: for<'a>FnMut(LifetimeStruct<'a>)>(mut f: F) {
+    f(LifetimeStruct(PhantomData));
+}
diff --git a/vendor/derivative/tests/rustc-issue-19358.rs b/vendor/derivative/tests/rustc-issue-19358.rs
new file mode 100644
index 000000000..6f528adfe
--- /dev/null
+++ b/vendor/derivative/tests/rustc-issue-19358.rs
@@ -0,0 +1,38 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+trait Trait { fn dummy(&self) { } }
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct Foo<T: Trait> {
+    foo: T,
+}
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct Bar<T> where T: Trait {
+    bar: T,
+}
+
+impl Trait for isize {}
+
+#[test]
+fn main() {
+    let a = Foo { foo: 12 };
+    let b = Bar { bar: 12 };
+    println!("{:?} {:?}", a, b);
+}
diff --git a/vendor/derivative/tests/rustc-issue-21402.rs b/vendor/derivative/tests/rustc-issue-21402.rs
new file mode 100644
index 000000000..6e951178d
--- /dev/null
+++ b/vendor/derivative/tests/rustc-issue-21402.rs
@@ -0,0 +1,29 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// pretty-expanded FIXME #23616
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Hash)]
+#[allow(dead_code)]
+struct Foo {
+    a: Vec<bool>,
+    b: (bool, bool),
+    c: [bool; 2],
+}
+
+#[test]
+fn main() {}
diff --git a/vendor/derivative/tests/rustc-issue-23649-3.rs b/vendor/derivative/tests/rustc-issue-23649-3.rs
new file mode 100644
index 000000000..1437fe1e1
--- /dev/null
+++ b/vendor/derivative/tests/rustc-issue-23649-3.rs
@@ -0,0 +1,23 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[allow(dead_code)]
+#[derive(Derivative)]
+#[derivative(PartialEq)]
+struct Slice { slice: [u8] }
+
+#[test]
+fn main() {}
diff --git a/vendor/derivative/tests/rustc-issue-24085.rs b/vendor/derivative/tests/rustc-issue-24085.rs
new file mode 100644
index 000000000..d3db02615
--- /dev/null
+++ b/vendor/derivative/tests/rustc-issue-24085.rs
@@ -0,0 +1,38 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Regression test for #24085. Errors were occurring in region
+// inference due to the requirement that `'a:b'`, which was getting
+// incorrectly translated in connection with the closure below.
+
+#![allow(clippy::redundant_closure)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Copy,Clone)]
+#[allow(dead_code)]
+struct Path<'a:'b, 'b> {
+    x: &'a i32,
+    tail: Option<&'b Path<'a, 'b>>
+}
+
+#[allow(dead_code, unconditional_recursion)]
+fn foo<'a,'b,F>(p: Path<'a, 'b>, mut f: F)
+                where F: for<'c> FnMut(Path<'a, 'c>) {
+    foo(p, |x| f(x))
+}
+
+#[test]
+fn main() { }
diff --git a/vendor/derivative/tests/rustc-issue-25394.rs b/vendor/derivative/tests/rustc-issue-25394.rs
new file mode 100644
index 000000000..7f75ef993
--- /dev/null
+++ b/vendor/derivative/tests/rustc-issue-25394.rs
@@ -0,0 +1,26 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct Row<T>([T]);
+
+fn use_row(_: &Row<u8>) {}
+
+#[test]
+fn main() {
+    let _ = use_row;
+}
diff --git a/vendor/derivative/tests/rustc-issue-28561.rs b/vendor/derivative/tests/rustc-issue-28561.rs
new file mode 100644
index 000000000..4476646fa
--- /dev/null
+++ b/vendor/derivative/tests/rustc-issue-28561.rs
@@ -0,0 +1,136 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![allow(clippy::zero_prefixed_literal, clippy::type_complexity)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Debug, Default, Eq, Hash, PartialEq)]
+// TODO: Ord, PartialOrd
+struct Array<T> {
+    f00: [T; 00],
+    f01: [T; 01],
+    f02: [T; 02],
+    f03: [T; 03],
+    f04: [T; 04],
+    f05: [T; 05],
+    f06: [T; 06],
+    f07: [T; 07],
+    f08: [T; 08],
+    f09: [T; 09],
+    f10: [T; 10],
+    f11: [T; 11],
+    f12: [T; 12],
+    f13: [T; 13],
+    f14: [T; 14],
+    f15: [T; 15],
+    f16: [T; 16],
+    f17: [T; 17],
+    f18: [T; 18],
+    f19: [T; 19],
+    f20: [T; 20],
+    f21: [T; 21],
+    f22: [T; 22],
+    f23: [T; 23],
+    f24: [T; 24],
+    f25: [T; 25],
+    f26: [T; 26],
+    f27: [T; 27],
+    f28: [T; 28],
+    f29: [T; 29],
+    f30: [T; 30],
+    f31: [T; 31],
+    f32: [T; 32],
+}
+
+// FIXME(#7622): merge with `Array` once `[T; N]: Clone` where `T: Clone`
+#[derive(Derivative)]
+#[derivative(Clone, Copy)]
+struct CopyArray<T: Copy> {
+    f00: [T; 00],
+    f01: [T; 01],
+    f02: [T; 02],
+    f03: [T; 03],
+    f04: [T; 04],
+    f05: [T; 05],
+    f06: [T; 06],
+    f07: [T; 07],
+    f08: [T; 08],
+    f09: [T; 09],
+    f10: [T; 10],
+    f11: [T; 11],
+    f12: [T; 12],
+    f13: [T; 13],
+    f14: [T; 14],
+    f15: [T; 15],
+    f16: [T; 16],
+    f17: [T; 17],
+    f18: [T; 18],
+    f19: [T; 19],
+    f20: [T; 20],
+    f21: [T; 21],
+    f22: [T; 22],
+    f23: [T; 23],
+    f24: [T; 24],
+    f25: [T; 25],
+    f26: [T; 26],
+    f27: [T; 27],
+    f28: [T; 28],
+    f29: [T; 29],
+    f30: [T; 30],
+    f31: [T; 31],
+    f32: [T; 32],
+}
+
+#[derive(Derivative)]
+#[derivative(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+// TODO: Ord, PartialOrd
+struct Fn<A, B, C, D, E, F, G, H, I, J, K, L> {
+    f00: fn(),
+    f01: fn(A),
+    f02: fn(A, B),
+    f03: fn(A, B, C),
+    f04: fn(A, B, C, D),
+    f05: fn(A, B, C, D, E),
+    f06: fn(A, B, C, D, E, F),
+    f07: fn(A, B, C, D, E, F, G),
+    f08: fn(A, B, C, D, E, F, G, H),
+    f09: fn(A, B, C, D, E, F, G, H, I),
+    f10: fn(A, B, C, D, E, F, G, H, I, J),
+    f11: fn(A, B, C, D, E, F, G, H, I, J, K),
+    f12: fn(A, B, C, D, E, F, G, H, I, J, K, L),
+}
+
+#[derive(Derivative)]
+#[derivative(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
+// TODO: Ord, PartialOrd
+struct Tuple<A, B, C, D, E, F, G, H, I, J, K, L> {
+    f00: (),
+    f01: (A,),
+    f02: (A, B),
+    f03: (A, B, C),
+    f04: (A, B, C, D),
+    f05: (A, B, C, D, E),
+    f06: (A, B, C, D, E, F),
+    f07: (A, B, C, D, E, F, G),
+    f08: (A, B, C, D, E, F, G, H),
+    f09: (A, B, C, D, E, F, G, H, I),
+    f10: (A, B, C, D, E, F, G, H, I, J),
+    f11: (A, B, C, D, E, F, G, H, I, J, K),
+    f12: (A, B, C, D, E, F, G, H, I, J, K, L),
+}
+
+#[test]
+fn main() {}
diff --git a/vendor/derivative/tests/rustc-issue-29030.rs b/vendor/derivative/tests/rustc-issue-29030.rs
new file mode 100644
index 000000000..c893ece7d
--- /dev/null
+++ b/vendor/derivative/tests/rustc-issue-29030.rs
@@ -0,0 +1,30 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct Message<'a, P: 'a = &'a [u8]> {
+    header: &'a [u8],
+    payload: P,
+}
+
+#[test]
+fn main() {
+    let _ = Message {
+        header: &[1],
+        payload: &[1],
+    };
+}
diff --git a/vendor/derivative/tests/rustc-issue-29540.rs b/vendor/derivative/tests/rustc-issue-29540.rs
new file mode 100644
index 000000000..3b1fcf74d
--- /dev/null
+++ b/vendor/derivative/tests/rustc-issue-29540.rs
@@ -0,0 +1,509 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub struct Config {
+    pub name: String,
+    pub cluster: String,
+    pub debug_none: String,
+    pub debug_lockdep: String,
+    pub debug_context: String,
+    pub debug_crush: String,
+    pub debug_mds: String,
+    pub debug_mds_balancer: String,
+    pub debug_mds_locker: String,
+    pub debug_mds_log: String,
+    pub debug_mds_log_expire: String,
+    pub debug_mds_migrator: String,
+    pub debug_buffer: String,
+    pub debug_timer: String,
+    pub debug_filer: String,
+    pub debug_striper: String,
+    pub debug_objecter: String,
+    pub debug_rados: String,
+    pub debug_rbd: String,
+    pub debug_journaler: String,
+    pub debug_objectcacher: String,
+    pub debug_client: String,
+    pub debug_osd: String,
+    pub debug_optracker: String,
+    pub debug_objclass: String,
+    pub debug_filestore: String,
+    pub debug_keyvaluestore: String,
+    pub debug_journal: String,
+    pub debug_ms: String,
+    pub debug_mon: String,
+    pub debug_monc: String,
+    pub debug_paxos: String,
+    pub debug_tp: String,
+    pub debug_auth: String,
+    pub debug_crypto: String,
+    pub debug_finisher: String,
+    pub debug_heartbeatmap: String,
+    pub debug_perfcounter: String,
+    pub debug_rgw: String,
+    pub debug_civetweb: String,
+    pub debug_javaclient: String,
+    pub debug_asok: String,
+    pub debug_throttle: String,
+    pub host: String,
+    pub fsid: String,
+    pub public_addr: String,
+    pub cluster_addr: String,
+    pub public_network: String,
+    pub cluster_network: String,
+    pub num_client: String,
+    pub monmap: String,
+    pub mon_host: String,
+    pub lockdep: String,
+    pub run_dir: String,
+    pub admin_socket: String,
+    pub daemonize: String,
+    pub pid_file: String,
+    pub chdir: String,
+    pub max_open_files: String,
+    pub restapi_log_level: String,
+    pub restapi_base_url: String,
+    pub fatal_signal_handlers: String,
+    pub log_file: String,
+    pub log_max_new: String,
+    pub log_max_recent: String,
+    pub log_to_stderr: String,
+    pub err_to_stderr: String,
+    pub log_to_syslog: String,
+    pub err_to_syslog: String,
+    pub log_flush_on_exit: String,
+    pub log_stop_at_utilization: String,
+    pub clog_to_monitors: String,
+    pub clog_to_syslog: String,
+    pub clog_to_syslog_level: String,
+    pub clog_to_syslog_facility: String,
+    pub mon_cluster_log_to_syslog: String,
+    pub mon_cluster_log_to_syslog_level: String,
+    pub mon_cluster_log_to_syslog_facility: String,
+    pub mon_cluster_log_file: String,
+    pub mon_cluster_log_file_level: String,
+    pub key: String,
+    pub keyfile: String,
+    pub keyring: String,
+    pub heartbeat_interval: String,
+    pub heartbeat_file: String,
+    pub heartbeat_inject_failure: String,
+    pub perf: String,
+    pub ms_tcp_nodelay: String,
+    pub ms_tcp_rcvbuf: String,
+    pub ms_initial_backoff: String,
+    pub ms_max_backoff: String,
+    pub ms_nocrc: String,
+    pub ms_die_on_bad_msg: String,
+    pub ms_die_on_unhandled_msg: String,
+    pub ms_die_on_old_message: String,
+    pub ms_dispatch_throttle_bytes: String,
+    pub ms_bind_ipv6: String,
+    pub ms_bind_port_min: String,
+    pub ms_bind_port_max: String,
+    pub ms_rwthread_stack_bytes: String,
+    pub ms_tcp_read_timeout: String,
+    pub ms_pq_max_tokens_per_priority: String,
+    pub ms_pq_min_cost: String,
+    pub ms_inject_socket_failures: String,
+    pub ms_inject_delay_type: String,
+    pub ms_inject_delay_msg_type: String,
+    pub ms_inject_delay_max: String,
+    pub ms_inject_delay_probability: String,
+    pub ms_inject_internal_delays: String,
+    pub ms_dump_on_send: String,
+    pub inject_early_sigterm: String,
+    pub mon_data: String,
+    pub mon_initial_members: String,
+    pub mon_sync_fs_threshold: String,
+    pub mon_compact_on_start: String,
+    pub mon_compact_on_bootstrap: String,
+    pub mon_compact_on_trim: String,
+    pub mon_tick_interval: String,
+    pub mon_subscribe_interval: String,
+    pub mon_delta_reset_interval: String,
+    pub mon_osd_laggy_halflife: String,
+    pub mon_osd_laggy_weight: String,
+    pub mon_osd_adjust_heartbeat_grace: String,
+    pub mon_osd_adjust_down_out_interval: String,
+    pub mon_osd_auto_mark_in: String,
+    pub mon_osd_auto_mark_auto_out_in: String,
+    pub mon_osd_auto_mark_new_in: String,
+    pub mon_osd_down_out_interval: String,
+    pub mon_osd_down_out_subtree_limit: String,
+    pub mon_osd_min_up_ratio: String,
+    pub mon_osd_min_in_ratio: String,
+    pub mon_osd_max_op_age: String,
+    pub mon_osd_max_split_count: String,
+    pub mon_osd_allow_primary_temp: String,
+    pub mon_osd_allow_primary_affinity: String,
+    pub mon_stat_smooth_intervals: String,
+    pub mon_lease: String,
+    pub mon_lease_renew_interval: String,
+    pub mon_lease_ack_timeout: String,
+    pub mon_clock_drift_allowed: String,
+    pub mon_clock_drift_warn_backoff: String,
+    pub mon_timecheck_interval: String,
+    pub mon_accept_timeout: String,
+    pub mon_pg_create_interval: String,
+    pub mon_pg_stuck_threshold: String,
+    pub mon_pg_warn_min_per_osd: String,
+    pub mon_pg_warn_max_object_skew: String,
+    pub mon_pg_warn_min_objects: String,
+    pub mon_pg_warn_min_pool_objects: String,
+    pub mon_cache_target_full_warn_ratio: String,
+    pub mon_osd_full_ratio: String,
+    pub mon_osd_nearfull_ratio: String,
+    pub mon_globalid_prealloc: String,
+    pub mon_osd_report_timeout: String,
+    pub mon_force_standby_active: String,
+    pub mon_warn_on_old_mons: String,
+    pub mon_warn_on_legacy_crush_tunables: String,
+    pub mon_warn_on_osd_down_out_interval_zero: String,
+    pub mon_warn_on_cache_pools_without_hit_sets: String,
+    pub mon_min_osdmap_epochs: String,
+    pub mon_max_pgmap_epochs: String,
+    pub mon_max_log_epochs: String,
+    pub mon_max_mdsmap_epochs: String,
+    pub mon_max_osd: String,
+    pub mon_probe_timeout: String,
+    pub mon_slurp_timeout: String,
+    pub mon_slurp_bytes: String,
+    pub mon_client_bytes: String,
+    pub mon_daemon_bytes: String,
+    pub mon_max_log_entries_per_event: String,
+    pub mon_health_data_update_interval: String,
+    pub mon_data_avail_crit: String,
+    pub mon_data_avail_warn: String,
+    pub mon_config_key_max_entry_size: String,
+    pub mon_sync_timeout: String,
+    pub mon_sync_max_payload_size: String,
+    pub mon_sync_debug: String,
+    pub mon_sync_debug_leader: String,
+    pub mon_sync_debug_provider: String,
+    pub mon_sync_debug_provider_fallback: String,
+    pub mon_inject_sync_get_chunk_delay: String,
+    pub mon_osd_min_down_reporters: String,
+    pub mon_osd_min_down_reports: String,
+    pub mon_osd_force_trim_to: String,
+    pub mon_mds_force_trim_to: String,
+    pub mon_advanced_debug_mode: String,
+    pub mon_debug_dump_transactions: String,
+    pub mon_debug_dump_location: String,
+    pub mon_sync_provider_kill_at: String,
+    pub mon_sync_requester_kill_at: String,
+    pub mon_leveldb_write_buffer_size: String,
+    pub mon_leveldb_cache_size: String,
+    pub mon_leveldb_block_size: String,
+    pub mon_leveldb_bloom_size: String,
+    pub mon_leveldb_max_open_files: String,
+    pub mon_leveldb_compression: String,
+    pub mon_leveldb_paranoid: String,
+    pub mon_leveldb_log: String,
+    pub mon_leveldb_size_warn: String,
+    pub mon_force_quorum_join: String,
+    pub paxos_stash_full_interval: String,
+    pub paxos_max_join_drift: String,
+    pub paxos_propose_interval: String,
+    pub paxos_min_wait: String,
+    pub paxos_min: String,
+    pub paxos_trim_min: String,
+    pub paxos_trim_max: String,
+    pub paxos_service_trim_min: String,
+    pub paxos_service_trim_max: String,
+    pub paxos_kill_at: String,
+    pub clock_offset: String,
+    pub auth_cluster_required: String,
+    pub auth_service_required: String,
+    pub auth_client_required: String,
+    pub auth_supported: String,
+    pub cephx_require_signatures: String,
+    pub cephx_cluster_require_signatures: String,
+    pub cephx_service_require_signatures: String,
+    pub cephx_sign_messages: String,
+    pub auth_mon_ticket_ttl: String,
+    pub auth_service_ticket_ttl: String,
+    pub auth_debug: String,
+    pub mon_client_hunt_interval: String,
+    pub mon_client_ping_interval: String,
+    pub mon_client_ping_timeout: String,
+    pub mon_client_hunt_interval_backoff: String,
+    pub mon_client_hunt_interval_max_multiple: String,
+    pub mon_client_max_log_entries_per_message: String,
+    pub mon_max_pool_pg_num: String,
+    pub mon_pool_quota_warn_threshold: String,
+    pub mon_pool_quota_crit_threshold: String,
+    pub client_cache_size: String,
+    pub client_cache_mid: String,
+    pub client_use_random_mds: String,
+    pub client_mount_timeout: String,
+    pub client_tick_interval: String,
+    pub client_trace: String,
+    pub client_readahead_min: String,
+    pub client_readahead_max_bytes: String,
+    pub client_readahead_max_periods: String,
+    pub client_snapdir: String,
+    pub client_mountpoint: String,
+    pub client_notify_timeout: String,
+    pub osd_client_watch_timeout: String,
+    pub client_caps_release_delay: String,
+    pub client_oc: String,
+    pub client_oc_size: String,
+    pub client_oc_max_dirty: String,
+    pub client_oc_target_dirty: String,
+    pub client_oc_max_dirty_age: String,
+    pub client_oc_max_objects: String,
+    pub client_debug_force_sync_read: String,
+    pub client_debug_inject_tick_delay: String,
+    pub client_max_inline_size: String,
+    pub fuse_use_invalidate_cb: String,
+    pub fuse_allow_other: String,
+    pub fuse_default_permissions: String,
+    pub fuse_big_writes: String,
+    pub fuse_atomic_o_trunc: String,
+    pub fuse_debug: String,
+    pub fuse_multithreaded: String,
+    pub crush_location: String,
+    pub objecter_tick_interval: String,
+    pub objecter_timeout: String,
+    pub objecter_inflight_op_bytes: String,
+    pub objecter_inflight_ops: String,
+    pub journaler_allow_split_entries: String,
+    pub journaler_write_head_interval: String,
+    pub journaler_prefetch_periods: String,
+    pub journaler_prezero_periods: String,
+    pub journaler_batch_interval: String,
+    pub journaler_batch_max: String,
+    pub mds_data: String,
+    pub mds_max_file_size: String,
+    pub mds_cache_size: String,
+    pub mds_cache_mid: String,
+    pub mds_mem_max: String,
+    pub mds_dir_max_commit_size: String,
+    pub mds_decay_halflife: String,
+    pub mds_beacon_interval: String,
+    pub mds_beacon_grace: String,
+    pub mds_enforce_unique_name: String,
+    pub mds_blacklist_interval: String,
+    pub mds_session_timeout: String,
+    pub mds_freeze_tree_timeout: String,
+    pub mds_session_autoclose: String,
+    pub mds_reconnect_timeout: String,
+    pub mds_tick_interval: String,
+    pub mds_dirstat_min_interval: String,
+    pub mds_scatter_nudge_interval: String,
+    pub mds_client_prealloc_inos: String,
+    pub mds_early_reply: String,
+    pub mds_default_dir_hash: String,
+    pub mds_log: String,
+    pub mds_log_skip_corrupt_events: String,
+    pub mds_log_max_events: String,
+    pub mds_log_segment_size: String,
+    pub mds_log_max_segments: String,
+    pub mds_log_max_expiring: String,
+    pub mds_bal_sample_interval: String,
+    pub mds_bal_replicate_threshold: String,
+    pub mds_bal_unreplicate_threshold: String,
+    pub mds_bal_frag: String,
+    pub mds_bal_split_size: String,
+    pub mds_bal_split_rd: String,
+    pub mds_bal_split_wr: String,
+    pub mds_bal_split_bits: String,
+    pub mds_bal_merge_size: String,
+    pub mds_bal_merge_rd: String,
+    pub mds_bal_merge_wr: String,
+    pub mds_bal_interval: String,
+    pub mds_bal_fragment_interval: String,
+    pub mds_bal_idle_threshold: String,
+    pub mds_bal_max: String,
+    pub mds_bal_max_until: String,
+    pub mds_bal_mode: String,
+    pub mds_bal_min_rebalance: String,
+    pub mds_bal_min_start: String,
+    pub mds_bal_need_min: String,
+    pub mds_bal_need_max: String,
+    pub mds_bal_midchunk: String,
+    pub mds_bal_minchunk: String,
+    pub mds_bal_target_removal_min: String,
+    pub mds_bal_target_removal_max: String,
+    pub mds_replay_interval: String,
+    pub mds_shutdown_check: String,
+    pub mds_thrash_exports: String,
+    pub mds_thrash_fragments: String,
+    pub mds_dump_cache_on_map: String,
+    pub mds_dump_cache_after_rejoin: String,
+    pub mds_verify_scatter: String,
+    pub mds_debug_scatterstat: String,
+    pub mds_debug_frag: String,
+    pub mds_debug_auth_pins: String,
+    pub mds_debug_subtrees: String,
+    pub mds_kill_mdstable_at: String,
+    pub mds_kill_export_at: String,
+    pub mds_kill_import_at: String,
+    pub mds_kill_link_at: String,
+    pub mds_kill_rename_at: String,
+    pub mds_kill_openc_at: String,
+    pub mds_kill_journal_at: String,
+    pub mds_kill_journal_expire_at: String,
+    pub mds_kill_journal_replay_at: String,
+    pub mds_kill_create_at: String,
+    pub mds_open_remote_link_mode: String,
+    pub mds_inject_traceless_reply_probability: String,
+    pub mds_wipe_sessions: String,
+    pub mds_wipe_ino_prealloc: String,
+    pub mds_skip_ino: String,
+    pub max_mds: String,
+    pub mds_standby_for_name: String,
+    pub mds_standby_for_rank: String,
+    pub mds_standby_replay: String,
+    pub osd_compact_leveldb_on_mount: String,
+    pub osd_max_backfills: String,
+    pub osd_backfill_full_ratio: String,
+    pub osd_backfill_retry_interval: String,
+    pub osd_agent_max_ops: String,
+    pub osd_agent_min_evict_effort: String,
+    pub osd_agent_quantize_effort: String,
+    pub osd_agent_delay_time: String,
+    pub osd_agent_hist_halflife: String,
+    pub osd_agent_slop: String,
+    pub osd_uuid: String,
+    pub osd_data: String,
+    pub osd_journal: String,
+    pub osd_journal_size: String,
+    pub osd_max_write_size: String,
+    pub osd_max_pgls: String,
+    pub osd_client_message_size_cap: String,
+    pub osd_client_message_cap: String,
+    pub osd_pg_bits: String,
+    pub osd_pgp_bits: String,
+    pub osd_crush_chooseleaf_type: String,
+    pub osd_pool_default_crush_rule: String,
+    pub osd_pool_default_crush_replicated_ruleset: String,
+    pub osd_pool_erasure_code_stripe_width: String,
+    pub osd_pool_default_size: String,
+    pub osd_pool_default_min_size: String,
+    pub osd_pool_default_pg_num: String,
+    pub osd_pool_default_pgp_num: String,
+    pub osd_pool_default_erasure_code_directory: String,
+    pub osd_pool_default_erasure_code_profile: String,
+    pub osd_erasure_code_plugins: String,
+    pub osd_pool_default_flags: String,
+    pub osd_pool_default_flag_hashpspool: String,
+    pub osd_pool_default_hit_set_bloom_fpp: String,
+    pub osd_pool_default_cache_target_dirty_ratio: String,
+    pub osd_pool_default_cache_target_full_ratio: String,
+    pub osd_pool_default_cache_min_flush_age: String,
+    pub osd_pool_default_cache_min_evict_age: String,
+    pub osd_hit_set_min_size: String,
+    pub osd_hit_set_max_size: String,
+    pub osd_hit_set_namespace: String,
+    pub osd_tier_default_cache_mode: String,
+    pub osd_tier_default_cache_hit_set_count: String,
+    pub osd_tier_default_cache_hit_set_period: String,
+    pub osd_tier_default_cache_hit_set_type: String,
+    pub osd_map_dedup: String,
+    pub osd_map_max_advance: String,
+    pub osd_map_cache_size: String,
+    pub osd_map_message_max: String,
+    pub osd_map_share_max_epochs: String,
+    pub osd_op_threads: String,
+    pub osd_peering_wq_batch_size: String,
+    pub osd_op_pq_max_tokens_per_priority: String,
+    pub osd_op_pq_min_cost: String,
+    pub osd_disk_threads: String,
+    pub osd_disk_thread_ioprio_class: String,
+    pub osd_disk_thread_ioprio_priority: String,
+    pub osd_recovery_threads: String,
+    pub osd_recover_clone_overlap: String,
+    pub osd_recover_clone_overlap_limit: String,
+    pub osd_backfill_scan_min: String,
+    pub osd_backfill_scan_max: String,
+    pub osd_op_thread_timeout: String,
+    pub osd_recovery_thread_timeout: String,
+    pub osd_snap_trim_thread_timeout: String,
+    pub osd_snap_trim_sleep: String,
+    pub osd_scrub_thread_timeout: String,
+    pub osd_scrub_finalize_thread_timeout: String,
+    pub osd_scrub_invalid_stats: String,
+    pub osd_remove_thread_timeout: String,
+    pub osd_command_thread_timeout: String,
+    pub osd_age: String,
+    pub osd_age_time: String,
+    pub osd_heartbeat_addr: String,
+    pub osd_heartbeat_interval: String,
+    pub osd_heartbeat_grace: String,
+    pub osd_heartbeat_min_peers: String,
+    pub osd_pg_max_concurrent_snap_trims: String,
+    pub osd_heartbeat_min_healthy_ratio: String,
+    pub osd_mon_heartbeat_interval: String,
+    pub osd_mon_report_interval_max: String,
+    pub osd_mon_report_interval_min: String,
+    pub osd_pg_stat_report_interval_max: String,
+    pub osd_mon_ack_timeout: String,
+    pub osd_default_data_pool_replay_window: String,
+    pub osd_preserve_trimmed_log: String,
+    pub osd_auto_mark_unfound_lost: String,
+    pub osd_recovery_delay_start: String,
+    pub osd_recovery_max_active: String,
+    pub osd_recovery_max_single_start: String,
+    pub osd_recovery_max_chunk: String,
+    pub osd_copyfrom_max_chunk: String,
+    pub osd_push_per_object_cost: String,
+    pub osd_max_push_cost: String,
+    pub osd_max_push_objects: String,
+    pub osd_recovery_forget_lost_objects: String,
+    pub osd_max_scrubs: String,
+    pub osd_scrub_load_threshold: String,
+    pub osd_scrub_min_interval: String,
+    pub osd_scrub_max_interval: String,
+    pub osd_scrub_chunk_min: String,
+    pub osd_scrub_chunk_max: String,
+    pub osd_scrub_sleep: String,
+    pub osd_deep_scrub_interval: String,
+    pub osd_deep_scrub_stride: String,
+    pub osd_scan_list_ping_tp_interval: String,
+    pub osd_auto_weight: String,
+    pub osd_class_dir: String,
+    pub osd_open_classes_on_start: String,
+    pub osd_check_for_log_corruption: String,
+    pub osd_use_stale_snap: String,
+    pub osd_rollback_to_cluster_snap: String,
+    pub osd_default_notify_timeout: String,
+    pub osd_kill_backfill_at: String,
+    pub osd_pg_epoch_persisted_max_stale: String,
+    pub osd_min_pg_log_entries: String,
+    pub osd_max_pg_log_entries: String,
+    pub osd_op_complaint_time: String,
+    pub osd_command_max_records: String,
+    pub osd_op_log_threshold: String,
+    pub osd_verify_sparse_read_holes: String,
+    pub osd_debug_drop_ping_probability: String,
+    pub osd_debug_drop_ping_duration: String,
+    pub osd_debug_drop_pg_create_probability: String,
+    pub osd_debug_drop_pg_create_duration: String,
+    pub osd_debug_drop_op_probability: String,
+    pub osd_debug_op_order: String,
+    pub osd_debug_verify_snaps_on_info: String,
+    pub osd_debug_verify_stray_on_activate: String,
+    pub osd_debug_skip_full_check_in_backfill_reservation: String,
+    pub osd_debug_reject_backfill_probability: String,
+    pub osd_enable_op_tracker: String,
+}
+
+#[test]
+fn main() {}
diff --git a/vendor/derivative/tests/rustc-issue-29710.rs b/vendor/derivative/tests/rustc-issue-29710.rs
new file mode 100644
index 000000000..d2198ed7a
--- /dev/null
+++ b/vendor/derivative/tests/rustc-issue-29710.rs
@@ -0,0 +1,29 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![deny(unused_results)]
+#![allow(dead_code)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct A(usize);
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct B { a: usize }
+
+#[test]
+fn main() {}
diff --git a/vendor/derivative/tests/rustc-issue-32292.rs b/vendor/derivative/tests/rustc-issue-32292.rs
new file mode 100644
index 000000000..6d4be3838
--- /dev/null
+++ b/vendor/derivative/tests/rustc-issue-32292.rs
@@ -0,0 +1,27 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![deny(warnings)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Hash, Eq, PartialEq, Debug, Clone, Copy)]
+// TODO: Ord, PartialOrd
+struct Foo;
+
+#[test]
+fn main() {
+    let _ = Foo;
+}
diff --git a/vendor/derivative/tests/rustc-issue-3935.rs b/vendor/derivative/tests/rustc-issue-3935.rs
new file mode 100644
index 000000000..a63e6a771
--- /dev/null
+++ b/vendor/derivative/tests/rustc-issue-3935.rs
@@ -0,0 +1,29 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(PartialEq)]
+struct Bike {
+    name: String,
+}
+
+#[test]
+fn main() {
+    let town_bike = Bike { name: "schwinn".to_string() };
+    let my_bike = Bike { name: "surly".to_string() };
+
+    assert!(town_bike != my_bike);
+}
diff --git a/vendor/derivative/tests/rustc-issue-42453.rs b/vendor/derivative/tests/rustc-issue-42453.rs
new file mode 100644
index 000000000..bd349de77
--- /dev/null
+++ b/vendor/derivative/tests/rustc-issue-42453.rs
@@ -0,0 +1,28 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![deny(warnings)]
+
+#![allow(dead_code)]
+#![allow(non_camel_case_types)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct builder;
+
+fn main() {
+
+}
diff --git a/vendor/derivative/tests/rustc-issue-58319.rs b/vendor/derivative/tests/rustc-issue-58319.rs
new file mode 100644
index 000000000..4bb0077da
--- /dev/null
+++ b/vendor/derivative/tests/rustc-issue-58319.rs
@@ -0,0 +1,644 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![deny(warnings)]
+
+#![allow(dead_code)]
+#![allow(non_camel_case_types)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+fn main() {}
+
+#[derive(Derivative)]
+#[derivative(Clone)]
+pub struct Little;
+
+#[derive(Clone)]
+pub struct Big(
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+    Little,
+);
diff --git a/vendor/derivative/tests/rustc-issue-6341.rs b/vendor/derivative/tests/rustc-issue-6341.rs
new file mode 100644
index 000000000..674f1918c
--- /dev/null
+++ b/vendor/derivative/tests/rustc-issue-6341.rs
@@ -0,0 +1,30 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// pretty-expanded FIXME #23616
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+#[derive(Derivative)]
+#[derivative(PartialEq)]
+struct A { x: usize }
+
+impl Drop for A {
+    fn drop(&mut self) {}
+}
+
+#[test]
+fn main() {
+    A { x: 42 };
+}
diff --git a/vendor/derivative/tests/rustc-typeclasses-eq-example.rs b/vendor/derivative/tests/rustc-typeclasses-eq-example.rs
new file mode 100644
index 000000000..4755df5b9
--- /dev/null
+++ b/vendor/derivative/tests/rustc-typeclasses-eq-example.rs
@@ -0,0 +1,83 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![allow(non_snake_case)]
+#![allow(non_camel_case_types)]
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+// Example from lkuper's intern talk, August 2012.
+use Color::{cyan, magenta, yellow, black};
+use ColorTree::{leaf, branch};
+
+trait Equal {
+    fn isEq(&self, a: &Self) -> bool;
+}
+
+#[derive(Derivative)]
+#[derivative(Clone, Copy)]
+enum Color { cyan, magenta, yellow, black }
+
+impl Equal for Color {
+    fn isEq(&self, a: &Color) -> bool {
+        match (*self, *a) {
+          (cyan, cyan)       => { true  }
+          (magenta, magenta) => { true  }
+          (yellow, yellow)   => { true  }
+          (black, black)     => { true  }
+          _                  => { false }
+        }
+    }
+}
+
+#[derive(Derivative)]
+#[derivative(Clone)]
+enum ColorTree {
+    leaf(Color),
+    branch(Box<ColorTree>, Box<ColorTree>)
+}
+
+impl Equal for ColorTree {
+    fn isEq(&self, a: &ColorTree) -> bool {
+        match (self, a) {
+          (&leaf(ref x), &leaf(ref y)) => { x.isEq(&(*y)) }
+          (&branch(ref l1, ref r1), &branch(ref l2, ref r2)) => {
+            (*l1).isEq(&(**l2).clone()) && (*r1).isEq(&(**r2).clone())
+          }
+          _ => { false }
+        }
+    }
+}
+
+#[test]
+fn main() {
+    assert!(cyan.isEq(&cyan));
+    assert!(magenta.isEq(&magenta));
+    assert!(!cyan.isEq(&yellow));
+    assert!(!magenta.isEq(&cyan));
+
+    assert!(leaf(cyan).isEq(&leaf(cyan)));
+    assert!(!leaf(cyan).isEq(&leaf(yellow)));
+
+    assert!(branch(Box::new(leaf(magenta)), Box::new(leaf(cyan)))
+        .isEq(&branch(Box::new(leaf(magenta)), Box::new(leaf(cyan)))));
+
+    assert!(branch(Box::new(leaf(black)), Box::new(leaf(cyan)))
+        .isEq(&branch(Box::new(leaf(black)), Box::new(leaf(cyan)))));
+
+    assert!(!branch(Box::new(leaf(magenta)), Box::new(leaf(cyan)))
+        .isEq(&branch(Box::new(leaf(magenta)), Box::new(leaf(magenta)))));
+
+    println!("Assertions all succeeded!");
+}
diff --git a/vendor/derivative/tests/rustc-zero-sized-btreemap-insert.rs b/vendor/derivative/tests/rustc-zero-sized-btreemap-insert.rs
new file mode 100644
index 000000000..b6329f5d4
--- /dev/null
+++ b/vendor/derivative/tests/rustc-zero-sized-btreemap-insert.rs
@@ -0,0 +1,41 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(feature = "use_core")]
+extern crate core;
+
+#[macro_use]
+extern crate derivative;
+
+use std::collections::BTreeMap;
+use std::iter::Iterator;
+
+#[derive(Derivative)]
+#[derive(Ord, PartialOrd)]
+#[derivative(Eq, Hash, Debug, PartialEq)]
+// TODO: Ord, PartialOrd
+struct Zst;
+
+#[test]
+fn main() {
+    const N: usize = 8;
+
+    for len in 0..N {
+        let mut tester = BTreeMap::new();
+        assert_eq!(tester.len(), 0);
+        for _ in 0..len {
+            tester.insert(Zst, ());
+        }
+        assert_eq!(tester.len(), if len == 0 { 0 } else { 1 });
+        assert_eq!(tester.iter().count(), if len == 0 { 0 } else { 1 });
+        assert_eq!(tester.get(&Zst).is_some(), len > 0);
+        tester.clear();
+    }
+}