| #![feature(prelude_import)] |
| // check-pass |
| // compile-flags: -Zunpretty=expanded |
| // edition:2021 |
| // |
| // This test checks the code generated for all[*] the builtin derivable traits |
| // on a variety of structs and enums. It protects against accidental changes to |
| // the generated code, and makes deliberate changes to the generated code |
| // easier to review. |
| // |
| // [*] It excludes `Copy` in some cases, because that changes the code |
| // generated for `Clone`. |
| // |
| // [*] It excludes `RustcEncodable` and `RustDecodable`, which are obsolete and |
| // also require the `rustc_serialize` crate. |
| |
| #![crate_type = "lib"] |
| #![allow(dead_code)] |
| #![allow(deprecated)] |
| #[prelude_import] |
| use std::prelude::rust_2021::*; |
| #[macro_use] |
| extern crate std; |
| |
| // Empty struct. |
| struct Empty; |
| #[automatically_derived] |
| impl ::core::clone::Clone for Empty { |
| #[inline] |
| fn clone(&self) -> Empty { *self } |
| } |
| #[automatically_derived] |
| impl ::core::marker::Copy for Empty { } |
| #[automatically_derived] |
| impl ::core::fmt::Debug for Empty { |
| fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { |
| ::core::fmt::Formatter::write_str(f, "Empty") |
| } |
| } |
| #[automatically_derived] |
| impl ::core::default::Default for Empty { |
| #[inline] |
| fn default() -> Empty { Empty {} } |
| } |
| #[automatically_derived] |
| impl ::core::hash::Hash for Empty { |
| fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {} |
| } |
| #[automatically_derived] |
| impl ::core::marker::StructuralPartialEq for Empty { } |
| #[automatically_derived] |
| impl ::core::cmp::PartialEq for Empty { |
| #[inline] |
| fn eq(&self, other: &Empty) -> bool { true } |
| } |
| #[automatically_derived] |
| impl ::core::marker::StructuralEq for Empty { } |
| #[automatically_derived] |
| impl ::core::cmp::Eq for Empty { |
| #[inline] |
| #[doc(hidden)] |
| #[no_coverage] |
| fn assert_receiver_is_total_eq(&self) -> () {} |
| } |
| #[automatically_derived] |
| impl ::core::cmp::PartialOrd for Empty { |
| #[inline] |
| fn partial_cmp(&self, other: &Empty) |
| -> ::core::option::Option<::core::cmp::Ordering> { |
| ::core::option::Option::Some(::core::cmp::Ordering::Equal) |
| } |
| } |
| #[automatically_derived] |
| impl ::core::cmp::Ord for Empty { |
| #[inline] |
| fn cmp(&self, other: &Empty) -> ::core::cmp::Ordering { |
| ::core::cmp::Ordering::Equal |
| } |
| } |
| |
| // A basic struct. |
| struct Point { |
| x: u32, |
| y: u32, |
| } |
| #[automatically_derived] |
| impl ::core::clone::Clone for Point { |
| #[inline] |
| fn clone(&self) -> Point { |
| let _: ::core::clone::AssertParamIsClone<u32>; |
| *self |
| } |
| } |
| #[automatically_derived] |
| impl ::core::marker::Copy for Point { } |
| #[automatically_derived] |
| impl ::core::fmt::Debug for Point { |
| fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { |
| ::core::fmt::Formatter::debug_struct_field2_finish(f, "Point", "x", |
| &&self.x, "y", &&self.y) |
| } |
| } |
| #[automatically_derived] |
| impl ::core::default::Default for Point { |
| #[inline] |
| fn default() -> Point { |
| Point { |
| x: ::core::default::Default::default(), |
| y: ::core::default::Default::default(), |
| } |
| } |
| } |
| #[automatically_derived] |
| impl ::core::hash::Hash for Point { |
| fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { |
| ::core::hash::Hash::hash(&self.x, state); |
| ::core::hash::Hash::hash(&self.y, state) |
| } |
| } |
| #[automatically_derived] |
| impl ::core::marker::StructuralPartialEq for Point { } |
| #[automatically_derived] |
| impl ::core::cmp::PartialEq for Point { |
| #[inline] |
| fn eq(&self, other: &Point) -> bool { |
| self.x == other.x && self.y == other.y |
| } |
| } |
| #[automatically_derived] |
| impl ::core::marker::StructuralEq for Point { } |
| #[automatically_derived] |
| impl ::core::cmp::Eq for Point { |
| #[inline] |
| #[doc(hidden)] |
| #[no_coverage] |
| fn assert_receiver_is_total_eq(&self) -> () { |
| let _: ::core::cmp::AssertParamIsEq<u32>; |
| } |
| } |
| #[automatically_derived] |
| impl ::core::cmp::PartialOrd for Point { |
| #[inline] |
| fn partial_cmp(&self, other: &Point) |
| -> ::core::option::Option<::core::cmp::Ordering> { |
| match ::core::cmp::PartialOrd::partial_cmp(&self.x, &other.x) { |
| ::core::option::Option::Some(::core::cmp::Ordering::Equal) => |
| ::core::cmp::PartialOrd::partial_cmp(&self.y, &other.y), |
| cmp => cmp, |
| } |
| } |
| } |
| #[automatically_derived] |
| impl ::core::cmp::Ord for Point { |
| #[inline] |
| fn cmp(&self, other: &Point) -> ::core::cmp::Ordering { |
| match ::core::cmp::Ord::cmp(&self.x, &other.x) { |
| ::core::cmp::Ordering::Equal => |
| ::core::cmp::Ord::cmp(&self.y, &other.y), |
| cmp => cmp, |
| } |
| } |
| } |
| |
| // A large struct. |
| struct Big { |
| b1: u32, |
| b2: u32, |
| b3: u32, |
| b4: u32, |
| b5: u32, |
| b6: u32, |
| b7: u32, |
| b8: u32, |
| } |
| #[automatically_derived] |
| impl ::core::clone::Clone for Big { |
| #[inline] |
| fn clone(&self) -> Big { |
| Big { |
| b1: ::core::clone::Clone::clone(&self.b1), |
| b2: ::core::clone::Clone::clone(&self.b2), |
| b3: ::core::clone::Clone::clone(&self.b3), |
| b4: ::core::clone::Clone::clone(&self.b4), |
| b5: ::core::clone::Clone::clone(&self.b5), |
| b6: ::core::clone::Clone::clone(&self.b6), |
| b7: ::core::clone::Clone::clone(&self.b7), |
| b8: ::core::clone::Clone::clone(&self.b8), |
| } |
| } |
| } |
| #[automatically_derived] |
| impl ::core::fmt::Debug for Big { |
| fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { |
| let names: &'static _ = |
| &["b1", "b2", "b3", "b4", "b5", "b6", "b7", "b8"]; |
| let values: &[&dyn ::core::fmt::Debug] = |
| &[&&self.b1, &&self.b2, &&self.b3, &&self.b4, &&self.b5, |
| &&self.b6, &&self.b7, &&self.b8]; |
| ::core::fmt::Formatter::debug_struct_fields_finish(f, "Big", names, |
| values) |
| } |
| } |
| #[automatically_derived] |
| impl ::core::default::Default for Big { |
| #[inline] |
| fn default() -> Big { |
| Big { |
| b1: ::core::default::Default::default(), |
| b2: ::core::default::Default::default(), |
| b3: ::core::default::Default::default(), |
| b4: ::core::default::Default::default(), |
| b5: ::core::default::Default::default(), |
| b6: ::core::default::Default::default(), |
| b7: ::core::default::Default::default(), |
| b8: ::core::default::Default::default(), |
| } |
| } |
| } |
| #[automatically_derived] |
| impl ::core::hash::Hash for Big { |
| fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { |
| ::core::hash::Hash::hash(&self.b1, state); |
| ::core::hash::Hash::hash(&self.b2, state); |
| ::core::hash::Hash::hash(&self.b3, state); |
| ::core::hash::Hash::hash(&self.b4, state); |
| ::core::hash::Hash::hash(&self.b5, state); |
| ::core::hash::Hash::hash(&self.b6, state); |
| ::core::hash::Hash::hash(&self.b7, state); |
| ::core::hash::Hash::hash(&self.b8, state) |
| } |
| } |
| #[automatically_derived] |
| impl ::core::marker::StructuralPartialEq for Big { } |
| #[automatically_derived] |
| impl ::core::cmp::PartialEq for Big { |
| #[inline] |
| fn eq(&self, other: &Big) -> bool { |
| self.b1 == other.b1 && self.b2 == other.b2 && self.b3 == other.b3 && |
| self.b4 == other.b4 && self.b5 == other.b5 && |
| self.b6 == other.b6 && self.b7 == other.b7 && |
| self.b8 == other.b8 |
| } |
| } |
| #[automatically_derived] |
| impl ::core::marker::StructuralEq for Big { } |
| #[automatically_derived] |
| impl ::core::cmp::Eq for Big { |
| #[inline] |
| #[doc(hidden)] |
| #[no_coverage] |
| fn assert_receiver_is_total_eq(&self) -> () { |
| let _: ::core::cmp::AssertParamIsEq<u32>; |
| } |
| } |
| #[automatically_derived] |
| impl ::core::cmp::PartialOrd for Big { |
| #[inline] |
| fn partial_cmp(&self, other: &Big) |
| -> ::core::option::Option<::core::cmp::Ordering> { |
| match ::core::cmp::PartialOrd::partial_cmp(&self.b1, &other.b1) { |
| ::core::option::Option::Some(::core::cmp::Ordering::Equal) => |
| match ::core::cmp::PartialOrd::partial_cmp(&self.b2, |
| &other.b2) { |
| ::core::option::Option::Some(::core::cmp::Ordering::Equal) |
| => |
| match ::core::cmp::PartialOrd::partial_cmp(&self.b3, |
| &other.b3) { |
| ::core::option::Option::Some(::core::cmp::Ordering::Equal) |
| => |
| match ::core::cmp::PartialOrd::partial_cmp(&self.b4, |
| &other.b4) { |
| ::core::option::Option::Some(::core::cmp::Ordering::Equal) |
| => |
| match ::core::cmp::PartialOrd::partial_cmp(&self.b5, |
| &other.b5) { |
| ::core::option::Option::Some(::core::cmp::Ordering::Equal) |
| => |
| match ::core::cmp::PartialOrd::partial_cmp(&self.b6, |
| &other.b6) { |
| ::core::option::Option::Some(::core::cmp::Ordering::Equal) |
| => |
| match ::core::cmp::PartialOrd::partial_cmp(&self.b7, |
| &other.b7) { |
| ::core::option::Option::Some(::core::cmp::Ordering::Equal) |
| => |
| ::core::cmp::PartialOrd::partial_cmp(&self.b8, &other.b8), |
| cmp => cmp, |
| }, |
| cmp => cmp, |
| }, |
| cmp => cmp, |
| }, |
| cmp => cmp, |
| }, |
| cmp => cmp, |
| }, |
| cmp => cmp, |
| }, |
| cmp => cmp, |
| } |
| } |
| } |
| #[automatically_derived] |
| impl ::core::cmp::Ord for Big { |
| #[inline] |
| fn cmp(&self, other: &Big) -> ::core::cmp::Ordering { |
| match ::core::cmp::Ord::cmp(&self.b1, &other.b1) { |
| ::core::cmp::Ordering::Equal => |
| match ::core::cmp::Ord::cmp(&self.b2, &other.b2) { |
| ::core::cmp::Ordering::Equal => |
| match ::core::cmp::Ord::cmp(&self.b3, &other.b3) { |
| ::core::cmp::Ordering::Equal => |
| match ::core::cmp::Ord::cmp(&self.b4, &other.b4) { |
| ::core::cmp::Ordering::Equal => |
| match ::core::cmp::Ord::cmp(&self.b5, &other.b5) { |
| ::core::cmp::Ordering::Equal => |
| match ::core::cmp::Ord::cmp(&self.b6, &other.b6) { |
| ::core::cmp::Ordering::Equal => |
| match ::core::cmp::Ord::cmp(&self.b7, &other.b7) { |
| ::core::cmp::Ordering::Equal => |
| ::core::cmp::Ord::cmp(&self.b8, &other.b8), |
| cmp => cmp, |
| }, |
| cmp => cmp, |
| }, |
| cmp => cmp, |
| }, |
| cmp => cmp, |
| }, |
| cmp => cmp, |
| }, |
| cmp => cmp, |
| }, |
| cmp => cmp, |
| } |
| } |
| } |
| |
| // A struct with an unsized field. Some derives are not usable in this case. |
| struct Unsized([u32]); |
| #[automatically_derived] |
| impl ::core::fmt::Debug for Unsized { |
| fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { |
| ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Unsized", |
| &&self.0) |
| } |
| } |
| #[automatically_derived] |
| impl ::core::hash::Hash for Unsized { |
| fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { |
| ::core::hash::Hash::hash(&self.0, state) |
| } |
| } |
| #[automatically_derived] |
| impl ::core::marker::StructuralPartialEq for Unsized { } |
| #[automatically_derived] |
| impl ::core::cmp::PartialEq for Unsized { |
| #[inline] |
| fn eq(&self, other: &Unsized) -> bool { self.0 == other.0 } |
| } |
| #[automatically_derived] |
| impl ::core::marker::StructuralEq for Unsized { } |
| #[automatically_derived] |
| impl ::core::cmp::Eq for Unsized { |
| #[inline] |
| #[doc(hidden)] |
| #[no_coverage] |
| fn assert_receiver_is_total_eq(&self) -> () { |
| let _: ::core::cmp::AssertParamIsEq<[u32]>; |
| } |
| } |
| #[automatically_derived] |
| impl ::core::cmp::PartialOrd for Unsized { |
| #[inline] |
| fn partial_cmp(&self, other: &Unsized) |
| -> ::core::option::Option<::core::cmp::Ordering> { |
| ::core::cmp::PartialOrd::partial_cmp(&self.0, &other.0) |
| } |
| } |
| #[automatically_derived] |
| impl ::core::cmp::Ord for Unsized { |
| #[inline] |
| fn cmp(&self, other: &Unsized) -> ::core::cmp::Ordering { |
| ::core::cmp::Ord::cmp(&self.0, &other.0) |
| } |
| } |
| |
| // A packed tuple struct that impls `Copy`. |
| #[repr(packed)] |
| struct PackedCopy(u32); |
| #[automatically_derived] |
| impl ::core::clone::Clone for PackedCopy { |
| #[inline] |
| fn clone(&self) -> PackedCopy { |
| let _: ::core::clone::AssertParamIsClone<u32>; |
| *self |
| } |
| } |
| #[automatically_derived] |
| impl ::core::marker::Copy for PackedCopy { } |
| #[automatically_derived] |
| impl ::core::fmt::Debug for PackedCopy { |
| fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { |
| ::core::fmt::Formatter::debug_tuple_field1_finish(f, "PackedCopy", |
| &&{ self.0 }) |
| } |
| } |
| #[automatically_derived] |
| impl ::core::default::Default for PackedCopy { |
| #[inline] |
| fn default() -> PackedCopy { |
| PackedCopy(::core::default::Default::default()) |
| } |
| } |
| #[automatically_derived] |
| impl ::core::hash::Hash for PackedCopy { |
| fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { |
| ::core::hash::Hash::hash(&{ self.0 }, state) |
| } |
| } |
| #[automatically_derived] |
| impl ::core::marker::StructuralPartialEq for PackedCopy { } |
| #[automatically_derived] |
| impl ::core::cmp::PartialEq for PackedCopy { |
| #[inline] |
| fn eq(&self, other: &PackedCopy) -> bool { { self.0 } == { other.0 } } |
| } |
| #[automatically_derived] |
| impl ::core::marker::StructuralEq for PackedCopy { } |
| #[automatically_derived] |
| impl ::core::cmp::Eq for PackedCopy { |
| #[inline] |
| #[doc(hidden)] |
| #[no_coverage] |
| fn assert_receiver_is_total_eq(&self) -> () { |
| let _: ::core::cmp::AssertParamIsEq<u32>; |
| } |
| } |
| #[automatically_derived] |
| impl ::core::cmp::PartialOrd for PackedCopy { |
| #[inline] |
| fn partial_cmp(&self, other: &PackedCopy) |
| -> ::core::option::Option<::core::cmp::Ordering> { |
| ::core::cmp::PartialOrd::partial_cmp(&{ self.0 }, &{ other.0 }) |
| } |
| } |
| #[automatically_derived] |
| impl ::core::cmp::Ord for PackedCopy { |
| #[inline] |
| fn cmp(&self, other: &PackedCopy) -> ::core::cmp::Ordering { |
| ::core::cmp::Ord::cmp(&{ self.0 }, &{ other.0 }) |
| } |
| } |
| |
| // A packed tuple struct that does not impl `Copy`. Note that the alignment of |
| // the field must be 1 for this code to be valid. Otherwise it triggers an |
| // error "`#[derive]` can't be used on a `#[repr(packed)]` struct that does not |
| // derive Copy (error E0133)" at MIR building time. This is a weird case and |
| // it's possible that this struct is not supposed to work, but for now it does. |
| #[repr(packed)] |
| struct PackedNonCopy(u8); |
| #[automatically_derived] |
| impl ::core::clone::Clone for PackedNonCopy { |
| #[inline] |
| fn clone(&self) -> PackedNonCopy { |
| PackedNonCopy(::core::clone::Clone::clone(&self.0)) |
| } |
| } |
| #[automatically_derived] |
| impl ::core::fmt::Debug for PackedNonCopy { |
| fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { |
| ::core::fmt::Formatter::debug_tuple_field1_finish(f, "PackedNonCopy", |
| &&self.0) |
| } |
| } |
| #[automatically_derived] |
| impl ::core::default::Default for PackedNonCopy { |
| #[inline] |
| fn default() -> PackedNonCopy { |
| PackedNonCopy(::core::default::Default::default()) |
| } |
| } |
| #[automatically_derived] |
| impl ::core::hash::Hash for PackedNonCopy { |
| fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { |
| ::core::hash::Hash::hash(&self.0, state) |
| } |
| } |
| #[automatically_derived] |
| impl ::core::marker::StructuralPartialEq for PackedNonCopy { } |
| #[automatically_derived] |
| impl ::core::cmp::PartialEq for PackedNonCopy { |
| #[inline] |
| fn eq(&self, other: &PackedNonCopy) -> bool { self.0 == other.0 } |
| } |
| #[automatically_derived] |
| impl ::core::marker::StructuralEq for PackedNonCopy { } |
| #[automatically_derived] |
| impl ::core::cmp::Eq for PackedNonCopy { |
| #[inline] |
| #[doc(hidden)] |
| #[no_coverage] |
| fn assert_receiver_is_total_eq(&self) -> () { |
| let _: ::core::cmp::AssertParamIsEq<u8>; |
| } |
| } |
| #[automatically_derived] |
| impl ::core::cmp::PartialOrd for PackedNonCopy { |
| #[inline] |
| fn partial_cmp(&self, other: &PackedNonCopy) |
| -> ::core::option::Option<::core::cmp::Ordering> { |
| ::core::cmp::PartialOrd::partial_cmp(&self.0, &other.0) |
| } |
| } |
| #[automatically_derived] |
| impl ::core::cmp::Ord for PackedNonCopy { |
| #[inline] |
| fn cmp(&self, other: &PackedNonCopy) -> ::core::cmp::Ordering { |
| ::core::cmp::Ord::cmp(&self.0, &other.0) |
| } |
| } |
| |
| // An empty enum. |
| enum Enum0 {} |
| #[automatically_derived] |
| impl ::core::clone::Clone for Enum0 { |
| #[inline] |
| fn clone(&self) -> Enum0 { *self } |
| } |
| #[automatically_derived] |
| impl ::core::marker::Copy for Enum0 { } |
| #[automatically_derived] |
| impl ::core::fmt::Debug for Enum0 { |
| fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { |
| unsafe { ::core::intrinsics::unreachable() } |
| } |
| } |
| #[automatically_derived] |
| impl ::core::hash::Hash for Enum0 { |
| fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { |
| unsafe { ::core::intrinsics::unreachable() } |
| } |
| } |
| #[automatically_derived] |
| impl ::core::marker::StructuralPartialEq for Enum0 { } |
| #[automatically_derived] |
| impl ::core::cmp::PartialEq for Enum0 { |
| #[inline] |
| fn eq(&self, other: &Enum0) -> bool { |
| unsafe { ::core::intrinsics::unreachable() } |
| } |
| } |
| #[automatically_derived] |
| impl ::core::marker::StructuralEq for Enum0 { } |
| #[automatically_derived] |
| impl ::core::cmp::Eq for Enum0 { |
| #[inline] |
| #[doc(hidden)] |
| #[no_coverage] |
| fn assert_receiver_is_total_eq(&self) -> () {} |
| } |
| #[automatically_derived] |
| impl ::core::cmp::PartialOrd for Enum0 { |
| #[inline] |
| fn partial_cmp(&self, other: &Enum0) |
| -> ::core::option::Option<::core::cmp::Ordering> { |
| unsafe { ::core::intrinsics::unreachable() } |
| } |
| } |
| #[automatically_derived] |
| impl ::core::cmp::Ord for Enum0 { |
| #[inline] |
| fn cmp(&self, other: &Enum0) -> ::core::cmp::Ordering { |
| unsafe { ::core::intrinsics::unreachable() } |
| } |
| } |
| |
| // A single-variant enum. |
| enum Enum1 { |
| Single { |
| x: u32, |
| }, |
| } |
| #[automatically_derived] |
| impl ::core::clone::Clone for Enum1 { |
| #[inline] |
| fn clone(&self) -> Enum1 { |
| match self { |
| Enum1::Single { x: __self_0 } => |
| Enum1::Single { x: ::core::clone::Clone::clone(__self_0) }, |
| } |
| } |
| } |
| #[automatically_derived] |
| impl ::core::fmt::Debug for Enum1 { |
| fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { |
| match self { |
| Enum1::Single { x: __self_0 } => |
| ::core::fmt::Formatter::debug_struct_field1_finish(f, |
| "Single", "x", &__self_0), |
| } |
| } |
| } |
| #[automatically_derived] |
| impl ::core::hash::Hash for Enum1 { |
| fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { |
| match self { |
| Enum1::Single { x: __self_0 } => |
| ::core::hash::Hash::hash(__self_0, state), |
| } |
| } |
| } |
| #[automatically_derived] |
| impl ::core::marker::StructuralPartialEq for Enum1 { } |
| #[automatically_derived] |
| impl ::core::cmp::PartialEq for Enum1 { |
| #[inline] |
| fn eq(&self, other: &Enum1) -> bool { |
| match (self, other) { |
| (Enum1::Single { x: __self_0 }, Enum1::Single { x: __arg1_0 }) => |
| *__self_0 == *__arg1_0, |
| } |
| } |
| } |
| #[automatically_derived] |
| impl ::core::marker::StructuralEq for Enum1 { } |
| #[automatically_derived] |
| impl ::core::cmp::Eq for Enum1 { |
| #[inline] |
| #[doc(hidden)] |
| #[no_coverage] |
| fn assert_receiver_is_total_eq(&self) -> () { |
| let _: ::core::cmp::AssertParamIsEq<u32>; |
| } |
| } |
| #[automatically_derived] |
| impl ::core::cmp::PartialOrd for Enum1 { |
| #[inline] |
| fn partial_cmp(&self, other: &Enum1) |
| -> ::core::option::Option<::core::cmp::Ordering> { |
| match (self, other) { |
| (Enum1::Single { x: __self_0 }, Enum1::Single { x: __arg1_0 }) => |
| ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0), |
| } |
| } |
| } |
| #[automatically_derived] |
| impl ::core::cmp::Ord for Enum1 { |
| #[inline] |
| fn cmp(&self, other: &Enum1) -> ::core::cmp::Ordering { |
| match (self, other) { |
| (Enum1::Single { x: __self_0 }, Enum1::Single { x: __arg1_0 }) => |
| ::core::cmp::Ord::cmp(__self_0, __arg1_0), |
| } |
| } |
| } |
| |
| // A C-like, fieldless enum with a single variant. |
| enum Fieldless1 { |
| |
| #[default] |
| A, |
| } |
| #[automatically_derived] |
| impl ::core::clone::Clone for Fieldless1 { |
| #[inline] |
| fn clone(&self) -> Fieldless1 { Fieldless1::A } |
| } |
| #[automatically_derived] |
| impl ::core::fmt::Debug for Fieldless1 { |
| fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { |
| ::core::fmt::Formatter::write_str(f, "A") |
| } |
| } |
| #[automatically_derived] |
| impl ::core::default::Default for Fieldless1 { |
| #[inline] |
| fn default() -> Fieldless1 { Self::A } |
| } |
| #[automatically_derived] |
| impl ::core::hash::Hash for Fieldless1 { |
| fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {} |
| } |
| #[automatically_derived] |
| impl ::core::marker::StructuralPartialEq for Fieldless1 { } |
| #[automatically_derived] |
| impl ::core::cmp::PartialEq for Fieldless1 { |
| #[inline] |
| fn eq(&self, other: &Fieldless1) -> bool { true } |
| } |
| #[automatically_derived] |
| impl ::core::marker::StructuralEq for Fieldless1 { } |
| #[automatically_derived] |
| impl ::core::cmp::Eq for Fieldless1 { |
| #[inline] |
| #[doc(hidden)] |
| #[no_coverage] |
| fn assert_receiver_is_total_eq(&self) -> () {} |
| } |
| #[automatically_derived] |
| impl ::core::cmp::PartialOrd for Fieldless1 { |
| #[inline] |
| fn partial_cmp(&self, other: &Fieldless1) |
| -> ::core::option::Option<::core::cmp::Ordering> { |
| ::core::option::Option::Some(::core::cmp::Ordering::Equal) |
| } |
| } |
| #[automatically_derived] |
| impl ::core::cmp::Ord for Fieldless1 { |
| #[inline] |
| fn cmp(&self, other: &Fieldless1) -> ::core::cmp::Ordering { |
| ::core::cmp::Ordering::Equal |
| } |
| } |
| |
| // A C-like, fieldless enum. |
| enum Fieldless { |
| |
| #[default] |
| A, |
| B, |
| C, |
| } |
| #[automatically_derived] |
| impl ::core::clone::Clone for Fieldless { |
| #[inline] |
| fn clone(&self) -> Fieldless { *self } |
| } |
| #[automatically_derived] |
| impl ::core::marker::Copy for Fieldless { } |
| #[automatically_derived] |
| impl ::core::fmt::Debug for Fieldless { |
| fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { |
| ::core::fmt::Formatter::write_str(f, |
| match self { |
| Fieldless::A => "A", |
| Fieldless::B => "B", |
| Fieldless::C => "C", |
| }) |
| } |
| } |
| #[automatically_derived] |
| impl ::core::default::Default for Fieldless { |
| #[inline] |
| fn default() -> Fieldless { Self::A } |
| } |
| #[automatically_derived] |
| impl ::core::hash::Hash for Fieldless { |
| fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { |
| let __self_tag = ::core::intrinsics::discriminant_value(self); |
| ::core::hash::Hash::hash(&__self_tag, state) |
| } |
| } |
| #[automatically_derived] |
| impl ::core::marker::StructuralPartialEq for Fieldless { } |
| #[automatically_derived] |
| impl ::core::cmp::PartialEq for Fieldless { |
| #[inline] |
| fn eq(&self, other: &Fieldless) -> bool { |
| let __self_tag = ::core::intrinsics::discriminant_value(self); |
| let __arg1_tag = ::core::intrinsics::discriminant_value(other); |
| __self_tag == __arg1_tag |
| } |
| } |
| #[automatically_derived] |
| impl ::core::marker::StructuralEq for Fieldless { } |
| #[automatically_derived] |
| impl ::core::cmp::Eq for Fieldless { |
| #[inline] |
| #[doc(hidden)] |
| #[no_coverage] |
| fn assert_receiver_is_total_eq(&self) -> () {} |
| } |
| #[automatically_derived] |
| impl ::core::cmp::PartialOrd for Fieldless { |
| #[inline] |
| fn partial_cmp(&self, other: &Fieldless) |
| -> ::core::option::Option<::core::cmp::Ordering> { |
| let __self_tag = ::core::intrinsics::discriminant_value(self); |
| let __arg1_tag = ::core::intrinsics::discriminant_value(other); |
| ::core::cmp::PartialOrd::partial_cmp(&__self_tag, &__arg1_tag) |
| } |
| } |
| #[automatically_derived] |
| impl ::core::cmp::Ord for Fieldless { |
| #[inline] |
| fn cmp(&self, other: &Fieldless) -> ::core::cmp::Ordering { |
| let __self_tag = ::core::intrinsics::discriminant_value(self); |
| let __arg1_tag = ::core::intrinsics::discriminant_value(other); |
| ::core::cmp::Ord::cmp(&__self_tag, &__arg1_tag) |
| } |
| } |
| |
| // An enum with multiple fieldless and fielded variants. |
| enum Mixed { |
| |
| #[default] |
| P, |
| Q, |
| R(u32), |
| S { |
| d1: Option<u32>, |
| d2: Option<i32>, |
| }, |
| } |
| #[automatically_derived] |
| impl ::core::clone::Clone for Mixed { |
| #[inline] |
| fn clone(&self) -> Mixed { |
| let _: ::core::clone::AssertParamIsClone<u32>; |
| let _: ::core::clone::AssertParamIsClone<Option<u32>>; |
| let _: ::core::clone::AssertParamIsClone<Option<i32>>; |
| *self |
| } |
| } |
| #[automatically_derived] |
| impl ::core::marker::Copy for Mixed { } |
| #[automatically_derived] |
| impl ::core::fmt::Debug for Mixed { |
| fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { |
| match self { |
| Mixed::P => ::core::fmt::Formatter::write_str(f, "P"), |
| Mixed::Q => ::core::fmt::Formatter::write_str(f, "Q"), |
| Mixed::R(__self_0) => |
| ::core::fmt::Formatter::debug_tuple_field1_finish(f, "R", |
| &__self_0), |
| Mixed::S { d1: __self_0, d2: __self_1 } => |
| ::core::fmt::Formatter::debug_struct_field2_finish(f, "S", |
| "d1", &__self_0, "d2", &__self_1), |
| } |
| } |
| } |
| #[automatically_derived] |
| impl ::core::default::Default for Mixed { |
| #[inline] |
| fn default() -> Mixed { Self::P } |
| } |
| #[automatically_derived] |
| impl ::core::hash::Hash for Mixed { |
| fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { |
| let __self_tag = ::core::intrinsics::discriminant_value(self); |
| ::core::hash::Hash::hash(&__self_tag, state); |
| match self { |
| Mixed::R(__self_0) => ::core::hash::Hash::hash(__self_0, state), |
| Mixed::S { d1: __self_0, d2: __self_1 } => { |
| ::core::hash::Hash::hash(__self_0, state); |
| ::core::hash::Hash::hash(__self_1, state) |
| } |
| _ => {} |
| } |
| } |
| } |
| #[automatically_derived] |
| impl ::core::marker::StructuralPartialEq for Mixed { } |
| #[automatically_derived] |
| impl ::core::cmp::PartialEq for Mixed { |
| #[inline] |
| fn eq(&self, other: &Mixed) -> bool { |
| let __self_tag = ::core::intrinsics::discriminant_value(self); |
| let __arg1_tag = ::core::intrinsics::discriminant_value(other); |
| __self_tag == __arg1_tag && |
| match (self, other) { |
| (Mixed::R(__self_0), Mixed::R(__arg1_0)) => |
| *__self_0 == *__arg1_0, |
| (Mixed::S { d1: __self_0, d2: __self_1 }, Mixed::S { |
| d1: __arg1_0, d2: __arg1_1 }) => |
| *__self_0 == *__arg1_0 && *__self_1 == *__arg1_1, |
| _ => true, |
| } |
| } |
| } |
| #[automatically_derived] |
| impl ::core::marker::StructuralEq for Mixed { } |
| #[automatically_derived] |
| impl ::core::cmp::Eq for Mixed { |
| #[inline] |
| #[doc(hidden)] |
| #[no_coverage] |
| fn assert_receiver_is_total_eq(&self) -> () { |
| let _: ::core::cmp::AssertParamIsEq<u32>; |
| let _: ::core::cmp::AssertParamIsEq<Option<u32>>; |
| let _: ::core::cmp::AssertParamIsEq<Option<i32>>; |
| } |
| } |
| #[automatically_derived] |
| impl ::core::cmp::PartialOrd for Mixed { |
| #[inline] |
| fn partial_cmp(&self, other: &Mixed) |
| -> ::core::option::Option<::core::cmp::Ordering> { |
| let __self_tag = ::core::intrinsics::discriminant_value(self); |
| let __arg1_tag = ::core::intrinsics::discriminant_value(other); |
| match ::core::cmp::PartialOrd::partial_cmp(&__self_tag, &__arg1_tag) { |
| ::core::option::Option::Some(::core::cmp::Ordering::Equal) => |
| match (self, other) { |
| (Mixed::R(__self_0), Mixed::R(__arg1_0)) => |
| ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0), |
| (Mixed::S { d1: __self_0, d2: __self_1 }, Mixed::S { |
| d1: __arg1_0, d2: __arg1_1 }) => |
| match ::core::cmp::PartialOrd::partial_cmp(__self_0, |
| __arg1_0) { |
| ::core::option::Option::Some(::core::cmp::Ordering::Equal) |
| => ::core::cmp::PartialOrd::partial_cmp(__self_1, __arg1_1), |
| cmp => cmp, |
| }, |
| _ => |
| ::core::option::Option::Some(::core::cmp::Ordering::Equal), |
| }, |
| cmp => cmp, |
| } |
| } |
| } |
| #[automatically_derived] |
| impl ::core::cmp::Ord for Mixed { |
| #[inline] |
| fn cmp(&self, other: &Mixed) -> ::core::cmp::Ordering { |
| let __self_tag = ::core::intrinsics::discriminant_value(self); |
| let __arg1_tag = ::core::intrinsics::discriminant_value(other); |
| match ::core::cmp::Ord::cmp(&__self_tag, &__arg1_tag) { |
| ::core::cmp::Ordering::Equal => |
| match (self, other) { |
| (Mixed::R(__self_0), Mixed::R(__arg1_0)) => |
| ::core::cmp::Ord::cmp(__self_0, __arg1_0), |
| (Mixed::S { d1: __self_0, d2: __self_1 }, Mixed::S { |
| d1: __arg1_0, d2: __arg1_1 }) => |
| match ::core::cmp::Ord::cmp(__self_0, __arg1_0) { |
| ::core::cmp::Ordering::Equal => |
| ::core::cmp::Ord::cmp(__self_1, __arg1_1), |
| cmp => cmp, |
| }, |
| _ => ::core::cmp::Ordering::Equal, |
| }, |
| cmp => cmp, |
| } |
| } |
| } |
| |
| // An enum with no fieldless variants. Note that `Default` cannot be derived |
| // for this enum. |
| enum Fielded { X(u32), Y(bool), Z(Option<i32>), } |
| #[automatically_derived] |
| impl ::core::clone::Clone for Fielded { |
| #[inline] |
| fn clone(&self) -> Fielded { |
| match self { |
| Fielded::X(__self_0) => |
| Fielded::X(::core::clone::Clone::clone(__self_0)), |
| Fielded::Y(__self_0) => |
| Fielded::Y(::core::clone::Clone::clone(__self_0)), |
| Fielded::Z(__self_0) => |
| Fielded::Z(::core::clone::Clone::clone(__self_0)), |
| } |
| } |
| } |
| #[automatically_derived] |
| impl ::core::fmt::Debug for Fielded { |
| fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { |
| match self { |
| Fielded::X(__self_0) => |
| ::core::fmt::Formatter::debug_tuple_field1_finish(f, "X", |
| &__self_0), |
| Fielded::Y(__self_0) => |
| ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Y", |
| &__self_0), |
| Fielded::Z(__self_0) => |
| ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Z", |
| &__self_0), |
| } |
| } |
| } |
| #[automatically_derived] |
| impl ::core::hash::Hash for Fielded { |
| fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { |
| let __self_tag = ::core::intrinsics::discriminant_value(self); |
| ::core::hash::Hash::hash(&__self_tag, state); |
| match self { |
| Fielded::X(__self_0) => ::core::hash::Hash::hash(__self_0, state), |
| Fielded::Y(__self_0) => ::core::hash::Hash::hash(__self_0, state), |
| Fielded::Z(__self_0) => ::core::hash::Hash::hash(__self_0, state), |
| } |
| } |
| } |
| #[automatically_derived] |
| impl ::core::marker::StructuralPartialEq for Fielded { } |
| #[automatically_derived] |
| impl ::core::cmp::PartialEq for Fielded { |
| #[inline] |
| fn eq(&self, other: &Fielded) -> bool { |
| let __self_tag = ::core::intrinsics::discriminant_value(self); |
| let __arg1_tag = ::core::intrinsics::discriminant_value(other); |
| __self_tag == __arg1_tag && |
| match (self, other) { |
| (Fielded::X(__self_0), Fielded::X(__arg1_0)) => |
| *__self_0 == *__arg1_0, |
| (Fielded::Y(__self_0), Fielded::Y(__arg1_0)) => |
| *__self_0 == *__arg1_0, |
| (Fielded::Z(__self_0), Fielded::Z(__arg1_0)) => |
| *__self_0 == *__arg1_0, |
| _ => unsafe { ::core::intrinsics::unreachable() } |
| } |
| } |
| } |
| #[automatically_derived] |
| impl ::core::marker::StructuralEq for Fielded { } |
| #[automatically_derived] |
| impl ::core::cmp::Eq for Fielded { |
| #[inline] |
| #[doc(hidden)] |
| #[no_coverage] |
| fn assert_receiver_is_total_eq(&self) -> () { |
| let _: ::core::cmp::AssertParamIsEq<u32>; |
| let _: ::core::cmp::AssertParamIsEq<bool>; |
| let _: ::core::cmp::AssertParamIsEq<Option<i32>>; |
| } |
| } |
| #[automatically_derived] |
| impl ::core::cmp::PartialOrd for Fielded { |
| #[inline] |
| fn partial_cmp(&self, other: &Fielded) |
| -> ::core::option::Option<::core::cmp::Ordering> { |
| let __self_tag = ::core::intrinsics::discriminant_value(self); |
| let __arg1_tag = ::core::intrinsics::discriminant_value(other); |
| match ::core::cmp::PartialOrd::partial_cmp(&__self_tag, &__arg1_tag) { |
| ::core::option::Option::Some(::core::cmp::Ordering::Equal) => |
| match (self, other) { |
| (Fielded::X(__self_0), Fielded::X(__arg1_0)) => |
| ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0), |
| (Fielded::Y(__self_0), Fielded::Y(__arg1_0)) => |
| ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0), |
| (Fielded::Z(__self_0), Fielded::Z(__arg1_0)) => |
| ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0), |
| _ => unsafe { ::core::intrinsics::unreachable() } |
| }, |
| cmp => cmp, |
| } |
| } |
| } |
| #[automatically_derived] |
| impl ::core::cmp::Ord for Fielded { |
| #[inline] |
| fn cmp(&self, other: &Fielded) -> ::core::cmp::Ordering { |
| let __self_tag = ::core::intrinsics::discriminant_value(self); |
| let __arg1_tag = ::core::intrinsics::discriminant_value(other); |
| match ::core::cmp::Ord::cmp(&__self_tag, &__arg1_tag) { |
| ::core::cmp::Ordering::Equal => |
| match (self, other) { |
| (Fielded::X(__self_0), Fielded::X(__arg1_0)) => |
| ::core::cmp::Ord::cmp(__self_0, __arg1_0), |
| (Fielded::Y(__self_0), Fielded::Y(__arg1_0)) => |
| ::core::cmp::Ord::cmp(__self_0, __arg1_0), |
| (Fielded::Z(__self_0), Fielded::Z(__arg1_0)) => |
| ::core::cmp::Ord::cmp(__self_0, __arg1_0), |
| _ => unsafe { ::core::intrinsics::unreachable() } |
| }, |
| cmp => cmp, |
| } |
| } |
| } |
| |
| // A union. Most builtin traits are not derivable for unions. |
| pub union Union { |
| pub b: bool, |
| pub u: u32, |
| pub i: i32, |
| } |
| #[automatically_derived] |
| impl ::core::clone::Clone for Union { |
| #[inline] |
| fn clone(&self) -> Union { |
| let _: ::core::clone::AssertParamIsCopy<Self>; |
| *self |
| } |
| } |
| #[automatically_derived] |
| impl ::core::marker::Copy for Union { } |
