Vendor dependencies for 0.3.0 release

vendor/derive_more/tests/add.rs

@@ -0,0 +1,24 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+#![allow(dead_code)] // some code is tested for type checking only
+
+use derive_more::Add;
+
+#[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,
+}

vendor/derive_more/tests/add_assign.rs

@@ -0,0 +1,13 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+#![allow(dead_code)] // some code is tested for type checking only
+
+use derive_more::AddAssign;
+
+#[derive(AddAssign)]
+struct MyInts(i32, i32);
+
+#[derive(AddAssign)]
+struct Point2D {
+    x: i32,
+    y: i32,
+}

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
+
+use derive_more::Display;
+
+#[derive(Display)]
+#[display("An error has occurred.")]
+struct UnitError;
+
+#[test]
+fn unit_struct() {
+    let s = UnitError.to_string();
+    assert_eq!(s, "An error has occurred.");
+}
+
+#[derive(Display)]
+#[display("Error code: {}", code)]
+struct RecordError {
+    code: u32,
+}
+
+#[test]
+fn record_struct() {
+    let s = RecordError { code: 0 }.to_string();
+    assert_eq!(s, "Error code: 0");
+}
+
+#[derive(Display)]
+#[display("Error code: {}", _0)]
+struct TupleError(i32);
+
+#[test]
+fn tuple_struct() {
+    let s = TupleError(2).to_string();
+    assert_eq!(s, "Error code: 2");
+}
+
+#[allow(clippy::enum_variant_names)] // because of the original source
+#[derive(Display)]
+enum EnumError {
+    #[display("Error code: {}", code)]
+    StructVariant { code: i32 },
+    #[display("Error: {}", _0)]
+    TupleVariant(&'static str),
+    #[display("An error has occurred.")]
+    UnitVariant,
+}
+
+#[test]
+fn enum_error() {
+    let s = EnumError::StructVariant { code: 2 }.to_string();
+    assert_eq!(s, "Error code: 2");
+    let s = EnumError::TupleVariant("foobar").to_string();
+    assert_eq!(s, "Error: foobar");
+    let s = EnumError::UnitVariant.to_string();
+    assert_eq!(s, "An error has occurred.");
+}

vendor/derive_more/tests/compile_fail/as_mut/enum.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::AsMut)]
+enum Foo {
+    Bar(i32),
+    Baz(i32),
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/as_mut/multiple_field_attrs.rs

@@ -0,0 +1,8 @@
+#[derive(derive_more::AsMut)]
+struct Foo {
+    #[as_mut]
+    #[as_mut(forward)]
+    bar: i32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/as_mut/multiple_struct_attrs.rs

@@ -0,0 +1,8 @@
+#[derive(derive_more::AsMut)]
+#[as_mut(forward)]
+#[as_mut(forward)]
+struct Foo {
+    bar: i32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/as_mut/renamed_generic.rs

@@ -0,0 +1,12 @@
+struct Foo<T>(T);
+
+type Bar<T> = Foo<T>;
+
+#[derive(derive_more::AsMut)]
+#[as_mut(Bar<T>)]
+struct Baz<T>(Foo<T>);
+
+fn main() {
+    let mut item = Baz(Foo(1i32));
+    let _: &mut Bar<i32> = item.as_mut();
+}

vendor/derive_more/tests/compile_fail/as_mut/skip_and_others.rs

@@ -0,0 +1,9 @@
+#[derive(derive_more::AsMut)]
+struct Foo {
+    #[as_mut]
+    bar: i32,
+    #[as_mut(ignore)]
+    baz: f32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/as_mut/struct_and_field.rs

@@ -0,0 +1,8 @@
+#[derive(derive_more::AsMut)]
+#[as_mut(forward)]
+struct Foo {
+    #[as_mut]
+    bar: i32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/as_mut/struct_attr_empty.rs

@@ -0,0 +1,5 @@
+#[derive(derive_more::AsMut)]
+#[as_mut(forward)]
+struct Foo;
+
+fn main() {}

vendor/derive_more/tests/compile_fail/as_mut/struct_attr_multiple_fields.rs

@@ -0,0 +1,8 @@
+#[derive(derive_more::AsMut)]
+#[as_mut(forward)]
+struct Foo {
+    bar: i32,
+    baz: f32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/as_mut/struct_attr_tuple.rs

@@ -0,0 +1,8 @@
+#[derive(derive_more::AsMut)]
+#[as_mut((i32, f32))]
+struct Foo {
+    bar: i32,
+    baz: f32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/as_mut/union.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::AsMut)]
+union Foo {
+    f1: u32,
+    f2: f32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/as_mut/unknown_field_attr_arg.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::AsMut)]
+struct Foo {
+    #[as_mut(baz)]
+    bar: i32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/as_mut/unknown_struct_attr_arg.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::AsMut)]
+#[as_mut(baz)]
+struct Foo {
+    bar: i32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/as_ref/enum.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::AsRef)]
+enum Foo {
+    Bar(i32),
+    Baz(i32),
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/as_ref/multiple_field_attrs.rs

@@ -0,0 +1,8 @@
+#[derive(derive_more::AsRef)]
+struct Foo {
+    #[as_ref]
+    #[as_ref(forward)]
+    bar: i32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/as_ref/multiple_struct_attrs.rs

@@ -0,0 +1,8 @@
+#[derive(derive_more::AsRef)]
+#[as_ref(forward)]
+#[as_ref(forward)]
+struct Foo {
+    bar: i32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/as_ref/renamed_generic.rs

@@ -0,0 +1,12 @@
+struct Foo<T>(T);
+
+type Bar<T> = Foo<T>;
+
+#[derive(derive_more::AsRef)]
+#[as_ref(Bar<T>)]
+struct Baz<T>(Foo<T>);
+
+fn main() {
+    let item = Baz(Foo(1i32));
+    let _: &Bar<i32> = item.as_ref();
+}

vendor/derive_more/tests/compile_fail/as_ref/skip_and_others.rs

@@ -0,0 +1,9 @@
+#[derive(derive_more::AsRef)]
+struct Foo {
+    #[as_ref]
+    bar: i32,
+    #[as_ref(skip)]
+    baz: f32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/as_ref/struct_and_field.rs

@@ -0,0 +1,8 @@
+#[derive(derive_more::AsRef)]
+#[as_ref(forward)]
+struct Foo {
+    #[as_ref]
+    bar: i32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/as_ref/struct_attr_empty.rs

@@ -0,0 +1,5 @@
+#[derive(derive_more::AsRef)]
+#[as_ref(forward)]
+struct Foo;
+
+fn main() {}

vendor/derive_more/tests/compile_fail/as_ref/struct_attr_multiple_fields.rs

@@ -0,0 +1,8 @@
+#[derive(derive_more::AsRef)]
+#[as_ref(forward)]
+struct Foo {
+    bar: i32,
+    baz: f32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/as_ref/struct_attr_tuple.rs

@@ -0,0 +1,8 @@
+#[derive(derive_more::AsRef)]
+#[as_ref((i32, f32))]
+struct Foo {
+    bar: i32,
+    baz: f32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/as_ref/union.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::AsRef)]
+union Foo {
+    f1: u32,
+    f2: f32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/as_ref/unknown_field_attr_arg.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::AsRef)]
+struct Foo {
+    #[as_ref(baz)]
+    bar: i32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/as_ref/unknown_struct_attr_arg.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::AsRef)]
+#[as_ref(baz)]
+struct Foo {
+    bar: i32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/debug/both_fmt_and_skip_on_field.rs

@@ -0,0 +1,8 @@
+#[derive(derive_more::Debug)]
+pub struct Foo {
+    #[debug("Stuff({}): {}", bar)]
+    #[debug(skip)]
+    bar: String,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/debug/duplicate_fmt_on_struct.rs

@@ -0,0 +1,6 @@
+#[derive(derive_more::Debug)]
+#[debug("Test")]
+#[debug("Second")]
+pub struct Foo {}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/debug/duplicate_fmt_on_variant.rs

@@ -0,0 +1,8 @@
+#[derive(derive_more::Debug)]
+pub enum Foo {
+    #[debug("Test")]
+    #[debug("Second")]
+    Unit,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/debug/extra_placeholder.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::Debug)]
+pub struct Foo {
+    #[debug("Stuff({}): {}", bar)]
+    bar: String,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/debug/fmt_on_container_and_field_simultaneously.rs

@@ -0,0 +1,8 @@
+#[derive(derive_more::Debug)]
+#[debug("{bar}")]
+pub struct Foo {
+    #[debug("{bar}")]
+    bar: String,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/debug/fmt_on_enum.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::Debug)]
+#[debug("Test")]
+pub enum Foo {
+    Unit
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/debug/legacy_bound_syntax.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::Debug)]
+#[debug(bound = "String: std::fmt::Display")]
+pub struct Foo {
+    bar: String,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/debug/legacy_fmt_syntax.rs

@@ -0,0 +1,11 @@
+#[derive(derive_more::Debug)]
+pub struct Foo {
+    #[debug(fmt = "Stuff({}): {}", "bar")]
+    bar: String,
+}
+
+#[derive(derive_more::Debug)]
+#[debug(fmt = "Stuff({}): {}", _0)]
+pub struct Bar(String);
+
+fn main() {}

vendor/derive_more/tests/compile_fail/debug/lifetime_no_debug.rs

@@ -0,0 +1,10 @@
+struct NoDebug<'a> {
+    a: &'a f64,
+}
+
+#[derive(derive_more::Debug)]
+struct SomeType<'a> {
+    no_debug: NoDebug<'a>,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/debug/missing_placeholder.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::Debug)]
+pub struct Foo {
+    #[debug("Stuff()", bar)]
+    bar: String,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/debug/named_field_prefixed_with_dot.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::Debug)]
+pub struct Foo {
+    #[debug("Stuff({})", .bar)]
+    bar: String,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/debug/unclosed_brace.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::Debug)]
+pub struct Foo {
+    #[debug("Stuff({)", bar)]
+    bar: String,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/debug/union.rs

@@ -0,0 +1,6 @@
+#[derive(derive_more::Debug)]
+pub union Foo {
+    bar: i32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/debug/unknown_attribute.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::Debug)]
+#[debug(unknown = "unknown")]
+pub struct Foo {
+    bar: String,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/debug/unnamed_field_prefixed_with_dot.rs

@@ -0,0 +1,4 @@
+#[derive(derive_more::Debug)]
+pub struct Foo(#[debug("Stuff({})", .0)] String);
+
+fn main() {}

vendor/derive_more/tests/compile_fail/debug/wrong_formatting_argument.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::Debug)]
+pub struct Foo {
+    #[debug("Stuff({bar:M})")]
+    bar: String,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/debug/wrong_named_parameter.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::Debug)]
+pub struct Foo {
+    #[debug("Stuff({bars})")]
+    bar: String,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/debug/wrong_unnamed_parameter.rs

@@ -0,0 +1,4 @@
+#[derive(derive_more::Debug)]
+pub struct Foo(#[debug("Stuff({_1})")] String);
+
+fn main() {}

vendor/derive_more/tests/compile_fail/display/extra_placeholder.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::Display)]
+#[display("Stuff({}): {}", bar)]
+pub struct Foo {
+    bar: String,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/display/legacy_bound_syntax.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::Display)]
+#[display(bound = "String: std::fmt::Display")]
+pub struct Foo {
+    bar: String,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/display/legacy_fmt_syntax.rs

@@ -0,0 +1,11 @@
+#[derive(derive_more::Display)]
+#[display(fmt = "Stuff({}): {}", "bar")]
+pub struct Foo {
+    bar: String,
+}
+
+#[derive(derive_more::Display)]
+#[display(fmt = "Stuff({}): {}", _0)]
+pub struct Bar(String);
+
+fn main() {}

vendor/derive_more/tests/compile_fail/display/missing_placeholder.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::Display)]
+#[display("Stuff()", bar)]
+pub struct Foo {
+    bar: String,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/display/mutlifield_enum_variant_without_attribute.rs

@@ -0,0 +1,6 @@
+#[derive(derive_more::Display)]
+enum Enum {
+    Variant { foo: String, bar: String },
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/display/mutlifield_struct_without_attribute.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::Display)]
+pub struct Foo {
+    foo: String,
+    bar: String,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/display/named_field_prefixed_with_dot.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::Display)]
+#[display("Stuff({})", .bar)]
+pub struct Foo {
+    bar: String,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/display/non_display_implicit_enum_unit_variant.rs

@@ -0,0 +1,6 @@
+#[derive(derive_more::Display, derive_more::UpperHex)]
+enum Enum {
+    UnitVariant,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/display/shared_format_positional_placeholders.rs

@@ -0,0 +1,19 @@
+#[derive(derive_more::Display)]
+#[display("Stuff({})")]
+enum Foo {
+    A,
+}
+
+#[derive(derive_more::Display)]
+#[display("Stuff({0})")]
+enum Foo2 {
+    A,
+}
+
+#[derive(derive_more::Display)]
+#[display("Stuff()", _0, _2)]
+enum Foo3 {
+    A,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/display/shared_format_unclosed_brace.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::Display)]
+#[display("Stuff({)")]
+enum Foo {
+    A,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/display/shared_format_variant_spec.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::Display)]
+#[display("Stuff({_variant:?})")]
+enum Foo {
+    A,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/display/unclosed_brace.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::Display)]
+#[display("Stuff({)", bar)]
+pub struct Foo {
+    bar: String,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/display/unknown_attribute.rs

@@ -0,0 +1,8 @@
+#[derive(derive_more::Display)]
+#[display("Stuff({})", bar)]
+#[display(unknown = "unknown")]
+pub struct Foo {
+    bar: String,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/display/unnamed_field_prefixed_with_dot.rs

@@ -0,0 +1,5 @@
+#[derive(derive_more::Display)]
+#[display("Stuff({})", .0)]
+pub struct Foo(String);
+
+fn main() {}

vendor/derive_more/tests/compile_fail/display/wrong_formatting_argument.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::Display)]
+#[display("Stuff({:M})", bar)]
+pub struct Foo {
+    bar: String,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/display/wrong_named_parameter.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::Display)]
+#[display("Stuff({bars})")]
+pub struct Foo {
+    bar: String,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/display/wrong_unnamed_parameter.rs

@@ -0,0 +1,5 @@
+#[derive(derive_more::Display)]
+#[display("Stuff({_1})")]
+pub struct Foo(String);
+
+fn main() {}

vendor/derive_more/tests/compile_fail/from/legacy_enum_attribute.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::From)]
+enum Foo {
+    #[from(types(i32, "&str"))]
+    Bar(String),
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/from/legacy_struct_attribute.rs

@@ -0,0 +1,8 @@
+#[derive(derive_more::From)]
+#[from(types(i32, "&str"))]
+struct Foo {
+    foo: String,
+    bar: String,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/from/multiple_enum_attributes.rs

@@ -0,0 +1,8 @@
+#[derive(derive_more::From)]
+enum Foo {
+    #[from(i32)]
+    #[from(forward)]
+    Bar(i32),
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/from/multiple_struct_attributes.rs

@@ -0,0 +1,6 @@
+#[derive(derive_more::From)]
+#[from(i32)]
+#[from(forward)]
+struct Foo(i32);
+
+fn main() {}

vendor/derive_more/tests/compile_fail/from/struct_tuple_no_parens.rs

@@ -0,0 +1,8 @@
+#[derive(derive_more::From)]
+#[from(i16, i16)]
+struct Point {
+    x: i32,
+    y: i32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/from/struct_tuple_too_long.rs

@@ -0,0 +1,8 @@
+#[derive(derive_more::From)]
+#[from((i16, i16, i16))]
+struct Point {
+    x: i32,
+    y: i32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/from/struct_tuple_too_short.rs

@@ -0,0 +1,8 @@
+#[derive(derive_more::From)]
+#[from((i16,))]
+struct Point {
+    x: i32,
+    y: i32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/from/union.rs

@@ -0,0 +1,6 @@
+#[derive(derive_more::From)]
+pub union Foo {
+    bar: i32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/into/enum.rs

@@ -0,0 +1,6 @@
+#[derive(derive_more::Into)]
+enum Foo {
+    Foo(i32),
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/into/legacy_complex_attribute.rs

@@ -0,0 +1,5 @@
+#[derive(derive_more::Into)]
+#[into(owned(types("Cow<'_ str>")), ref, ref_mut, types(i32, "&str"))]
+struct Foo(String);
+
+fn main() {}

vendor/derive_more/tests/compile_fail/into/legacy_types_attribute.rs

@@ -0,0 +1,5 @@
+#[derive(derive_more::Into)]
+#[into(types(i32, "&str"))]
+struct Foo(String);
+
+fn main() {}

vendor/derive_more/tests/compile_fail/into/mixed_field_skip_types.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::Into)]
+struct Foo {
+    #[into(skip, i32)]
+    a: i32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/into/mixed_regular_and_wrapped_types.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::Into)]
+#[into(owned, ref(i32), i32)]
+struct Foo {
+    bar: i32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/into/multiple_skip.rs

@@ -0,0 +1,8 @@
+#[derive(derive_more::Into)]
+struct Foo {
+    #[into(skip)]
+    #[into(skip)]
+    a: i32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/into/tuple_no_parens.rs

@@ -0,0 +1,8 @@
+#[derive(derive_more::Into)]
+#[into(i16, i16)]
+struct Point {
+    x: i32,
+    y: i32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/into/tuple_too_long.rs

@@ -0,0 +1,8 @@
+#[derive(derive_more::Into)]
+#[into((i16, i16, i16))]
+struct Point {
+    x: i32,
+    y: i32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/into/tuple_too_short.rs

@@ -0,0 +1,8 @@
+#[derive(derive_more::Into)]
+#[into((i16,))]
+struct Point {
+    x: i32,
+    y: i32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/into/union.rs

@@ -0,0 +1,6 @@
+#[derive(derive_more::Into)]
+pub union Foo {
+    bar: i32,
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/is_variant/must_use.rs

@@ -0,0 +1,10 @@
+#[derive(derive_more::IsVariant)]
+enum MustUse {
+    Yes,
+}
+
+#[forbid(unused_must_use)]
+fn main() {
+    let must_use = MustUse::Yes;
+    must_use.is_yes();
+}

vendor/derive_more/tests/compile_fail/mod.rs

@@ -0,0 +1,6 @@
+#[rustversion::stable]
+#[test]
+fn compile_fail() {
+    let t = trybuild::TestCases::new();
+    t.compile_fail("tests/compile_fail/*/*.rs");
+}

vendor/derive_more/tests/compile_fail/try_from/invalid_repr.rs

@@ -0,0 +1,7 @@
+#[derive(derive_more::TryFrom)]
+#[repr(a + b)]
+enum Enum {
+    Variant
+}
+
+fn main() {}

vendor/derive_more/tests/compile_fail/try_from/struct.rs

@@ -0,0 +1,4 @@
+#[derive(derive_more::TryFrom)]
+struct Struct;
+
+fn main() {}

vendor/derive_more/tests/compile_fail/try_from/union.rs

@@ -0,0 +1,6 @@
+#[derive(derive_more::TryFrom)]
+union Union {
+    field: i32,
+}
+
+fn main() {}

vendor/derive_more/tests/constructor.rs

@@ -0,0 +1,32 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+#![allow(dead_code)] // some code is tested for type checking only
+
+use derive_more::Constructor;
+
+#[derive(Constructor)]
+struct EmptyTuple();
+
+const EMPTY_TUPLE: EmptyTuple = EmptyTuple::new();
+
+#[derive(Constructor)]
+struct EmptyStruct {}
+
+const EMPTY_STRUCT: EmptyStruct = EmptyStruct::new();
+
+#[derive(Constructor)]
+struct EmptyUnit;
+
+const EMPTY_UNIT: EmptyUnit = EmptyUnit::new();
+
+#[derive(Constructor)]
+struct MyInts(i32, i32);
+
+const MY_INTS: MyInts = MyInts::new(1, 2);
+
+#[derive(Constructor)]
+struct Point2D {
+    x: i32,
+    y: i32,
+}
+
+const POINT_2D: Point2D = Point2D::new(-4, 7);

vendor/derive_more/tests/deref.rs

@@ -0,0 +1,75 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+#![allow(dead_code)] // some code is tested for type checking only
+
+#[cfg(not(feature = "std"))]
+extern crate alloc;
+
+#[cfg(not(feature = "std"))]
+use ::alloc::{boxed::Box, vec::Vec};
+
+use derive_more::Deref;
+
+#[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);
+}

vendor/derive_more/tests/deref_mut.rs

@@ -0,0 +1,137 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+#![allow(dead_code)] // some code is tested for type checking only
+
+#[cfg(not(feature = "std"))]
+extern crate alloc;
+
+#[cfg(not(feature = "std"))]
+use alloc::{boxed::Box, vec, vec::Vec};
+
+use derive_more::DerefMut;
+
+#[derive(DerefMut)]
+#[deref_mut(forward)]
+struct MyBoxedInt(Box<i32>);
+
+// `Deref` implementation is required 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 required 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 required 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 required for `DerefMut`.
+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 required for `DerefMut`.
+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>,
+}
+
+// `Deref` implementation is required for `DerefMut`.
+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>);
+
+// `Deref` implementation is required for `DerefMut`.
+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>);
+
+// `Deref` implementation is required for `DerefMut`.
+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);
+}

vendor/derive_more/tests/error/derives_for_enums_with_source.rs

@@ -0,0 +1,268 @@
+#![allow(dead_code)] // some code is tested for type checking only
+
+use super::*;
+
+derive_display!(TestErr);
+#[derive(Debug, Error)]
+enum TestErr {
+    Unit,
+    NamedImplicitNoSource {
+        field: i32,
+    },
+    NamedImplicitSource {
+        source: SimpleErr,
+        field: i32,
+    },
+    #[cfg(feature = "std")]
+    NamedImplicitBoxedSource {
+        source: Box<dyn Error + Send + 'static>,
+        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>());
+}
+
+#[cfg(feature = "std")]
+#[test]
+fn named_implicit_boxed_source() {
+    let err = TestErr::NamedImplicitBoxedSource {
+        source: Box::new(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())
+}

vendor/derive_more/tests/error/derives_for_generic_enums_with_source.rs

@@ -0,0 +1,250 @@
+#![allow(dead_code)] // some code is tested for type checking only
+
+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())
+}

vendor/derive_more/tests/error/derives_for_generic_structs_with_source.rs

@@ -0,0 +1,247 @@
+#![allow(dead_code)] // some code is tested for type checking only
+
+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())
+}

vendor/derive_more/tests/error/derives_for_structs_with_source.rs

@@ -0,0 +1,251 @@
+#![allow(dead_code)] // some code is tested for type checking only
+
+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())
+}

