| #![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)] | |
| #![feature(derive_from)] | |
| extern crate std; | |
| #[prelude_import] | |
| use std::prelude::rust_2021::*; | |
| use std::from::From; | |
| // Empty struct. | |
| struct Empty; | |
| #[automatically_derived] | |
| #[doc(hidden)] | |
| unsafe impl ::core::clone::TrivialClone for 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 { | |
| #[inline] | |
| 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 { | |
| #[inline] | |
| 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::cmp::Eq for Empty { | |
| #[inline] | |
| #[doc(hidden)] | |
| #[coverage(off)] | |
| fn assert_fields_are_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. Note: because this derives `Copy`, it gets the trivial | |
| // `clone` implemention that just does `*self`. | |
| struct Point { | |
| x: u32, | |
| y: u32, | |
| } | |
| #[automatically_derived] | |
| #[doc(hidden)] | |
| unsafe impl ::core::clone::TrivialClone for Point { } | |
| #[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 { | |
| #[inline] | |
| 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 { | |
| #[inline] | |
| 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::cmp::Eq for Point { | |
| #[inline] | |
| #[doc(hidden)] | |
| #[coverage(off)] | |
| fn assert_fields_are_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 basic packed struct. Note: because this derives `Copy`, it gets the trivial | |
| // `clone` implemention that just does `*self`. | |
| #[repr(packed)] | |
| struct PackedPoint { | |
| x: u32, | |
| y: u32, | |
| } | |
| #[automatically_derived] | |
| #[doc(hidden)] | |
| unsafe impl ::core::clone::TrivialClone for PackedPoint { } | |
| #[automatically_derived] | |
| impl ::core::clone::Clone for PackedPoint { | |
| #[inline] | |
| fn clone(&self) -> PackedPoint { | |
| let _: ::core::clone::AssertParamIsClone<u32>; | |
| *self | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::marker::Copy for PackedPoint { } | |
| #[automatically_derived] | |
| impl ::core::fmt::Debug for PackedPoint { | |
| #[inline] | |
| fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { | |
| ::core::fmt::Formatter::debug_struct_field2_finish(f, "PackedPoint", | |
| "x", &{ self.x }, "y", &&{ self.y }) | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::default::Default for PackedPoint { | |
| #[inline] | |
| fn default() -> PackedPoint { | |
| PackedPoint { | |
| x: ::core::default::Default::default(), | |
| y: ::core::default::Default::default(), | |
| } | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::hash::Hash for PackedPoint { | |
| #[inline] | |
| 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 PackedPoint { } | |
| #[automatically_derived] | |
| impl ::core::cmp::PartialEq for PackedPoint { | |
| #[inline] | |
| fn eq(&self, other: &PackedPoint) -> bool { | |
| ({ self.x }) == ({ other.x }) && ({ self.y }) == ({ other.y }) | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::cmp::Eq for PackedPoint { | |
| #[inline] | |
| #[doc(hidden)] | |
| #[coverage(off)] | |
| fn assert_fields_are_eq(&self) { | |
| let _: ::core::cmp::AssertParamIsEq<u32>; | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::cmp::PartialOrd for PackedPoint { | |
| #[inline] | |
| fn partial_cmp(&self, other: &PackedPoint) | |
| -> ::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 PackedPoint { | |
| #[inline] | |
| fn cmp(&self, other: &PackedPoint) -> ::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, | |
| } | |
| } | |
| } | |
| struct TupleSingleField(u32); | |
| #[automatically_derived] | |
| #[doc(hidden)] | |
| unsafe impl ::core::clone::TrivialClone for TupleSingleField { } | |
| #[automatically_derived] | |
| impl ::core::clone::Clone for TupleSingleField { | |
| #[inline] | |
| fn clone(&self) -> TupleSingleField { | |
| let _: ::core::clone::AssertParamIsClone<u32>; | |
| *self | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::marker::Copy for TupleSingleField { } | |
| #[automatically_derived] | |
| impl ::core::fmt::Debug for TupleSingleField { | |
| #[inline] | |
| fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { | |
| ::core::fmt::Formatter::debug_tuple_field1_finish(f, | |
| "TupleSingleField", &&self.0) | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::default::Default for TupleSingleField { | |
| #[inline] | |
| fn default() -> TupleSingleField { | |
| TupleSingleField(::core::default::Default::default()) | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::convert::From<u32> for TupleSingleField { | |
| #[inline] | |
| fn from(value: u32) -> TupleSingleField { Self(value) } | |
| } | |
| #[automatically_derived] | |
| impl ::core::hash::Hash for TupleSingleField { | |
| #[inline] | |
| fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) { | |
| ::core::hash::Hash::hash(&self.0, state) | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::marker::StructuralPartialEq for TupleSingleField { } | |
| #[automatically_derived] | |
| impl ::core::cmp::PartialEq for TupleSingleField { | |
| #[inline] | |
| fn eq(&self, other: &TupleSingleField) -> bool { self.0 == other.0 } | |
| } | |
| #[automatically_derived] | |
| impl ::core::cmp::Eq for TupleSingleField { | |
| #[inline] | |
| #[doc(hidden)] | |
| #[coverage(off)] | |
| fn assert_fields_are_eq(&self) { | |
| let _: ::core::cmp::AssertParamIsEq<u32>; | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::cmp::PartialOrd for TupleSingleField { | |
| #[inline] | |
| fn partial_cmp(&self, other: &TupleSingleField) | |
| -> ::core::option::Option<::core::cmp::Ordering> { | |
| ::core::cmp::PartialOrd::partial_cmp(&self.0, &other.0) | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::cmp::Ord for TupleSingleField { | |
| #[inline] | |
| fn cmp(&self, other: &TupleSingleField) -> ::core::cmp::Ordering { | |
| ::core::cmp::Ord::cmp(&self.0, &other.0) | |
| } | |
| } | |
| struct SingleField { | |
| foo: bool, | |
| } | |
| #[automatically_derived] | |
| #[doc(hidden)] | |
| unsafe impl ::core::clone::TrivialClone for SingleField { } | |
| #[automatically_derived] | |
| impl ::core::clone::Clone for SingleField { | |
| #[inline] | |
| fn clone(&self) -> SingleField { | |
| let _: ::core::clone::AssertParamIsClone<bool>; | |
| *self | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::marker::Copy for SingleField { } | |
| #[automatically_derived] | |
| impl ::core::fmt::Debug for SingleField { | |
| #[inline] | |
| fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { | |
| ::core::fmt::Formatter::debug_struct_field1_finish(f, "SingleField", | |
| "foo", &&self.foo) | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::default::Default for SingleField { | |
| #[inline] | |
| fn default() -> SingleField { | |
| SingleField { foo: ::core::default::Default::default() } | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::convert::From<bool> for SingleField { | |
| #[inline] | |
| fn from(value: bool) -> SingleField { Self { foo: value } } | |
| } | |
| #[automatically_derived] | |
| impl ::core::hash::Hash for SingleField { | |
| #[inline] | |
| fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) { | |
| ::core::hash::Hash::hash(&self.foo, state) | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::marker::StructuralPartialEq for SingleField { } | |
| #[automatically_derived] | |
| impl ::core::cmp::PartialEq for SingleField { | |
| #[inline] | |
| fn eq(&self, other: &SingleField) -> bool { self.foo == other.foo } | |
| } | |
| #[automatically_derived] | |
| impl ::core::cmp::Eq for SingleField { | |
| #[inline] | |
| #[doc(hidden)] | |
| #[coverage(off)] | |
| fn assert_fields_are_eq(&self) { | |
| let _: ::core::cmp::AssertParamIsEq<bool>; | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::cmp::PartialOrd for SingleField { | |
| #[inline] | |
| fn partial_cmp(&self, other: &SingleField) | |
| -> ::core::option::Option<::core::cmp::Ordering> { | |
| ::core::cmp::PartialOrd::partial_cmp(&self.foo, &other.foo) | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::cmp::Ord for SingleField { | |
| #[inline] | |
| fn cmp(&self, other: &SingleField) -> ::core::cmp::Ordering { | |
| ::core::cmp::Ord::cmp(&self.foo, &other.foo) | |
| } | |
| } | |
| // A large struct. Note: because this derives `Copy`, it gets the trivial | |
| // `clone` implemention that just does `*self`. | |
| struct Big { | |
| b1: u32, | |
| b2: u32, | |
| b3: u32, | |
| b4: u32, | |
| b5: u32, | |
| b6: u32, | |
| b7: u32, | |
| b8: u32, | |
| } | |
| #[automatically_derived] | |
| #[doc(hidden)] | |
| unsafe impl ::core::clone::TrivialClone for Big { } | |
| #[automatically_derived] | |
| impl ::core::clone::Clone for Big { | |
| #[inline] | |
| fn clone(&self) -> Big { | |
| let _: ::core::clone::AssertParamIsClone<u32>; | |
| *self | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::marker::Copy for Big { } | |
| #[automatically_derived] | |
| impl ::core::fmt::Debug for Big { | |
| #[inline] | |
| 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 { | |
| #[inline] | |
| 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::cmp::Eq for Big { | |
| #[inline] | |
| #[doc(hidden)] | |
| #[coverage(off)] | |
| fn assert_fields_are_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, | |
| } | |
| } | |
| } | |
| // It is more efficient to compare scalar types before non-scalar types. | |
| struct Reorder { | |
| b1: Option<f32>, | |
| b2: u16, | |
| b3: &'static str, | |
| b4: i8, | |
| b5: u128, | |
| _b: *mut &'static dyn FnMut() -> (), | |
| b6: f64, | |
| b7: &'static mut (), | |
| b8: char, | |
| b9: &'static [i64], | |
| b10: &'static *const bool, | |
| } | |
| #[automatically_derived] | |
| impl ::core::marker::StructuralPartialEq for Reorder { } | |
| #[automatically_derived] | |
| impl ::core::cmp::PartialEq for Reorder { | |
| #[inline] | |
| fn eq(&self, other: &Reorder) -> bool { | |
| self.b2 == other.b2 && self.b4 == other.b4 && self.b5 == other.b5 && | |
| self.b6 == other.b6 && self.b7 == other.b7 && | |
| self.b8 == other.b8 && self.b10 == other.b10 && | |
| self.b1 == other.b1 && self.b3 == other.b3 && | |
| self._b == other._b && self.b9 == other.b9 | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::cmp::PartialOrd for Reorder { | |
| #[inline] | |
| fn partial_cmp(&self, other: &Reorder) | |
| -> ::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._b, | |
| &other._b) { | |
| ::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) | |
| => | |
| match ::core::cmp::PartialOrd::partial_cmp(&self.b8, | |
| &other.b8) { | |
| ::core::option::Option::Some(::core::cmp::Ordering::Equal) | |
| => | |
| match ::core::cmp::PartialOrd::partial_cmp(&self.b9, | |
| &other.b9) { | |
| ::core::option::Option::Some(::core::cmp::Ordering::Equal) | |
| => | |
| ::core::cmp::PartialOrd::partial_cmp(&self.b10, &other.b10), | |
| cmp => cmp, | |
| }, | |
| cmp => cmp, | |
| }, | |
| cmp => cmp, | |
| }, | |
| cmp => cmp, | |
| }, | |
| cmp => cmp, | |
| }, | |
| cmp => cmp, | |
| }, | |
| cmp => cmp, | |
| }, | |
| cmp => cmp, | |
| }, | |
| cmp => cmp, | |
| }, | |
| cmp => cmp, | |
| } | |
| } | |
| } | |
| // A struct that doesn't impl `Copy`, which means it gets the non-trivial | |
| // `clone` implemention that clones the fields individually. | |
| struct NonCopy(u32); | |
| #[automatically_derived] | |
| impl ::core::clone::Clone for NonCopy { | |
| #[inline] | |
| fn clone(&self) -> NonCopy { | |
| NonCopy(::core::clone::Clone::clone(&self.0)) | |
| } | |
| } | |
| // A packed struct that doesn't impl `Copy`, which means it gets the non-trivial | |
| // `clone` implemention that clones the fields individually. | |
| #[repr(packed)] | |
| struct PackedNonCopy(u32); | |
| #[automatically_derived] | |
| impl ::core::clone::Clone for PackedNonCopy { | |
| #[inline] | |
| fn clone(&self) -> PackedNonCopy { | |
| PackedNonCopy(::core::clone::Clone::clone(&{ self.0 })) | |
| } | |
| } | |
| // A struct that impls `Copy` manually, which means it gets the non-trivial | |
| // `clone` implemention that clones the fields individually. | |
| struct ManualCopy(u32); | |
| #[automatically_derived] | |
| impl ::core::clone::Clone for ManualCopy { | |
| #[inline] | |
| fn clone(&self) -> ManualCopy { | |
| ManualCopy(::core::clone::Clone::clone(&self.0)) | |
| } | |
| } | |
| impl Copy for ManualCopy {} | |
| // A packed struct that impls `Copy` manually, which means it gets the | |
| // non-trivial `clone` implemention that clones the fields individually. | |
| #[repr(packed)] | |
| struct PackedManualCopy(u32); | |
| #[automatically_derived] | |
| impl ::core::clone::Clone for PackedManualCopy { | |
| #[inline] | |
| fn clone(&self) -> PackedManualCopy { | |
| PackedManualCopy(::core::clone::Clone::clone(&{ self.0 })) | |
| } | |
| } | |
| impl Copy for PackedManualCopy {} | |
| // 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 { | |
| #[inline] | |
| 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::convert::From<[u32]> for Unsized { | |
| #[inline] | |
| fn from(value: [u32]) -> Unsized { Self(value) } | |
| } | |
| #[automatically_derived] | |
| impl ::core::hash::Hash for Unsized { | |
| #[inline] | |
| 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::cmp::Eq for Unsized { | |
| #[inline] | |
| #[doc(hidden)] | |
| #[coverage(off)] | |
| fn assert_fields_are_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) | |
| } | |
| } | |
| trait Trait { | |
| type A; | |
| } | |
| // A generic struct involving an associated type. | |
| struct Generic<T: Trait, U> { | |
| t: T, | |
| ta: T::A, | |
| u: U, | |
| } | |
| #[automatically_derived] | |
| impl<T: ::core::clone::Clone + Trait, U: ::core::clone::Clone> | |
| ::core::clone::Clone for Generic<T, U> where T::A: ::core::clone::Clone { | |
| #[inline] | |
| fn clone(&self) -> Generic<T, U> { | |
| Generic { | |
| t: ::core::clone::Clone::clone(&self.t), | |
| ta: ::core::clone::Clone::clone(&self.ta), | |
| u: ::core::clone::Clone::clone(&self.u), | |
| } | |
| } | |
| } | |
| #[automatically_derived] | |
| impl<T: ::core::marker::Copy + Trait, U: ::core::marker::Copy> | |
| ::core::marker::Copy for Generic<T, U> where T::A: ::core::marker::Copy { | |
| } | |
| #[automatically_derived] | |
| impl<T: ::core::fmt::Debug + Trait, U: ::core::fmt::Debug> ::core::fmt::Debug | |
| for Generic<T, U> where T::A: ::core::fmt::Debug { | |
| #[inline] | |
| fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { | |
| ::core::fmt::Formatter::debug_struct_field3_finish(f, "Generic", "t", | |
| &self.t, "ta", &self.ta, "u", &&self.u) | |
| } | |
| } | |
| #[automatically_derived] | |
| impl<T: ::core::default::Default + Trait, U: ::core::default::Default> | |
| ::core::default::Default for Generic<T, U> where | |
| T::A: ::core::default::Default { | |
| #[inline] | |
| fn default() -> Generic<T, U> { | |
| Generic { | |
| t: ::core::default::Default::default(), | |
| ta: ::core::default::Default::default(), | |
| u: ::core::default::Default::default(), | |
| } | |
| } | |
| } | |
| #[automatically_derived] | |
| impl<T: ::core::hash::Hash + Trait, U: ::core::hash::Hash> ::core::hash::Hash | |
| for Generic<T, U> where T::A: ::core::hash::Hash { | |
| #[inline] | |
| fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) { | |
| ::core::hash::Hash::hash(&self.t, state); | |
| ::core::hash::Hash::hash(&self.ta, state); | |
| ::core::hash::Hash::hash(&self.u, state) | |
| } | |
| } | |
| #[automatically_derived] | |
| impl<T: Trait, U> ::core::marker::StructuralPartialEq for Generic<T, U> { } | |
| #[automatically_derived] | |
| impl<T: ::core::cmp::PartialEq + Trait, U: ::core::cmp::PartialEq> | |
| ::core::cmp::PartialEq for Generic<T, U> where | |
| T::A: ::core::cmp::PartialEq { | |
| #[inline] | |
| fn eq(&self, other: &Generic<T, U>) -> bool { | |
| self.t == other.t && self.ta == other.ta && self.u == other.u | |
| } | |
| } | |
| #[automatically_derived] | |
| impl<T: ::core::cmp::Eq + Trait, U: ::core::cmp::Eq> ::core::cmp::Eq for | |
| Generic<T, U> where T::A: ::core::cmp::Eq { | |
| #[inline] | |
| #[doc(hidden)] | |
| #[coverage(off)] | |
| fn assert_fields_are_eq(&self) { | |
| let _: ::core::cmp::AssertParamIsEq<T>; | |
| let _: ::core::cmp::AssertParamIsEq<T::A>; | |
| let _: ::core::cmp::AssertParamIsEq<U>; | |
| } | |
| } | |
| #[automatically_derived] | |
| impl<T: ::core::cmp::PartialOrd + Trait, U: ::core::cmp::PartialOrd> | |
| ::core::cmp::PartialOrd for Generic<T, U> where | |
| T::A: ::core::cmp::PartialOrd { | |
| #[inline] | |
| fn partial_cmp(&self, other: &Generic<T, U>) | |
| -> ::core::option::Option<::core::cmp::Ordering> { | |
| match ::core::cmp::PartialOrd::partial_cmp(&self.t, &other.t) { | |
| ::core::option::Option::Some(::core::cmp::Ordering::Equal) => | |
| match ::core::cmp::PartialOrd::partial_cmp(&self.ta, | |
| &other.ta) { | |
| ::core::option::Option::Some(::core::cmp::Ordering::Equal) | |
| => ::core::cmp::PartialOrd::partial_cmp(&self.u, &other.u), | |
| cmp => cmp, | |
| }, | |
| cmp => cmp, | |
| } | |
| } | |
| } | |
| #[automatically_derived] | |
| impl<T: ::core::cmp::Ord + Trait, U: ::core::cmp::Ord> ::core::cmp::Ord for | |
| Generic<T, U> where T::A: ::core::cmp::Ord { | |
| #[inline] | |
| fn cmp(&self, other: &Generic<T, U>) -> ::core::cmp::Ordering { | |
| match ::core::cmp::Ord::cmp(&self.t, &other.t) { | |
| ::core::cmp::Ordering::Equal => | |
| match ::core::cmp::Ord::cmp(&self.ta, &other.ta) { | |
| ::core::cmp::Ordering::Equal => | |
| ::core::cmp::Ord::cmp(&self.u, &other.u), | |
| cmp => cmp, | |
| }, | |
| cmp => cmp, | |
| } | |
| } | |
| } | |
| // A packed, generic tuple struct involving an associated type. Because it is | |
| // packed, a `T: Copy` bound is added to all impls (and where clauses within | |
| // them) except for `Default`. This is because we must access fields using | |
| // copies (e.g. `&{self.0}`), instead of using direct references (e.g. | |
| // `&self.0`) which may be misaligned in a packed struct. | |
| #[repr(packed)] | |
| struct PackedGeneric<T: Trait, U>(T, T::A, U); | |
| #[automatically_derived] | |
| impl<T: ::core::clone::Clone + ::core::marker::Copy + Trait, | |
| U: ::core::clone::Clone + ::core::marker::Copy> ::core::clone::Clone for | |
| PackedGeneric<T, U> where T::A: ::core::clone::Clone + | |
| ::core::marker::Copy { | |
| #[inline] | |
| fn clone(&self) -> PackedGeneric<T, U> { | |
| PackedGeneric(::core::clone::Clone::clone(&{ self.0 }), | |
| ::core::clone::Clone::clone(&{ self.1 }), | |
| ::core::clone::Clone::clone(&{ self.2 })) | |
| } | |
| } | |
| #[automatically_derived] | |
| impl<T: ::core::marker::Copy + Trait, U: ::core::marker::Copy> | |
| ::core::marker::Copy for PackedGeneric<T, U> where | |
| T::A: ::core::marker::Copy { | |
| } | |
| #[automatically_derived] | |
| impl<T: ::core::fmt::Debug + ::core::marker::Copy + Trait, | |
| U: ::core::fmt::Debug + ::core::marker::Copy> ::core::fmt::Debug for | |
| PackedGeneric<T, U> where T::A: ::core::fmt::Debug + ::core::marker::Copy | |
| { | |
| #[inline] | |
| fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { | |
| ::core::fmt::Formatter::debug_tuple_field3_finish(f, "PackedGeneric", | |
| &{ self.0 }, &{ self.1 }, &&{ self.2 }) | |
| } | |
| } | |
| #[automatically_derived] | |
| impl<T: ::core::default::Default + Trait, U: ::core::default::Default> | |
| ::core::default::Default for PackedGeneric<T, U> where | |
| T::A: ::core::default::Default { | |
| #[inline] | |
| fn default() -> PackedGeneric<T, U> { | |
| PackedGeneric(::core::default::Default::default(), | |
| ::core::default::Default::default(), | |
| ::core::default::Default::default()) | |
| } | |
| } | |
| #[automatically_derived] | |
| impl<T: ::core::hash::Hash + ::core::marker::Copy + Trait, | |
| U: ::core::hash::Hash + ::core::marker::Copy> ::core::hash::Hash for | |
| PackedGeneric<T, U> where T::A: ::core::hash::Hash + ::core::marker::Copy | |
| { | |
| #[inline] | |
| fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) { | |
| ::core::hash::Hash::hash(&{ self.0 }, state); | |
| ::core::hash::Hash::hash(&{ self.1 }, state); | |
| ::core::hash::Hash::hash(&{ self.2 }, state) | |
| } | |
| } | |
| #[automatically_derived] | |
| impl<T: Trait, U> ::core::marker::StructuralPartialEq for PackedGeneric<T, U> | |
| { | |
| } | |
| #[automatically_derived] | |
| impl<T: ::core::cmp::PartialEq + ::core::marker::Copy + Trait, | |
| U: ::core::cmp::PartialEq + ::core::marker::Copy> ::core::cmp::PartialEq | |
| for PackedGeneric<T, U> where T::A: ::core::cmp::PartialEq + | |
| ::core::marker::Copy { | |
| #[inline] | |
| fn eq(&self, other: &PackedGeneric<T, U>) -> bool { | |
| ({ self.0 }) == ({ other.0 }) && ({ self.1 }) == ({ other.1 }) && | |
| ({ self.2 }) == ({ other.2 }) | |
| } | |
| } | |
| #[automatically_derived] | |
| impl<T: ::core::cmp::Eq + ::core::marker::Copy + Trait, U: ::core::cmp::Eq + | |
| ::core::marker::Copy> ::core::cmp::Eq for PackedGeneric<T, U> where | |
| T::A: ::core::cmp::Eq + ::core::marker::Copy { | |
| #[inline] | |
| #[doc(hidden)] | |
| #[coverage(off)] | |
| fn assert_fields_are_eq(&self) { | |
| let _: ::core::cmp::AssertParamIsEq<T>; | |
| let _: ::core::cmp::AssertParamIsEq<T::A>; | |
| let _: ::core::cmp::AssertParamIsEq<U>; | |
| } | |
| } | |
| #[automatically_derived] | |
| impl<T: ::core::cmp::PartialOrd + ::core::marker::Copy + Trait, | |
| U: ::core::cmp::PartialOrd + ::core::marker::Copy> ::core::cmp::PartialOrd | |
| for PackedGeneric<T, U> where T::A: ::core::cmp::PartialOrd + | |
| ::core::marker::Copy { | |
| #[inline] | |
| fn partial_cmp(&self, other: &PackedGeneric<T, U>) | |
| -> ::core::option::Option<::core::cmp::Ordering> { | |
| match ::core::cmp::PartialOrd::partial_cmp(&{ self.0 }, &{ other.0 }) | |
| { | |
| ::core::option::Option::Some(::core::cmp::Ordering::Equal) => | |
| match ::core::cmp::PartialOrd::partial_cmp(&{ self.1 }, | |
| &{ other.1 }) { | |
| ::core::option::Option::Some(::core::cmp::Ordering::Equal) | |
| => | |
| ::core::cmp::PartialOrd::partial_cmp(&{ self.2 }, | |
| &{ other.2 }), | |
| cmp => cmp, | |
| }, | |
| cmp => cmp, | |
| } | |
| } | |
| } | |
| #[automatically_derived] | |
| impl<T: ::core::cmp::Ord + ::core::marker::Copy + Trait, U: ::core::cmp::Ord + | |
| ::core::marker::Copy> ::core::cmp::Ord for PackedGeneric<T, U> where | |
| T::A: ::core::cmp::Ord + ::core::marker::Copy { | |
| #[inline] | |
| fn cmp(&self, other: &PackedGeneric<T, U>) -> ::core::cmp::Ordering { | |
| match ::core::cmp::Ord::cmp(&{ self.0 }, &{ other.0 }) { | |
| ::core::cmp::Ordering::Equal => | |
| match ::core::cmp::Ord::cmp(&{ self.1 }, &{ other.1 }) { | |
| ::core::cmp::Ordering::Equal => | |
| ::core::cmp::Ord::cmp(&{ self.2 }, &{ other.2 }), | |
| cmp => cmp, | |
| }, | |
| cmp => cmp, | |
| } | |
| } | |
| } | |
| // An empty enum. | |
| enum Enum0 {} | |
| #[automatically_derived] | |
| #[doc(hidden)] | |
| unsafe impl ::core::clone::TrivialClone for 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 { | |
| #[inline] | |
| fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { | |
| match *self {} | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::hash::Hash for Enum0 { | |
| #[inline] | |
| fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) { | |
| match *self {} | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::marker::StructuralPartialEq for Enum0 { } | |
| #[automatically_derived] | |
| impl ::core::cmp::PartialEq for Enum0 { | |
| #[inline] | |
| fn eq(&self, other: &Enum0) -> bool { match *self {} } | |
| } | |
| #[automatically_derived] | |
| impl ::core::cmp::Eq for Enum0 { | |
| #[inline] | |
| #[doc(hidden)] | |
| #[coverage(off)] | |
| fn assert_fields_are_eq(&self) {} | |
| } | |
| #[automatically_derived] | |
| impl ::core::cmp::PartialOrd for Enum0 { | |
| #[inline] | |
| fn partial_cmp(&self, other: &Enum0) | |
| -> ::core::option::Option<::core::cmp::Ordering> { | |
| match *self {} | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::cmp::Ord for Enum0 { | |
| #[inline] | |
| fn cmp(&self, other: &Enum0) -> ::core::cmp::Ordering { match *self {} } | |
| } | |
| // 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 { | |
| #[inline] | |
| 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 { | |
| #[inline] | |
| 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::cmp::Eq for Enum1 { | |
| #[inline] | |
| #[doc(hidden)] | |
| #[coverage(off)] | |
| fn assert_fields_are_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 { | |
| #[inline] | |
| 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 { | |
| #[inline] | |
| 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::cmp::Eq for Fieldless1 { | |
| #[inline] | |
| #[doc(hidden)] | |
| #[coverage(off)] | |
| fn assert_fields_are_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] | |
| #[doc(hidden)] | |
| unsafe impl ::core::clone::TrivialClone for Fieldless { } | |
| #[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 { | |
| #[inline] | |
| 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 { | |
| #[inline] | |
| fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) { | |
| let __self_discr = ::core::intrinsics::discriminant_value(self); | |
| ::core::hash::Hash::hash(&__self_discr, 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_discr = ::core::intrinsics::discriminant_value(self); | |
| let __arg1_discr = ::core::intrinsics::discriminant_value(other); | |
| __self_discr == __arg1_discr | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::cmp::Eq for Fieldless { | |
| #[inline] | |
| #[doc(hidden)] | |
| #[coverage(off)] | |
| fn assert_fields_are_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_discr = ::core::intrinsics::discriminant_value(self); | |
| let __arg1_discr = ::core::intrinsics::discriminant_value(other); | |
| ::core::cmp::PartialOrd::partial_cmp(&__self_discr, &__arg1_discr) | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::cmp::Ord for Fieldless { | |
| #[inline] | |
| fn cmp(&self, other: &Fieldless) -> ::core::cmp::Ordering { | |
| let __self_discr = ::core::intrinsics::discriminant_value(self); | |
| let __arg1_discr = ::core::intrinsics::discriminant_value(other); | |
| ::core::cmp::Ord::cmp(&__self_discr, &__arg1_discr) | |
| } | |
| } | |
| // An enum with multiple fieldless and fielded variants. | |
| enum Mixed { | |
| #[default] | |
| P, | |
| Q, | |
| R(u32), | |
| S { | |
| d1: Option<u32>, | |
| d2: Option<i32>, | |
| }, | |
| } | |
| #[automatically_derived] | |
| #[doc(hidden)] | |
| unsafe impl ::core::clone::TrivialClone for Mixed { } | |
| #[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 { | |
| #[inline] | |
| 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 { | |
| #[inline] | |
| fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) { | |
| let __self_discr = ::core::intrinsics::discriminant_value(self); | |
| ::core::hash::Hash::hash(&__self_discr, 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_discr = ::core::intrinsics::discriminant_value(self); | |
| let __arg1_discr = ::core::intrinsics::discriminant_value(other); | |
| __self_discr == __arg1_discr && | |
| 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::cmp::Eq for Mixed { | |
| #[inline] | |
| #[doc(hidden)] | |
| #[coverage(off)] | |
| fn assert_fields_are_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_discr = ::core::intrinsics::discriminant_value(self); | |
| let __arg1_discr = ::core::intrinsics::discriminant_value(other); | |
| 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::cmp::PartialOrd::partial_cmp(&__self_discr, | |
| &__arg1_discr), | |
| } | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::cmp::Ord for Mixed { | |
| #[inline] | |
| fn cmp(&self, other: &Mixed) -> ::core::cmp::Ordering { | |
| let __self_discr = ::core::intrinsics::discriminant_value(self); | |
| let __arg1_discr = ::core::intrinsics::discriminant_value(other); | |
| match ::core::cmp::Ord::cmp(&__self_discr, &__arg1_discr) { | |
| ::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, | |
| } | |
| } | |
| } | |
| // When comparing enum variant it is more efficient to compare scalar types before non-scalar types. | |
| enum ReorderEnum { | |
| A(i32), | |
| B, | |
| C(i8), | |
| D, | |
| E, | |
| F, | |
| G(&'static mut str, *const u8, *const dyn Fn() -> ()), | |
| H, | |
| I, | |
| } | |
| #[automatically_derived] | |
| impl ::core::marker::StructuralPartialEq for ReorderEnum { } | |
| #[automatically_derived] | |
| impl ::core::cmp::PartialEq for ReorderEnum { | |
| #[inline] | |
| fn eq(&self, other: &ReorderEnum) -> bool { | |
| let __self_discr = ::core::intrinsics::discriminant_value(self); | |
| let __arg1_discr = ::core::intrinsics::discriminant_value(other); | |
| __self_discr == __arg1_discr && | |
| match (self, other) { | |
| (ReorderEnum::A(__self_0), ReorderEnum::A(__arg1_0)) => | |
| __self_0 == __arg1_0, | |
| (ReorderEnum::C(__self_0), ReorderEnum::C(__arg1_0)) => | |
| __self_0 == __arg1_0, | |
| (ReorderEnum::G(__self_0, __self_1, __self_2), | |
| ReorderEnum::G(__arg1_0, __arg1_1, __arg1_2)) => | |
| __self_1 == __arg1_1 && __self_0 == __arg1_0 && | |
| __self_2 == __arg1_2, | |
| _ => true, | |
| } | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::cmp::PartialOrd for ReorderEnum { | |
| #[inline] | |
| fn partial_cmp(&self, other: &ReorderEnum) | |
| -> ::core::option::Option<::core::cmp::Ordering> { | |
| let __self_discr = ::core::intrinsics::discriminant_value(self); | |
| let __arg1_discr = ::core::intrinsics::discriminant_value(other); | |
| match ::core::cmp::PartialOrd::partial_cmp(&__self_discr, | |
| &__arg1_discr) { | |
| ::core::option::Option::Some(::core::cmp::Ordering::Equal) => | |
| match (self, other) { | |
| (ReorderEnum::A(__self_0), ReorderEnum::A(__arg1_0)) => | |
| ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0), | |
| (ReorderEnum::C(__self_0), ReorderEnum::C(__arg1_0)) => | |
| ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0), | |
| (ReorderEnum::G(__self_0, __self_1, __self_2), | |
| ReorderEnum::G(__arg1_0, __arg1_1, __arg1_2)) => | |
| match ::core::cmp::PartialOrd::partial_cmp(__self_0, | |
| __arg1_0) { | |
| ::core::option::Option::Some(::core::cmp::Ordering::Equal) | |
| => | |
| match ::core::cmp::PartialOrd::partial_cmp(__self_1, | |
| __arg1_1) { | |
| ::core::option::Option::Some(::core::cmp::Ordering::Equal) | |
| => ::core::cmp::PartialOrd::partial_cmp(__self_2, __arg1_2), | |
| cmp => cmp, | |
| }, | |
| cmp => cmp, | |
| }, | |
| _ => | |
| ::core::option::Option::Some(::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 { | |
| #[inline] | |
| 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 { | |
| #[inline] | |
| fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) { | |
| let __self_discr = ::core::intrinsics::discriminant_value(self); | |
| ::core::hash::Hash::hash(&__self_discr, 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_discr = ::core::intrinsics::discriminant_value(self); | |
| let __arg1_discr = ::core::intrinsics::discriminant_value(other); | |
| __self_discr == __arg1_discr && | |
| 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::cmp::Eq for Fielded { | |
| #[inline] | |
| #[doc(hidden)] | |
| #[coverage(off)] | |
| fn assert_fields_are_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_discr = ::core::intrinsics::discriminant_value(self); | |
| let __arg1_discr = ::core::intrinsics::discriminant_value(other); | |
| 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), | |
| _ => | |
| ::core::cmp::PartialOrd::partial_cmp(&__self_discr, | |
| &__arg1_discr), | |
| } | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::cmp::Ord for Fielded { | |
| #[inline] | |
| fn cmp(&self, other: &Fielded) -> ::core::cmp::Ordering { | |
| let __self_discr = ::core::intrinsics::discriminant_value(self); | |
| let __arg1_discr = ::core::intrinsics::discriminant_value(other); | |
| match ::core::cmp::Ord::cmp(&__self_discr, &__arg1_discr) { | |
| ::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 generic enum. Note that `Default` cannot be derived for this enum. | |
| enum EnumGeneric<T, U> { One(T), Two(U), } | |
| #[automatically_derived] | |
| impl<T: ::core::clone::Clone, U: ::core::clone::Clone> ::core::clone::Clone | |
| for EnumGeneric<T, U> { | |
| #[inline] | |
| fn clone(&self) -> EnumGeneric<T, U> { | |
| match self { | |
| EnumGeneric::One(__self_0) => | |
| EnumGeneric::One(::core::clone::Clone::clone(__self_0)), | |
| EnumGeneric::Two(__self_0) => | |
| EnumGeneric::Two(::core::clone::Clone::clone(__self_0)), | |
| } | |
| } | |
| } | |
| #[automatically_derived] | |
| impl<T: ::core::marker::Copy, U: ::core::marker::Copy> ::core::marker::Copy | |
| for EnumGeneric<T, U> { | |
| } | |
| #[automatically_derived] | |
| impl<T: ::core::fmt::Debug, U: ::core::fmt::Debug> ::core::fmt::Debug for | |
| EnumGeneric<T, U> { | |
| #[inline] | |
| fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { | |
| match self { | |
| EnumGeneric::One(__self_0) => | |
| ::core::fmt::Formatter::debug_tuple_field1_finish(f, "One", | |
| &__self_0), | |
| EnumGeneric::Two(__self_0) => | |
| ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Two", | |
| &__self_0), | |
| } | |
| } | |
| } | |
| #[automatically_derived] | |
| impl<T: ::core::hash::Hash, U: ::core::hash::Hash> ::core::hash::Hash for | |
| EnumGeneric<T, U> { | |
| #[inline] | |
| fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) { | |
| let __self_discr = ::core::intrinsics::discriminant_value(self); | |
| ::core::hash::Hash::hash(&__self_discr, state); | |
| match self { | |
| EnumGeneric::One(__self_0) => | |
| ::core::hash::Hash::hash(__self_0, state), | |
| EnumGeneric::Two(__self_0) => | |
| ::core::hash::Hash::hash(__self_0, state), | |
| } | |
| } | |
| } | |
| #[automatically_derived] | |
| impl<T, U> ::core::marker::StructuralPartialEq for EnumGeneric<T, U> { } | |
| #[automatically_derived] | |
| impl<T: ::core::cmp::PartialEq, U: ::core::cmp::PartialEq> | |
| ::core::cmp::PartialEq for EnumGeneric<T, U> { | |
| #[inline] | |
| fn eq(&self, other: &EnumGeneric<T, U>) -> bool { | |
| let __self_discr = ::core::intrinsics::discriminant_value(self); | |
| let __arg1_discr = ::core::intrinsics::discriminant_value(other); | |
| __self_discr == __arg1_discr && | |
| match (self, other) { | |
| (EnumGeneric::One(__self_0), EnumGeneric::One(__arg1_0)) => | |
| __self_0 == __arg1_0, | |
| (EnumGeneric::Two(__self_0), EnumGeneric::Two(__arg1_0)) => | |
| __self_0 == __arg1_0, | |
| _ => unsafe { ::core::intrinsics::unreachable() } | |
| } | |
| } | |
| } | |
| #[automatically_derived] | |
| impl<T: ::core::cmp::Eq, U: ::core::cmp::Eq> ::core::cmp::Eq for | |
| EnumGeneric<T, U> { | |
| #[inline] | |
| #[doc(hidden)] | |
| #[coverage(off)] | |
| fn assert_fields_are_eq(&self) { | |
| let _: ::core::cmp::AssertParamIsEq<T>; | |
| let _: ::core::cmp::AssertParamIsEq<U>; | |
| } | |
| } | |
| #[automatically_derived] | |
| impl<T: ::core::cmp::PartialOrd, U: ::core::cmp::PartialOrd> | |
| ::core::cmp::PartialOrd for EnumGeneric<T, U> { | |
| #[inline] | |
| fn partial_cmp(&self, other: &EnumGeneric<T, U>) | |
| -> ::core::option::Option<::core::cmp::Ordering> { | |
| let __self_discr = ::core::intrinsics::discriminant_value(self); | |
| let __arg1_discr = ::core::intrinsics::discriminant_value(other); | |
| match (self, other) { | |
| (EnumGeneric::One(__self_0), EnumGeneric::One(__arg1_0)) => | |
| ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0), | |
| (EnumGeneric::Two(__self_0), EnumGeneric::Two(__arg1_0)) => | |
| ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0), | |
| _ => | |
| ::core::cmp::PartialOrd::partial_cmp(&__self_discr, | |
| &__arg1_discr), | |
| } | |
| } | |
| } | |
| #[automatically_derived] | |
| impl<T: ::core::cmp::Ord, U: ::core::cmp::Ord> ::core::cmp::Ord for | |
| EnumGeneric<T, U> { | |
| #[inline] | |
| fn cmp(&self, other: &EnumGeneric<T, U>) -> ::core::cmp::Ordering { | |
| let __self_discr = ::core::intrinsics::discriminant_value(self); | |
| let __arg1_discr = ::core::intrinsics::discriminant_value(other); | |
| match ::core::cmp::Ord::cmp(&__self_discr, &__arg1_discr) { | |
| ::core::cmp::Ordering::Equal => | |
| match (self, other) { | |
| (EnumGeneric::One(__self_0), EnumGeneric::One(__arg1_0)) => | |
| ::core::cmp::Ord::cmp(__self_0, __arg1_0), | |
| (EnumGeneric::Two(__self_0), EnumGeneric::Two(__arg1_0)) => | |
| ::core::cmp::Ord::cmp(__self_0, __arg1_0), | |
| _ => unsafe { ::core::intrinsics::unreachable() } | |
| }, | |
| cmp => cmp, | |
| } | |
| } | |
| } | |
| // An enum that has variant, which does't implement `Copy`. | |
| enum NonCopyEnum { | |
| // The `dyn NonCopyTrait` implements `PartialEq`, but it doesn't require `Copy`. | |
| // So we cannot generate `PartialEq` with dereference. | |
| NonCopyField(Box<dyn NonCopyTrait>), | |
| } | |
| #[automatically_derived] | |
| impl ::core::marker::StructuralPartialEq for NonCopyEnum { } | |
| #[automatically_derived] | |
| impl ::core::cmp::PartialEq for NonCopyEnum { | |
| #[inline] | |
| fn eq(&self, other: &NonCopyEnum) -> bool { | |
| match (self, other) { | |
| (NonCopyEnum::NonCopyField(__self_0), | |
| NonCopyEnum::NonCopyField(__arg1_0)) => __self_0 == __arg1_0, | |
| } | |
| } | |
| } | |
| trait NonCopyTrait {} | |
| impl PartialEq for dyn NonCopyTrait { | |
| fn eq(&self, _other: &Self) -> bool { true } | |
| } | |
| // A union. Most builtin traits are not derivable for unions. | |
| pub union Union { | |
| pub b: bool, | |
| pub u: u32, | |
| pub i: i32, | |
| } | |
| #[automatically_derived] | |
| #[doc(hidden)] | |
| unsafe impl ::core::clone::TrivialClone for Union { } | |
| #[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 { } | |
| struct FooCopyClone(i32); | |
| #[automatically_derived] | |
| impl ::core::marker::Copy for FooCopyClone { } | |
| #[automatically_derived] | |
| #[doc(hidden)] | |
| unsafe impl ::core::clone::TrivialClone for FooCopyClone { } | |
| #[automatically_derived] | |
| impl ::core::clone::Clone for FooCopyClone { | |
| #[inline] | |
| fn clone(&self) -> FooCopyClone { | |
| let _: ::core::clone::AssertParamIsClone<i32>; | |
| *self | |
| } | |
| } | |
| struct FooCloneCopy(i32); | |
| #[automatically_derived] | |
| #[doc(hidden)] | |
| unsafe impl ::core::clone::TrivialClone for FooCloneCopy { } | |
| #[automatically_derived] | |
| impl ::core::clone::Clone for FooCloneCopy { | |
| #[inline] | |
| fn clone(&self) -> FooCloneCopy { | |
| let _: ::core::clone::AssertParamIsClone<i32>; | |
| *self | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::marker::Copy for FooCloneCopy { } | |
| struct FooCopyAndClone(i32); | |
| #[automatically_derived] | |
| #[doc(hidden)] | |
| unsafe impl ::core::clone::TrivialClone for FooCopyAndClone { } | |
| #[automatically_derived] | |
| impl ::core::clone::Clone for FooCopyAndClone { | |
| #[inline] | |
| fn clone(&self) -> FooCopyAndClone { | |
| let _: ::core::clone::AssertParamIsClone<i32>; | |
| *self | |
| } | |
| } | |
| #[automatically_derived] | |
| impl ::core::marker::Copy for FooCopyAndClone { } | |
| // FIXME(#124794): the previous three structs all have a trivial `Copy`-aware | |
| // `clone`. But this one doesn't because when the `clone` is generated the | |
| // `derive(Copy)` hasn't yet been seen. | |
| struct FooCloneAndCopy(i32); | |
| #[automatically_derived] | |
| impl ::core::marker::Copy for FooCloneAndCopy { } | |
| #[automatically_derived] | |
| impl ::core::clone::Clone for FooCloneAndCopy { | |
| #[inline] | |
| fn clone(&self) -> FooCloneAndCopy { | |
| FooCloneAndCopy(::core::clone::Clone::clone(&self.0)) | |
| } | |
| } |