1 #![feature(prelude_import)]
3 // compile-flags: -Zunpretty=expanded
6 // This test checks the code generated for all[*] the builtin derivable traits
7 // on a variety of structs and enums. It protects against accidental changes to
8 // the generated code, and makes deliberate changes to the generated code
11 // [*] It excludes `Copy` in some cases, because that changes the code
12 // generated for `Clone`.
14 // [*] It excludes `RustcEncodable` and `RustDecodable`, which are obsolete and
15 // also require the `rustc_serialize` crate.
17 #![crate_type = "lib"]
21 use std::prelude::rust_2021::*;
27 #[automatically_derived]
28 impl ::core::clone::Clone for Empty {
30 fn clone(&self) -> Empty { *self }
32 #[automatically_derived]
33 impl ::core::marker::Copy for Empty { }
34 #[automatically_derived]
35 impl ::core::fmt::Debug for Empty {
36 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
37 ::core::fmt::Formatter::write_str(f, "Empty")
40 #[automatically_derived]
41 impl ::core::default::Default for Empty {
43 fn default() -> Empty { Empty {} }
45 #[automatically_derived]
46 impl ::core::hash::Hash for Empty {
47 fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {}
49 impl ::core::marker::StructuralPartialEq for Empty {}
50 #[automatically_derived]
51 impl ::core::cmp::PartialEq for Empty {
53 fn eq(&self, other: &Empty) -> bool { true }
55 impl ::core::marker::StructuralEq for Empty {}
56 #[automatically_derived]
57 impl ::core::cmp::Eq for Empty {
61 fn assert_receiver_is_total_eq(&self) -> () {}
63 #[automatically_derived]
64 impl ::core::cmp::PartialOrd for Empty {
66 fn partial_cmp(&self, other: &Empty)
67 -> ::core::option::Option<::core::cmp::Ordering> {
68 ::core::option::Option::Some(::core::cmp::Ordering::Equal)
71 #[automatically_derived]
72 impl ::core::cmp::Ord for Empty {
74 fn cmp(&self, other: &Empty) -> ::core::cmp::Ordering {
75 ::core::cmp::Ordering::Equal
84 #[automatically_derived]
85 impl ::core::clone::Clone for Point {
87 fn clone(&self) -> Point {
88 let _: ::core::clone::AssertParamIsClone<u32>;
92 #[automatically_derived]
93 impl ::core::marker::Copy for Point { }
94 #[automatically_derived]
95 impl ::core::fmt::Debug for Point {
96 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
97 ::core::fmt::Formatter::debug_struct_field2_finish(f, "Point", "x",
98 &&self.x, "y", &&self.y)
101 #[automatically_derived]
102 impl ::core::default::Default for Point {
104 fn default() -> Point {
106 x: ::core::default::Default::default(),
107 y: ::core::default::Default::default(),
111 #[automatically_derived]
112 impl ::core::hash::Hash for Point {
113 fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
114 ::core::hash::Hash::hash(&self.x, state);
115 ::core::hash::Hash::hash(&self.y, state)
118 impl ::core::marker::StructuralPartialEq for Point {}
119 #[automatically_derived]
120 impl ::core::cmp::PartialEq for Point {
122 fn eq(&self, other: &Point) -> bool {
123 self.x == other.x && self.y == other.y
126 impl ::core::marker::StructuralEq for Point {}
127 #[automatically_derived]
128 impl ::core::cmp::Eq for Point {
132 fn assert_receiver_is_total_eq(&self) -> () {
133 let _: ::core::cmp::AssertParamIsEq<u32>;
136 #[automatically_derived]
137 impl ::core::cmp::PartialOrd for Point {
139 fn partial_cmp(&self, other: &Point)
140 -> ::core::option::Option<::core::cmp::Ordering> {
141 match ::core::cmp::PartialOrd::partial_cmp(&self.x, &other.x) {
142 ::core::option::Option::Some(::core::cmp::Ordering::Equal) =>
143 ::core::cmp::PartialOrd::partial_cmp(&self.y, &other.y),
148 #[automatically_derived]
149 impl ::core::cmp::Ord for Point {
151 fn cmp(&self, other: &Point) -> ::core::cmp::Ordering {
152 match ::core::cmp::Ord::cmp(&self.x, &other.x) {
153 ::core::cmp::Ordering::Equal =>
154 ::core::cmp::Ord::cmp(&self.y, &other.y),
171 #[automatically_derived]
172 impl ::core::clone::Clone for Big {
174 fn clone(&self) -> Big {
176 b1: ::core::clone::Clone::clone(&self.b1),
177 b2: ::core::clone::Clone::clone(&self.b2),
178 b3: ::core::clone::Clone::clone(&self.b3),
179 b4: ::core::clone::Clone::clone(&self.b4),
180 b5: ::core::clone::Clone::clone(&self.b5),
181 b6: ::core::clone::Clone::clone(&self.b6),
182 b7: ::core::clone::Clone::clone(&self.b7),
183 b8: ::core::clone::Clone::clone(&self.b8),
187 #[automatically_derived]
188 impl ::core::fmt::Debug for Big {
189 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
190 let names: &'static _ =
191 &["b1", "b2", "b3", "b4", "b5", "b6", "b7", "b8"];
192 let values: &[&dyn ::core::fmt::Debug] =
193 &[&&self.b1, &&self.b2, &&self.b3, &&self.b4, &&self.b5,
194 &&self.b6, &&self.b7, &&self.b8];
195 ::core::fmt::Formatter::debug_struct_fields_finish(f, "Big", names,
199 #[automatically_derived]
200 impl ::core::default::Default for Big {
202 fn default() -> Big {
204 b1: ::core::default::Default::default(),
205 b2: ::core::default::Default::default(),
206 b3: ::core::default::Default::default(),
207 b4: ::core::default::Default::default(),
208 b5: ::core::default::Default::default(),
209 b6: ::core::default::Default::default(),
210 b7: ::core::default::Default::default(),
211 b8: ::core::default::Default::default(),
215 #[automatically_derived]
216 impl ::core::hash::Hash for Big {
217 fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
218 ::core::hash::Hash::hash(&self.b1, state);
219 ::core::hash::Hash::hash(&self.b2, state);
220 ::core::hash::Hash::hash(&self.b3, state);
221 ::core::hash::Hash::hash(&self.b4, state);
222 ::core::hash::Hash::hash(&self.b5, state);
223 ::core::hash::Hash::hash(&self.b6, state);
224 ::core::hash::Hash::hash(&self.b7, state);
225 ::core::hash::Hash::hash(&self.b8, state)
228 impl ::core::marker::StructuralPartialEq for Big {}
229 #[automatically_derived]
230 impl ::core::cmp::PartialEq for Big {
232 fn eq(&self, other: &Big) -> bool {
233 self.b1 == other.b1 && self.b2 == other.b2 && self.b3 == other.b3 &&
234 self.b4 == other.b4 && self.b5 == other.b5 &&
235 self.b6 == other.b6 && self.b7 == other.b7 &&
239 impl ::core::marker::StructuralEq for Big {}
240 #[automatically_derived]
241 impl ::core::cmp::Eq for Big {
245 fn assert_receiver_is_total_eq(&self) -> () {
246 let _: ::core::cmp::AssertParamIsEq<u32>;
249 #[automatically_derived]
250 impl ::core::cmp::PartialOrd for Big {
252 fn partial_cmp(&self, other: &Big)
253 -> ::core::option::Option<::core::cmp::Ordering> {
254 match ::core::cmp::PartialOrd::partial_cmp(&self.b1, &other.b1) {
255 ::core::option::Option::Some(::core::cmp::Ordering::Equal) =>
256 match ::core::cmp::PartialOrd::partial_cmp(&self.b2,
258 ::core::option::Option::Some(::core::cmp::Ordering::Equal)
260 match ::core::cmp::PartialOrd::partial_cmp(&self.b3,
262 ::core::option::Option::Some(::core::cmp::Ordering::Equal)
264 match ::core::cmp::PartialOrd::partial_cmp(&self.b4,
266 ::core::option::Option::Some(::core::cmp::Ordering::Equal)
268 match ::core::cmp::PartialOrd::partial_cmp(&self.b5,
270 ::core::option::Option::Some(::core::cmp::Ordering::Equal)
272 match ::core::cmp::PartialOrd::partial_cmp(&self.b6,
274 ::core::option::Option::Some(::core::cmp::Ordering::Equal)
276 match ::core::cmp::PartialOrd::partial_cmp(&self.b7,
278 ::core::option::Option::Some(::core::cmp::Ordering::Equal)
280 ::core::cmp::PartialOrd::partial_cmp(&self.b8, &other.b8),
297 #[automatically_derived]
298 impl ::core::cmp::Ord for Big {
300 fn cmp(&self, other: &Big) -> ::core::cmp::Ordering {
301 match ::core::cmp::Ord::cmp(&self.b1, &other.b1) {
302 ::core::cmp::Ordering::Equal =>
303 match ::core::cmp::Ord::cmp(&self.b2, &other.b2) {
304 ::core::cmp::Ordering::Equal =>
305 match ::core::cmp::Ord::cmp(&self.b3, &other.b3) {
306 ::core::cmp::Ordering::Equal =>
307 match ::core::cmp::Ord::cmp(&self.b4, &other.b4) {
308 ::core::cmp::Ordering::Equal =>
309 match ::core::cmp::Ord::cmp(&self.b5, &other.b5) {
310 ::core::cmp::Ordering::Equal =>
311 match ::core::cmp::Ord::cmp(&self.b6, &other.b6) {
312 ::core::cmp::Ordering::Equal =>
313 match ::core::cmp::Ord::cmp(&self.b7, &other.b7) {
314 ::core::cmp::Ordering::Equal =>
315 ::core::cmp::Ord::cmp(&self.b8, &other.b8),
333 // A struct with an unsized field. Some derives are not usable in this case.
334 struct Unsized([u32]);
335 #[automatically_derived]
336 impl ::core::fmt::Debug for Unsized {
337 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
338 ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Unsized",
342 #[automatically_derived]
343 impl ::core::hash::Hash for Unsized {
344 fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
345 ::core::hash::Hash::hash(&self.0, state)
348 impl ::core::marker::StructuralPartialEq for Unsized {}
349 #[automatically_derived]
350 impl ::core::cmp::PartialEq for Unsized {
352 fn eq(&self, other: &Unsized) -> bool { self.0 == other.0 }
354 impl ::core::marker::StructuralEq for Unsized {}
355 #[automatically_derived]
356 impl ::core::cmp::Eq for Unsized {
360 fn assert_receiver_is_total_eq(&self) -> () {
361 let _: ::core::cmp::AssertParamIsEq<[u32]>;
364 #[automatically_derived]
365 impl ::core::cmp::PartialOrd for Unsized {
367 fn partial_cmp(&self, other: &Unsized)
368 -> ::core::option::Option<::core::cmp::Ordering> {
369 ::core::cmp::PartialOrd::partial_cmp(&self.0, &other.0)
372 #[automatically_derived]
373 impl ::core::cmp::Ord for Unsized {
375 fn cmp(&self, other: &Unsized) -> ::core::cmp::Ordering {
376 ::core::cmp::Ord::cmp(&self.0, &other.0)
380 // A packed tuple struct that impls `Copy`.
382 struct PackedCopy(u32);
383 #[automatically_derived]
384 impl ::core::clone::Clone for PackedCopy {
386 fn clone(&self) -> PackedCopy {
387 let _: ::core::clone::AssertParamIsClone<u32>;
391 #[automatically_derived]
392 impl ::core::marker::Copy for PackedCopy { }
393 #[automatically_derived]
394 impl ::core::fmt::Debug for PackedCopy {
395 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
396 ::core::fmt::Formatter::debug_tuple_field1_finish(f, "PackedCopy",
400 #[automatically_derived]
401 impl ::core::default::Default for PackedCopy {
403 fn default() -> PackedCopy {
404 PackedCopy(::core::default::Default::default())
407 #[automatically_derived]
408 impl ::core::hash::Hash for PackedCopy {
409 fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
410 ::core::hash::Hash::hash(&{ self.0 }, state)
413 impl ::core::marker::StructuralPartialEq for PackedCopy {}
414 #[automatically_derived]
415 impl ::core::cmp::PartialEq for PackedCopy {
417 fn eq(&self, other: &PackedCopy) -> bool { { self.0 } == { other.0 } }
419 impl ::core::marker::StructuralEq for PackedCopy {}
420 #[automatically_derived]
421 impl ::core::cmp::Eq for PackedCopy {
425 fn assert_receiver_is_total_eq(&self) -> () {
426 let _: ::core::cmp::AssertParamIsEq<u32>;
429 #[automatically_derived]
430 impl ::core::cmp::PartialOrd for PackedCopy {
432 fn partial_cmp(&self, other: &PackedCopy)
433 -> ::core::option::Option<::core::cmp::Ordering> {
434 ::core::cmp::PartialOrd::partial_cmp(&{ self.0 }, &{ other.0 })
437 #[automatically_derived]
438 impl ::core::cmp::Ord for PackedCopy {
440 fn cmp(&self, other: &PackedCopy) -> ::core::cmp::Ordering {
441 ::core::cmp::Ord::cmp(&{ self.0 }, &{ other.0 })
445 // A packed tuple struct that does not impl `Copy`. Note that the alignment of
446 // the field must be 1 for this code to be valid. Otherwise it triggers an
447 // error "`#[derive]` can't be used on a `#[repr(packed)]` struct that does not
448 // derive Copy (error E0133)" at MIR building time. This is a weird case and
449 // it's possible that this struct is not supposed to work, but for now it does.
451 struct PackedNonCopy(u8);
452 #[automatically_derived]
453 impl ::core::clone::Clone for PackedNonCopy {
455 fn clone(&self) -> PackedNonCopy {
456 let Self(ref __self_0_0) = *self;
457 PackedNonCopy(::core::clone::Clone::clone(__self_0_0))
460 #[automatically_derived]
461 impl ::core::fmt::Debug for PackedNonCopy {
462 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
463 let Self(ref __self_0_0) = *self;
464 ::core::fmt::Formatter::debug_tuple_field1_finish(f, "PackedNonCopy",
468 #[automatically_derived]
469 impl ::core::default::Default for PackedNonCopy {
471 fn default() -> PackedNonCopy {
472 PackedNonCopy(::core::default::Default::default())
475 #[automatically_derived]
476 impl ::core::hash::Hash for PackedNonCopy {
477 fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
478 let Self(ref __self_0_0) = *self;
479 ::core::hash::Hash::hash(__self_0_0, state)
482 impl ::core::marker::StructuralPartialEq for PackedNonCopy {}
483 #[automatically_derived]
484 impl ::core::cmp::PartialEq for PackedNonCopy {
486 fn eq(&self, other: &PackedNonCopy) -> bool {
487 let Self(ref __self_0_0) = *self;
488 let Self(ref __self_1_0) = *other;
489 *__self_0_0 == *__self_1_0
492 impl ::core::marker::StructuralEq for PackedNonCopy {}
493 #[automatically_derived]
494 impl ::core::cmp::Eq for PackedNonCopy {
498 fn assert_receiver_is_total_eq(&self) -> () {
499 let _: ::core::cmp::AssertParamIsEq<u8>;
502 #[automatically_derived]
503 impl ::core::cmp::PartialOrd for PackedNonCopy {
505 fn partial_cmp(&self, other: &PackedNonCopy)
506 -> ::core::option::Option<::core::cmp::Ordering> {
507 let Self(ref __self_0_0) = *self;
508 let Self(ref __self_1_0) = *other;
509 ::core::cmp::PartialOrd::partial_cmp(__self_0_0, __self_1_0)
512 #[automatically_derived]
513 impl ::core::cmp::Ord for PackedNonCopy {
515 fn cmp(&self, other: &PackedNonCopy) -> ::core::cmp::Ordering {
516 let Self(ref __self_0_0) = *self;
517 let Self(ref __self_1_0) = *other;
518 ::core::cmp::Ord::cmp(__self_0_0, __self_1_0)
524 #[automatically_derived]
525 impl ::core::clone::Clone for Enum0 {
527 fn clone(&self) -> Enum0 { *self }
529 #[automatically_derived]
530 impl ::core::marker::Copy for Enum0 { }
531 #[automatically_derived]
532 impl ::core::fmt::Debug for Enum0 {
533 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
534 unsafe { ::core::intrinsics::unreachable() }
537 #[automatically_derived]
538 impl ::core::hash::Hash for Enum0 {
539 fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
540 unsafe { ::core::intrinsics::unreachable() }
543 impl ::core::marker::StructuralPartialEq for Enum0 {}
544 #[automatically_derived]
545 impl ::core::cmp::PartialEq for Enum0 {
547 fn eq(&self, other: &Enum0) -> bool {
548 unsafe { ::core::intrinsics::unreachable() }
551 impl ::core::marker::StructuralEq for Enum0 {}
552 #[automatically_derived]
553 impl ::core::cmp::Eq for Enum0 {
557 fn assert_receiver_is_total_eq(&self) -> () {}
559 #[automatically_derived]
560 impl ::core::cmp::PartialOrd for Enum0 {
562 fn partial_cmp(&self, other: &Enum0)
563 -> ::core::option::Option<::core::cmp::Ordering> {
564 unsafe { ::core::intrinsics::unreachable() }
567 #[automatically_derived]
568 impl ::core::cmp::Ord for Enum0 {
570 fn cmp(&self, other: &Enum0) -> ::core::cmp::Ordering {
571 unsafe { ::core::intrinsics::unreachable() }
575 // A single-variant enum.
581 #[automatically_derived]
582 impl ::core::clone::Clone for Enum1 {
584 fn clone(&self) -> Enum1 {
586 Enum1::Single { x: __self_0 } =>
587 Enum1::Single { x: ::core::clone::Clone::clone(__self_0) },
591 #[automatically_derived]
592 impl ::core::fmt::Debug for Enum1 {
593 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
595 Enum1::Single { x: __self_0 } =>
596 ::core::fmt::Formatter::debug_struct_field1_finish(f,
597 "Single", "x", &__self_0),
601 #[automatically_derived]
602 impl ::core::hash::Hash for Enum1 {
603 fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
605 Enum1::Single { x: __self_0 } =>
606 ::core::hash::Hash::hash(__self_0, state),
610 impl ::core::marker::StructuralPartialEq for Enum1 {}
611 #[automatically_derived]
612 impl ::core::cmp::PartialEq for Enum1 {
614 fn eq(&self, other: &Enum1) -> bool {
615 match (self, other) {
616 (Enum1::Single { x: __self_0 }, Enum1::Single { x: __arg1_0 }) =>
617 *__self_0 == *__arg1_0,
621 impl ::core::marker::StructuralEq for Enum1 {}
622 #[automatically_derived]
623 impl ::core::cmp::Eq for Enum1 {
627 fn assert_receiver_is_total_eq(&self) -> () {
628 let _: ::core::cmp::AssertParamIsEq<u32>;
631 #[automatically_derived]
632 impl ::core::cmp::PartialOrd for Enum1 {
634 fn partial_cmp(&self, other: &Enum1)
635 -> ::core::option::Option<::core::cmp::Ordering> {
636 match (self, other) {
637 (Enum1::Single { x: __self_0 }, Enum1::Single { x: __arg1_0 }) =>
638 ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0),
642 #[automatically_derived]
643 impl ::core::cmp::Ord for Enum1 {
645 fn cmp(&self, other: &Enum1) -> ::core::cmp::Ordering {
646 match (self, other) {
647 (Enum1::Single { x: __self_0 }, Enum1::Single { x: __arg1_0 }) =>
648 ::core::cmp::Ord::cmp(__self_0, __arg1_0),
653 // A C-like, fieldless enum with a single variant.
659 #[automatically_derived]
660 impl ::core::clone::Clone for Fieldless1 {
662 fn clone(&self) -> Fieldless1 { Fieldless1::A }
664 #[automatically_derived]
665 impl ::core::fmt::Debug for Fieldless1 {
666 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
667 ::core::fmt::Formatter::write_str(f, "A")
670 #[automatically_derived]
671 impl ::core::default::Default for Fieldless1 {
673 fn default() -> Fieldless1 { Self::A }
675 #[automatically_derived]
676 impl ::core::hash::Hash for Fieldless1 {
677 fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {}
679 impl ::core::marker::StructuralPartialEq for Fieldless1 {}
680 #[automatically_derived]
681 impl ::core::cmp::PartialEq for Fieldless1 {
683 fn eq(&self, other: &Fieldless1) -> bool { true }
685 impl ::core::marker::StructuralEq for Fieldless1 {}
686 #[automatically_derived]
687 impl ::core::cmp::Eq for Fieldless1 {
691 fn assert_receiver_is_total_eq(&self) -> () {}
693 #[automatically_derived]
694 impl ::core::cmp::PartialOrd for Fieldless1 {
696 fn partial_cmp(&self, other: &Fieldless1)
697 -> ::core::option::Option<::core::cmp::Ordering> {
698 ::core::option::Option::Some(::core::cmp::Ordering::Equal)
701 #[automatically_derived]
702 impl ::core::cmp::Ord for Fieldless1 {
704 fn cmp(&self, other: &Fieldless1) -> ::core::cmp::Ordering {
705 ::core::cmp::Ordering::Equal
709 // A C-like, fieldless enum.
717 #[automatically_derived]
718 impl ::core::clone::Clone for Fieldless {
720 fn clone(&self) -> Fieldless { *self }
722 #[automatically_derived]
723 impl ::core::marker::Copy for Fieldless { }
724 #[automatically_derived]
725 impl ::core::fmt::Debug for Fieldless {
726 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
728 Fieldless::A => ::core::fmt::Formatter::write_str(f, "A"),
729 Fieldless::B => ::core::fmt::Formatter::write_str(f, "B"),
730 Fieldless::C => ::core::fmt::Formatter::write_str(f, "C"),
734 #[automatically_derived]
735 impl ::core::default::Default for Fieldless {
737 fn default() -> Fieldless { Self::A }
739 #[automatically_derived]
740 impl ::core::hash::Hash for Fieldless {
741 fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
742 let __self_tag = ::core::intrinsics::discriminant_value(self);
743 ::core::hash::Hash::hash(&__self_tag, state)
746 impl ::core::marker::StructuralPartialEq for Fieldless {}
747 #[automatically_derived]
748 impl ::core::cmp::PartialEq for Fieldless {
750 fn eq(&self, other: &Fieldless) -> bool {
751 let __self_tag = ::core::intrinsics::discriminant_value(self);
752 let __arg1_tag = ::core::intrinsics::discriminant_value(other);
753 __self_tag == __arg1_tag
756 impl ::core::marker::StructuralEq for Fieldless {}
757 #[automatically_derived]
758 impl ::core::cmp::Eq for Fieldless {
762 fn assert_receiver_is_total_eq(&self) -> () {}
764 #[automatically_derived]
765 impl ::core::cmp::PartialOrd for Fieldless {
767 fn partial_cmp(&self, other: &Fieldless)
768 -> ::core::option::Option<::core::cmp::Ordering> {
769 let __self_tag = ::core::intrinsics::discriminant_value(self);
770 let __arg1_tag = ::core::intrinsics::discriminant_value(other);
771 ::core::cmp::PartialOrd::partial_cmp(&__self_tag, &__arg1_tag)
774 #[automatically_derived]
775 impl ::core::cmp::Ord for Fieldless {
777 fn cmp(&self, other: &Fieldless) -> ::core::cmp::Ordering {
778 let __self_tag = ::core::intrinsics::discriminant_value(self);
779 let __arg1_tag = ::core::intrinsics::discriminant_value(other);
780 ::core::cmp::Ord::cmp(&__self_tag, &__arg1_tag)
784 // An enum with multiple fieldless and fielded variants.
796 #[automatically_derived]
797 impl ::core::clone::Clone for Mixed {
799 fn clone(&self) -> Mixed {
800 let _: ::core::clone::AssertParamIsClone<u32>;
804 #[automatically_derived]
805 impl ::core::marker::Copy for Mixed { }
806 #[automatically_derived]
807 impl ::core::fmt::Debug for Mixed {
808 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
810 Mixed::P => ::core::fmt::Formatter::write_str(f, "P"),
811 Mixed::Q => ::core::fmt::Formatter::write_str(f, "Q"),
812 Mixed::R(__self_0) =>
813 ::core::fmt::Formatter::debug_tuple_field1_finish(f, "R",
815 Mixed::S { d1: __self_0, d2: __self_1 } =>
816 ::core::fmt::Formatter::debug_struct_field2_finish(f, "S",
817 "d1", &__self_0, "d2", &__self_1),
821 #[automatically_derived]
822 impl ::core::default::Default for Mixed {
824 fn default() -> Mixed { Self::P }
826 #[automatically_derived]
827 impl ::core::hash::Hash for Mixed {
828 fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
829 let __self_tag = ::core::intrinsics::discriminant_value(self);
830 ::core::hash::Hash::hash(&__self_tag, state);
832 Mixed::R(__self_0) => ::core::hash::Hash::hash(__self_0, state),
833 Mixed::S { d1: __self_0, d2: __self_1 } => {
834 ::core::hash::Hash::hash(__self_0, state);
835 ::core::hash::Hash::hash(__self_1, state)
841 impl ::core::marker::StructuralPartialEq for Mixed {}
842 #[automatically_derived]
843 impl ::core::cmp::PartialEq for Mixed {
845 fn eq(&self, other: &Mixed) -> bool {
846 let __self_tag = ::core::intrinsics::discriminant_value(self);
847 let __arg1_tag = ::core::intrinsics::discriminant_value(other);
848 __self_tag == __arg1_tag &&
849 match (self, other) {
850 (Mixed::R(__self_0), Mixed::R(__arg1_0)) =>
851 *__self_0 == *__arg1_0,
852 (Mixed::S { d1: __self_0, d2: __self_1 }, Mixed::S {
853 d1: __arg1_0, d2: __arg1_1 }) =>
854 *__self_0 == *__arg1_0 && *__self_1 == *__arg1_1,
859 impl ::core::marker::StructuralEq for Mixed {}
860 #[automatically_derived]
861 impl ::core::cmp::Eq for Mixed {
865 fn assert_receiver_is_total_eq(&self) -> () {
866 let _: ::core::cmp::AssertParamIsEq<u32>;
869 #[automatically_derived]
870 impl ::core::cmp::PartialOrd for Mixed {
872 fn partial_cmp(&self, other: &Mixed)
873 -> ::core::option::Option<::core::cmp::Ordering> {
874 let __self_tag = ::core::intrinsics::discriminant_value(self);
875 let __arg1_tag = ::core::intrinsics::discriminant_value(other);
876 match ::core::cmp::PartialOrd::partial_cmp(&__self_tag, &__arg1_tag) {
877 ::core::option::Option::Some(::core::cmp::Ordering::Equal) =>
878 match (self, other) {
879 (Mixed::R(__self_0), Mixed::R(__arg1_0)) =>
880 ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0),
881 (Mixed::S { d1: __self_0, d2: __self_1 }, Mixed::S {
882 d1: __arg1_0, d2: __arg1_1 }) =>
883 match ::core::cmp::PartialOrd::partial_cmp(__self_0,
885 ::core::option::Option::Some(::core::cmp::Ordering::Equal)
886 => ::core::cmp::PartialOrd::partial_cmp(__self_1, __arg1_1),
890 ::core::option::Option::Some(::core::cmp::Ordering::Equal),
896 #[automatically_derived]
897 impl ::core::cmp::Ord for Mixed {
899 fn cmp(&self, other: &Mixed) -> ::core::cmp::Ordering {
900 let __self_tag = ::core::intrinsics::discriminant_value(self);
901 let __arg1_tag = ::core::intrinsics::discriminant_value(other);
902 match ::core::cmp::Ord::cmp(&__self_tag, &__arg1_tag) {
903 ::core::cmp::Ordering::Equal =>
904 match (self, other) {
905 (Mixed::R(__self_0), Mixed::R(__arg1_0)) =>
906 ::core::cmp::Ord::cmp(__self_0, __arg1_0),
907 (Mixed::S { d1: __self_0, d2: __self_1 }, Mixed::S {
908 d1: __arg1_0, d2: __arg1_1 }) =>
909 match ::core::cmp::Ord::cmp(__self_0, __arg1_0) {
910 ::core::cmp::Ordering::Equal =>
911 ::core::cmp::Ord::cmp(__self_1, __arg1_1),
914 _ => ::core::cmp::Ordering::Equal,
921 // An enum with no fieldless variants. Note that `Default` cannot be derived
923 enum Fielded { X(u32), Y(bool), Z(Option<i32>), }
924 #[automatically_derived]
925 impl ::core::clone::Clone for Fielded {
927 fn clone(&self) -> Fielded {
929 Fielded::X(__self_0) =>
930 Fielded::X(::core::clone::Clone::clone(__self_0)),
931 Fielded::Y(__self_0) =>
932 Fielded::Y(::core::clone::Clone::clone(__self_0)),
933 Fielded::Z(__self_0) =>
934 Fielded::Z(::core::clone::Clone::clone(__self_0)),
938 #[automatically_derived]
939 impl ::core::fmt::Debug for Fielded {
940 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
942 Fielded::X(__self_0) =>
943 ::core::fmt::Formatter::debug_tuple_field1_finish(f, "X",
945 Fielded::Y(__self_0) =>
946 ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Y",
948 Fielded::Z(__self_0) =>
949 ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Z",
954 #[automatically_derived]
955 impl ::core::hash::Hash for Fielded {
956 fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
957 let __self_tag = ::core::intrinsics::discriminant_value(self);
958 ::core::hash::Hash::hash(&__self_tag, state);
960 Fielded::X(__self_0) => ::core::hash::Hash::hash(__self_0, state),
961 Fielded::Y(__self_0) => ::core::hash::Hash::hash(__self_0, state),
962 Fielded::Z(__self_0) => ::core::hash::Hash::hash(__self_0, state),
966 impl ::core::marker::StructuralPartialEq for Fielded {}
967 #[automatically_derived]
968 impl ::core::cmp::PartialEq for Fielded {
970 fn eq(&self, other: &Fielded) -> bool {
971 let __self_tag = ::core::intrinsics::discriminant_value(self);
972 let __arg1_tag = ::core::intrinsics::discriminant_value(other);
973 __self_tag == __arg1_tag &&
974 match (self, other) {
975 (Fielded::X(__self_0), Fielded::X(__arg1_0)) =>
976 *__self_0 == *__arg1_0,
977 (Fielded::Y(__self_0), Fielded::Y(__arg1_0)) =>
978 *__self_0 == *__arg1_0,
979 (Fielded::Z(__self_0), Fielded::Z(__arg1_0)) =>
980 *__self_0 == *__arg1_0,
981 _ => unsafe { ::core::intrinsics::unreachable() }
985 impl ::core::marker::StructuralEq for Fielded {}
986 #[automatically_derived]
987 impl ::core::cmp::Eq for Fielded {
991 fn assert_receiver_is_total_eq(&self) -> () {
992 let _: ::core::cmp::AssertParamIsEq<u32>;
993 let _: ::core::cmp::AssertParamIsEq<bool>;
994 let _: ::core::cmp::AssertParamIsEq<Option<i32>>;
997 #[automatically_derived]
998 impl ::core::cmp::PartialOrd for Fielded {
1000 fn partial_cmp(&self, other: &Fielded)
1001 -> ::core::option::Option<::core::cmp::Ordering> {
1002 let __self_tag = ::core::intrinsics::discriminant_value(self);
1003 let __arg1_tag = ::core::intrinsics::discriminant_value(other);
1004 match ::core::cmp::PartialOrd::partial_cmp(&__self_tag, &__arg1_tag) {
1005 ::core::option::Option::Some(::core::cmp::Ordering::Equal) =>
1006 match (self, other) {
1007 (Fielded::X(__self_0), Fielded::X(__arg1_0)) =>
1008 ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0),
1009 (Fielded::Y(__self_0), Fielded::Y(__arg1_0)) =>
1010 ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0),
1011 (Fielded::Z(__self_0), Fielded::Z(__arg1_0)) =>
1012 ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0),
1013 _ => unsafe { ::core::intrinsics::unreachable() }
1019 #[automatically_derived]
1020 impl ::core::cmp::Ord for Fielded {
1022 fn cmp(&self, other: &Fielded) -> ::core::cmp::Ordering {
1023 let __self_tag = ::core::intrinsics::discriminant_value(self);
1024 let __arg1_tag = ::core::intrinsics::discriminant_value(other);
1025 match ::core::cmp::Ord::cmp(&__self_tag, &__arg1_tag) {
1026 ::core::cmp::Ordering::Equal =>
1027 match (self, other) {
1028 (Fielded::X(__self_0), Fielded::X(__arg1_0)) =>
1029 ::core::cmp::Ord::cmp(__self_0, __arg1_0),
1030 (Fielded::Y(__self_0), Fielded::Y(__arg1_0)) =>
1031 ::core::cmp::Ord::cmp(__self_0, __arg1_0),
1032 (Fielded::Z(__self_0), Fielded::Z(__arg1_0)) =>
1033 ::core::cmp::Ord::cmp(__self_0, __arg1_0),
1034 _ => unsafe { ::core::intrinsics::unreachable() }
1041 // A union. Most builtin traits are not derivable for unions.
1047 #[automatically_derived]
1048 impl ::core::clone::Clone for Union {
1050 fn clone(&self) -> Union {
1051 let _: ::core::clone::AssertParamIsCopy<Self>;
1055 #[automatically_derived]
1056 impl ::core::marker::Copy for Union { }