vendor/derive_more/tests/error/mod.rs

@@ -0,0 +1,56 @@
+use derive_more::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 ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            write!(f, "")
+        }
+    };
+    ($type:ident) => {
+        impl ::core::fmt::Display for $type {
+            derive_display!(@fmt);
+        }
+    };
+    ($type:ident, $($type_parameters:ident),*) => {
+        impl<$($type_parameters),*> ::core::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(all(feature = "std", nightly))]
+mod nightly;
+
+derive_display!(SimpleErr);
+#[derive(Default, Debug, Error)]
+struct SimpleErr;

vendor/derive_more/tests/error/nightly/derives_for_enums_with_backtrace.rs

@@ -0,0 +1,472 @@
+// For creating backtraces with different addresses in tests.
+#![allow(clippy::redundant_closure, clippy::redundant_closure_call)] // for testing
+#![allow(dead_code)] // some code is tested for type checking only
+
+use core::error::{request_ref, request_value};
+
+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,
+    },
+    NamedExplicitSuppressesImplicit {
+        #[error(backtrace)]
+        not_backtrace: MyBacktrace,
+        backtrace: Backtrace,
+        field: i32,
+    },
+    NamedImplicitNoBacktraceFromSource {
+        #[error(source)]
+        err: BacktraceErr,
+    },
+    NamedExplicitNoBacktraceFromSource {
+        #[error(source, not(backtrace))]
+        err: BacktraceErr,
+    },
+    NamedExplicitBacktraceFromSource {
+        #[error(backtrace, source)]
+        err: BacktraceErr,
+    },
+    NamedImplicitDifferentSourceAndBacktrace {
+        #[error(source)]
+        err: BacktraceErr,
+        backtrace: Backtrace,
+    },
+    NamedExplicitDifferentSourceAndBacktrace {
+        #[error(source)]
+        err: BacktraceErr,
+        #[error(backtrace)]
+        backtrace: Backtrace,
+    },
+    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),
+    UnnamedExplicitSuppressesImplicit(#[error(backtrace)] MyBacktrace, Backtrace, i32),
+    UnnamedImplicitNoBacktraceFromSource(BacktraceErr),
+    UnnamedExplicitNoBacktraceFromSource(#[error(not(backtrace))] BacktraceErr),
+    UnnamedExplicitBacktraceFromSource(#[error(backtrace)] BacktraceErr),
+    UnnamedImplicitDifferentSourceAndBacktrace(
+        #[error(source)] BacktraceErr,
+        Backtrace,
+    ),
+    UnnamedExplicitDifferentSourceAndBacktrace(
+        #[error(source)] BacktraceErr,
+        #[error(backtrace)] Backtrace,
+    ),
+}
+
+impl TestErr {
+    fn get_stored_backtrace(&self) -> &Backtrace {
+        match self {
+            Self::NamedImplicitBacktraceByFieldName { backtrace, .. }
+            | Self::NamedImplicitBacktraceByFieldType {
+                implicit_backtrace: backtrace,
+                ..
+            }
+            | Self::NamedExplicitBacktrace {
+                explicit_backtrace: backtrace,
+                ..
+            }
+            | Self::NamedExplicitBacktraceByFieldNameRedundant { backtrace, .. }
+            | Self::NamedExplicitBacktraceByFieldTypeRedundant {
+                implicit_backtrace: backtrace,
+                ..
+            }
+            | Self::NamedExplicitSuppressesImplicit {
+                not_backtrace: backtrace,
+                ..
+            }
+            | Self::NamedImplicitDifferentSourceAndBacktrace { backtrace, .. }
+            | Self::NamedExplicitDifferentSourceAndBacktrace { backtrace, .. }
+            | Self::UnnamedImplicitBacktrace(backtrace, _, _)
+            | Self::UnnamedExplicitBacktrace(backtrace, _, _)
+            | Self::UnnamedExplicitBacktraceRedundant(backtrace, _, _)
+            | Self::UnnamedExplicitSuppressesImplicit(backtrace, _, _)
+            | Self::UnnamedImplicitDifferentSourceAndBacktrace(_, backtrace)
+            | Self::UnnamedExplicitDifferentSourceAndBacktrace(_, backtrace) => {
+                backtrace
+            }
+            _ => panic!("ERROR IN TEST IMPLEMENTATION"),
+        }
+    }
+
+    fn get_unused_backtrace(&self) -> &Backtrace {
+        match self {
+            Self::NamedExplicitSuppressesImplicit { backtrace, .. } => backtrace,
+            Self::UnnamedExplicitSuppressesImplicit(_, backtrace, _) => backtrace,
+            _ => panic!("ERROR IN TEST IMPLEMENTATION"),
+        }
+    }
+
+    fn get_source_backtrace(&self) -> &Backtrace {
+        request_ref(match self {
+            Self::NamedExplicitBacktraceFromSource { err }
+            | Self::NamedExplicitDifferentSourceAndBacktrace { err, .. }
+            | Self::NamedImplicitDifferentSourceAndBacktrace { err, .. }
+            | Self::UnnamedExplicitBacktraceFromSource(err)
+            | Self::UnnamedExplicitDifferentSourceAndBacktrace(err, ..)
+            | Self::UnnamedImplicitDifferentSourceAndBacktrace(err, ..) => err,
+            _ => panic!("ERROR IN TEST IMPLEMENTATION"),
+        })
+        .unwrap()
+    }
+}
+
+type MyBacktrace = Backtrace;
+
+#[test]
+fn unit() {
+    assert!(request_ref::<Backtrace>(&TestErr::Unit).is_none());
+}
+
+#[test]
+fn named_implicit_no_backtrace() {
+    let err = TestErr::NamedImplicitNoBacktrace { field: 0 };
+
+    assert!(request_ref::<Backtrace>(&err).is_none());
+}
+
+#[test]
+fn named_implicit_backtrace_by_field_name() {
+    let err = TestErr::NamedImplicitBacktraceByFieldName {
+        backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+
+    assert!(request_ref::<Backtrace>(&err).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!(request_ref::<Backtrace>(&err).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!(request_ref::<Backtrace>(&err).is_none());
+}
+
+#[test]
+fn named_explicit_no_backtrace_by_field_type() {
+    let err = TestErr::NamedExplicitNoBacktraceByFieldType {
+        implicit_backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+
+    assert!(request_ref::<Backtrace>(&err).is_none());
+}
+
+#[test]
+fn named_explicit_backtrace() {
+    let err = TestErr::NamedExplicitBacktrace {
+        explicit_backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+
+    assert!(request_ref::<Backtrace>(&err).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!(request_ref::<Backtrace>(&err).is_none());
+}
+
+#[test]
+fn named_explicit_backtrace_by_field_name_redundant() {
+    let err = TestErr::NamedExplicitBacktraceByFieldNameRedundant {
+        backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+
+    assert!(request_ref::<Backtrace>(&err).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!(request_ref::<Backtrace>(&err).is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+}
+
+#[test]
+fn named_explicit_suppresses_implicit() {
+    let err = TestErr::NamedExplicitSuppressesImplicit {
+        not_backtrace: Backtrace::force_capture(),
+        backtrace: (|| Backtrace::force_capture())(), // ensure backtraces are different
+        field: 0,
+    };
+
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+    assert_bt!(!=, err, .get_unused_backtrace);
+}
+
+#[test]
+fn named_implicit_no_backtrace_from_source() {
+    let err = TestErr::NamedImplicitNoBacktraceFromSource {
+        err: BacktraceErr {
+            backtrace: Backtrace::force_capture(),
+        },
+    };
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_none());
+    assert!(request_value::<i32>(&err).is_none());
+}
+
+#[test]
+fn named_explicit_no_backtrace_from_source() {
+    let err = TestErr::NamedExplicitNoBacktraceFromSource {
+        err: BacktraceErr {
+            backtrace: Backtrace::force_capture(),
+        },
+    };
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_none());
+    assert!(request_value::<i32>(&err).is_none());
+}
+
+#[test]
+fn named_explicit_backtrace_from_source() {
+    let err = TestErr::NamedExplicitBacktraceFromSource {
+        err: BacktraceErr {
+            backtrace: Backtrace::force_capture(),
+        },
+    };
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_eq!(request_value::<i32>(&err), Some(42));
+    assert_bt!(==, err, .get_source_backtrace);
+}
+
+#[test]
+fn named_implicit_different_source_and_backtrace() {
+    let err = TestErr::NamedImplicitDifferentSourceAndBacktrace {
+        err: BacktraceErr {
+            backtrace: Backtrace::force_capture(),
+        },
+        backtrace: (|| Backtrace::force_capture())(), // ensure backtraces are different
+    };
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_eq!(request_value::<i32>(&err), Some(42));
+    assert_bt!(==, err, .get_stored_backtrace);
+    assert_bt!(!=, err, .get_source_backtrace);
+}
+
+#[test]
+fn named_explicit_different_source_and_backtrace() {
+    let err = TestErr::NamedExplicitDifferentSourceAndBacktrace {
+        err: BacktraceErr {
+            backtrace: Backtrace::force_capture(),
+        },
+        backtrace: (|| Backtrace::force_capture())(), // ensure backtraces are different
+    };
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_eq!(request_value::<i32>(&err), Some(42));
+    assert_bt!(==, err, .get_stored_backtrace);
+    assert_bt!(!=, err, .get_source_backtrace);
+}
+
+#[test]
+fn unnamed_implicit_no_backtrace() {
+    let err = TestErr::UnnamedImplicitNoBacktrace(0, 0);
+
+    assert!(request_ref::<Backtrace>(&err).is_none());
+}
+
+#[test]
+fn unnamed_implicit_backtrace() {
+    let err = TestErr::UnnamedImplicitBacktrace(Backtrace::force_capture(), 0, 0);
+
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+}
+
+#[test]
+fn unnamed_explicit_no_backtrace() {
+    let err = TestErr::UnnamedExplicitNoBacktrace(Backtrace::force_capture(), 0);
+
+    assert!(request_ref::<Backtrace>(&err).is_none());
+}
+
+#[test]
+fn unnamed_explicit_backtrace() {
+    let err = TestErr::UnnamedExplicitBacktrace(Backtrace::force_capture(), 0, 0);
+
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+}
+
+#[test]
+fn unnamed_explicit_no_backtrace_redundant() {
+    let err =
+        TestErr::UnnamedExplicitNoBacktraceRedundant(Backtrace::force_capture(), 0);
+
+    assert!(request_ref::<Backtrace>(&err).is_none());
+}
+
+#[test]
+fn unnamed_explicit_backtrace_redundant() {
+    let err =
+        TestErr::UnnamedExplicitBacktraceRedundant(Backtrace::force_capture(), 0, 0);
+
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+}
+
+#[test]
+fn unnamed_explicit_suppresses_implicit() {
+    let err = TestErr::UnnamedExplicitSuppressesImplicit(
+        Backtrace::force_capture(),
+        (|| Backtrace::force_capture())(), // ensure backtraces are different
+        0,
+    );
+
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+    assert_bt!(!=, err, .get_unused_backtrace);
+}
+
+#[test]
+fn unnamed_implicit_no_backtrace_from_source() {
+    let err = TestErr::UnnamedImplicitNoBacktraceFromSource(BacktraceErr {
+        backtrace: Backtrace::force_capture(),
+    });
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_none());
+    assert!(request_value::<i32>(&err).is_none());
+}
+
+#[test]
+fn unnamed_explicit_no_backtrace_from_source() {
+    let err = TestErr::UnnamedExplicitNoBacktraceFromSource(BacktraceErr {
+        backtrace: Backtrace::force_capture(),
+    });
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_none());
+    assert!(request_value::<i32>(&err).is_none());
+}
+
+#[test]
+fn unnamed_explicit_backtrace_from_source() {
+    let err = TestErr::UnnamedExplicitBacktraceFromSource(BacktraceErr {
+        backtrace: Backtrace::force_capture(),
+    });
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_eq!(request_value::<i32>(&err), Some(42));
+    assert_bt!(==, err, .get_source_backtrace);
+}
+
+#[test]
+fn unnamed_implicit_different_source_and_backtrace() {
+    let err = TestErr::UnnamedImplicitDifferentSourceAndBacktrace(
+        BacktraceErr {
+            backtrace: Backtrace::force_capture(),
+        },
+        (|| Backtrace::force_capture())(), // ensure backtraces are different
+    );
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_eq!(request_value::<i32>(&err), Some(42));
+    assert_bt!(==, err, .get_stored_backtrace);
+    assert_bt!(!=, err, .get_source_backtrace);
+}
+
+#[test]
+fn unnamed_explicit_different_source_and_backtrace() {
+    let err = TestErr::UnnamedExplicitDifferentSourceAndBacktrace(
+        BacktraceErr {
+            backtrace: Backtrace::force_capture(),
+        },
+        (|| Backtrace::force_capture())(), // ensure backtraces are different
+    );
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_eq!(request_value::<i32>(&err), Some(42));
+    assert_bt!(==, err, .get_stored_backtrace);
+    assert_bt!(!=, err, .get_source_backtrace);
+}

vendor/derive_more/tests/error/nightly/derives_for_generic_enums_with_backtrace.rs

@@ -0,0 +1,481 @@
+// For creating backtraces with different addresses in tests.
+#![allow(clippy::redundant_closure, clippy::redundant_closure_call)] // for testing
+#![allow(dead_code)] // some code is tested for type checking only
+
+use core::error::{request_ref, request_value};
+
+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,
+    },
+    NamedExplicitSuppressesImplicit {
+        #[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),
+    UnnamedExplicitSuppressesImplicit(#[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::NamedExplicitSuppressesImplicit { not_backtrace, .. } => {
+                not_backtrace
+            }
+            Self::UnnamedImplicitBacktrace(backtrace, _, _) => backtrace,
+            Self::UnnamedExplicitBacktrace(backtrace, _, _) => backtrace,
+            Self::UnnamedExplicitBacktraceRedundant(backtrace, _, _) => backtrace,
+            Self::UnnamedExplicitSuppressesImplicit(backtrace, _, _) => backtrace,
+            _ => panic!("ERROR IN TEST IMPLEMENTATION"),
+        }
+    }
+
+    fn get_unused_backtrace(&self) -> &Backtrace {
+        match self {
+            Self::NamedExplicitSuppressesImplicit { backtrace, .. } => backtrace,
+            Self::UnnamedExplicitSuppressesImplicit(_, backtrace, _) => backtrace,
+            _ => panic!("ERROR IN TEST IMPLEMENTATION"),
+        }
+    }
+}
+
+type MyBacktrace = Backtrace;
+
+#[test]
+fn unit() {
+    assert!(request_ref::<Backtrace>(&TestErr::<i32>::Unit).is_none());
+}
+
+#[test]
+fn named_implicit_no_backtrace() {
+    let err = TestErr::NamedImplicitNoBacktrace { field: 0 };
+
+    assert!(request_ref::<Backtrace>(&err).is_none());
+}
+
+#[test]
+fn named_implicit_backtrace_by_field_name() {
+    let err = TestErr::NamedImplicitBacktraceByFieldName {
+        backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+
+    assert!(request_ref::<Backtrace>(&err).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!(request_ref::<Backtrace>(&err).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!(request_ref::<Backtrace>(&err).is_none());
+}
+
+#[test]
+fn named_explicit_no_backtrace_by_field_type() {
+    let err = TestErr::NamedExplicitNoBacktraceByFieldType {
+        implicit_backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+
+    assert!(request_ref::<Backtrace>(&err).is_none());
+}
+
+#[test]
+fn named_explicit_backtrace() {
+    let err = TestErr::NamedExplicitBacktrace {
+        explicit_backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+
+    assert!(request_ref::<Backtrace>(&err).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!(request_ref::<Backtrace>(&err).is_none());
+}
+
+#[test]
+fn named_explicit_backtrace_by_field_name_redundant() {
+    let err = TestErr::NamedExplicitBacktraceByFieldNameRedundant {
+        backtrace: Backtrace::force_capture(),
+        field: 0,
+    };
+
+    assert!(request_ref::<Backtrace>(&err).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!(request_ref::<Backtrace>(&err).is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+}
+
+#[test]
+fn named_explicit_suppresses_implicit() {
+    let err = TestErr::NamedExplicitSuppressesImplicit {
+        not_backtrace: Backtrace::force_capture(),
+        backtrace: (|| Backtrace::force_capture())(), // ensure backtraces are different
+        field: 0,
+    };
+
+    assert!(request_ref::<Backtrace>(&err).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!(request_ref::<Backtrace>(&err).is_none());
+}
+
+#[test]
+fn unnamed_implicit_backtrace() {
+    let err = TestErr::UnnamedImplicitBacktrace(Backtrace::force_capture(), 0, 0);
+
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+}
+
+#[test]
+fn unnamed_explicit_no_backtrace() {
+    let err = TestErr::UnnamedExplicitNoBacktrace(Backtrace::force_capture(), 0);
+
+    assert!(request_ref::<Backtrace>(&err).is_none());
+}
+
+#[test]
+fn unnamed_explicit_backtrace() {
+    let err = TestErr::UnnamedExplicitBacktrace(Backtrace::force_capture(), 0, 0);
+
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+}
+
+#[test]
+fn unnamed_explicit_no_backtrace_redundant() {
+    let err =
+        TestErr::UnnamedExplicitNoBacktraceRedundant(Backtrace::force_capture(), 0);
+
+    assert!(request_ref::<Backtrace>(&err).is_none());
+}
+
+#[test]
+fn unnamed_explicit_backtrace_redundant() {
+    let err =
+        TestErr::UnnamedExplicitBacktraceRedundant(Backtrace::force_capture(), 0, 0);
+
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+}
+
+#[test]
+fn unnamed_explicit_suppresses_implicit() {
+    let err = TestErr::UnnamedExplicitSuppressesImplicit(
+        Backtrace::force_capture(),
+        (|| Backtrace::force_capture())(), // ensure backtraces are different
+        0,
+    );
+
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_bt!(==, err, .get_stored_backtrace);
+    assert_bt!(!=, err, .get_unused_backtrace);
+}
+
+derive_display!(BoundedTestErr, T);
+#[derive(Debug, Error)]
+enum BoundedTestErr<T> {
+    NamedImplicitNoBacktraceFromSource {
+        #[error(source)]
+        err: T,
+    },
+    NamedExplicitNoBacktraceFromSource {
+        #[error(source, not(backtrace))]
+        err: T,
+    },
+    NamedExplicitBacktraceFromSource {
+        #[error(backtrace, source)]
+        err: T,
+    },
+    NamedImplicitDifferentSourceAndBacktrace {
+        #[error(source)]
+        err: T,
+        backtrace: Backtrace,
+    },
+    NamedExplicitDifferentSourceAndBacktrace {
+        #[error(source)]
+        err: T,
+        #[error(backtrace)]
+        backtrace: Backtrace,
+    },
+    UnnamedImplicitNoBacktraceFromSource(T),
+    UnnamedExplicitNoBacktraceFromSource(#[error(not(backtrace))] T),
+    UnnamedExplicitBacktraceFromSource(#[error(backtrace)] T),
+    UnnamedImplicitDifferentSourceAndBacktrace(#[error(source)] T, Backtrace),
+    UnnamedExplicitDifferentSourceAndBacktrace(
+        #[error(source)] T,
+        #[error(backtrace)] Backtrace,
+    ),
+}
+
+impl<T: Error> BoundedTestErr<T> {
+    fn get_stored_backtrace(&self) -> &Backtrace {
+        match self {
+            Self::NamedImplicitDifferentSourceAndBacktrace { backtrace, .. }
+            | Self::NamedExplicitDifferentSourceAndBacktrace { backtrace, .. }
+            | Self::UnnamedImplicitDifferentSourceAndBacktrace(_, backtrace)
+            | Self::UnnamedExplicitDifferentSourceAndBacktrace(_, backtrace) => {
+                backtrace
+            }
+            _ => panic!("ERROR IN TEST IMPLEMENTATION"),
+        }
+    }
+
+    fn get_source_backtrace(&self) -> &Backtrace {
+        request_ref(match self {
+            Self::NamedExplicitBacktraceFromSource { err }
+            | Self::NamedExplicitDifferentSourceAndBacktrace { err, .. }
+            | Self::NamedImplicitDifferentSourceAndBacktrace { err, .. }
+            | Self::UnnamedExplicitBacktraceFromSource(err)
+            | Self::UnnamedExplicitDifferentSourceAndBacktrace(err, ..)
+            | Self::UnnamedImplicitDifferentSourceAndBacktrace(err, ..) => err,
+            _ => panic!("ERROR IN TEST IMPLEMENTATION"),
+        })
+        .unwrap()
+    }
+}
+
+#[test]
+fn named_implicit_no_backtrace_from_source() {
+    let err = BoundedTestErr::NamedImplicitNoBacktraceFromSource {
+        err: BacktraceErr {
+            backtrace: Backtrace::force_capture(),
+        },
+    };
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_none());
+    assert!(request_value::<i32>(&err).is_none());
+}
+
+#[test]
+fn named_explicit_no_backtrace_from_source() {
+    let err = BoundedTestErr::NamedExplicitNoBacktraceFromSource {
+        err: BacktraceErr {
+            backtrace: Backtrace::force_capture(),
+        },
+    };
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_none());
+    assert!(request_value::<i32>(&err).is_none());
+}
+
+#[test]
+fn named_explicit_backtrace_from_source() {
+    let err = BoundedTestErr::NamedExplicitBacktraceFromSource {
+        err: BacktraceErr {
+            backtrace: Backtrace::force_capture(),
+        },
+    };
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_eq!(request_value::<i32>(&err), Some(42));
+    assert_bt!(==, err, .get_source_backtrace);
+}
+
+#[test]
+fn named_implicit_different_source_and_backtrace() {
+    let err = BoundedTestErr::NamedImplicitDifferentSourceAndBacktrace {
+        err: BacktraceErr {
+            backtrace: Backtrace::force_capture(),
+        },
+        backtrace: (|| Backtrace::force_capture())(), // ensure backtraces are different
+    };
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_eq!(request_value::<i32>(&err), Some(42));
+    assert_bt!(==, err, .get_stored_backtrace);
+    assert_bt!(!=, err, .get_source_backtrace);
+}
+
+#[test]
+fn named_explicit_different_source_and_backtrace() {
+    let err = BoundedTestErr::NamedExplicitDifferentSourceAndBacktrace {
+        err: BacktraceErr {
+            backtrace: Backtrace::force_capture(),
+        },
+        backtrace: (|| Backtrace::force_capture())(), // ensure backtraces are different
+    };
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_eq!(request_value::<i32>(&err), Some(42));
+    assert_bt!(==, err, .get_stored_backtrace);
+    assert_bt!(!=, err, .get_source_backtrace);
+}
+
+#[test]
+fn unnamed_implicit_no_backtrace_from_source() {
+    let err = BoundedTestErr::UnnamedImplicitNoBacktraceFromSource(BacktraceErr {
+        backtrace: Backtrace::force_capture(),
+    });
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_none());
+    assert!(request_value::<i32>(&err).is_none());
+}
+
+#[test]
+fn unnamed_explicit_no_backtrace_from_source() {
+    let err = BoundedTestErr::UnnamedExplicitNoBacktraceFromSource(BacktraceErr {
+        backtrace: Backtrace::force_capture(),
+    });
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_none());
+    assert!(request_value::<i32>(&err).is_none());
+}
+
+#[test]
+fn unnamed_explicit_backtrace_from_source() {
+    let err = BoundedTestErr::UnnamedExplicitBacktraceFromSource(BacktraceErr {
+        backtrace: Backtrace::force_capture(),
+    });
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_eq!(request_value::<i32>(&err), Some(42));
+    assert_bt!(==, err, .get_source_backtrace);
+}
+
+#[test]
+fn unnamed_implicit_different_source_and_backtrace() {
+    let err = BoundedTestErr::UnnamedImplicitDifferentSourceAndBacktrace(
+        BacktraceErr {
+            backtrace: Backtrace::force_capture(),
+        },
+        (|| Backtrace::force_capture())(), // ensure backtraces are different
+    );
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_eq!(request_value::<i32>(&err), Some(42));
+    assert_bt!(==, err, .get_stored_backtrace);
+    assert_bt!(!=, err, .get_source_backtrace);
+}
+
+#[test]
+fn unnamed_explicit_different_source_and_backtrace() {
+    let err = BoundedTestErr::UnnamedExplicitDifferentSourceAndBacktrace(
+        BacktraceErr {
+            backtrace: Backtrace::force_capture(),
+        },
+        (|| Backtrace::force_capture())(), // ensure backtraces are different
+    );
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_eq!(request_value::<i32>(&err), Some(42));
+    assert_bt!(==, err, .get_stored_backtrace);
+    assert_bt!(!=, err, .get_source_backtrace);
+}

vendor/derive_more/tests/error/nightly/derives_for_generic_structs_with_backtrace.rs

@@ -0,0 +1,478 @@
+// For creating backtraces with different addresses in tests.
+#![allow(clippy::redundant_closure, clippy::redundant_closure_call)] // for testing
+#![allow(dead_code)] // some code is tested for type checking only
+
+use core::error::{request_ref, request_value};
+
+use super::*;
+
+#[test]
+fn named_implicit_no_backtrace() {
+    derive_display!(TestErr, T);
+    #[derive(Default, Debug, Error)]
+    struct TestErr<T> {
+        field: T,
+    }
+
+    assert!(request_ref::<Backtrace>(&TestErr::<i32>::default()).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!(request_ref::<Backtrace>(&err).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!(request_ref::<Backtrace>(&err).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!(request_ref::<Backtrace>(&TestErr {
+        backtrace: Backtrace::force_capture(),
+        field: 0
+    })
+    .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!(request_ref::<Backtrace>(&TestErr {
+        implicit_backtrace: Backtrace::force_capture(),
+        field: 0
+    })
+    .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!(request_ref::<Backtrace>(&err).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!(request_ref::<Backtrace>(&TestErr {
+        not_backtrace: Backtrace::force_capture(),
+        field: 0
+    })
+    .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!(request_ref::<Backtrace>(&err).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!(request_ref::<Backtrace>(&err).is_some());
+    assert_bt!(==, err, implicit_backtrace);
+}
+
+#[test]
+fn named_explicit_suppresses_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!(request_ref::<Backtrace>(&err).is_some());
+    assert_bt!(==, err, not_backtrace);
+    assert_bt!(!=, err);
+}
+
+#[test]
+fn named_implicit_no_backtrace_from_source() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T> {
+        #[error(source)]
+        err: T,
+    }
+
+    let err = TestErr {
+        err: BacktraceErr {
+            backtrace: Backtrace::force_capture(),
+        },
+    };
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_none());
+    assert!(request_value::<i32>(&err).is_none());
+}
+
+#[test]
+fn named_explicit_no_backtrace_from_source() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T> {
+        #[error(source, not(backtrace))]
+        err: T,
+    }
+
+    let err = TestErr {
+        err: BacktraceErr {
+            backtrace: Backtrace::force_capture(),
+        },
+    };
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_none());
+    assert!(request_value::<i32>(&err).is_none());
+}
+
+#[test]
+fn named_explicit_backtrace_from_source() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T> {
+        #[error(backtrace, source)]
+        err: T,
+    }
+
+    let err = TestErr {
+        err: BacktraceErr {
+            backtrace: Backtrace::force_capture(),
+        },
+    };
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_eq!(request_value::<i32>(&err), Some(42));
+    assert_bt!(==, err, request_ref::<Backtrace>(&err.err).unwrap());
+}
+
+#[test]
+fn named_implicit_different_source_and_backtrace() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T> {
+        #[error(source)]
+        err: T,
+        backtrace: Backtrace,
+    }
+
+    let err = TestErr {
+        err: BacktraceErr {
+            backtrace: Backtrace::force_capture(),
+        },
+        backtrace: (|| Backtrace::force_capture())(), // ensure backtraces are different
+    };
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_eq!(request_value::<i32>(&err), Some(42));
+    assert_bt!(==, err, backtrace);
+    assert_bt!(!=, err, request_ref::<Backtrace>(&err.err).unwrap());
+}
+
+#[test]
+fn named_explicit_different_source_and_backtrace() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T> {
+        #[error(source)]
+        err: T,
+        #[error(backtrace)]
+        backtrace: Backtrace,
+    }
+
+    let err = TestErr {
+        err: BacktraceErr {
+            backtrace: Backtrace::force_capture(),
+        },
+        backtrace: (|| Backtrace::force_capture())(), // ensure backtraces are different
+    };
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_eq!(request_value::<i32>(&err), Some(42));
+    assert_bt!(==, err, backtrace);
+    assert_bt!(!=, err, request_ref::<Backtrace>(&err.err).unwrap());
+}
+
+#[test]
+fn unnamed_implicit_no_backtrace() {
+    derive_display!(TestErr, T);
+    #[derive(Default, Debug, Error)]
+    struct TestErr<T>(T, T);
+
+    assert!(request_ref::<Backtrace>(&TestErr::<i32>::default()).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!(request_ref::<Backtrace>(&err).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!(
+        request_ref::<Backtrace>(&TestErr(Backtrace::force_capture(), 0)).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!(request_ref::<Backtrace>(&err).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!(
+        request_ref::<Backtrace>(&TestErr(Backtrace::force_capture(), 0)).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!(request_ref::<Backtrace>(&err).is_some());
+    assert_bt!(==, err, .0);
+}
+
+#[test]
+fn unnamed_explicit_suppresses_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!(request_ref::<Backtrace>(&err).is_some());
+    assert_bt!(==, err, .0);
+    assert_bt!(!=, err, .1);
+}
+
+#[test]
+fn unnamed_implicit_no_backtrace_from_source() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T>(T);
+
+    let err = TestErr(BacktraceErr {
+        backtrace: Backtrace::force_capture(),
+    });
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_none());
+    assert!(request_value::<i32>(&err).is_none());
+}
+
+#[test]
+fn unnamed_explicit_no_backtrace_from_source() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T>(#[error(not(backtrace))] T);
+
+    let err = TestErr(BacktraceErr {
+        backtrace: Backtrace::force_capture(),
+    });
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_none());
+    assert!(request_value::<i32>(&err).is_none());
+}
+
+#[test]
+fn unnamed_explicit_backtrace_from_source() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T>(#[error(backtrace)] T);
+
+    let err = TestErr(BacktraceErr {
+        backtrace: Backtrace::force_capture(),
+    });
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_eq!(request_value::<i32>(&err), Some(42));
+    assert_bt!(==, err, request_ref::<Backtrace>(&err.0).unwrap());
+}
+
+#[test]
+fn unnamed_implicit_different_source_and_backtrace() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T>(#[error(source)] T, Backtrace);
+
+    let err = TestErr(
+        BacktraceErr {
+            backtrace: Backtrace::force_capture(),
+        },
+        (|| Backtrace::force_capture())(), // ensure backtraces are different
+    );
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_eq!(request_value::<i32>(&err), Some(42));
+    assert_bt!(==, err, .1);
+    assert_bt!(!=, err, request_ref::<Backtrace>(&err.0).unwrap());
+}
+
+#[test]
+fn unnamed_explicit_different_source_and_backtrace() {
+    derive_display!(TestErr, T);
+    #[derive(Debug, Error)]
+    struct TestErr<T>(#[error(source)] T, #[error(backtrace)] Backtrace);
+
+    let err = TestErr(
+        BacktraceErr {
+            backtrace: Backtrace::force_capture(),
+        },
+        (|| Backtrace::force_capture())(), // ensure backtraces are different
+    );
+
+    assert!(err.source().is_some());
+    assert!(request_ref::<Backtrace>(&err).is_some());
+    assert_eq!(request_value::<i32>(&err), Some(42));
+    assert_bt!(==, err, .1);
+    assert_bt!(!=, err, request_ref::<Backtrace>(&err.0).unwrap());
+}