Merging upstream version 1.67.1+dfsg1.

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

36 files changed, 4515 insertions, 0 deletions

diff --git a/vendor/derive_more/tests/add.rs b/vendor/derive_more/tests/add.rs
new file mode 100644
index 000000000..f9ec5a77f
--- /dev/null
+++ b/vendor/derive_more/tests/add.rs
@@ -0,0 +1,23 @@
+#![allow(dead_code)]
+#[macro_use]
+extern crate derive_more;
+
+#[derive(Add)]
+struct MyInts(i32, i32);
+
+#[derive(Add)]
+struct Point2D {
+    x: i32,
+    y: i32,
+}
+
+#[derive(Add)]
+enum MixedInts {
+    SmallInt(i32),
+    BigInt(i64),
+    TwoSmallInts(i32, i32),
+    NamedSmallInts { x: i32, y: i32 },
+    UnsignedOne(u32),
+    UnsignedTwo(u32),
+    Unit,
+}
diff --git a/vendor/derive_more/tests/add_assign.rs b/vendor/derive_more/tests/add_assign.rs
new file mode 100644
index 000000000..32681787c
--- /dev/null
+++ b/vendor/derive_more/tests/add_assign.rs
@@ -0,0 +1,12 @@
+#![allow(dead_code)]
+#[macro_use]
+extern crate derive_more;
+
+#[derive(AddAssign)]
+struct MyInts(i32, i32);
+
+#[derive(AddAssign)]
+struct Point2D {
+    x: i32,
+    y: i32,
+}
diff --git a/vendor/derive_more/tests/as_mut.rs b/vendor/derive_more/tests/as_mut.rs
new file mode 100644
index 000000000..e074f8b02
--- /dev/null
+++ b/vendor/derive_more/tests/as_mut.rs
@@ -0,0 +1,108 @@
+#![allow(dead_code)]
+
+#[macro_use]
+extern crate derive_more;
+
+use std::path::PathBuf;
+use std::ptr;
+
+#[derive(AsMut)]
+struct SingleFieldTuple(String);
+
+#[test]
+fn single_field_tuple() {
+    let mut item = SingleFieldTuple(String::from("test"));
+
+    assert!(ptr::eq(&mut item.0, item.as_mut()));
+}
+
+#[derive(AsMut)]
+#[as_mut(forward)]
+struct SingleFieldForward(Vec<i32>);
+
+#[test]
+fn single_field_forward() {
+    let mut item = SingleFieldForward(vec![]);
+    let _: &mut [i32] = (&mut item).as_mut();
+}
+
+#[derive(AsMut)]
+struct SingleFieldStruct {
+    first: String,
+}
+
+#[test]
+fn single_field_struct() {
+    let mut item = SingleFieldStruct {
+        first: String::from("test"),
+    };
+
+    assert!(ptr::eq(&mut item.first, item.as_mut()));
+}
+
+#[derive(AsMut)]
+struct MultiFieldTuple(#[as_mut] String, #[as_mut] PathBuf, Vec<usize>);
+
+#[test]
+fn multi_field_tuple() {
+    let mut item = MultiFieldTuple(String::from("test"), PathBuf::new(), vec![]);
+
+    assert!(ptr::eq(&mut item.0, item.as_mut()));
+    assert!(ptr::eq(&mut item.1, item.as_mut()));
+}
+
+#[derive(AsMut)]
+struct MultiFieldStruct {
+    #[as_mut]
+    first: String,
+    #[as_mut]
+    second: PathBuf,
+    third: Vec<usize>,
+}
+
+#[test]
+fn multi_field_struct() {
+    let mut item = MultiFieldStruct {
+        first: String::from("test"),
+        second: PathBuf::new(),
+        third: vec![],
+    };
+
+    assert!(ptr::eq(&mut item.first, item.as_mut()));
+    assert!(ptr::eq(&mut item.second, item.as_mut()));
+}
+
+#[derive(AsMut)]
+struct SingleFieldGenericStruct<T> {
+    first: T,
+}
+
+#[test]
+fn single_field_generic_struct() {
+    let mut item = SingleFieldGenericStruct {
+        first: String::from("test"),
+    };
+
+    assert!(ptr::eq(&mut item.first, item.as_mut()));
+}
+
+#[derive(AsMut)]
+struct MultiFieldGenericStruct<T> {
+    #[as_mut]
+    first: Vec<T>,
+    #[as_mut]
+    second: PathBuf,
+    third: Vec<usize>,
+}
+
+#[test]
+fn multi_field_generic_struct() {
+    let mut item = MultiFieldGenericStruct {
+        first: b"test".to_vec(),
+        second: PathBuf::new(),
+        third: vec![],
+    };
+
+    assert!(ptr::eq(&mut item.first, item.as_mut()));
+    assert!(ptr::eq(&mut item.second, item.as_mut()));
+}
diff --git a/vendor/derive_more/tests/as_ref.rs b/vendor/derive_more/tests/as_ref.rs
new file mode 100644
index 000000000..1e355d28f
--- /dev/null
+++ b/vendor/derive_more/tests/as_ref.rs
@@ -0,0 +1,108 @@
+#![allow(dead_code)]
+
+#[macro_use]
+extern crate derive_more;
+
+use std::path::PathBuf;
+use std::ptr;
+
+#[derive(AsRef)]
+struct SingleFieldTuple(String);
+
+#[test]
+fn single_field_tuple() {
+    let item = SingleFieldTuple(String::from("test"));
+
+    assert!(ptr::eq(&item.0, item.as_ref()));
+}
+
+#[derive(AsRef)]
+#[as_ref(forward)]
+struct SingleFieldForward(Vec<i32>);
+
+#[test]
+fn single_field_forward() {
+    let item = SingleFieldForward(vec![]);
+    let _: &[i32] = (&item).as_ref();
+}
+
+#[derive(AsRef)]
+struct SingleFieldStruct {
+    first: String,
+}
+
+#[test]
+fn single_field_struct() {
+    let item = SingleFieldStruct {
+        first: String::from("test"),
+    };
+
+    assert!(ptr::eq(&item.first, item.as_ref()));
+}
+
+#[derive(AsRef)]
+struct MultiFieldTuple(#[as_ref] String, #[as_ref] PathBuf, Vec<usize>);
+
+#[test]
+fn multi_field_tuple() {
+    let item = MultiFieldTuple(String::from("test"), PathBuf::new(), vec![]);
+
+    assert!(ptr::eq(&item.0, item.as_ref()));
+    assert!(ptr::eq(&item.1, item.as_ref()));
+}
+
+#[derive(AsRef)]
+struct MultiFieldStruct {
+    #[as_ref]
+    first: String,
+    #[as_ref]
+    second: PathBuf,
+    third: Vec<usize>,
+}
+
+#[test]
+fn multi_field_struct() {
+    let item = MultiFieldStruct {
+        first: String::from("test"),
+        second: PathBuf::new(),
+        third: vec![],
+    };
+
+    assert!(ptr::eq(&item.first, item.as_ref()));
+    assert!(ptr::eq(&item.second, item.as_ref()));
+}
+
+#[derive(AsRef)]
+struct SingleFieldGenericStruct<T> {
+    first: T,
+}
+
+#[test]
+fn single_field_generic_struct() {
+    let item = SingleFieldGenericStruct {
+        first: String::from("test"),
+    };
+
+    assert!(ptr::eq(&item.first, item.as_ref()));
+}
+
+#[derive(AsRef)]
+struct MultiFieldGenericStruct<T, U> {
+    #[as_ref]
+    first: Vec<T>,
+    #[as_ref]
+    second: [U; 2],
+    third: Vec<usize>,
+}
+
+#[test]
+fn multi_field_generic_struct() {
+    let item = MultiFieldGenericStruct {
+        first: b"test".to_vec(),
+        second: [0i32, 1i32],
+        third: vec![],
+    };
+
+    assert!(ptr::eq(&item.first, item.as_ref()));
+    assert!(ptr::eq(&item.second, item.as_ref()));
+}
diff --git a/vendor/derive_more/tests/boats_display_derive.rs b/vendor/derive_more/tests/boats_display_derive.rs
new file mode 100644
index 000000000..b64f75df8
--- /dev/null
+++ b/vendor/derive_more/tests/boats_display_derive.rs
@@ -0,0 +1,57 @@
+// The following code is from https://github.com/withoutboats/display_derive/blob/232a32ee19e262aacbd2c93be5b4ce9e89a5fc30/tests/tests.rs
+// Written by without boats originally
+
+#[macro_use]
+extern crate derive_more;
+
+#[derive(Display)]
+#[display(fmt = "An error has occurred.")]
+struct UnitError;
+
+#[test]
+fn unit_struct() {
+    let s = format!("{}", UnitError);
+    assert_eq!(&s[..], "An error has occurred.");
+}
+
+#[derive(Display)]
+#[display(fmt = "Error code: {}", code)]
+struct RecordError {
+    code: u32,
+}
+
+#[test]
+fn record_struct() {
+    let s = format!("{}", RecordError { code: 0 });
+    assert_eq!(&s[..], "Error code: 0");
+}
+
+#[derive(Display)]
+#[display(fmt = "Error code: {}", _0)]
+struct TupleError(i32);
+
+#[test]
+fn tuple_struct() {
+    let s = format!("{}", TupleError(2));
+    assert_eq!(&s[..], "Error code: 2");
+}
+
+#[derive(Display)]
+enum EnumError {
+    #[display(fmt = "Error code: {}", code)]
+    StructVariant { code: i32 },
+    #[display(fmt = "Error: {}", _0)]
+    TupleVariant(&'static str),
+    #[display(fmt = "An error has occurred.")]
+    UnitVariant,
+}
+
+#[test]
+fn enum_error() {
+    let s = format!("{}", EnumError::StructVariant { code: 2 });
+    assert_eq!(&s[..], "Error code: 2");
+    let s = format!("{}", EnumError::TupleVariant("foobar"));
+    assert_eq!(&s[..], "Error: foobar");
+    let s = format!("{}", EnumError::UnitVariant);
+    assert_eq!(&s[..], "An error has occurred.");
+}
diff --git a/vendor/derive_more/tests/constructor.rs b/vendor/derive_more/tests/constructor.rs
new file mode 100644
index 000000000..07fddb883
--- /dev/null
+++ b/vendor/derive_more/tests/constructor.rs
@@ -0,0 +1,21 @@
+#![allow(dead_code)]
+#[macro_use]
+extern crate derive_more;
+
+#[derive(Constructor)]
+struct EmptyTuple();
+
+#[derive(Constructor)]
+struct EmptyStruct {}
+
+#[derive(Constructor)]
+struct EmptyUnit;
+
+#[derive(Constructor)]
+struct MyInts(i32, i32);
+
+#[derive(Constructor)]
+struct Point2D {
+    x: i32,
+    y: i32,
+}
diff --git a/vendor/derive_more/tests/deref.rs b/vendor/derive_more/tests/deref.rs
new file mode 100644
index 000000000..8227f88f9
--- /dev/null
+++ b/vendor/derive_more/tests/deref.rs
@@ -0,0 +1,68 @@
+#![allow(dead_code, unused_imports)]
+#[macro_use]
+extern crate derive_more;
+
+#[derive(Deref)]
+#[deref(forward)]
+struct MyBoxedInt(Box<i32>);
+
+#[derive(Deref)]
+#[deref(forward)]
+struct NumRef<'a> {
+    num: &'a i32,
+}
+
+#[derive(Deref)]
+struct NumRef2<'a> {
+    #[deref(forward)]
+    num: &'a i32,
+    useless: bool,
+}
+
+#[derive(Deref)]
+#[deref(forward)]
+struct NumRef3<'a> {
+    num: &'a i32,
+    #[deref(ignore)]
+    useless: bool,
+}
+
+#[derive(Deref)]
+struct MyInt(i32);
+
+#[derive(Deref)]
+struct Point1D {
+    x: i32,
+}
+
+#[derive(Deref)]
+struct Point1D2 {
+    x: i32,
+    #[deref(ignore)]
+    useless: bool,
+}
+
+#[derive(Deref)]
+struct CoolVec {
+    cool: bool,
+    #[deref]
+    vec: Vec<i32>,
+}
+
+#[derive(Deref)]
+struct GenericVec<T>(Vec<T>);
+
+#[test]
+fn deref_generic() {
+    let gv = GenericVec(Vec::<i32>::new());
+    assert!(gv.is_empty())
+}
+
+#[derive(Deref)]
+struct GenericBox<T>(#[deref(forward)] Box<T>);
+
+#[test]
+fn deref_generic_forward() {
+    let boxed = GenericBox(Box::new(1i32));
+    assert_eq!(*boxed, 1i32);
+}
diff --git a/vendor/derive_more/tests/deref_mut.rs b/vendor/derive_more/tests/deref_mut.rs
new file mode 100644
index 000000000..51a95e4f2
--- /dev/null
+++ b/vendor/derive_more/tests/deref_mut.rs
@@ -0,0 +1,124 @@
+#![allow(dead_code, unused_imports)]
+#[macro_use]
+extern crate derive_more;
+
+#[derive(DerefMut)]
+#[deref_mut(forward)]
+struct MyBoxedInt(Box<i32>);
+// Deref implementation is needed for DerefMut
+impl ::core::ops::Deref for MyBoxedInt {
+    type Target = <Box<i32> as ::core::ops::Deref>::Target;
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        <Box<i32> as ::core::ops::Deref>::deref(&self.0)
+    }
+}
+
+#[derive(DerefMut)]
+struct NumRef<'a> {
+    #[deref_mut(forward)]
+    num: &'a mut i32,
+}
+// Deref implementation is needed for DerefMut
+impl<'a> ::core::ops::Deref for NumRef<'a> {
+    type Target = <&'a mut i32 as ::core::ops::Deref>::Target;
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        <&'a mut i32 as ::core::ops::Deref>::deref(&self.num)
+    }
+}
+
+#[derive(DerefMut)]
+#[deref_mut(forward)]
+struct NumRef2<'a> {
+    num: &'a mut i32,
+    #[deref_mut(ignore)]
+    useless: bool,
+}
+
+// Deref implementation is needed for DerefMut
+impl<'a> ::core::ops::Deref for NumRef2<'a> {
+    type Target = <&'a mut i32 as ::core::ops::Deref>::Target;
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        <&'a mut i32 as ::core::ops::Deref>::deref(&self.num)
+    }
+}
+
+#[derive(DerefMut)]
+struct MyInt(i32);
+
+// Deref implementation is needed for DerefMutToInner
+impl ::core::ops::Deref for MyInt {
+    type Target = i32;
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[derive(DerefMut)]
+struct Point1D {
+    x: i32,
+}
+
+// Deref implementation is needed for DerefMutToInner
+impl ::core::ops::Deref for Point1D {
+    type Target = i32;
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.x
+    }
+}
+
+#[derive(DerefMut)]
+struct CoolVec {
+    cool: bool,
+    #[deref_mut]
+    vec: Vec<i32>,
+}
+impl ::core::ops::Deref for CoolVec {
+    type Target = Vec<i32>;
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.vec
+    }
+}
+
+#[derive(DerefMut)]
+struct GenericVec<T>(Vec<T>);
+
+impl<T> ::core::ops::Deref for GenericVec<T> {
+    type Target = Vec<T>;
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[test]
+fn deref_mut_generic() {
+    let mut gv = GenericVec::<i32>(vec![42]);
+    assert!(gv.get_mut(0).is_some());
+}
+
+#[derive(DerefMut)]
+struct GenericBox<T>(#[deref_mut(forward)] Box<T>);
+
+impl<T> ::core::ops::Deref for GenericBox<T>
+where
+    Box<T>: ::core::ops::Deref,
+{
+    type Target = <Box<T> as ::core::ops::Deref>::Target;
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        <Box<T> as ::core::ops::Deref>::deref(&self.0)
+    }
+}
+
+#[test]
+fn deref_mut_generic_forward() {
+    let mut boxed = GenericBox(Box::new(1i32));
+    *boxed = 3;
+    assert_eq!(*boxed, 3i32);
+}
diff --git a/vendor/derive_more/tests/display.rs b/vendor/derive_more/tests/display.rs
new file mode 100644
index 000000000..fae596b84
--- /dev/null
+++ b/vendor/derive_more/tests/display.rs
@@ -0,0 +1,429 @@
+#![allow(dead_code, unused_imports)]
+#[macro_use]
+extern crate derive_more;
+
+use std::path::PathBuf;
+
+// Here just to make sure that this doesn't conflict with
+// the derives in some way
+use std::fmt::Binary;
+
+#[derive(Display, Octal, Binary)]
+struct MyInt(i32);
+
+#[derive(UpperHex)]
+enum IntEnum {
+    U8(u8),
+    I8(i8),
+}
+
+#[derive(Display)]
+#[display(fmt = "({}, {})", x, y)]
+struct Point2D {
+    x: i32,
+    y: i32,
+}
+
+#[derive(Display)]
+#[display(fmt = "{}", "self.sign()")]
+struct PositiveOrNegative {
+    x: i32,
+}
+
+impl PositiveOrNegative {
+    fn sign(&self) -> &str {
+        if self.x >= 0 {
+            "Positive"
+        } else {
+            "Negative"
+        }
+    }
+}
+
+#[derive(Display)]
+#[display(fmt = "{}", message)]
+struct Error {
+    message: &'static str,
+    backtrace: (),
+}
+
+impl Error {
+    fn new(message: &'static str) -> Self {
+        Self {
+            message,
+            backtrace: (),
+        }
+    }
+}
+
+#[derive(Display)]
+enum E {
+    Uint(u32),
+    #[display(fmt = "I am B {:b}", i)]
+    Binary {
+        i: i8,
+    },
+    #[display(fmt = "I am C {}", "_0.display()")]
+    Path(PathBuf),
+}
+
+#[derive(Display)]
+#[display(fmt = "Java EE")]
+enum EE {
+    A,
+    B,
+}
+
+#[derive(Display)]
+#[display(fmt = "Hello there!")]
+union U {
+    i: u32,
+}
+
+#[derive(Octal)]
+#[octal(fmt = "7")]
+struct S;
+
+#[derive(UpperHex)]
+#[upper_hex(fmt = "UpperHex")]
+struct UH;
+
+#[derive(DebugCustom)]
+#[debug(fmt = "MyDebug")]
+struct D;
+
+#[derive(Display)]
+struct Unit;
+
+#[derive(Display)]
+struct UnitStruct {}
+
+#[derive(Display)]
+enum EmptyEnum {}
+
+#[derive(Display)]
+#[display(fmt = "Generic")]
+struct Generic<T>(T);
+
+#[derive(Display)]
+#[display(fmt = "Here's a prefix for {} and a suffix")]
+enum Affix {
+    A(u32),
+    #[display(fmt = "{} -- {}", wat, stuff)]
+    B {
+        wat: String,
+        stuff: bool,
+    },
+}
+
+#[derive(Debug, Display)]
+#[display(fmt = "{:?}", self)]
+struct DebugStructAsDisplay;
+
+#[test]
+fn check_display() {
+    assert_eq!(MyInt(-2).to_string(), "-2");
+    assert_eq!(format!("{:b}", MyInt(9)), "1001");
+    assert_eq!(format!("{:#b}", MyInt(9)), "0b1001");
+    assert_eq!(format!("{:o}", MyInt(9)), "11");
+    assert_eq!(format!("{:X}", IntEnum::I8(-1)), "FF");
+    assert_eq!(format!("{:#X}", IntEnum::U8(255)), "0xFF");
+    assert_eq!(Point2D { x: 3, y: 4 }.to_string(), "(3, 4)");
+    assert_eq!(PositiveOrNegative { x: 123 }.to_string(), "Positive");
+    assert_eq!(PositiveOrNegative { x: 0 }.to_string(), "Positive");
+    assert_eq!(PositiveOrNegative { x: -465 }.to_string(), "Negative");
+    assert_eq!(Error::new("Error").to_string(), "Error");
+    assert_eq!(E::Uint(2).to_string(), "2");
+    assert_eq!(E::Binary { i: -2 }.to_string(), "I am B 11111110");
+    assert_eq!(E::Path("abc".into()).to_string(), "I am C abc");
+    assert_eq!(EE::A.to_string(), "Java EE");
+    assert_eq!(EE::B.to_string(), "Java EE");
+    assert_eq!(U { i: 2 }.to_string(), "Hello there!");
+    assert_eq!(format!("{:o}", S), "7");
+    assert_eq!(format!("{:X}", UH), "UpperHex");
+    assert_eq!(format!("{:?}", D), "MyDebug");
+    assert_eq!(Unit.to_string(), "Unit");
+    assert_eq!(UnitStruct {}.to_string(), "UnitStruct");
+    assert_eq!(Generic(()).to_string(), "Generic");
+    assert_eq!(
+        Affix::A(2).to_string(),
+        "Here's a prefix for 2 and a suffix"
+    );
+    assert_eq!(
+        Affix::B {
+            wat: "things".to_owned(),
+            stuff: false,
+        }
+        .to_string(),
+        "Here's a prefix for things -- false and a suffix"
+    );
+    assert_eq!(DebugStructAsDisplay.to_string(), "DebugStructAsDisplay");
+}
+
+mod generic {
+    #[derive(Display)]
+    #[display(fmt = "Generic {}", field)]
+    struct NamedGenericStruct<T> {
+        field: T,
+    }
+    #[test]
+    fn named_generic_struct() {
+        assert_eq!(NamedGenericStruct { field: 1 }.to_string(), "Generic 1");
+    }
+
+    #[derive(Display)]
+    struct AutoNamedGenericStruct<T> {
+        field: T,
+    }
+    #[test]
+    fn auto_named_generic_struct() {
+        assert_eq!(AutoNamedGenericStruct { field: 1 }.to_string(), "1");
+    }
+
+    #[derive(Display)]
+    #[display(fmt = "Generic {}", "_0")]
+    struct UnnamedGenericStruct<T>(T);
+    #[test]
+    fn unnamed_generic_struct() {
+        assert_eq!(UnnamedGenericStruct(2).to_string(), "Generic 2");
+    }
+
+    #[derive(Display)]
+    struct AutoUnnamedGenericStruct<T>(T);
+    #[test]
+    fn auto_unnamed_generic_struct() {
+        assert_eq!(AutoUnnamedGenericStruct(2).to_string(), "2");
+    }
+
+    #[derive(Display)]
+    enum GenericEnum<A, B> {
+        #[display(fmt = "Gen::A {}", field)]
+        A { field: A },
+        #[display(fmt = "Gen::B {}", "_0")]
+        B(B),
+    }
+    #[test]
+    fn generic_enum() {
+        assert_eq!(GenericEnum::A::<_, u8> { field: 1 }.to_string(), "Gen::A 1");
+        assert_eq!(GenericEnum::B::<u8, _>(2).to_string(), "Gen::B 2");
+    }
+
+    #[derive(Display)]
+    enum AutoGenericEnum<A, B> {
+        A { field: A },
+        B(B),
+    }
+    #[test]
+    fn auto_generic_enum() {
+        assert_eq!(AutoGenericEnum::A::<_, u8> { field: 1 }.to_string(), "1");
+        assert_eq!(AutoGenericEnum::B::<u8, _>(2).to_string(), "2");
+    }
+
+    #[derive(Display)]
+    #[display(fmt = "{} {} <-> {0:o} {1:#x} <-> {0:?} {1:X?}", a, b)]
+    struct MultiTraitNamedGenericStruct<A, B> {
+        a: A,
+        b: B,
+    }
+    #[test]
+    fn multi_trait_named_generic_struct() {
+        let s = MultiTraitNamedGenericStruct { a: 8u8, b: 255 };
+        assert_eq!(s.to_string(), "8 255 <-> 10 0xff <-> 8 FF");
+    }
+
+    #[derive(Display)]
+    #[display(fmt = "{} {} {{}} {0:o} {1:#x} - {0:>4?} {1:^4X?}", "_0", "_1")]
+    struct MultiTraitUnnamedGenericStruct<A, B>(A, B);
+    #[test]
+    fn multi_trait_unnamed_generic_struct() {
+        let s = MultiTraitUnnamedGenericStruct(8u8, 255);
+        assert_eq!(s.to_string(), "8 255 {} 10 0xff -    8  FF ");
+    }
+
+    #[derive(Display)]
+    #[display(fmt = "{}", "3 * 4")]
+    struct UnusedGenericStruct<T>(T);
+    #[test]
+    fn unused_generic_struct() {
+        let s = UnusedGenericStruct(());
+        assert_eq!(s.to_string(), "12");
+    }
+
+    mod associated_type_field_enumerator {
+        use super::*;
+
+        trait Trait {
+            type Type;
+        }
+
+        struct Struct;
+
+        impl Trait for Struct {
+            type Type = i32;
+        }
+
+        #[test]
+        fn auto_generic_named_struct_associated() {
+            #[derive(Display)]
+            struct AutoGenericNamedStructAssociated<T: Trait> {
+                field: <T as Trait>::Type,
+            }
+
+            let s = AutoGenericNamedStructAssociated::<Struct> { field: 10 };
+            assert_eq!(s.to_string(), "10");
+        }
+
+        #[test]
+        fn auto_generic_unnamed_struct_associated() {
+            #[derive(Display)]
+            struct AutoGenericUnnamedStructAssociated<T: Trait>(<T as Trait>::Type);
+
+            let s = AutoGenericUnnamedStructAssociated::<Struct>(10);
+            assert_eq!(s.to_string(), "10");
+        }
+
+        #[test]
+        fn auto_generic_enum_associated() {
+            #[derive(Display)]
+            enum AutoGenericEnumAssociated<T: Trait> {
+                Enumerator(<T as Trait>::Type),
+            }
+
+            let e = AutoGenericEnumAssociated::<Struct>::Enumerator(10);
+            assert_eq!(e.to_string(), "10");
+        }
+    }
+
+    mod complex_type_field_enumerator {
+        use super::*;
+
+        #[derive(Display)]
+        struct Struct<T>(T);
+
+        #[test]
+        fn auto_generic_named_struct_complex() {
+            #[derive(Display)]
+            struct AutoGenericNamedStructComplex<T> {
+                field: Struct<T>,
+            }
+
+            let s = AutoGenericNamedStructComplex { field: Struct(10) };
+            assert_eq!(s.to_string(), "10");
+        }
+
+        #[test]
+        fn auto_generic_unnamed_struct_complex() {
+            #[derive(Display)]
+            struct AutoGenericUnnamedStructComplex<T>(Struct<T>);
+
+            let s = AutoGenericUnnamedStructComplex(Struct(10));
+            assert_eq!(s.to_string(), "10");
+        }
+
+        #[test]
+        fn auto_generic_enum_complex() {
+            #[derive(Display)]
+            enum AutoGenericEnumComplex<T> {
+                Enumerator(Struct<T>),
+            }
+
+            let e = AutoGenericEnumComplex::Enumerator(Struct(10));
+            assert_eq!(e.to_string(), "10")
+        }
+    }
+
+    mod reference {
+        use super::*;
+
+        #[test]
+        fn auto_generic_reference() {
+            #[derive(Display)]
+            struct AutoGenericReference<'a, T>(&'a T);
+
+            let s = AutoGenericReference(&10);
+            assert_eq!(s.to_string(), "10");
+        }
+
+        #[test]
+        fn auto_generic_static_reference() {
+            #[derive(Display)]
+            struct AutoGenericStaticReference<T: 'static>(&'static T);
+
+            let s = AutoGenericStaticReference(&10);
+            assert_eq!(s.to_string(), "10");
+        }
+    }
+
+    mod indirect {
+        use super::*;
+
+        #[derive(Display)]
+        struct Struct<T>(T);
+
+        #[test]
+        fn auto_generic_indirect() {
+            #[derive(Display)]
+            struct AutoGenericIndirect<T: 'static>(Struct<&'static T>);
+
+            const V: i32 = 10;
+            let s = AutoGenericIndirect(Struct(&V));
+            assert_eq!(s.to_string(), "10");
+        }
+    }
+
+    mod bound {
+        use super::*;
+
+        #[test]
+        fn simple() {
+            #[derive(Display)]
+            #[display(fmt = "{} {}", _0, _1)]
+            struct Struct<T1, T2>(T1, T2);
+
+            let s = Struct(10, 20);
+            assert_eq!(s.to_string(), "10 20");
+        }
+
+        #[test]
+        fn redundant() {
+            #[derive(Display)]
+            #[display(bound = "T1: ::core::fmt::Display, T2: ::core::fmt::Display")]
+            #[display(fmt = "{} {}", _0, _1)]
+            struct Struct<T1, T2>(T1, T2);
+
+            let s = Struct(10, 20);
+            assert_eq!(s.to_string(), "10 20");
+        }
+
+        #[test]
+        fn complex() {
+            trait Trait1 {
+                fn function1(&self) -> &'static str;
+            }
+
+            trait Trait2 {
+                fn function2(&self) -> &'static str;
+            }
+
+            impl Trait1 for i32 {
+                fn function1(&self) -> &'static str {
+                    "WHAT"
+                }
+            }
+
+            impl Trait2 for i32 {
+                fn function2(&self) -> &'static str {
+                    "EVER"
+                }
+            }
+
+            #[derive(Display)]
+            #[display(bound = "T1: Trait1 + Trait2, T2: Trait1 + Trait2")]
+            #[display(fmt = "{} {} {} {}", "_0.function1()", _0, "_1.function2()", _1)]
+            struct Struct<T1, T2>(T1, T2);
+
+            let s = Struct(10, 20);
+            assert_eq!(s.to_string(), "WHAT 10 EVER 20");
+        }
+    }
+}
diff --git a/vendor/derive_more/tests/error/derives_for_enums_with_source.rs b/vendor/derive_more/tests/error/derives_for_enums_with_source.rs
new file mode 100644
index 000000000..2513ab60c
--- /dev/null
+++ b/vendor/derive_more/tests/error/derives_for_enums_with_source.rs
@@ -0,0 +1,249 @@
+use super::*;
+
+derive_display!(TestErr);
+#[derive(Debug, Error)]
+enum TestErr {
+    Unit,
+    NamedImplicitNoSource {
+        field: i32,
+    },
+    NamedImplicitSource {
+        source: SimpleErr,
+        field: i32,
+    },
+    NamedExplicitNoSource {
+        #[error(not(source))]
+        source: SimpleErr,
+        field: i32,
+    },
+    NamedExplicitSource {
+        #[error(source)]
+        explicit_source: SimpleErr,
+        field: i32,
+    },
+    NamedExplicitNoSourceRedundant {
+        #[error(not(source))]
+        field: i32,
+    },
+    NamedExplicitSourceRedundant {
+        #[error(source)]
+        source: SimpleErr,
+        field: i32,
+    },
+    NamedExplicitSuppressesImplicit {
+        source: i32,
+        #[error(source)]
+        field: SimpleErr,
+    },
+    UnnamedImplicitNoSource(i32, i32),
+    UnnamedImplicitSource(SimpleErr),
+    UnnamedExplicitNoSource(#[error(not(source))] SimpleErr),
+    UnnamedExplicitSource(#[error(source)] SimpleErr, i32),
+    UnnamedExplicitNoSourceRedundant(
+        #[error(not(source))] i32,
+        #[error(not(source))] i32,
+    ),
+    UnnamedExplicitSourceRedundant(#[error(source)] SimpleErr),
+    NamedIgnore {
+        #[error(ignore)]
+        source: SimpleErr,
+        field: i32,
+    },
+    UnnamedIgnore(#[error(ignore)] SimpleErr),
+    NamedIgnoreRedundant {
+        #[error(ignore)]
+        field: i32,
+    },
+    UnnamedIgnoreRedundant(#[error(ignore)] i32, #[error(ignore)] i32),
+    #[error(ignore)]
+    NamedVariantIgnore {
+        source: SimpleErr,
+        field: i32,
+    },
+    #[error(ignore)]
+    UnnamedVariantIgnore(SimpleErr),
+    #[error(ignore)]
+    NamedVariantIgnoreRedundant {
+        field: i32,
+    },
+    #[error(ignore)]
+    UnnamedVariantIgnoreRedundant(i32, i32),
+}
+
+#[test]
+fn unit() {
+    assert!(TestErr::Unit.source().is_none());
+}
+
+#[test]
+fn named_implicit_no_source() {
+    let err = TestErr::NamedImplicitNoSource { field: 0 };
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn named_implicit_source() {
+    let err = TestErr::NamedImplicitSource {
+        source: SimpleErr,
+        field: 0,
+    };
+
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn named_explicit_no_source() {
+    let err = TestErr::NamedExplicitNoSource {
+        source: SimpleErr,
+        field: 0,
+    };
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn named_explicit_source() {
+    let err = TestErr::NamedExplicitSource {
+        explicit_source: SimpleErr,
+        field: 0,
+    };
+
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn named_explicit_no_source_redundant() {
+    let err = TestErr::NamedExplicitNoSourceRedundant { field: 0 };
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn named_explicit_source_redundant() {
+    let err = TestErr::NamedExplicitSourceRedundant {
+        source: SimpleErr,
+        field: 0,
+    };
+
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn named_explicit_suppresses_implicit() {
+    let err = TestErr::NamedExplicitSuppressesImplicit {
+        source: 0,
+        field: SimpleErr,
+    };
+
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn unnamed_implicit_no_source() {
+    assert!(TestErr::UnnamedImplicitNoSource(0, 0).source().is_none());
+}
+
+#[test]
+fn unnamed_implicit_source() {
+    let err = TestErr::UnnamedImplicitSource(SimpleErr);
+
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn unnamed_explicit_no_source() {
+    let err = TestErr::UnnamedExplicitNoSource(SimpleErr);
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn unnamed_explicit_source() {
+    let err = TestErr::UnnamedExplicitSource(SimpleErr, 0);
+
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn unnamed_explicit_no_source_redundant() {
+    let err = TestErr::UnnamedExplicitNoSourceRedundant(0, 0);
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn unnamed_explicit_source_redundant() {
+    let err = TestErr::UnnamedExplicitSourceRedundant(SimpleErr);
+
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn named_ignore() {
+    let err = TestErr::NamedIgnore {
+        source: SimpleErr,
+        field: 0,
+    };
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn unnamed_ignore() {
+    let err = TestErr::UnnamedIgnore(SimpleErr);
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn named_ignore_redundant() {
+    let err = TestErr::NamedIgnoreRedundant { field: 0 };
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn unnamed_ignore_redundant() {
+    let err = TestErr::UnnamedIgnoreRedundant(0, 0);
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn named_variant_ignore() {
+    let err = TestErr::NamedVariantIgnore {
+        source: SimpleErr,
+        field: 0,
+    };
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn unnamed_variant_ignore() {
+    let err = TestErr::UnnamedVariantIgnore(SimpleErr);
+
+    assert!(err.source().is_none())
+}
+
+#[test]
+fn named_variant_ignore_redundant() {
+    let err = TestErr::NamedVariantIgnoreRedundant { field: 0 };
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn unnamed_variant_ignore_redundant() {
+    let err = TestErr::UnnamedVariantIgnoreRedundant(0, 0);
+
+    assert!(err.source().is_none())
+}
diff --git a/vendor/derive_more/tests/error/derives_for_generic_enums_with_source.rs b/vendor/derive_more/tests/error/derives_for_generic_enums_with_source.rs
new file mode 100644
index 000000000..92f3b3ae9
--- /dev/null
+++ b/vendor/derive_more/tests/error/derives_for_generic_enums_with_source.rs
@@ -0,0 +1,248 @@
+use super::*;
+
+derive_display!(TestErr, T, E);
+#[derive(Debug, Error)]
+enum TestErr<E, T> {
+    Unit,
+    NamedImplicitNoSource {
+        field: T,
+    },
+    NamedImplicitSource {
+        source: E,
+        field: T,
+    },
+    NamedExplicitNoSource {
+        #[error(not(source))]
+        source: E,
+        field: T,
+    },
+    NamedExplicitSource {
+        #[error(source)]
+        explicit_source: E,
+        field: T,
+    },
+    NamedExplicitNoSourceRedundant {
+        #[error(not(source))]
+        field: T,
+    },
+    NamedExplicitSourceRedundant {
+        #[error(source)]
+        source: E,
+        field: T,
+    },
+    NamedExplicitSuppressesImplicit {
+        source: T,
+        #[error(source)]
+        field: E,
+    },
+    UnnamedImplicitNoSource(T, T),
+    UnnamedImplicitSource(E),
+    UnnamedExplicitNoSource(#[error(not(source))] E),
+    UnnamedExplicitSource(#[error(source)] E, T),
+    UnnamedExplicitNoSourceRedundant(#[error(not(source))] T, #[error(not(source))] T),
+    UnnamedExplicitSourceRedundant(#[error(source)] E),
+    NamedIgnore {
+        #[error(ignore)]
+        source: E,
+        field: T,
+    },
+    UnnamedIgnore(#[error(ignore)] E),
+    NamedIgnoreRedundant {
+        #[error(ignore)]
+        field: T,
+    },
+    UnnamedIgnoreRedundant(#[error(ignore)] T, #[error(ignore)] T),
+    #[error(ignore)]
+    NamedVariantIgnore {
+        source: E,
+        field: T,
+    },
+    #[error(ignore)]
+    UnnamedVariantIgnore(E),
+    #[error(ignore)]
+    NamedVariantIgnoreRedundant {
+        field: T,
+    },
+    #[error(ignore)]
+    UnnamedVariantIgnoreRedundant(T, T),
+}
+
+#[test]
+fn unit() {
+    assert!(TestErr::<SimpleErr, i32>::Unit.source().is_none());
+}
+
+#[test]
+fn named_implicit_no_source() {
+    let err = TestErr::<SimpleErr, _>::NamedImplicitNoSource { field: 0 };
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn named_implicit_source() {
+    let err = TestErr::NamedImplicitSource {
+        source: SimpleErr,
+        field: 0,
+    };
+
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn named_explicit_no_source() {
+    let err = TestErr::NamedExplicitNoSource {
+        source: SimpleErr,
+        field: 0,
+    };
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn named_explicit_source() {
+    let err = TestErr::NamedExplicitSource {
+        explicit_source: SimpleErr,
+        field: 0,
+    };
+
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn named_explicit_no_source_redundant() {
+    let err = TestErr::<SimpleErr, _>::NamedExplicitNoSourceRedundant { field: 0 };
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn named_explicit_source_redundant() {
+    let err = TestErr::NamedExplicitSourceRedundant {
+        source: SimpleErr,
+        field: 0,
+    };
+
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn named_explicit_suppresses_implicit() {
+    let err = TestErr::NamedExplicitSuppressesImplicit {
+        source: 0,
+        field: SimpleErr,
+    };
+
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn unnamed_implicit_no_source() {
+    let err = TestErr::<SimpleErr, _>::UnnamedImplicitNoSource(0, 0);
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn unnamed_implicit_source() {
+    let err = TestErr::<_, i32>::UnnamedImplicitSource(SimpleErr);
+
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn unnamed_explicit_no_source() {
+    let err = TestErr::<_, i32>::UnnamedExplicitNoSource(SimpleErr);
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn unnamed_explicit_source() {
+    let err = TestErr::UnnamedExplicitSource(SimpleErr, 0);
+
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn unnamed_explicit_no_source_redundant() {
+    let err = TestErr::<SimpleErr, _>::UnnamedExplicitNoSourceRedundant(0, 0);
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn unnamed_explicit_source_redundant() {
+    let err = TestErr::<_, i32>::UnnamedExplicitSourceRedundant(SimpleErr);
+
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn named_ignore() {
+    let err = TestErr::NamedIgnore {
+        source: SimpleErr,
+        field: 0,
+    };
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn unnamed_ignore() {
+    let err = TestErr::<_, i32>::UnnamedIgnore(SimpleErr);
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn named_ignore_redundant() {
+    let err = TestErr::<SimpleErr, _>::NamedIgnoreRedundant { field: 0 };
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn unnamed_ignore_redundant() {
+    let err = TestErr::<SimpleErr, _>::UnnamedIgnoreRedundant(0, 0);
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn named_variant_ignore() {
+    let err = TestErr::NamedVariantIgnore {
+        source: SimpleErr,
+        field: 0,
+    };
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn unnamed_variant_ignore() {
+    let err = TestErr::<_, i32>::UnnamedVariantIgnore(SimpleErr);
+
+    assert!(err.source().is_none())
+}
+
+#[test]
+fn named_variant_ignore_redundant() {
+    let err = TestErr::<SimpleErr, _>::NamedVariantIgnoreRedundant { field: 0 };
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn unnamed_variant_ignore_redundant() {
+    let err = TestErr::<SimpleErr, _>::UnnamedVariantIgnoreRedundant(0, 0);
+
+    assert!(err.source().is_none())
+}
diff --git a/vendor/derive_more/tests/error/derives_for_generic_structs_with_source.rs b/vendor/derive_more/tests/error/derives_for_generic_structs_with_source.rs
new file mode 100644
index 000000000..248e3c97f
--- /dev/null
+++ b/vendor/derive_more/tests/error/derives_for_generic_structs_with_source.rs
@@ -0,0 +1,245 @@
+use super::*;
+
+#[test]
+fn named_implicit_no_source() {
+    derive_display!(TestErr, T);
+    #[derive(Default, Debug, Error)]
+    struct TestErr<T> {
+        field: T,
+    }
+
+    assert!(TestErr::<i32>::default().source().is_none());
+}
+
+#[test]
+fn named_implicit_source() {
+    derive_display!(TestErr, E, T);
+    #[derive(Default, Debug, Error)]
+    struct TestErr<E, T> {
+        source: E,
+        field: T,
+    }
+
+    let err = TestErr::<SimpleErr, i32>::default();
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn named_explicit_no_source() {
+    derive_display!(TestErr, E, T);
+    #[derive(Default, Debug, Error)]
+    struct TestErr<E, T> {
+        #[error(not(source))]
+        source: E,
+        field: T,
+    }
+
+    let err = TestErr::<SimpleErr, i32>::default();
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn named_explicit_source() {
+    derive_display!(TestErr, E, T);
+    #[derive(Default, Debug, Error)]
+    struct TestErr<E, T> {
+        #[error(source)]
+        explicit_source: E,
+        field: T,
+    }
+
+    let err = TestErr::<SimpleErr, i32>::default();
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn named_explicit_no_source_redundant() {
+    derive_display!(TestErr, T);
+    #[derive(Default, Debug, Error)]
+    struct TestErr<T> {
+        #[error(not(source))]
+        field: T,
+    }
+
+    assert!(TestErr::<i32>::default().source().is_none());
+}
+
+#[test]
+fn named_explicit_source_redundant() {
+    derive_display!(TestErr, E, T);
+    #[derive(Default, Debug, Error)]
+    struct TestErr<E, T> {
+        #[error(source)]
+        source: E,
+        field: T,
+    }
+
+    let err = TestErr::<SimpleErr, i32>::default();
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn named_explicit_suppresses_implicit() {
+    derive_display!(TestErr, E, T);
+    #[derive(Default, Debug, Error)]
+    struct TestErr<E, T> {
+        source: E,
+        #[error(source)]
+        field: T,
+    }
+
+    let err = TestErr::<i32, SimpleErr>::default();
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn unnamed_implicit_no_source() {
+    derive_display!(TestErr, T);
+    #[derive(Default, Debug, Error)]
+    struct TestErr<T>(T, T);
+
+    assert!(TestErr::<i32>::default().source().is_none());
+}
+
+#[test]
+fn unnamed_implicit_source() {
+    derive_display!(TestErr, E);
+    #[derive(Default, Debug, Error)]
+    struct TestErr<E>(E);
+
+    let err = TestErr::<SimpleErr>::default();
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn unnamed_explicit_no_source() {
+    derive_display!(TestErr, E);
+    #[derive(Default, Debug, Error)]
+    struct TestErr<E>(#[error(not(source))] E);
+
+    assert!(TestErr::<SimpleErr>::default().source().is_none());
+}
+
+#[test]
+fn unnamed_explicit_source() {
+    derive_display!(TestErr, E, T);
+    #[derive(Default, Debug, Error)]
+    struct TestErr<E, T>(#[error(source)] E, T);
+
+    let err = TestErr::<SimpleErr, i32>::default();
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn unnamed_explicit_no_source_redundant() {
+    derive_display!(TestErr, T);
+    #[derive(Default, Debug, Error)]
+    struct TestErr<T>(#[error(not(source))] T, #[error(not(source))] T);
+
+    assert!(TestErr::<i32>::default().source().is_none());
+}
+
+#[test]
+fn unnamed_explicit_source_redundant() {
+    derive_display!(TestErr, E);
+    #[derive(Default, Debug, Error)]
+    struct TestErr<E>(#[error(source)] E);
+
+    let err = TestErr::<SimpleErr>::default();
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn named_ignore() {
+    derive_display!(TestErr, E, T);
+    #[derive(Default, Debug, Error)]
+    struct TestErr<E, T> {
+        #[error(ignore)]
+        source: E,
+        field: T,
+    }
+
+    assert!(TestErr::<SimpleErr, i32>::default().source().is_none());
+}
+
+#[test]
+fn unnamed_ignore() {
+    derive_display!(TestErr, E);
+    #[derive(Default, Debug, Error)]
+    struct TestErr<E>(#[error(ignore)] E);
+
+    assert!(TestErr::<SimpleErr>::default().source().is_none());
+}
+
+#[test]
+fn named_ignore_redundant() {
+    derive_display!(TestErr, T);
+    #[derive(Default, Debug, Error)]
+    struct TestErr<T> {
+        #[error(ignore)]
+        field: T,
+    }
+
+    assert!(TestErr::<i32>::default().source().is_none());
+}
+
+#[test]
+fn unnamed_ignore_redundant() {
+    derive_display!(TestErr, T);
+    #[derive(Default, Debug, Error)]
+    struct TestErr<T>(#[error(ignore)] T, #[error(ignore)] T);
+
+    assert!(TestErr::<i32>::default().source().is_none());
+}
+
+#[test]
+fn named_struct_ignore() {
+    derive_display!(TestErr, E, T);
+    #[derive(Default, Debug, Error)]
+    #[error(ignore)]
+    struct TestErr<E, T> {
+        source: E,
+        field: T,
+    }
+
+    assert!(TestErr::<SimpleErr, i32>::default().source().is_none())
+}
+
+#[test]
+fn unnamed_struct_ignore() {
+    derive_display!(TestErr, E);
+    #[derive(Default, Debug, Error)]
+    #[error(ignore)]
+    struct TestErr<E>(E);
+
+    assert!(TestErr::<SimpleErr>::default().source().is_none())
+}
+
+#[test]
+fn named_struct_ignore_redundant() {
+    derive_display!(TestErr, T);
+    #[derive(Default, Debug, Error)]
+    #[error(ignore)]
+    struct TestErr<T> {
+        field: T,
+    }
+
+    assert!(TestErr::<i32>::default().source().is_none())
+}
+
+#[test]
+fn unnamed_struct_ignore_redundant() {
+    derive_display!(TestErr, T);
+    #[derive(Default, Debug, Error)]
+    #[error(ignore)]
+    struct TestErr<T>(T, T);
+
+    assert!(TestErr::<i32>::default().source().is_none())
+}
diff --git a/vendor/derive_more/tests/error/derives_for_structs_with_source.rs b/vendor/derive_more/tests/error/derives_for_structs_with_source.rs
new file mode 100644
index 000000000..d46bd5ad5
--- /dev/null
+++ b/vendor/derive_more/tests/error/derives_for_structs_with_source.rs
@@ -0,0 +1,249 @@
+use super::*;
+
+#[test]
+fn unit() {
+    assert!(SimpleErr.source().is_none());
+}
+
+#[test]
+fn named_implicit_no_source() {
+    derive_display!(TestErr);
+    #[derive(Default, Debug, Error)]
+    struct TestErr {
+        field: i32,
+    }
+
+    assert!(TestErr::default().source().is_none());
+}
+
+#[test]
+fn named_implicit_source() {
+    derive_display!(TestErr);
+    #[derive(Default, Debug, Error)]
+    struct TestErr {
+        source: SimpleErr,
+        field: i32,
+    }
+
+    let err = TestErr::default();
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn named_explicit_no_source() {
+    derive_display!(TestErr);
+    #[derive(Default, Debug, Error)]
+    struct TestErr {
+        #[error(not(source))]
+        source: SimpleErr,
+        field: i32,
+    }
+
+    assert!(TestErr::default().source().is_none());
+}
+
+#[test]
+fn named_explicit_source() {
+    derive_display!(TestErr);
+    #[derive(Default, Debug, Error)]
+    struct TestErr {
+        #[error(source)]
+        explicit_source: SimpleErr,
+        field: i32,
+    }
+
+    let err = TestErr::default();
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn named_explicit_no_source_redundant() {
+    derive_display!(TestErr);
+    #[derive(Default, Debug, Error)]
+    struct TestErr {
+        #[error(not(source))]
+        field: i32,
+    }
+
+    assert!(TestErr::default().source().is_none());
+}
+
+#[test]
+fn named_explicit_source_redundant() {
+    derive_display!(TestErr);
+    #[derive(Default, Debug, Error)]
+    struct TestErr {
+        #[error(source)]
+        source: SimpleErr,
+        field: i32,
+    }
+
+    let err = TestErr::default();
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn named_explicit_suppresses_implicit() {
+    derive_display!(TestErr);
+    #[derive(Default, Debug, Error)]
+    struct TestErr {
+        source: i32,
+        #[error(source)]
+        field: SimpleErr,
+    }
+
+    let err = TestErr::default();
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn unnamed_implicit_no_source() {
+    derive_display!(TestErr);
+    #[derive(Default, Debug, Error)]
+    struct TestErr(i32, i32);
+
+    assert!(TestErr::default().source().is_none());
+}
+
+#[test]
+fn unnamed_implicit_source() {
+    derive_display!(TestErr);
+    #[derive(Default, Debug, Error)]
+    struct TestErr(SimpleErr);
+
+    let err = TestErr::default();
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn unnamed_explicit_no_source() {
+    derive_display!(TestErr);
+    #[derive(Default, Debug, Error)]
+    struct TestErr(#[error(not(source))] SimpleErr);
+
+    assert!(TestErr::default().source().is_none());
+}
+
+#[test]
+fn unnamed_explicit_source() {
+    derive_display!(TestErr);
+    #[derive(Default, Debug, Error)]
+    struct TestErr(#[error(source)] SimpleErr, i32);
+
+    let err = TestErr::default();
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn unnamed_explicit_no_source_redundant() {
+    derive_display!(TestErr);
+    #[derive(Default, Debug, Error)]
+    struct TestErr(#[error(not(source))] i32, #[error(not(source))] i32);
+
+    assert!(TestErr::default().source().is_none());
+}
+
+#[test]
+fn unnamed_explicit_source_redundant() {
+    derive_display!(TestErr);
+    #[derive(Default, Debug, Error)]
+    struct TestErr(#[error(source)] SimpleErr);
+
+    let err = TestErr::default();
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
+}
+
+#[test]
+fn named_ignore() {
+    derive_display!(TestErr);
+    #[derive(Default, Debug, Error)]
+    struct TestErr {
+        #[error(ignore)]
+        source: SimpleErr,
+        field: i32,
+    }
+
+    assert!(TestErr::default().source().is_none());
+}
+
+#[test]
+fn unnamed_ignore() {
+    derive_display!(TestErr);
+    #[derive(Default, Debug, Error)]
+    struct TestErr(#[error(ignore)] SimpleErr);
+
+    assert!(TestErr::default().source().is_none());
+}
+
+#[test]
+fn named_ignore_redundant() {
+    derive_display!(TestErr);
+    #[derive(Default, Debug, Error)]
+    struct TestErr {
+        #[error(ignore)]
+        field: i32,
+    }
+
+    assert!(TestErr::default().source().is_none());
+}
+
+#[test]
+fn unnamed_ignore_redundant() {
+    derive_display!(TestErr);
+    #[derive(Default, Debug, Error)]
+    struct TestErr(#[error(ignore)] i32, #[error(ignore)] i32);
+
+    assert!(TestErr::default().source().is_none());
+}
+
+#[test]
+fn named_struct_ignore() {
+    derive_display!(TestErr);
+    #[derive(Default, Debug, Error)]
+    #[error(ignore)]
+    struct TestErr {
+        source: SimpleErr,
+        field: i32,
+    }
+
+    assert!(TestErr::default().source().is_none())
+}
+
+#[test]
+fn unnamed_struct_ignore() {
+    derive_display!(TestErr);
+    #[derive(Default, Debug, Error)]
+    #[error(ignore)]
+    struct TestErr(SimpleErr);
+
+    assert!(TestErr::default().source().is_none())
+}
+
+#[test]
+fn named_struct_ignore_redundant() {
+    derive_display!(TestErr);
+    #[derive(Default, Debug, Error)]
+    #[error(ignore)]
+    struct TestErr {
+        field: i32,
+    }
+
+    assert!(TestErr::default().source().is_none())
+}
+
+#[test]
+fn unnamed_struct_ignore_redundant() {
+    derive_display!(TestErr);
+    #[derive(Default, Debug, Error)]
+    #[error(ignore)]
+    struct TestErr(i32, i32);
+
+    assert!(TestErr::default().source().is_none())
+}
diff --git a/vendor/derive_more/tests/error/mod.rs b/vendor/derive_more/tests/error/mod.rs
new file mode 100644
index 000000000..5d7190d8f
--- /dev/null
+++ b/vendor/derive_more/tests/error/mod.rs
@@ -0,0 +1,56 @@
+use std::error::Error;
+
+/// Derives `std::fmt::Display` for structs/enums.
+/// Derived implementation outputs empty string.
+/// Useful, as a way to formally satisfy `Display` trait bound.
+///
+/// ## Syntax:
+///
+/// For regular structs/enums:
+///
+/// ```
+/// enum MyEnum {
+///     ...
+/// }
+///
+/// derive_display!(MyEnum);
+/// ```
+///
+/// For generic structs/enums:
+///
+/// ```
+/// struct MyGenericStruct<T, U> {
+///     ...
+/// }
+///
+/// derive_display!(MyGenericStruct, T, U);
+/// ```
+macro_rules! derive_display {
+    (@fmt) => {
+        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+            write!(f, "")
+        }
+    };
+    ($type:ident) => {
+        impl ::std::fmt::Display for $type {
+            derive_display!(@fmt);
+        }
+    };
+    ($type:ident, $($type_parameters:ident),*) => {
+        impl<$($type_parameters),*> ::std::fmt::Display for $type<$($type_parameters),*> {
+            derive_display!(@fmt);
+        }
+    };
+}
+
+mod derives_for_enums_with_source;
+mod derives_for_generic_enums_with_source;
+mod derives_for_generic_structs_with_source;
+mod derives_for_structs_with_source;
+
+#[cfg(feature = "nightly")]
+mod nightly;
+
+derive_display!(SimpleErr);
+#[derive(Default, Debug, Error)]
+struct SimpleErr;
diff --git a/vendor/derive_more/tests/error/nightly/derives_for_enums_with_backtrace.rs b/vendor/derive_more/tests/error/nightly/derives_for_enums_with_backtrace.rs
new file mode 100644
index 000000000..c4ff4817d
--- /dev/null
+++ b/vendor/derive_more/tests/error/nightly/derives_for_enums_with_backtrace.rs
@@ -0,0 +1,272 @@
+use super::*;
+
+derive_display!(TestErr);
+#[derive(Debug, Error)]
+enum TestErr {
+    Unit,
+    NamedImplicitNoBacktrace {
+        field: i32,
+    },
+    NamedImplicitBacktraceByFieldName {
+        backtrace: MyBacktrace,
+        field: i32,
+    },
+    NamedImplicitBacktraceByFieldType {
+        implicit_backtrace: Backtrace,
+        field: i32,
+    },
+    NamedExplicitNoBacktraceByFieldName {
+        #[error(not(backtrace))]
+        backtrace: MyBacktrace,
+        field: i32,
+    },
+    NamedExplicitNoBacktraceByFieldType {
+        #[error(not(backtrace))]
+        implicit_backtrace: Backtrace,
+        field: i32,
+    },
+    NamedExplicitBacktrace {
+        #[error(backtrace)]
+        explicit_backtrace: MyBacktrace,
+        field: i32,
+    },
+    NamedExplicitNoBacktraceRedundant {
+        #[error(not(backtrace))]
+        not_backtrace: MyBacktrace,
+        #[error(not(backtrace))]
+        field: i32,
+    },
+    NamedExplicitBacktraceByFieldNameRedundant {
+        #[error(backtrace)]
+        backtrace: MyBacktrace,
+        field: i32,
+    },
+    NamedExplicitBacktraceByFieldTypeRedundant {
+        #[error(backtrace)]
+        implicit_backtrace: Backtrace,
+        field: i32,
+    },
+    NamedExplicitSupressesImplicit {
+        #[error(backtrace)]
+        not_backtrace: MyBacktrace,
+        backtrace: Backtrace,
+        field: i32,
+    },
+    UnnamedImplicitNoBacktrace(i32, i32),
+    UnnamedImplicitBacktrace(Backtrace, i32, i32),
+    UnnamedExplicitNoBacktrace(#[error(not(backtrace))] Backtrace, i32),
+    UnnamedExplicitBacktrace(#[error(backtrace)] MyBacktrace, i32, i32),
+    UnnamedExplicitNoBacktraceRedundant(
+        #[error(not(backtrace))] MyBacktrace,
+        #[error(not(backtrace))] i32,
+    ),
+    UnnamedExplicitBacktraceRedundant(#[error(backtrace)] Backtrace, i32, i32),
+    UnnamedExplicitSupressesImplicit(#[error(backtrace)] MyBacktrace, Backtrace, i32),
+}
+
+impl TestErr {
+    fn get_stored_backtrace(&self) -> &Backtrace {
+        match self {
+            Self::NamedImplicitBacktraceByFieldName { backtrace, .. } => backtrace,
+            Self::NamedImplicitBacktraceByFieldType {
+                implicit_backtrace, ..
+            } => implicit_backtrace,
+            Self::NamedExplicitBacktrace {
+                explicit_backtrace, ..
+            } => explicit_backtrace,
+            Self::NamedExplicitBacktraceByFieldNameRedundant { backtrace, .. } => {
+                backtrace
+            }
+            Self::NamedExplicitBacktraceByFieldTypeRedundant {
+                implicit_backtrace,
+                ..
+            } => implicit_backtrace,
+            Self::NamedExplicitSupressesImplicit { not_backtrace, .. } => not_backtrace,
+            Self::UnnamedImplicitBacktrace(backtrace, _, _) => backtrace,
+            Self::UnnamedExplicitBacktrace(backtrace, _, _) => backtrace,
+            Self::UnnamedExplicitBacktraceRedundant(backtrace, _, _) => backtrace,
+            Self::UnnamedExplicitSupressesImplicit(backtrace, _, _) => backtrace,
+            _ => panic!("ERROR IN TEST IMPLEMENTATION"),
+        }
+    }
+
+    fn get_unused_backtrace(&self) -> &Backtrace {
+        match self {
+            Self::NamedExplicitSupressesImplicit { backtrace, .. } => backtrace,
+            Self::UnnamedExplicitSupressesImplicit(_, backtrace, _) => backtrace,
+            _ => panic!("ERROR IN TEST IMPLEMENTATION"),
+        }
+    }
+}
+
+type MyBacktrace = Backtrace;
+
+#[test]
+fn unit() {
+    assert!(TestErr::Unit.backtrace().is_none());
+}
+
+#[test]
+fn named_implicit_no_backtrace() {
+    let err = TestErr::NamedImplicitNoBacktrace { field: 0 };
+
+    assert!(err.backtrace().is_none());
+}
+
+#[test]
+fn named_implicit_backtrace_by_field_name() {
+    let err = TestErr::NamedImplicitBacktraceByFieldName {
+        backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+}
+
+#[test]
+fn named_implicit_backtrace_by_field_type() {
+    let err = TestErr::NamedImplicitBacktraceByFieldType {
+        implicit_backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+}
+
+#[test]
+fn named_explicit_no_backtrace_by_field_name() {
+    let err = TestErr::NamedExplicitNoBacktraceByFieldName {
+        backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+
+    assert!(err.backtrace().is_none());
+}
+
+#[test]
+fn named_explicit_no_backtrace_by_field_type() {
+    let err = TestErr::NamedExplicitNoBacktraceByFieldType {
+        implicit_backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+
+    assert!(err.backtrace().is_none());
+}
+
+#[test]
+fn named_explicit_backtrace() {
+    let err = TestErr::NamedExplicitBacktrace {
+        explicit_backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+}
+
+#[test]
+fn named_explicit_no_backtrace_redundant() {
+    let err = TestErr::NamedExplicitNoBacktraceRedundant {
+        not_backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+
+    assert!(err.backtrace().is_none());
+}
+
+#[test]
+fn named_explicit_backtrace_by_field_name_redundant() {
+    let err = TestErr::NamedExplicitBacktraceByFieldNameRedundant {
+        backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+}
+
+#[test]
+fn named_explicit_backtrace_by_field_type_redundant() {
+    let err = TestErr::NamedExplicitBacktraceByFieldTypeRedundant {
+        implicit_backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+}
+
+#[test]
+fn named_explicit_supresses_implicit() {
+    let err = TestErr::NamedExplicitSupressesImplicit {
+        not_backtrace: Backtrace::force_capture(),
+        backtrace: (|| Backtrace::force_capture())(), // ensure backtraces are different
+        field: 0,
+    };
+
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+    assert_bt!(!=, err, .get_unused_backtrace);
+}
+
+#[test]
+fn unnamed_implicit_no_backtrace() {
+    let err = TestErr::UnnamedImplicitNoBacktrace(0, 0);
+
+    assert!(err.backtrace().is_none());
+}
+
+#[test]
+fn unnamed_implicit_backtrace() {
+    let err = TestErr::UnnamedImplicitBacktrace(Backtrace::force_capture(), 0, 0);
+
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+}
+
+#[test]
+fn unnamed_explicit_no_backtrace() {
+    let err = TestErr::UnnamedExplicitNoBacktrace(Backtrace::force_capture(), 0);
+
+    assert!(err.backtrace().is_none());
+}
+
+#[test]
+fn unnamed_explicit_backtrace() {
+    let err = TestErr::UnnamedExplicitBacktrace(Backtrace::force_capture(), 0, 0);
+
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+}
+
+#[test]
+fn unnamed_explicit_no_backtrace_redundant() {
+    let err =
+        TestErr::UnnamedExplicitNoBacktraceRedundant(Backtrace::force_capture(), 0);
+
+    assert!(err.backtrace().is_none());
+}
+
+#[test]
+fn unnamed_explicit_backtrace_redundant() {
+    let err =
+        TestErr::UnnamedExplicitBacktraceRedundant(Backtrace::force_capture(), 0, 0);
+
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+}
+
+#[test]
+fn unnamed_explicit_supresses_implicit() {
+    let err = TestErr::UnnamedExplicitSupressesImplicit(
+        Backtrace::force_capture(),
+        (|| Backtrace::force_capture())(), // ensure backtraces are different
+        0,
+    );
+
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+    assert_bt!(!=, err, .get_unused_backtrace);
+}
diff --git a/vendor/derive_more/tests/error/nightly/derives_for_generic_enums_with_backtrace.rs b/vendor/derive_more/tests/error/nightly/derives_for_generic_enums_with_backtrace.rs
new file mode 100644
index 000000000..8574751d0
--- /dev/null
+++ b/vendor/derive_more/tests/error/nightly/derives_for_generic_enums_with_backtrace.rs
@@ -0,0 +1,272 @@
+use super::*;
+
+derive_display!(TestErr, T);
+#[derive(Debug, Error)]
+enum TestErr<T> {
+    Unit,
+    NamedImplicitNoBacktrace {
+        field: T,
+    },
+    NamedImplicitBacktraceByFieldName {
+        backtrace: MyBacktrace,
+        field: T,
+    },
+    NamedImplicitBacktraceByFieldType {
+        implicit_backtrace: Backtrace,
+        field: T,
+    },
+    NamedExplicitNoBacktraceByFieldName {
+        #[error(not(backtrace))]
+        backtrace: MyBacktrace,
+        field: T,
+    },
+    NamedExplicitNoBacktraceByFieldType {
+        #[error(not(backtrace))]
+        implicit_backtrace: Backtrace,
+        field: T,
+    },
+    NamedExplicitBacktrace {
+        #[error(backtrace)]
+        explicit_backtrace: MyBacktrace,
+        field: T,
+    },
+    NamedExplicitNoBacktraceRedundant {
+        #[error(not(backtrace))]
+        not_backtrace: MyBacktrace,
+        #[error(not(backtrace))]
+        field: T,
+    },
+    NamedExplicitBacktraceByFieldNameRedundant {
+        #[error(backtrace)]
+        backtrace: MyBacktrace,
+        field: T,
+    },
+    NamedExplicitBacktraceByFieldTypeRedundant {
+        #[error(backtrace)]
+        implicit_backtrace: Backtrace,
+        field: T,
+    },
+    NamedExplicitSupressesImplicit {
+        #[error(backtrace)]
+        not_backtrace: MyBacktrace,
+        backtrace: Backtrace,
+        field: T,
+    },
+    UnnamedImplicitNoBacktrace(T, T),
+    UnnamedImplicitBacktrace(Backtrace, T, T),
+    UnnamedExplicitNoBacktrace(#[error(not(backtrace))] Backtrace, T),
+    UnnamedExplicitBacktrace(#[error(backtrace)] MyBacktrace, T, T),
+    UnnamedExplicitNoBacktraceRedundant(
+        #[error(not(backtrace))] MyBacktrace,
+        #[error(not(backtrace))] T,
+    ),
+    UnnamedExplicitBacktraceRedundant(#[error(backtrace)] Backtrace, T, T),
+    UnnamedExplicitSupressesImplicit(#[error(backtrace)] MyBacktrace, Backtrace, T),
+}
+
+impl<T> TestErr<T> {
+    fn get_stored_backtrace(&self) -> &Backtrace {
+        match self {
+            Self::NamedImplicitBacktraceByFieldName { backtrace, .. } => backtrace,
+            Self::NamedImplicitBacktraceByFieldType {
+                implicit_backtrace, ..
+            } => implicit_backtrace,
+            Self::NamedExplicitBacktrace {
+                explicit_backtrace, ..
+            } => explicit_backtrace,
+            Self::NamedExplicitBacktraceByFieldNameRedundant { backtrace, .. } => {
+                backtrace
+            }
+            Self::NamedExplicitBacktraceByFieldTypeRedundant {
+                implicit_backtrace,
+                ..
+            } => implicit_backtrace,
+            Self::NamedExplicitSupressesImplicit { not_backtrace, .. } => not_backtrace,
+            Self::UnnamedImplicitBacktrace(backtrace, _, _) => backtrace,
+            Self::UnnamedExplicitBacktrace(backtrace, _, _) => backtrace,
+            Self::UnnamedExplicitBacktraceRedundant(backtrace, _, _) => backtrace,
+            Self::UnnamedExplicitSupressesImplicit(backtrace, _, _) => backtrace,
+            _ => panic!("ERROR IN TEST IMPLEMENTATION"),
+        }
+    }
+
+    fn get_unused_backtrace(&self) -> &Backtrace {
+        match self {
+            Self::NamedExplicitSupressesImplicit { backtrace, .. } => backtrace,
+            Self::UnnamedExplicitSupressesImplicit(_, backtrace, _) => backtrace,
+            _ => panic!("ERROR IN TEST IMPLEMENTATION"),
+        }
+    }
+}
+
+type MyBacktrace = Backtrace;
+
+#[test]
+fn unit() {
+    assert!(TestErr::<i32>::Unit.backtrace().is_none());
+}
+
+#[test]
+fn named_implicit_no_backtrace() {
+    let err = TestErr::NamedImplicitNoBacktrace { field: 0 };
+
+    assert!(err.backtrace().is_none());
+}
+
+#[test]
+fn named_implicit_backtrace_by_field_name() {
+    let err = TestErr::NamedImplicitBacktraceByFieldName {
+        backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+}
+
+#[test]
+fn named_implicit_backtrace_by_field_type() {
+    let err = TestErr::NamedImplicitBacktraceByFieldType {
+        implicit_backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+}
+
+#[test]
+fn named_explicit_no_backtrace_by_field_name() {
+    let err = TestErr::NamedExplicitNoBacktraceByFieldName {
+        backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+
+    assert!(err.backtrace().is_none());
+}
+
+#[test]
+fn named_explicit_no_backtrace_by_field_type() {
+    let err = TestErr::NamedExplicitNoBacktraceByFieldType {
+        implicit_backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+
+    assert!(err.backtrace().is_none());
+}
+
+#[test]
+fn named_explicit_backtrace() {
+    let err = TestErr::NamedExplicitBacktrace {
+        explicit_backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+}
+
+#[test]
+fn named_explicit_no_backtrace_redundant() {
+    let err = TestErr::NamedExplicitNoBacktraceRedundant {
+        not_backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+
+    assert!(err.backtrace().is_none());
+}
+
+#[test]
+fn named_explicit_backtrace_by_field_name_redundant() {
+    let err = TestErr::NamedExplicitBacktraceByFieldNameRedundant {
+        backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+}
+
+#[test]
+fn named_explicit_backtrace_by_field_type_redundant() {
+    let err = TestErr::NamedExplicitBacktraceByFieldTypeRedundant {
+        implicit_backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+}
+
+#[test]
+fn named_explicit_supresses_implicit() {
+    let err = TestErr::NamedExplicitSupressesImplicit {
+        not_backtrace: Backtrace::force_capture(),
+        backtrace: (|| Backtrace::force_capture())(), // ensure backtraces are different
+        field: 0,
+    };
+
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+    assert_bt!(!=, err, .get_unused_backtrace);
+}
+
+#[test]
+fn unnamed_implicit_no_backtrace() {
+    let err = TestErr::UnnamedImplicitNoBacktrace(0, 0);
+
+    assert!(err.backtrace().is_none());
+}
+
+#[test]
+fn unnamed_implicit_backtrace() {
+    let err = TestErr::UnnamedImplicitBacktrace(Backtrace::force_capture(), 0, 0);
+
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+}
+
+#[test]
+fn unnamed_explicit_no_backtrace() {
+    let err = TestErr::UnnamedExplicitNoBacktrace(Backtrace::force_capture(), 0);
+
+    assert!(err.backtrace().is_none());
+}
+
+#[test]
+fn unnamed_explicit_backtrace() {
+    let err = TestErr::UnnamedExplicitBacktrace(Backtrace::force_capture(), 0, 0);
+
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+}
+
+#[test]
+fn unnamed_explicit_no_backtrace_redundant() {
+    let err =
+        TestErr::UnnamedExplicitNoBacktraceRedundant(Backtrace::force_capture(), 0);
+
+    assert!(err.backtrace().is_none());
+}
+
+#[test]
+fn unnamed_explicit_backtrace_redundant() {
+    let err =
+        TestErr::UnnamedExplicitBacktraceRedundant(Backtrace::force_capture(), 0, 0);
+
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+}
+
+#[test]
+fn unnamed_explicit_supresses_implicit() {
+    let err = TestErr::UnnamedExplicitSupressesImplicit(
+        Backtrace::force_capture(),
+        (|| Backtrace::force_capture())(), // ensure backtraces are different
+        0,
+    );
+
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+    assert_bt!(!=, err, .get_unused_backtrace);
+}
diff --git a/vendor/derive_more/tests/error/nightly/derives_for_generic_structs_with_backtrace.rs b/vendor/derive_more/tests/error/nightly/derives_for_generic_structs_with_backtrace.rs
new file mode 100644
index 000000000..91df87c82
--- /dev/null
+++ b/vendor/derive_more/tests/error/nightly/derives_for_generic_structs_with_backtrace.rs
@@ -0,0 +1,275 @@
+use super::*;
+
+#[test]
+fn named_implicit_no_backtrace() {
+    derive_display!(TestErr, T);
+    #[derive(Default, Debug, Error)]
+    struct TestErr<T> {
+        field: T,
+    }
+
+    assert!(TestErr::<i32>::default().backtrace().is_none());
+}
+
+#[test]
+fn named_implicit_backtrace_by_field_name() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T> {
+        backtrace: MyBacktrace,
+        field: T,
+    }
+
+    type MyBacktrace = Backtrace;
+
+    let err = TestErr {
+        backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err);
+}
+
+#[test]
+fn named_implicit_backtrace_by_field_type() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T> {
+        implicit_backtrace: Backtrace,
+        field: T,
+    }
+
+    let err = TestErr {
+        implicit_backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, implicit_backtrace);
+}
+
+#[test]
+fn named_explicit_no_backtrace_by_field_name() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T> {
+        #[error(not(backtrace))]
+        backtrace: MyBacktrace,
+        field: T,
+    }
+
+    type MyBacktrace = Backtrace;
+
+    assert!(TestErr {
+        backtrace: Backtrace::force_capture(),
+        field: 0
+    }
+    .backtrace()
+    .is_none());
+}
+
+#[test]
+fn named_explicit_no_backtrace_by_field_type() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T> {
+        #[error(not(backtrace))]
+        implicit_backtrace: Backtrace,
+        field: T,
+    }
+
+    assert!(TestErr {
+        implicit_backtrace: Backtrace::force_capture(),
+        field: 0
+    }
+    .backtrace()
+    .is_none());
+}
+
+#[test]
+fn named_explicit_backtrace() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T> {
+        #[error(backtrace)]
+        explicit_backtrace: MyBacktrace,
+        field: T,
+    }
+
+    type MyBacktrace = Backtrace;
+
+    let err = TestErr {
+        explicit_backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, explicit_backtrace);
+}
+
+#[test]
+fn named_explicit_no_backtrace_redundant() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T> {
+        #[error(not(backtrace))]
+        not_backtrace: MyBacktrace,
+        #[error(not(backtrace))]
+        field: T,
+    }
+
+    type MyBacktrace = Backtrace;
+
+    assert!(TestErr {
+        not_backtrace: Backtrace::force_capture(),
+        field: 0
+    }
+    .backtrace()
+    .is_none());
+}
+
+#[test]
+fn named_explicit_backtrace_by_field_name_redundant() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T> {
+        #[error(backtrace)]
+        backtrace: MyBacktrace,
+        field: T,
+    }
+
+    type MyBacktrace = Backtrace;
+
+    let err = TestErr {
+        backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err);
+}
+
+#[test]
+fn named_explicit_backtrace_by_field_type_redundant() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T> {
+        #[error(backtrace)]
+        implicit_backtrace: Backtrace,
+        field: T,
+    }
+
+    let err = TestErr {
+        implicit_backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, implicit_backtrace);
+}
+
+#[test]
+fn named_explicit_supresses_implicit() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T> {
+        #[error(backtrace)]
+        not_backtrace: MyBacktrace,
+        backtrace: Backtrace,
+        field: T,
+    }
+
+    type MyBacktrace = Backtrace;
+
+    let err = TestErr {
+        not_backtrace: Backtrace::force_capture(),
+        backtrace: (|| Backtrace::force_capture())(), // ensure backtraces are different
+        field: 0,
+    };
+
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, not_backtrace);
+    assert_bt!(!=, err);
+}
+
+#[test]
+fn unnamed_implicit_no_backtrace() {
+    derive_display!(TestErr, T);
+    #[derive(Default, Debug, Error)]
+    struct TestErr<T>(T, T);
+
+    assert!(TestErr::<i32>::default().backtrace().is_none());
+}
+
+#[test]
+fn unnamed_implicit_backtrace() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T>(Backtrace, T, T);
+
+    let err = TestErr(Backtrace::force_capture(), 0, 0);
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, 0);
+}
+
+#[test]
+fn unnamed_explicit_no_backtrace() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T>(#[error(not(backtrace))] Backtrace, T);
+
+    assert!(TestErr(Backtrace::force_capture(), 0).backtrace().is_none());
+}
+
+#[test]
+fn unnamed_explicit_backtrace() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T>(#[error(backtrace)] MyBacktrace, T, T);
+
+    type MyBacktrace = Backtrace;
+
+    let err = TestErr(Backtrace::force_capture(), 0, 0);
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, 0);
+}
+
+#[test]
+fn unnamed_explicit_no_backtrace_redundant() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T>(
+        #[error(not(backtrace))] MyBacktrace,
+        #[error(not(backtrace))] T,
+    );
+
+    type MyBacktrace = Backtrace;
+
+    assert!(TestErr(Backtrace::force_capture(), 0).backtrace().is_none());
+}
+
+#[test]
+fn unnamed_explicit_backtrace_redundant() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T>(#[error(backtrace)] Backtrace, T, T);
+
+    let err = TestErr(Backtrace::force_capture(), 0, 0);
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, 0);
+}
+
+#[test]
+fn unnamed_explicit_supresses_implicit() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T>(#[error(backtrace)] MyBacktrace, Backtrace, T);
+
+    type MyBacktrace = Backtrace;
+
+    let err = TestErr(
+        Backtrace::force_capture(),
+        (|| Backtrace::force_capture())(), // ensure backtraces are different
+        0,
+    );
+
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, 0);
+    assert_bt!(!=, err, 1);
+}
diff --git a/vendor/derive_more/tests/error/nightly/derives_for_structs_with_backtrace.rs b/vendor/derive_more/tests/error/nightly/derives_for_structs_with_backtrace.rs
new file mode 100644
index 000000000..18e268f84
--- /dev/null
+++ b/vendor/derive_more/tests/error/nightly/derives_for_structs_with_backtrace.rs
@@ -0,0 +1,280 @@
+use super::*;
+
+#[test]
+fn unit() {
+    assert!(SimpleErr.backtrace().is_none());
+}
+
+#[test]
+fn named_implicit_no_backtrace() {
+    derive_display!(TestErr);
+    #[derive(Default, Debug, Error)]
+    struct TestErr {
+        field: i32,
+    }
+
+    assert!(TestErr::default().backtrace().is_none());
+}
+
+#[test]
+fn named_implicit_backtrace_by_field_name() {
+    derive_display!(TestErr);
+    #[derive(Debug, Error)]
+    struct TestErr {
+        backtrace: MyBacktrace,
+        field: i32,
+    }
+
+    type MyBacktrace = Backtrace;
+
+    let err = TestErr {
+        backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err);
+}
+
+#[test]
+fn named_implicit_backtrace_by_field_type() {
+    derive_display!(TestErr);
+    #[derive(Debug, Error)]
+    struct TestErr {
+        implicit_backtrace: Backtrace,
+        field: i32,
+    }
+
+    let err = TestErr {
+        implicit_backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, implicit_backtrace);
+}
+
+#[test]
+fn named_explicit_no_backtrace_by_field_name() {
+    derive_display!(TestErr);
+    #[derive(Debug, Error)]
+    struct TestErr {
+        #[error(not(backtrace))]
+        backtrace: MyBacktrace,
+        field: i32,
+    }
+
+    type MyBacktrace = Backtrace;
+
+    assert!(TestErr {
+        backtrace: Backtrace::force_capture(),
+        field: 0
+    }
+    .backtrace()
+    .is_none());
+}
+
+#[test]
+fn named_explicit_no_backtrace_by_field_type() {
+    derive_display!(TestErr);
+    #[derive(Debug, Error)]
+    struct TestErr {
+        #[error(not(backtrace))]
+        implicit_backtrace: Backtrace,
+        field: i32,
+    }
+
+    assert!(TestErr {
+        implicit_backtrace: Backtrace::force_capture(),
+        field: 0
+    }
+    .backtrace()
+    .is_none());
+}
+
+#[test]
+fn named_explicit_backtrace() {
+    derive_display!(TestErr);
+    #[derive(Debug, Error)]
+    struct TestErr {
+        #[error(backtrace)]
+        explicit_backtrace: MyBacktrace,
+        field: i32,
+    }
+
+    type MyBacktrace = Backtrace;
+
+    let err = TestErr {
+        explicit_backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, explicit_backtrace);
+}
+
+#[test]
+fn named_explicit_no_backtrace_redundant() {
+    derive_display!(TestErr);
+    #[derive(Debug, Error)]
+    struct TestErr {
+        #[error(not(backtrace))]
+        not_backtrace: MyBacktrace,
+        #[error(not(backtrace))]
+        field: i32,
+    }
+
+    type MyBacktrace = Backtrace;
+
+    assert!(TestErr {
+        not_backtrace: Backtrace::force_capture(),
+        field: 0
+    }
+    .backtrace()
+    .is_none());
+}
+
+#[test]
+fn named_explicit_backtrace_by_field_name_redundant() {
+    derive_display!(TestErr);
+    #[derive(Debug, Error)]
+    struct TestErr {
+        #[error(backtrace)]
+        backtrace: MyBacktrace,
+        field: i32,
+    }
+
+    type MyBacktrace = Backtrace;
+
+    let err = TestErr {
+        backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err);
+}
+
+#[test]
+fn named_explicit_backtrace_by_field_type_redundant() {
+    derive_display!(TestErr);
+    #[derive(Debug, Error)]
+    struct TestErr {
+        #[error(backtrace)]
+        implicit_backtrace: Backtrace,
+        field: i32,
+    }
+
+    let err = TestErr {
+        implicit_backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, implicit_backtrace);
+}
+
+#[test]
+fn named_explicit_supresses_implicit() {
+    derive_display!(TestErr);
+    #[derive(Debug, Error)]
+    struct TestErr {
+        #[error(backtrace)]
+        not_backtrace: MyBacktrace,
+        backtrace: Backtrace,
+        field: i32,
+    }
+
+    type MyBacktrace = Backtrace;
+
+    let err = TestErr {
+        not_backtrace: Backtrace::force_capture(),
+        backtrace: (|| Backtrace::force_capture())(), // ensure backtraces are different
+        field: 0,
+    };
+
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, not_backtrace);
+    assert_bt!(!=, err);
+}
+
+#[test]
+fn unnamed_implicit_no_backtrace() {
+    derive_display!(TestErr);
+    #[derive(Default, Debug, Error)]
+    struct TestErr(i32, i32);
+
+    assert!(TestErr::default().backtrace().is_none());
+}
+
+#[test]
+fn unnamed_implicit_backtrace() {
+    derive_display!(TestErr);
+    #[derive(Debug, Error)]
+    struct TestErr(Backtrace, i32, i32);
+
+    let err = TestErr(Backtrace::force_capture(), 0, 0);
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, 0);
+}
+
+#[test]
+fn unnamed_explicit_no_backtrace() {
+    derive_display!(TestErr);
+    #[derive(Debug, Error)]
+    struct TestErr(#[error(not(backtrace))] Backtrace, i32);
+
+    assert!(TestErr(Backtrace::force_capture(), 0).backtrace().is_none());
+}
+
+#[test]
+fn unnamed_explicit_backtrace() {
+    derive_display!(TestErr);
+    #[derive(Debug, Error)]
+    struct TestErr(#[error(backtrace)] MyBacktrace, i32, i32);
+
+    type MyBacktrace = Backtrace;
+
+    let err = TestErr(Backtrace::force_capture(), 0, 0);
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, 0);
+}
+
+#[test]
+fn unnamed_explicit_no_backtrace_redundant() {
+    derive_display!(TestErr);
+    #[derive(Debug, Error)]
+    struct TestErr(
+        #[error(not(backtrace))] MyBacktrace,
+        #[error(not(backtrace))] i32,
+    );
+
+    type MyBacktrace = Backtrace;
+
+    assert!(TestErr(Backtrace::force_capture(), 0).backtrace().is_none());
+}
+
+#[test]
+fn unnamed_explicit_backtrace_redundant() {
+    derive_display!(TestErr);
+    #[derive(Debug, Error)]
+    struct TestErr(#[error(backtrace)] Backtrace, i32, i32);
+
+    let err = TestErr(Backtrace::force_capture(), 0, 0);
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, 0);
+}
+
+#[test]
+fn unnamed_explicit_supresses_implicit() {
+    derive_display!(TestErr);
+    #[derive(Debug, Error)]
+    struct TestErr(#[error(backtrace)] MyBacktrace, Backtrace, i32);
+
+    type MyBacktrace = Backtrace;
+
+    let err = TestErr(
+        Backtrace::force_capture(),
+        (|| Backtrace::force_capture())(), // ensure backtraces are different
+        0,
+    );
+
+    assert!(err.backtrace().is_some());
+    assert_bt!(==, err, 0);
+    assert_bt!(!=, err, 1);
+}
diff --git a/vendor/derive_more/tests/error/nightly/mod.rs b/vendor/derive_more/tests/error/nightly/mod.rs
new file mode 100644
index 000000000..57de7ba2a
--- /dev/null
+++ b/vendor/derive_more/tests/error/nightly/mod.rs
@@ -0,0 +1,85 @@
+use std::backtrace::Backtrace;
+
+use super::*;
+
+/// Asserts that backtrace returned by `Error::backtrace` method equals/not-equals
+/// backtrace stored in object itself.
+///
+/// Comparison is done by converting backtraces to strings
+/// and then comparing these strings.
+///
+/// ## Syntax
+///
+/// * Equals: `assert_bt!(==, ...)`
+/// * Not-equals: `assert_bt!(!=, ...)`
+///
+/// ### Backtrace Access
+///
+/// Shortcut for named-structs with `backtrace` field.
+/// Access backtrace as `error.backtrace`.
+///
+/// ```
+/// assert_bt!(==, error);
+/// ```
+///
+/// Full form for named- and tuple-structs.
+/// Access backtrace as `error.some_other_field` and `error.1` respectively.
+///
+/// ```
+/// assert_bt!(!=, error, some_other_field);
+/// assert_bt!(==, error, 1);
+/// ```
+///
+/// Access as a method call.
+/// Useful for enums (i.e., you can define a method that will match on enum variants
+/// and return backtrace for each variant).
+/// Access backtrace as `error.get_stored_backtrace_method()`.
+///
+/// ```
+/// assert_bt!(!=, error, .get_stored_backtrace_method);
+/// ```
+macro_rules! assert_bt {
+    (@impl $macro:ident, $error:expr, $backtrace:expr) => {
+        $macro!($error.backtrace().unwrap().to_string(), $backtrace.to_string());
+    };
+    (@expand $macro:ident, $error:expr, .$backtrace:ident) => {
+        assert_bt!(@impl $macro, $error, $error.$backtrace())
+    };
+    (@expand $macro:ident, $error:expr, $backtrace:tt) => {
+        assert_bt!(@impl $macro, $error, $error.$backtrace)
+    };
+    (@expand $macro:ident, $error:expr) => {
+        assert_bt!(@expand $macro, $error, backtrace)
+    };
+    (==, $($args:tt)*) => {
+        assert_bt!(@expand assert_eq, $($args)*)
+    };
+    (!=, $($args:tt)*) => {
+        assert_bt!(@expand assert_ne, $($args)*)
+    };
+}
+
+mod derives_for_enums_with_backtrace;
+mod derives_for_generic_enums_with_backtrace;
+mod derives_for_generic_structs_with_backtrace;
+mod derives_for_structs_with_backtrace;
+
+derive_display!(BacktraceErr);
+#[derive(Debug)]
+struct BacktraceErr {
+    backtrace: Backtrace,
+}
+
+impl Default for BacktraceErr {
+    fn default() -> Self {
+        Self {
+            backtrace: Backtrace::force_capture(),
+        }
+    }
+}
+
+impl Error for BacktraceErr {
+    fn backtrace(&self) -> Option<&Backtrace> {
+        Some(&self.backtrace)
+    }
+}
diff --git a/vendor/derive_more/tests/error_tests.rs b/vendor/derive_more/tests/error_tests.rs
new file mode 100644
index 000000000..c2798bd14
--- /dev/null
+++ b/vendor/derive_more/tests/error_tests.rs
@@ -0,0 +1,6 @@
+#![cfg_attr(feature = "nightly", feature(backtrace))]
+
+#[macro_use]
+extern crate derive_more;
+
+mod error;
diff --git a/vendor/derive_more/tests/from.rs b/vendor/derive_more/tests/from.rs
new file mode 100644
index 000000000..63bb10201
--- /dev/null
+++ b/vendor/derive_more/tests/from.rs
@@ -0,0 +1,187 @@
+#![allow(dead_code)]
+#[macro_use]
+extern crate derive_more;
+
+use std::borrow::Cow;
+
+#[derive(From)]
+struct EmptyTuple();
+
+#[derive(From)]
+struct EmptyStruct {}
+
+#[derive(From)]
+struct EmptyUnit;
+
+#[derive(From)]
+struct MyInt(i32);
+
+#[derive(From)]
+struct MyInts(i32, i32);
+
+#[derive(From)]
+struct Point1D {
+    x: i32,
+}
+
+#[derive(From)]
+struct Point2D {
+    x: i32,
+    y: i32,
+}
+
+#[derive(From)]
+enum MixedInts {
+    SmallInt(i32),
+    NamedBigInt {
+        int: i64,
+    },
+    TwoSmallInts(i32, i32),
+    NamedBigInts {
+        x: i64,
+        y: i64,
+    },
+    #[from(ignore)]
+    Unsigned(u32),
+    NamedUnsigned {
+        x: u32,
+    },
+}
+
+#[derive(PartialEq, Eq, Debug)]
+#[derive(From)]
+#[from(forward)]
+struct MyIntForward(u64);
+
+#[test]
+fn forward_struct() {
+    assert_eq!(MyIntForward(42), 42u32.into());
+    assert_eq!(MyIntForward(42), 42u16.into());
+    assert_eq!(MyIntForward(42), 42u64.into());
+}
+
+#[derive(PartialEq, Eq, Debug)]
+#[derive(From)]
+enum MixedIntsForward {
+    #[from(forward)]
+    SmallInt(i32),
+    NamedBigInt {
+        int: i64,
+    },
+}
+
+#[test]
+fn forward_enum() {
+    assert_eq!(MixedIntsForward::SmallInt(42), 42i32.into());
+    assert_eq!(MixedIntsForward::SmallInt(42), 42i16.into());
+}
+
+#[derive(From, PartialEq)]
+enum AutoIgnore {
+    SmallInt(i32),
+    Uninteresting,
+    Uninteresting2,
+}
+
+#[test]
+fn auto_ignore_variants() {
+    assert!(AutoIgnore::SmallInt(42) == 42i32.into());
+}
+
+#[derive(From, PartialEq)]
+enum AutoIgnoreWithDefaultTrue {
+    #[from(ignore)]
+    SmallInt(i32),
+    Uninteresting,
+    Uninteresting2,
+}
+
+#[derive(From, PartialEq)]
+enum AutoIgnoreWithForwardFields2 {
+    #[from(forward)]
+    SmallInt(i32),
+    SmallIntIgnore(i32),
+}
+
+#[test]
+fn auto_ignore_with_forward_field2() {
+    assert!(AutoIgnoreWithForwardFields2::SmallInt(42) == 42i32.into());
+    assert!(AutoIgnoreWithForwardFields2::SmallInt(42) == 42i16.into());
+}
+
+#[derive(Debug, Eq, PartialEq)]
+#[derive(From)]
+#[from(types(u8, u16, u32))]
+struct MyIntExplicit(u64);
+
+#[test]
+fn explicit_types_struct() {
+    assert_eq!(MyIntExplicit(42), 42u8.into());
+    assert_eq!(MyIntExplicit(42), 42u16.into());
+    assert_eq!(MyIntExplicit(42), 42u32.into());
+    assert_eq!(MyIntExplicit(42), 42u64.into());
+}
+
+#[derive(Debug, Eq, PartialEq)]
+#[derive(From)]
+#[from(types(i8, i16))]
+struct MyIntsExplicit(i32, i32);
+
+#[test]
+fn explicit_types_struct_tupled() {
+    assert_eq!(MyIntsExplicit(42, 42), (42i32, 42i32).into());
+    assert_eq!(MyIntsExplicit(42, 42), (42i8, 42i8).into());
+    assert_eq!(MyIntsExplicit(42, 42), (42i16, 42i16).into());
+}
+
+#[derive(Debug, Eq, PartialEq)]
+#[derive(From)]
+enum MixedIntsExplicit {
+    #[from(types(i8))]
+    SmallInt(i32),
+    #[from(types(i16, i64))]
+    AnotherInt(i128),
+    NamedBigInt {
+        int: i64,
+    },
+}
+
+#[test]
+fn explicit_types_enum() {
+    assert_eq!(MixedIntsExplicit::SmallInt(42), 42i32.into());
+    assert_eq!(MixedIntsExplicit::SmallInt(42), 42i8.into());
+
+    assert_eq!(MixedIntsExplicit::AnotherInt(42), 42i128.into());
+    assert_eq!(MixedIntsExplicit::AnotherInt(42), 42i64.into());
+    assert_eq!(MixedIntsExplicit::AnotherInt(42), 42i16.into());
+}
+
+#[derive(Debug, Eq, PartialEq)]
+#[derive(From)]
+#[from(types(i8, i16))]
+struct Point2DExplicit {
+    x: i32,
+    y: i32,
+}
+
+#[test]
+fn explicit_types_point_2d() {
+    let expected = Point2DExplicit { x: 42, y: 42 };
+    assert_eq!(expected, (42i32, 42i32).into());
+    assert_eq!(expected, (42i8, 42i8).into());
+    assert_eq!(expected, (42i16, 42i16).into());
+}
+
+#[derive(Debug, Eq, PartialEq)]
+#[derive(From)]
+#[from(types("Cow<'_, str>", "&str"))]
+struct Name(String);
+
+#[test]
+fn explicit_complex_types_name() {
+    let name = "Eärendil";
+    let expected = Name(name.to_owned());
+    assert_eq!(expected, name.to_owned().into());
+    assert_eq!(expected, name.into());
+    assert_eq!(expected, Cow::Borrowed(name).into());
+}
diff --git a/vendor/derive_more/tests/from_str.rs b/vendor/derive_more/tests/from_str.rs
new file mode 100644
index 000000000..4bb0eca63
--- /dev/null
+++ b/vendor/derive_more/tests/from_str.rs
@@ -0,0 +1,11 @@
+#![allow(dead_code)]
+#[macro_use]
+extern crate derive_more;
+
+#[derive(FromStr)]
+struct MyInt(i32);
+
+#[derive(FromStr)]
+struct Point1D {
+    x: i32,
+}
diff --git a/vendor/derive_more/tests/generics.rs b/vendor/derive_more/tests/generics.rs
new file mode 100644
index 000000000..17af5f397
--- /dev/null
+++ b/vendor/derive_more/tests/generics.rs
@@ -0,0 +1,123 @@
+#![allow(dead_code, non_camel_case_types)]
+#[macro_use]
+extern crate derive_more;
+
+#[derive(
+    From,
+    FromStr,
+    Display,
+    Index,
+    Not,
+    Add,
+    Mul,
+    Sum,
+    IndexMut,
+    AddAssign,
+    MulAssign,
+    Deref,
+    DerefMut,
+    IntoIterator,
+    Constructor
+)]
+#[deref(forward)]
+#[deref_mut(forward)]
+#[into_iterator(owned, ref, ref_mut)]
+struct Wrapped<T: Clone>(T);
+
+#[derive(Deref, DerefMut)]
+struct Wrapped2<T: Clone>(T);
+
+#[derive(From, Not, Add, Mul, AddAssign, MulAssign, Constructor, Sum)]
+struct WrappedDouble<T: Clone, U: Clone>(T, U);
+
+#[derive(From)]
+#[from(forward)]
+struct WrappedDouble2<T: Clone, U: Clone>(T, U);
+
+#[cfg(feature = "nightly")]
+#[derive(
+    From,
+    FromStr,
+    Display,
+    Index,
+    Not,
+    Add,
+    Mul,
+    Sum,
+    IndexMut,
+    AddAssign,
+    MulAssign,
+    Deref,
+    DerefMut,
+    IntoIterator,
+    Constructor
+)]
+struct WrappedWithConst<T, const C: u32>(T);
+
+#[derive(
+    From,
+    FromStr,
+    Display,
+    Index,
+    Not,
+    Add,
+    Mul,
+    IndexMut,
+    AddAssign,
+    MulAssign,
+    Deref,
+    DerefMut,
+    IntoIterator,
+    Constructor,
+    Sum
+)]
+#[deref(forward)]
+#[deref_mut(forward)]
+#[into_iterator(owned, ref, ref_mut)]
+struct Struct<T: Clone> {
+    t: T,
+}
+
+#[derive(Deref, DerefMut)]
+struct Struct2<T: Clone> {
+    t: T,
+}
+
+#[derive(From, Not, Add, Mul, AddAssign, MulAssign, Constructor, Sum)]
+struct DoubleStruct<T: Clone, U: Clone> {
+    t: T,
+    u: U,
+}
+
+#[derive(From)]
+#[from(forward)]
+struct DoubleStruct2<T: Clone, U: Clone> {
+    t: T,
+    u: U,
+}
+
+#[derive(From, Not, Add)]
+enum TupleEnum<T: Clone, U: Clone> {
+    Tuple(T),
+    DoubleTuple(T, U),
+}
+
+#[derive(From)]
+#[from(forward)]
+enum TupleEnum2<T: Clone, U: Clone, X: Clone> {
+    DoubleTuple(T, U),
+    TripleTuple(T, U, X),
+}
+
+#[derive(From, Not, Add)]
+enum StructEnum<T: Clone, U: Clone> {
+    Struct { t: T },
+    DoubleStruct { t: T, u: U },
+}
+
+#[derive(From)]
+#[from(forward)]
+enum StructEnum2<T: Clone, U: Clone, X: Clone> {
+    DoubleStruct { t: T, u: U },
+    TripleStruct { t: T, u: U, x: X },
+}
diff --git a/vendor/derive_more/tests/index.rs b/vendor/derive_more/tests/index.rs
new file mode 100644
index 000000000..952223c09
--- /dev/null
+++ b/vendor/derive_more/tests/index.rs
@@ -0,0 +1,13 @@
+#![allow(dead_code, unused_imports)]
+#[macro_use]
+extern crate derive_more;
+
+#[derive(Index)]
+struct MyVec(Vec<i32>);
+
+#[derive(Index)]
+struct Numbers {
+    #[index]
+    numbers: Vec<i32>,
+    useless: bool,
+}
diff --git a/vendor/derive_more/tests/index_mut.rs b/vendor/derive_more/tests/index_mut.rs
new file mode 100644
index 000000000..a053fd332
--- /dev/null
+++ b/vendor/derive_more/tests/index_mut.rs
@@ -0,0 +1,36 @@
+#![allow(dead_code, unused_imports)]
+#[macro_use]
+extern crate derive_more;
+
+#[derive(IndexMut)]
+struct MyVec(Vec<i32>);
+//Index implementation is required for IndexMut
+impl<__IdxT> ::core::ops::Index<__IdxT> for MyVec
+where
+    Vec<i32>: ::core::ops::Index<__IdxT>,
+{
+    type Output = <Vec<i32> as ::core::ops::Index<__IdxT>>::Output;
+    #[inline]
+    fn index(&self, idx: __IdxT) -> &Self::Output {
+        <Vec<i32> as ::core::ops::Index<__IdxT>>::index(&self.0, idx)
+    }
+}
+
+#[derive(IndexMut)]
+struct Numbers {
+    #[index_mut]
+    numbers: Vec<i32>,
+    useless: bool,
+}
+
+//Index implementation is required for IndexMut
+impl<__IdxT> ::core::ops::Index<__IdxT> for Numbers
+where
+    Vec<i32>: ::core::ops::Index<__IdxT>,
+{
+    type Output = <Vec<i32> as ::core::ops::Index<__IdxT>>::Output;
+    #[inline]
+    fn index(&self, idx: __IdxT) -> &Self::Output {
+        <Vec<i32> as ::core::ops::Index<__IdxT>>::index(&self.numbers, idx)
+    }
+}
diff --git a/vendor/derive_more/tests/into.rs b/vendor/derive_more/tests/into.rs
new file mode 100644
index 000000000..075abd1c9
--- /dev/null
+++ b/vendor/derive_more/tests/into.rs
@@ -0,0 +1,141 @@
+#![allow(dead_code)]
+#[macro_use]
+extern crate derive_more;
+
+use std::borrow::Cow;
+
+#[derive(Into)]
+#[into(owned, ref, ref_mut)]
+struct EmptyTuple();
+
+#[derive(Into)]
+#[into(owned, ref, ref_mut)]
+struct EmptyStruct {}
+
+#[derive(Into)]
+#[into(owned, ref, ref_mut)]
+struct EmptyUnit;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[derive(Into)]
+#[into(owned(types(i64, i128)), ref, ref_mut)]
+struct MyInt(i32);
+
+#[test]
+fn explicit_types_struct_owned_only() {
+    assert_eq!(i32::from(MyInt(42)), 42i32);
+    assert_eq!(<&i32>::from(&MyInt(42)), &42i32);
+    assert_eq!(<&mut i32>::from(&mut MyInt(42)), &mut 42i32);
+    assert_eq!(i64::from(MyInt(42)), 42i64);
+    assert_eq!(i128::from(MyInt(42)), 42i128);
+}
+
+#[derive(Into)]
+#[into(owned, ref, ref_mut)]
+struct MyInts(i32, i32);
+
+#[derive(Into)]
+#[into(owned, ref, ref_mut)]
+struct Point1D {
+    x: i32,
+}
+
+#[derive(Debug, Eq, PartialEq)]
+#[derive(Into)]
+#[into(owned, ref, ref_mut)]
+struct Point2D {
+    x: i32,
+    y: i32,
+}
+
+#[derive(Into)]
+#[into(owned, ref, ref_mut)]
+struct Point2DWithIgnored {
+    x: i32,
+    y: i32,
+    #[into(ignore)]
+    useless: bool,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[derive(Into)]
+#[into(owned(types(i64, i128)), ref, ref_mut, types(i32))]
+struct MyIntExplicit(MyInt);
+
+#[test]
+fn explicit_types_struct_all() {
+    let mut input = MyIntExplicit(MyInt(42));
+    assert_eq!(MyInt::from(input), MyInt(42));
+    assert_eq!(<&MyInt>::from(&input), &MyInt(42));
+    assert_eq!(<&mut MyInt>::from(&mut input), &mut MyInt(42));
+    assert_eq!(i32::from(input), 42i32);
+    assert_eq!(<&i32>::from(&input), &42i32);
+    assert_eq!(<&mut i32>::from(&mut input), &mut 42i32);
+    assert_eq!(i64::from(input), 42i64);
+    assert_eq!(i128::from(input), 42i128);
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[derive(Into)]
+#[into(owned(types(i32, i64, i128)), ref(types(i32)), ref_mut(types(i32)))]
+struct MyIntsExplicit(i32, MyInt, MyIntExplicit);
+
+#[test]
+fn explicit_types_struct_tupled() {
+    let mut input = MyIntsExplicit(42i32, MyInt(42), MyIntExplicit(MyInt(42)));
+    assert_eq!(
+        <(i32, MyInt, MyIntExplicit)>::from(input),
+        (42i32, MyInt(42), MyIntExplicit(MyInt(42))),
+    );
+    assert_eq!(
+        <(&i32, &MyInt, &MyIntExplicit)>::from(&input),
+        (&42i32, &MyInt(42), &MyIntExplicit(MyInt(42))),
+    );
+    assert_eq!(
+        <(&mut i32, &mut MyInt, &mut MyIntExplicit)>::from(&mut input),
+        (&mut 42i32, &mut MyInt(42), &mut MyIntExplicit(MyInt(42))),
+    );
+    assert_eq!(<(i32, i32, i32)>::from(input), (42i32, 42i32, 42i32));
+    assert_eq!(<(&i32, &i32, &i32)>::from(&input), (&42i32, &42i32, &42i32));
+    assert_eq!(
+        <(&mut i32, &mut i32, &mut i32)>::from(&mut input),
+        (&mut 42i32, &mut 42i32, &mut 42i32),
+    );
+    assert_eq!(<(i64, i64, i64)>::from(input), (42i64, 42i64, 42i64));
+    assert_eq!(<(i128, i128, i128)>::from(input), (42i128, 42i128, 42i128));
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[derive(Into)]
+#[into(owned, ref, ref_mut, types(i32))]
+struct Point2DExplicit {
+    x: MyInt,
+    y: MyInt,
+}
+
+#[test]
+fn explicit_types_point_2d() {
+    let mut input = Point2DExplicit {
+        x: MyInt(42),
+        y: MyInt(42),
+    };
+    assert_eq!(<(i32, i32)>::from(input), (42i32, 42i32));
+    assert_eq!(<(&i32, &i32)>::from(&input), (&42i32, &42i32));
+    assert_eq!(
+        <(&mut i32, &mut i32)>::from(&mut input),
+        (&mut 42i32, &mut 42i32)
+    );
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[derive(Into)]
+#[into(owned(types("Cow<'_, str>")))]
+struct Name(String);
+
+#[test]
+fn explicit_complex_types_name() {
+    let name = "Ñolofinwë";
+    let input = Name(name.to_owned());
+    assert_eq!(String::from(input.clone()), name.to_owned());
+    assert_eq!(Cow::from(input.clone()), Cow::Borrowed(name));
+}
diff --git a/vendor/derive_more/tests/into_iterator.rs b/vendor/derive_more/tests/into_iterator.rs
new file mode 100644
index 000000000..8c0e48f57
--- /dev/null
+++ b/vendor/derive_more/tests/into_iterator.rs
@@ -0,0 +1,39 @@
+#![allow(dead_code, unused_imports)]
+#[macro_use]
+extern crate derive_more;
+
+#[derive(IntoIterator)]
+#[into_iterator(owned, ref, ref_mut)]
+struct MyVec(Vec<i32>);
+
+#[derive(IntoIterator)]
+#[into_iterator(owned, ref, ref_mut)]
+struct Numbers {
+    numbers: Vec<i32>,
+}
+
+#[derive(IntoIterator)]
+struct Numbers2 {
+    #[into_iterator(owned, ref, ref_mut)]
+    numbers: Vec<i32>,
+    useless: bool,
+    useless2: bool,
+}
+
+#[derive(IntoIterator)]
+struct Numbers3 {
+    #[into_iterator(ref, ref_mut)]
+    numbers: Vec<i32>,
+    useless: bool,
+    useless2: bool,
+}
+
+// Test that owned is not enabled when ref/ref_mut are enabled without owned
+impl ::core::iter::IntoIterator for Numbers3 {
+    type Item = <Vec<i32> as ::core::iter::IntoIterator>::Item;
+    type IntoIter = <Vec<i32> as ::core::iter::IntoIterator>::IntoIter;
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        <Vec<i32> as ::core::iter::IntoIterator>::into_iter(self.numbers)
+    }
+}
diff --git a/vendor/derive_more/tests/is_variant.rs b/vendor/derive_more/tests/is_variant.rs
new file mode 100644
index 000000000..10876a40b
--- /dev/null
+++ b/vendor/derive_more/tests/is_variant.rs
@@ -0,0 +1,57 @@
+#![allow(dead_code)]
+
+#[macro_use]
+extern crate derive_more;
+
+#[derive(IsVariant)]
+enum Either<TLeft, TRight> {
+    Left(TLeft),
+    Right(TRight),
+}
+
+#[derive(IsVariant)]
+enum Maybe<T> {
+    Nothing,
+    Just(T),
+}
+
+#[derive(IsVariant)]
+enum Color {
+    RGB(u8, u8, u8),
+    CMYK { c: u8, m: u8, y: u8, k: u8 },
+}
+
+#[derive(IsVariant)]
+enum Nonsense<'a, T> {
+    Ref(&'a T),
+    NoRef,
+    #[is_variant(ignore)]
+    NoRefIgnored,
+}
+
+#[derive(IsVariant)]
+enum WithConstraints<T>
+where
+    T: Copy,
+{
+    One(T),
+    Two,
+}
+#[derive(IsVariant)]
+enum KitchenSink<'a, 'b, T1: Copy, T2: Clone>
+where
+    T2: Into<T1> + 'b,
+{
+    Left(&'a T1),
+    Right(&'b T2),
+    OwnBoth { left: T1, right: T2 },
+    Empty,
+    NeverMind(),
+    NothingToSeeHere {},
+}
+
+#[test]
+pub fn test_is_variant() {
+    assert!(Maybe::<()>::Nothing.is_nothing());
+    assert!(!Maybe::<()>::Nothing.is_just());
+}
diff --git a/vendor/derive_more/tests/lib.rs b/vendor/derive_more/tests/lib.rs
new file mode 100644
index 000000000..27fd53d33
--- /dev/null
+++ b/vendor/derive_more/tests/lib.rs
@@ -0,0 +1,275 @@
+#[macro_use]
+extern crate derive_more;
+
+#[derive(From)]
+#[derive(Into)]
+#[derive(Constructor)]
+#[derive(Eq, PartialEq, Debug, Clone)]
+#[derive(Add)]
+#[derive(Mul)]
+#[derive(Neg)]
+#[derive(AddAssign)]
+#[derive(MulAssign)]
+#[derive(FromStr)]
+#[derive(Display)]
+#[derive(Octal)]
+#[derive(Binary)]
+#[derive(Deref, DerefMut)]
+#[into(owned, ref, ref_mut)]
+struct MyInt(i32);
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[derive(Add)]
+#[derive(Sum)]
+#[derive(Mul)]
+#[derive(MulAssign)]
+#[derive(Product)]
+#[mul(forward)]
+#[mul_assign(forward)]
+struct MyInt2(i32);
+
+#[derive(Eq, PartialEq, Debug)]
+#[derive(Index, IndexMut)]
+#[derive(Deref, DerefMut)]
+#[derive(IntoIterator)]
+#[deref(forward)]
+#[deref_mut(forward)]
+#[into_iterator(owned, ref, ref_mut)]
+struct MyVec(Vec<i32>);
+
+#[derive(Eq, PartialEq, Debug)]
+#[derive(Deref, DerefMut)]
+#[deref(forward)]
+#[deref_mut(forward)]
+struct MyBoxedInt(Box<i32>);
+
+#[derive(Eq, PartialEq, Debug)]
+#[derive(Not)]
+#[derive(From)]
+struct MyBool(bool);
+
+#[derive(From)]
+#[derive(Into)]
+#[derive(Constructor)]
+#[derive(Add)]
+#[derive(Eq, PartialEq, Debug)]
+#[derive(Mul)]
+#[derive(AddAssign)]
+struct MyUInt(u64, u64);
+
+#[derive(From)]
+#[derive(Into)]
+#[derive(Constructor)]
+#[derive(FromStr)]
+#[derive(Eq, PartialEq, Debug)]
+#[derive(Display)]
+struct SimpleStruct {
+    int1: u64,
+}
+
+#[derive(From)]
+#[derive(Constructor)]
+#[derive(Add, Sub, Mul, Div, Rem, BitAnd, BitOr, BitXor, Shr, Shl)]
+#[derive(Eq, PartialEq, Debug, Clone, Copy)]
+#[derive(Into)]
+#[derive(AddAssign)]
+#[into(owned, ref, ref_mut)]
+struct NormalStruct {
+    int1: u64,
+    int2: u64,
+}
+
+#[derive(From)]
+#[derive(Eq, PartialEq, Debug)]
+struct NestedInt(MyInt);
+
+#[derive(Eq, PartialEq, Debug)]
+#[derive(From)]
+#[derive(Add, Sub)]
+enum SimpleMyIntEnum {
+    Int(i32),
+    #[from(ignore)]
+    _UnsignedOne(u32),
+    _UnsignedTwo(u32),
+}
+#[derive(Eq, PartialEq, Debug)]
+#[derive(From)]
+#[derive(Neg)]
+enum SimpleSignedIntEnum {
+    Int(i32),
+    Int2(i16),
+}
+
+#[derive(Eq, PartialEq, Debug)]
+#[derive(From)]
+#[derive(Add, Sub)]
+#[derive(Neg)]
+enum SimpleEnum {
+    Int(i32),
+    #[from(ignore)]
+    _Ints(i32, i32),
+    LabeledInts {
+        a: i32,
+        b: i32,
+    },
+    _SomeUnit,
+}
+
+#[derive(Eq, PartialEq, Debug)]
+#[derive(From)]
+#[derive(Add, Sub)]
+enum MyIntEnum {
+    SmallInt(i32),
+    BigInt(i64),
+    TwoInts(i32, i32),
+    Point2D {
+        x: i64,
+        y: i64,
+    },
+    #[from(ignore)]
+    _UnsignedOne(u32),
+    _UnsignedTwo(u32),
+    #[from(ignore)]
+    _Uints1(u64, u64),
+    _Uints2 {
+        x: u64,
+        y: u64,
+    },
+    Nothing,
+}
+
+#[derive(Eq, PartialEq, Debug)]
+#[derive(Add, Mul)]
+struct DoubleUInt(u32, u32);
+
+#[derive(Eq, PartialEq, Debug)]
+#[derive(Add, Mul)]
+struct DoubleUIntStruct {
+    x: u32,
+    y: u32,
+}
+
+#[derive(Eq, PartialEq, Debug)]
+#[derive(From, Into, Constructor)]
+struct Unit;
+
+// Tests that we can forward to a path
+// containing `$crate`
+macro_rules! use_dollar_crate {
+    () => {
+        struct Foo;
+        #[derive(From)]
+        enum Bar {
+            First(#[from(forward)] $crate::Foo),
+        }
+    };
+}
+
+use_dollar_crate!();
+
+#[test]
+fn main() {
+    let mut myint: MyInt = 5.into();
+    let _: SimpleMyIntEnum = 5i32.into();
+    let _: MyIntEnum = 5i32.into();
+    let _: MyIntEnum = 6i64.into();
+    let _: MyIntEnum = (5i32, 8i32).into();
+    let _: MyIntEnum = (5i64, 8i64).into();
+    let _: MyIntEnum = ().into();
+
+    let int_ref: &i32 = (&myint).into();
+    assert_eq!(int_ref, &5);
+
+    let int_ref_mut: &mut i32 = (&mut myint).into();
+    assert_eq!(int_ref_mut, &mut 5);
+
+    let mut myint: MyInt = 5.into();
+    let _: Unit = ().into();
+    assert_eq!((), Unit.into());
+    assert_eq!(Unit, Unit::new());
+    assert_eq!(MyInt(5), 5.into());
+    assert_eq!(Ok(MyInt(5)), "5".parse());
+    assert_eq!(5, MyInt(5).into());
+    assert_eq!(MyInt(5), MyInt::new(5));
+    assert_eq!(-MyInt(5), (-5).into());
+    assert_eq!("30", format!("{}", MyInt(30)));
+    assert_eq!("36", format!("{:o}", MyInt(30)));
+    assert_eq!("100", format!("{:b}", MyInt(4)));
+    assert_eq!(!MyBool(true), false.into());
+    assert_eq!(MyIntEnum::SmallInt(5), 5.into());
+
+    assert_eq!(SimpleStruct { int1: 5 }, 5.into());
+    assert_eq!(5u64, SimpleStruct { int1: 5 }.into());
+    assert_eq!(Ok(SimpleStruct { int1: 5 }), "5".parse());
+    assert_eq!("5", format!("{}", SimpleStruct { int1: 5 }));
+    assert_eq!(NormalStruct { int1: 5, int2: 6 }, (5, 6).into());
+    assert_eq!(SimpleStruct { int1: 5 }, SimpleStruct::new(5));
+    assert_eq!(NormalStruct { int1: 5, int2: 6 }, NormalStruct::new(5, 6));
+    assert_eq!((5, 6), NormalStruct::new(5, 6).into());
+    let mut norm_struct = NormalStruct::new(5, 6);
+    let uints_ref: (&u64, &u64) = (&norm_struct).into();
+    assert_eq!((&5, &6), uints_ref);
+    let uints_ref_mut: (&mut u64, &mut u64) = (&mut norm_struct).into();
+    assert_eq!((&mut 5, &mut 6), uints_ref_mut);
+
+    assert_eq!(MyInt(4) + MyInt(1), 5.into());
+    myint += MyInt(3);
+    assert_eq!(myint, 8.into());
+    myint *= 5;
+    assert_eq!(myint, 40.into());
+    assert_eq!(MyInt(4) + MyInt(1), 5.into());
+    assert_eq!(MyUInt(4, 5) + MyUInt(1, 2), MyUInt(5, 7));
+    assert_eq!(MyUInt(4, 5), MyUInt::new(4, 5));
+    assert_eq!((4, 5), MyUInt(4, 5).into());
+    let mut s1 = NormalStruct { int1: 1, int2: 2 };
+    let s2 = NormalStruct { int1: 2, int2: 3 };
+    let s3 = NormalStruct { int1: 3, int2: 5 };
+    assert_eq!(s1 + s2, s3);
+    assert_eq!(s3 - s2, s1);
+    s1 += s2;
+    assert_eq!(s1, s3);
+
+    assert_eq!((SimpleMyIntEnum::Int(6) + 5.into()).unwrap(), 11.into());
+    assert_eq!((SimpleMyIntEnum::Int(6) - 5.into()).unwrap(), 1.into());
+    assert_eq!((SimpleMyIntEnum::Int(6) - 5.into()).unwrap(), 1.into());
+    assert_eq!(-SimpleSignedIntEnum::Int(6), (-6i32).into());
+    assert_eq!(
+        (SimpleEnum::LabeledInts { a: 6, b: 5 }
+            + SimpleEnum::LabeledInts { a: 1, b: 4 })
+        .unwrap(),
+        SimpleEnum::LabeledInts { a: 7, b: 9 }
+    );
+
+    let _ = (MyIntEnum::SmallInt(5) + 6.into()).unwrap();
+    assert_eq!((-SimpleEnum::Int(5)).unwrap(), (-5).into());
+
+    assert_eq!(MyInt(50), MyInt(5) * 10);
+    assert_eq!(DoubleUInt(5, 6) * 10, DoubleUInt(50, 60));
+    // assert_eq!(DoubleUIntStruct{x:5, y:6} * 10, DoubleUIntStruct{x:50, y:60});
+
+    let mut myint = MyInt(5);
+    assert_eq!(5, *myint);
+    *myint = 7;
+    assert_eq!(MyInt(7), myint);
+
+    let mut my_vec = MyVec(vec![5, 8]);
+    assert_eq!(5, my_vec[0]);
+    assert_eq!(8, my_vec[1]);
+    my_vec[0] = 20;
+    assert_eq!(20, my_vec[0]);
+    assert_eq!((&my_vec).into_iter().next(), Some(&20));
+    assert_eq!((&mut my_vec).into_iter().next(), Some(&mut 20));
+    assert_eq!(my_vec.into_iter().next(), Some(20));
+
+    let int_vec = vec![MyInt2(2), MyInt2(3)];
+    assert_eq!(MyInt2(5), int_vec.clone().into_iter().sum());
+    assert_eq!(MyInt2(6), int_vec.clone().into_iter().product());
+    let mut myint2 = MyInt2(8);
+    myint2 *= MyInt2(4);
+    assert_eq!(MyInt2(32), myint2);
+
+    let mut boxed = MyBoxedInt(Box::new(5));
+    assert_eq!(5, *boxed);
+    *boxed = 7;
+    assert_eq!(MyBoxedInt(Box::new(7)), boxed)
+}
diff --git a/vendor/derive_more/tests/mul.rs b/vendor/derive_more/tests/mul.rs
new file mode 100644
index 000000000..192806032
--- /dev/null
+++ b/vendor/derive_more/tests/mul.rs
@@ -0,0 +1,20 @@
+#![allow(dead_code)]
+#[macro_use]
+extern crate derive_more;
+
+#[derive(Mul)]
+struct MyInt(i32);
+
+#[derive(Mul)]
+struct MyInts(i32, i32);
+
+#[derive(Mul)]
+struct Point1D {
+    x: i32,
+}
+
+#[derive(Mul)]
+struct Point2D {
+    x: i32,
+    y: i32,
+}
diff --git a/vendor/derive_more/tests/mul_assign.rs b/vendor/derive_more/tests/mul_assign.rs
new file mode 100644
index 000000000..f8aee3e18
--- /dev/null
+++ b/vendor/derive_more/tests/mul_assign.rs
@@ -0,0 +1,32 @@
+#![allow(dead_code)]
+use std::marker::PhantomData;
+
+#[macro_use]
+extern crate derive_more;
+
+#[derive(MulAssign)]
+struct MyInt(i32);
+
+#[derive(MulAssign)]
+struct MyInts(i32, i32);
+
+#[derive(MulAssign)]
+#[mul_assign(forward)]
+struct MyIntForward(i32);
+
+#[derive(MulAssign)]
+struct Point1D {
+    x: i32,
+}
+
+#[derive(MulAssign)]
+struct Point2D {
+    x: i32,
+    y: i32,
+}
+
+#[derive(MulAssign)]
+struct MyInt2<T> {
+    x: i32,
+    ph: PhantomData<T>,
+}
diff --git a/vendor/derive_more/tests/no_std.rs b/vendor/derive_more/tests/no_std.rs
new file mode 100644
index 000000000..a6680c38c
--- /dev/null
+++ b/vendor/derive_more/tests/no_std.rs
@@ -0,0 +1,74 @@
+#![no_std]
+#![allow(dead_code)]
+
+#[macro_use]
+extern crate derive_more;
+
+#[derive(
+    AddAssign,
+    MulAssign,
+    Add,
+    Mul,
+    Not,
+    Index,
+    Display,
+    FromStr,
+    Into,
+    From,
+    IndexMut,
+    Sum,
+    Deref,
+    DerefMut,
+    Constructor
+)]
+#[into(owned, ref, ref_mut)]
+struct MyInts(u64);
+
+#[derive(Deref, DerefMut)]
+#[deref(forward)]
+#[deref_mut(forward)]
+struct MyBoxedInt<'a>(&'a mut u64);
+
+#[derive(
+    From,
+    FromStr,
+    Display,
+    Index,
+    Not,
+    Add,
+    Mul,
+    Sum,
+    IndexMut,
+    AddAssign,
+    Deref,
+    DerefMut,
+    IntoIterator,
+    Constructor
+)]
+#[deref(forward)]
+#[deref_mut(forward)]
+#[into_iterator(owned, ref, ref_mut)]
+struct Wrapped<T: Clone>(T);
+
+#[derive(Deref, DerefMut)]
+struct Wrapped2<T: Clone>(T);
+
+#[derive(From, Not, Add, Mul, AddAssign, Constructor, Sum)]
+struct WrappedDouble<T: Clone, U: Clone>(T, U);
+
+#[derive(Add, Not, TryInto)]
+#[try_into(owned, ref, ref_mut)]
+enum MixedInts {
+    SmallInt(i32),
+    BigInt(i64),
+    TwoSmallInts(i32, i32),
+    NamedSmallInts { x: i32, y: i32 },
+    UnsignedOne(u32),
+    UnsignedTwo(u32),
+}
+
+#[derive(Not, Add)]
+enum EnumWithUnit {
+    SmallInt(i32),
+    Unit,
+}
diff --git a/vendor/derive_more/tests/not.rs b/vendor/derive_more/tests/not.rs
new file mode 100644
index 000000000..7e3ad8d01
--- /dev/null
+++ b/vendor/derive_more/tests/not.rs
@@ -0,0 +1,28 @@
+#![allow(dead_code)]
+#[macro_use]
+extern crate derive_more;
+
+#[derive(Not)]
+struct MyInts(i32, i32);
+
+#[derive(Not)]
+struct Point2D {
+    x: i32,
+    y: i32,
+}
+
+#[derive(Not)]
+enum MixedInts {
+    SmallInt(i32),
+    BigInt(i64),
+    TwoSmallInts(i32, i32),
+    NamedSmallInts { x: i32, y: i32 },
+    UnsignedOne(u32),
+    UnsignedTwo(u32),
+}
+
+#[derive(Not)]
+enum EnumWithUnit {
+    SmallInt(i32),
+    Unit,
+}
diff --git a/vendor/derive_more/tests/sum.rs b/vendor/derive_more/tests/sum.rs
new file mode 100644
index 000000000..a0b0967bd
--- /dev/null
+++ b/vendor/derive_more/tests/sum.rs
@@ -0,0 +1,31 @@
+#[macro_use]
+extern crate derive_more;
+
+#[derive(Sum)]
+struct MyInts(i32, i64);
+
+// Add implementation is needed for Sum
+impl ::core::ops::Add for MyInts {
+    type Output = MyInts;
+    #[inline]
+    fn add(self, rhs: MyInts) -> MyInts {
+        MyInts(self.0.add(rhs.0), self.1.add(rhs.1))
+    }
+}
+
+#[derive(Sum)]
+struct Point2D {
+    x: i32,
+    y: i32,
+}
+
+impl ::core::ops::Add for Point2D {
+    type Output = Point2D;
+    #[inline]
+    fn add(self, rhs: Point2D) -> Point2D {
+        Point2D {
+            x: self.x.add(rhs.x),
+            y: self.y.add(rhs.y),
+        }
+    }
+}
diff --git a/vendor/derive_more/tests/try_into.rs b/vendor/derive_more/tests/try_into.rs
new file mode 100644
index 000000000..837c8e991
--- /dev/null
+++ b/vendor/derive_more/tests/try_into.rs
@@ -0,0 +1,199 @@
+#![allow(dead_code)]
+
+#[macro_use]
+extern crate derive_more;
+
+use std::convert::{TryFrom, TryInto};
+
+// Ensure that the TryFrom macro is hygenic and doesn't break when `Result` has
+// been redefined.
+type Result = ();
+
+#[derive(Clone, Copy, TryInto)]
+#[try_into(owned, ref, ref_mut)]
+enum MixedInts {
+    SmallInt(i32),
+    NamedBigInt {
+        int: i64,
+    },
+    UnsignedWithIgnoredField(#[try_into(ignore)] bool, i64),
+    NamedUnsignedWithIgnnoredField {
+        #[try_into(ignore)]
+        useless: bool,
+        x: i64,
+    },
+    TwoSmallInts(i32, i32),
+    NamedBigInts {
+        x: i64,
+        y: i64,
+    },
+    Unsigned(u32),
+    NamedUnsigned {
+        x: u32,
+    },
+    Unit,
+    #[try_into(ignore)]
+    Unit2,
+}
+
+#[test]
+fn test_try_into() {
+    let mut i = MixedInts::SmallInt(42);
+    assert_eq!(Ok(42i32), i.try_into());
+    assert_eq!(Ok(&42i32), (&i).try_into());
+    assert_eq!(Ok(&mut 42i32), (&mut i).try_into());
+    assert_eq!(
+        i64::try_from(i),
+        Err("Only NamedBigInt, UnsignedWithIgnoredField, NamedUnsignedWithIgnnoredField can be converted to i64")
+    );
+    assert_eq!(
+        <(i32, i32)>::try_from(i),
+        Err("Only TwoSmallInts can be converted to (i32, i32)")
+    );
+    assert_eq!(
+        <(i64, i64)>::try_from(i),
+        Err("Only NamedBigInts can be converted to (i64, i64)")
+    );
+    assert_eq!(
+        u32::try_from(i),
+        Err("Only Unsigned, NamedUnsigned can be converted to u32")
+    );
+    assert_eq!(<()>::try_from(i), Err("Only Unit can be converted to ()"));
+
+    let mut i = MixedInts::NamedBigInt { int: 42 };
+    assert_eq!(
+        i32::try_from(i),
+        Err("Only SmallInt can be converted to i32")
+    );
+    assert_eq!(Ok(42i64), i.try_into());
+    assert_eq!(Ok(&42i64), (&i).try_into());
+    assert_eq!(Ok(&mut 42i64), (&mut i).try_into());
+    assert_eq!(
+        <(i32, i32)>::try_from(i),
+        Err("Only TwoSmallInts can be converted to (i32, i32)")
+    );
+    assert_eq!(
+        <(i64, i64)>::try_from(i),
+        Err("Only NamedBigInts can be converted to (i64, i64)")
+    );
+    assert_eq!(
+        u32::try_from(i),
+        Err("Only Unsigned, NamedUnsigned can be converted to u32")
+    );
+    assert_eq!(<()>::try_from(i), Err("Only Unit can be converted to ()"));
+
+    let mut i = MixedInts::TwoSmallInts(42, 64);
+    assert_eq!(
+        i32::try_from(i),
+        Err("Only SmallInt can be converted to i32")
+    );
+    assert_eq!(
+        i64::try_from(i),
+        Err("Only NamedBigInt, UnsignedWithIgnoredField, NamedUnsignedWithIgnnoredField can be converted to i64")
+    );
+    assert_eq!(Ok((42i32, 64i32)), i.try_into());
+    assert_eq!(Ok((&42i32, &64i32)), (&i).try_into());
+    assert_eq!(Ok((&mut 42i32, &mut 64i32)), (&mut i).try_into());
+    assert_eq!(
+        <(i64, i64)>::try_from(i),
+        Err("Only NamedBigInts can be converted to (i64, i64)")
+    );
+    assert_eq!(
+        u32::try_from(i),
+        Err("Only Unsigned, NamedUnsigned can be converted to u32")
+    );
+    assert_eq!(<()>::try_from(i), Err("Only Unit can be converted to ()"));
+
+    let mut i = MixedInts::NamedBigInts { x: 42, y: 64 };
+    assert_eq!(
+        i32::try_from(i),
+        Err("Only SmallInt can be converted to i32")
+    );
+    assert_eq!(
+        i64::try_from(i),
+        Err("Only NamedBigInt, UnsignedWithIgnoredField, NamedUnsignedWithIgnnoredField can be converted to i64")
+    );
+    assert_eq!(
+        <(i32, i32)>::try_from(i),
+        Err("Only TwoSmallInts can be converted to (i32, i32)")
+    );
+    assert_eq!(Ok((42i64, 64i64)), i.try_into());
+    assert_eq!(Ok((&42i64, &64i64)), (&i).try_into());
+    assert_eq!(Ok((&mut 42i64, &mut 64i64)), (&mut i).try_into());
+    assert_eq!(
+        u32::try_from(i),
+        Err("Only Unsigned, NamedUnsigned can be converted to u32")
+    );
+    assert_eq!(<()>::try_from(i), Err("Only Unit can be converted to ()"));
+
+    let mut i = MixedInts::Unsigned(42);
+    assert_eq!(
+        i32::try_from(i),
+        Err("Only SmallInt can be converted to i32")
+    );
+    assert_eq!(
+        i64::try_from(i),
+        Err("Only NamedBigInt, UnsignedWithIgnoredField, NamedUnsignedWithIgnnoredField can be converted to i64")
+    );
+    assert_eq!(
+        <(i32, i32)>::try_from(i),
+        Err("Only TwoSmallInts can be converted to (i32, i32)")
+    );
+    assert_eq!(
+        <(i64, i64)>::try_from(i),
+        Err("Only NamedBigInts can be converted to (i64, i64)")
+    );
+    assert_eq!(Ok(42u32), i.try_into());
+    assert_eq!(Ok(&42u32), (&i).try_into());
+    assert_eq!(Ok(&mut 42u32), (&mut i).try_into());
+    assert_eq!(<()>::try_from(i), Err("Only Unit can be converted to ()"));
+
+    let mut i = MixedInts::NamedUnsigned { x: 42 };
+    assert_eq!(
+        i32::try_from(i),
+        Err("Only SmallInt can be converted to i32")
+    );
+    assert_eq!(
+        i64::try_from(i),
+        Err("Only NamedBigInt, UnsignedWithIgnoredField, NamedUnsignedWithIgnnoredField can be converted to i64")
+    );
+    assert_eq!(
+        i64::try_from(i),
+        Err("Only NamedBigInt, UnsignedWithIgnoredField, NamedUnsignedWithIgnnoredField can be converted to i64")
+    );
+    assert_eq!(
+        <(i32, i32)>::try_from(i),
+        Err("Only TwoSmallInts can be converted to (i32, i32)")
+    );
+    assert_eq!(
+        <(i64, i64)>::try_from(i),
+        Err("Only NamedBigInts can be converted to (i64, i64)")
+    );
+    assert_eq!(Ok(42u32), i.try_into());
+    assert_eq!(Ok(&42u32), (&i).try_into());
+    assert_eq!(Ok(&mut 42u32), (&mut i).try_into());
+    assert_eq!(<()>::try_from(i), Err("Only Unit can be converted to ()"));
+
+    let i = MixedInts::Unit;
+    assert_eq!(
+        i32::try_from(i),
+        Err("Only SmallInt can be converted to i32")
+    );
+    assert_eq!(
+        i64::try_from(i),
+        Err("Only NamedBigInt, UnsignedWithIgnoredField, NamedUnsignedWithIgnnoredField can be converted to i64")
+    );
+    assert_eq!(
+        <(i32, i32)>::try_from(i),
+        Err("Only TwoSmallInts can be converted to (i32, i32)")
+    );
+    assert_eq!(
+        <(i64, i64)>::try_from(i),
+        Err("Only NamedBigInts can be converted to (i64, i64)")
+    );
+    assert_eq!(
+        u32::try_from(i),
+        Err("Only Unsigned, NamedUnsigned can be converted to u32")
+    );
+    assert_eq!(Ok(()), i.try_into());
+}
diff --git a/vendor/derive_more/tests/unwrap.rs b/vendor/derive_more/tests/unwrap.rs
new file mode 100644
index 000000000..ec84f7de9
--- /dev/null
+++ b/vendor/derive_more/tests/unwrap.rs
@@ -0,0 +1,62 @@
+#![allow(dead_code)]
+
+#[macro_use]
+extern crate derive_more;
+
+#[derive(Unwrap)]
+enum Either<TLeft, TRight> {
+    Left(TLeft),
+    Right(TRight),
+}
+
+#[derive(Unwrap)]
+enum Maybe<T> {
+    Nothing,
+    Just(T),
+}
+
+#[derive(Unwrap)]
+enum Color {
+    RGB(u8, u8, u8),
+    CMYK(u8, u8, u8, u8),
+}
+
+#[derive(Unwrap)]
+enum Nonsense<'a, T> {
+    Ref(&'a T),
+    NoRef,
+    #[unwrap(ignore)]
+    NoRefIgnored,
+}
+
+#[derive(Unwrap)]
+enum WithConstraints<T>
+where
+    T: Copy,
+{
+    One(T),
+    Two,
+}
+#[derive(Unwrap)]
+enum KitchenSink<'a, 'b, T1: Copy, T2: Clone>
+where
+    T2: Into<T1> + 'b,
+{
+    Left(&'a T1),
+    Right(&'b T2),
+    OwnBoth(T1, T2),
+    Empty,
+    NeverMind(),
+    NothingToSeeHere(),
+}
+
+#[test]
+pub fn test_unwrap() {
+    assert_eq!(Maybe::<()>::Nothing.unwrap_nothing(), ());
+}
+
+#[test]
+#[should_panic]
+pub fn test_unwrap_panic() {
+    Maybe::<()>::Nothing.unwrap_just()
+}