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 #[automatically_derived]
50 impl ::core::marker::StructuralPartialEq for Empty { }
51 #[automatically_derived]
52 impl ::core::cmp::PartialEq for Empty {
54 fn eq(&self, other: &Empty) -> bool { true }
56 #[automatically_derived]
57 impl ::core::marker::StructuralEq for Empty { }
58 #[automatically_derived]
59 impl ::core::cmp::Eq for Empty {
63 fn assert_receiver_is_total_eq(&self) -> () {}
65 #[automatically_derived]
66 impl ::core::cmp::PartialOrd for Empty {
68 fn partial_cmp(&self, other: &Empty)
69 -> ::core::option::Option<::core::cmp::Ordering> {
70 ::core::option::Option::Some(::core::cmp::Ordering::Equal)
73 #[automatically_derived]
74 impl ::core::cmp::Ord for Empty {
76 fn cmp(&self, other: &Empty) -> ::core::cmp::Ordering {
77 ::core::cmp::Ordering::Equal
86 #[automatically_derived]
87 impl ::core::clone::Clone for Point {
89 fn clone(&self) -> Point {
90 let _: ::core::clone::AssertParamIsClone<u32>;
94 #[automatically_derived]
95 impl ::core::marker::Copy for Point { }
96 #[automatically_derived]
97 impl ::core::fmt::Debug for Point {
98 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
99 ::core::fmt::Formatter::debug_struct_field2_finish(f, "Point", "x",
100 &&self.x, "y", &&self.y)
103 #[automatically_derived]
104 impl ::core::default::Default for Point {
106 fn default() -> Point {
108 x: ::core::default::Default::default(),
109 y: ::core::default::Default::default(),
113 #[automatically_derived]
114 impl ::core::hash::Hash for Point {
115 fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
116 ::core::hash::Hash::hash(&self.x, state);
117 ::core::hash::Hash::hash(&self.y, state)
120 #[automatically_derived]
121 impl ::core::marker::StructuralPartialEq for Point { }
122 #[automatically_derived]
123 impl ::core::cmp::PartialEq for Point {
125 fn eq(&self, other: &Point) -> bool {
126 self.x == other.x && self.y == other.y
129 #[automatically_derived]
130 impl ::core::marker::StructuralEq for Point { }
131 #[automatically_derived]
132 impl ::core::cmp::Eq for Point {
136 fn assert_receiver_is_total_eq(&self) -> () {
137 let _: ::core::cmp::AssertParamIsEq<u32>;
140 #[automatically_derived]
141 impl ::core::cmp::PartialOrd for Point {
143 fn partial_cmp(&self, other: &Point)
144 -> ::core::option::Option<::core::cmp::Ordering> {
145 match ::core::cmp::PartialOrd::partial_cmp(&self.x, &other.x) {
146 ::core::option::Option::Some(::core::cmp::Ordering::Equal) =>
147 ::core::cmp::PartialOrd::partial_cmp(&self.y, &other.y),
152 #[automatically_derived]
153 impl ::core::cmp::Ord for Point {
155 fn cmp(&self, other: &Point) -> ::core::cmp::Ordering {
156 match ::core::cmp::Ord::cmp(&self.x, &other.x) {
157 ::core::cmp::Ordering::Equal =>
158 ::core::cmp::Ord::cmp(&self.y, &other.y),
175 #[automatically_derived]
176 impl ::core::clone::Clone for Big {
178 fn clone(&self) -> Big {
180 b1: ::core::clone::Clone::clone(&self.b1),
181 b2: ::core::clone::Clone::clone(&self.b2),
182 b3: ::core::clone::Clone::clone(&self.b3),
183 b4: ::core::clone::Clone::clone(&self.b4),
184 b5: ::core::clone::Clone::clone(&self.b5),
185 b6: ::core::clone::Clone::clone(&self.b6),
186 b7: ::core::clone::Clone::clone(&self.b7),
187 b8: ::core::clone::Clone::clone(&self.b8),
191 #[automatically_derived]
192 impl ::core::fmt::Debug for Big {
193 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
194 let names: &'static _ =
195 &["b1", "b2", "b3", "b4", "b5", "b6", "b7", "b8"];
196 let values: &[&dyn ::core::fmt::Debug] =
197 &[&&self.b1, &&self.b2, &&self.b3, &&self.b4, &&self.b5,
198 &&self.b6, &&self.b7, &&self.b8];
199 ::core::fmt::Formatter::debug_struct_fields_finish(f, "Big", names,
203 #[automatically_derived]
204 impl ::core::default::Default for Big {
206 fn default() -> Big {
208 b1: ::core::default::Default::default(),
209 b2: ::core::default::Default::default(),
210 b3: ::core::default::Default::default(),
211 b4: ::core::default::Default::default(),
212 b5: ::core::default::Default::default(),
213 b6: ::core::default::Default::default(),
214 b7: ::core::default::Default::default(),
215 b8: ::core::default::Default::default(),
219 #[automatically_derived]
220 impl ::core::hash::Hash for Big {
221 fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
222 ::core::hash::Hash::hash(&self.b1, state);
223 ::core::hash::Hash::hash(&self.b2, state);
224 ::core::hash::Hash::hash(&self.b3, state);
225 ::core::hash::Hash::hash(&self.b4, state);
226 ::core::hash::Hash::hash(&self.b5, state);
227 ::core::hash::Hash::hash(&self.b6, state);
228 ::core::hash::Hash::hash(&self.b7, state);
229 ::core::hash::Hash::hash(&self.b8, state)
232 #[automatically_derived]
233 impl ::core::marker::StructuralPartialEq for Big { }
234 #[automatically_derived]
235 impl ::core::cmp::PartialEq for Big {
237 fn eq(&self, other: &Big) -> bool {
238 self.b1 == other.b1 && self.b2 == other.b2 && self.b3 == other.b3 &&
239 self.b4 == other.b4 && self.b5 == other.b5 &&
240 self.b6 == other.b6 && self.b7 == other.b7 &&
244 #[automatically_derived]
245 impl ::core::marker::StructuralEq for Big { }
246 #[automatically_derived]
247 impl ::core::cmp::Eq for Big {
251 fn assert_receiver_is_total_eq(&self) -> () {
252 let _: ::core::cmp::AssertParamIsEq<u32>;
255 #[automatically_derived]
256 impl ::core::cmp::PartialOrd for Big {
258 fn partial_cmp(&self, other: &Big)
259 -> ::core::option::Option<::core::cmp::Ordering> {
260 match ::core::cmp::PartialOrd::partial_cmp(&self.b1, &other.b1) {
261 ::core::option::Option::Some(::core::cmp::Ordering::Equal) =>
262 match ::core::cmp::PartialOrd::partial_cmp(&self.b2,
264 ::core::option::Option::Some(::core::cmp::Ordering::Equal)
266 match ::core::cmp::PartialOrd::partial_cmp(&self.b3,
268 ::core::option::Option::Some(::core::cmp::Ordering::Equal)
270 match ::core::cmp::PartialOrd::partial_cmp(&self.b4,
272 ::core::option::Option::Some(::core::cmp::Ordering::Equal)
274 match ::core::cmp::PartialOrd::partial_cmp(&self.b5,
276 ::core::option::Option::Some(::core::cmp::Ordering::Equal)
278 match ::core::cmp::PartialOrd::partial_cmp(&self.b6,
280 ::core::option::Option::Some(::core::cmp::Ordering::Equal)
282 match ::core::cmp::PartialOrd::partial_cmp(&self.b7,
284 ::core::option::Option::Some(::core::cmp::Ordering::Equal)
286 ::core::cmp::PartialOrd::partial_cmp(&self.b8, &other.b8),
303 #[automatically_derived]
304 impl ::core::cmp::Ord for Big {
306 fn cmp(&self, other: &Big) -> ::core::cmp::Ordering {
307 match ::core::cmp::Ord::cmp(&self.b1, &other.b1) {
308 ::core::cmp::Ordering::Equal =>
309 match ::core::cmp::Ord::cmp(&self.b2, &other.b2) {
310 ::core::cmp::Ordering::Equal =>
311 match ::core::cmp::Ord::cmp(&self.b3, &other.b3) {
312 ::core::cmp::Ordering::Equal =>
313 match ::core::cmp::Ord::cmp(&self.b4, &other.b4) {
314 ::core::cmp::Ordering::Equal =>
315 match ::core::cmp::Ord::cmp(&self.b5, &other.b5) {
316 ::core::cmp::Ordering::Equal =>
317 match ::core::cmp::Ord::cmp(&self.b6, &other.b6) {
318 ::core::cmp::Ordering::Equal =>
319 match ::core::cmp::Ord::cmp(&self.b7, &other.b7) {
320 ::core::cmp::Ordering::Equal =>
321 ::core::cmp::Ord::cmp(&self.b8, &other.b8),
339 // A struct with an unsized field. Some derives are not usable in this case.
340 struct Unsized([u32]);
341 #[automatically_derived]
342 impl ::core::fmt::Debug for Unsized {
343 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
344 ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Unsized",
348 #[automatically_derived]
349 impl ::core::hash::Hash for Unsized {
350 fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
351 ::core::hash::Hash::hash(&self.0, state)
354 #[automatically_derived]
355 impl ::core::marker::StructuralPartialEq for Unsized { }
356 #[automatically_derived]
357 impl ::core::cmp::PartialEq for Unsized {
359 fn eq(&self, other: &Unsized) -> bool { self.0 == other.0 }
361 #[automatically_derived]
362 impl ::core::marker::StructuralEq for Unsized { }
363 #[automatically_derived]
364 impl ::core::cmp::Eq for Unsized {
368 fn assert_receiver_is_total_eq(&self) -> () {
369 let _: ::core::cmp::AssertParamIsEq<[u32]>;
372 #[automatically_derived]
373 impl ::core::cmp::PartialOrd for Unsized {
375 fn partial_cmp(&self, other: &Unsized)
376 -> ::core::option::Option<::core::cmp::Ordering> {
377 ::core::cmp::PartialOrd::partial_cmp(&self.0, &other.0)
380 #[automatically_derived]
381 impl ::core::cmp::Ord for Unsized {
383 fn cmp(&self, other: &Unsized) -> ::core::cmp::Ordering {
384 ::core::cmp::Ord::cmp(&self.0, &other.0)
388 // A packed tuple struct that impls `Copy`.
390 struct PackedCopy(u32);
391 #[automatically_derived]
392 impl ::core::clone::Clone for PackedCopy {
394 fn clone(&self) -> PackedCopy {
395 let _: ::core::clone::AssertParamIsClone<u32>;
399 #[automatically_derived]
400 impl ::core::marker::Copy for PackedCopy { }
401 #[automatically_derived]
402 impl ::core::fmt::Debug for PackedCopy {
403 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
404 ::core::fmt::Formatter::debug_tuple_field1_finish(f, "PackedCopy",
408 #[automatically_derived]
409 impl ::core::default::Default for PackedCopy {
411 fn default() -> PackedCopy {
412 PackedCopy(::core::default::Default::default())
415 #[automatically_derived]
416 impl ::core::hash::Hash for PackedCopy {
417 fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
418 ::core::hash::Hash::hash(&{ self.0 }, state)
421 #[automatically_derived]
422 impl ::core::marker::StructuralPartialEq for PackedCopy { }
423 #[automatically_derived]
424 impl ::core::cmp::PartialEq for PackedCopy {
426 fn eq(&self, other: &PackedCopy) -> bool { { self.0 } == { other.0 } }
428 #[automatically_derived]
429 impl ::core::marker::StructuralEq for PackedCopy { }
430 #[automatically_derived]
431 impl ::core::cmp::Eq for PackedCopy {
435 fn assert_receiver_is_total_eq(&self) -> () {
436 let _: ::core::cmp::AssertParamIsEq<u32>;
439 #[automatically_derived]
440 impl ::core::cmp::PartialOrd for PackedCopy {
442 fn partial_cmp(&self, other: &PackedCopy)
443 -> ::core::option::Option<::core::cmp::Ordering> {
444 ::core::cmp::PartialOrd::partial_cmp(&{ self.0 }, &{ other.0 })
447 #[automatically_derived]
448 impl ::core::cmp::Ord for PackedCopy {
450 fn cmp(&self, other: &PackedCopy) -> ::core::cmp::Ordering {
451 ::core::cmp::Ord::cmp(&{ self.0 }, &{ other.0 })
455 // A packed tuple struct that does not impl `Copy`. Note that the alignment of
456 // the field must be 1 for this code to be valid. Otherwise it triggers an
457 // error "`#[derive]` can't be used on a `#[repr(packed)]` struct that does not
458 // derive Copy (error E0133)" at MIR building time. This is a weird case and
459 // it's possible that this struct is not supposed to work, but for now it does.
461 struct PackedNonCopy(u8);
462 #[automatically_derived]
463 impl ::core::clone::Clone for PackedNonCopy {
465 fn clone(&self) -> PackedNonCopy {
466 PackedNonCopy(::core::clone::Clone::clone(&self.0))
469 #[automatically_derived]
470 impl ::core::fmt::Debug for PackedNonCopy {
471 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
472 ::core::fmt::Formatter::debug_tuple_field1_finish(f, "PackedNonCopy",
476 #[automatically_derived]
477 impl ::core::default::Default for PackedNonCopy {
479 fn default() -> PackedNonCopy {
480 PackedNonCopy(::core::default::Default::default())
483 #[automatically_derived]
484 impl ::core::hash::Hash for PackedNonCopy {
485 fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
486 ::core::hash::Hash::hash(&self.0, state)
489 #[automatically_derived]
490 impl ::core::marker::StructuralPartialEq for PackedNonCopy { }
491 #[automatically_derived]
492 impl ::core::cmp::PartialEq for PackedNonCopy {
494 fn eq(&self, other: &PackedNonCopy) -> bool { self.0 == other.0 }
496 #[automatically_derived]
497 impl ::core::marker::StructuralEq for PackedNonCopy { }
498 #[automatically_derived]
499 impl ::core::cmp::Eq for PackedNonCopy {
503 fn assert_receiver_is_total_eq(&self) -> () {
504 let _: ::core::cmp::AssertParamIsEq<u8>;
507 #[automatically_derived]
508 impl ::core::cmp::PartialOrd for PackedNonCopy {
510 fn partial_cmp(&self, other: &PackedNonCopy)
511 -> ::core::option::Option<::core::cmp::Ordering> {
512 ::core::cmp::PartialOrd::partial_cmp(&self.0, &other.0)
515 #[automatically_derived]
516 impl ::core::cmp::Ord for PackedNonCopy {
518 fn cmp(&self, other: &PackedNonCopy) -> ::core::cmp::Ordering {
519 ::core::cmp::Ord::cmp(&self.0, &other.0)
525 #[automatically_derived]
526 impl ::core::clone::Clone for Enum0 {
528 fn clone(&self) -> Enum0 { *self }
530 #[automatically_derived]
531 impl ::core::marker::Copy for Enum0 { }
532 #[automatically_derived]
533 impl ::core::fmt::Debug for Enum0 {
534 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
535 unsafe { ::core::intrinsics::unreachable() }
538 #[automatically_derived]
539 impl ::core::hash::Hash for Enum0 {
540 fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
541 unsafe { ::core::intrinsics::unreachable() }
544 #[automatically_derived]
545 impl ::core::marker::StructuralPartialEq for Enum0 { }
546 #[automatically_derived]
547 impl ::core::cmp::PartialEq for Enum0 {
549 fn eq(&self, other: &Enum0) -> bool {
550 unsafe { ::core::intrinsics::unreachable() }
553 #[automatically_derived]
554 impl ::core::marker::StructuralEq for Enum0 { }
555 #[automatically_derived]
556 impl ::core::cmp::Eq for Enum0 {
560 fn assert_receiver_is_total_eq(&self) -> () {}
562 #[automatically_derived]
563 impl ::core::cmp::PartialOrd for Enum0 {
565 fn partial_cmp(&self, other: &Enum0)
566 -> ::core::option::Option<::core::cmp::Ordering> {
567 unsafe { ::core::intrinsics::unreachable() }
570 #[automatically_derived]
571 impl ::core::cmp::Ord for Enum0 {
573 fn cmp(&self, other: &Enum0) -> ::core::cmp::Ordering {
574 unsafe { ::core::intrinsics::unreachable() }
578 // A single-variant enum.
584 #[automatically_derived]
585 impl ::core::clone::Clone for Enum1 {
587 fn clone(&self) -> Enum1 {
589 Enum1::Single { x: __self_0 } =>
590 Enum1::Single { x: ::core::clone::Clone::clone(__self_0) },
594 #[automatically_derived]
595 impl ::core::fmt::Debug for Enum1 {
596 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
598 Enum1::Single { x: __self_0 } =>
599 ::core::fmt::Formatter::debug_struct_field1_finish(f,
600 "Single", "x", &__self_0),
604 #[automatically_derived]
605 impl ::core::hash::Hash for Enum1 {
606 fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
608 Enum1::Single { x: __self_0 } =>
609 ::core::hash::Hash::hash(__self_0, state),
613 #[automatically_derived]
614 impl ::core::marker::StructuralPartialEq for Enum1 { }
615 #[automatically_derived]
616 impl ::core::cmp::PartialEq for Enum1 {
618 fn eq(&self, other: &Enum1) -> bool {
619 match (self, other) {
620 (Enum1::Single { x: __self_0 }, Enum1::Single { x: __arg1_0 }) =>
621 *__self_0 == *__arg1_0,
625 #[automatically_derived]
626 impl ::core::marker::StructuralEq for Enum1 { }
627 #[automatically_derived]
628 impl ::core::cmp::Eq for Enum1 {
632 fn assert_receiver_is_total_eq(&self) -> () {
633 let _: ::core::cmp::AssertParamIsEq<u32>;
636 #[automatically_derived]
637 impl ::core::cmp::PartialOrd for Enum1 {
639 fn partial_cmp(&self, other: &Enum1)
640 -> ::core::option::Option<::core::cmp::Ordering> {
641 match (self, other) {
642 (Enum1::Single { x: __self_0 }, Enum1::Single { x: __arg1_0 }) =>
643 ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0),
647 #[automatically_derived]
648 impl ::core::cmp::Ord for Enum1 {
650 fn cmp(&self, other: &Enum1) -> ::core::cmp::Ordering {
651 match (self, other) {
652 (Enum1::Single { x: __self_0 }, Enum1::Single { x: __arg1_0 }) =>
653 ::core::cmp::Ord::cmp(__self_0, __arg1_0),
658 // A C-like, fieldless enum with a single variant.
664 #[automatically_derived]
665 impl ::core::clone::Clone for Fieldless1 {
667 fn clone(&self) -> Fieldless1 { Fieldless1::A }
669 #[automatically_derived]
670 impl ::core::fmt::Debug for Fieldless1 {
671 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
672 ::core::fmt::Formatter::write_str(f, "A")
675 #[automatically_derived]
676 impl ::core::default::Default for Fieldless1 {
678 fn default() -> Fieldless1 { Self::A }
680 #[automatically_derived]
681 impl ::core::hash::Hash for Fieldless1 {
682 fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {}
684 #[automatically_derived]
685 impl ::core::marker::StructuralPartialEq for Fieldless1 { }
686 #[automatically_derived]
687 impl ::core::cmp::PartialEq for Fieldless1 {
689 fn eq(&self, other: &Fieldless1) -> bool { true }
691 #[automatically_derived]
692 impl ::core::marker::StructuralEq for Fieldless1 { }
693 #[automatically_derived]
694 impl ::core::cmp::Eq for Fieldless1 {
698 fn assert_receiver_is_total_eq(&self) -> () {}
700 #[automatically_derived]
701 impl ::core::cmp::PartialOrd for Fieldless1 {
703 fn partial_cmp(&self, other: &Fieldless1)
704 -> ::core::option::Option<::core::cmp::Ordering> {
705 ::core::option::Option::Some(::core::cmp::Ordering::Equal)
708 #[automatically_derived]
709 impl ::core::cmp::Ord for Fieldless1 {
711 fn cmp(&self, other: &Fieldless1) -> ::core::cmp::Ordering {
712 ::core::cmp::Ordering::Equal
716 // A C-like, fieldless enum.
724 #[automatically_derived]
725 impl ::core::clone::Clone for Fieldless {
727 fn clone(&self) -> Fieldless { *self }
729 #[automatically_derived]
730 impl ::core::marker::Copy for Fieldless { }
731 #[automatically_derived]
732 impl ::core::fmt::Debug for Fieldless {
733 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
735 Fieldless::A => ::core::fmt::Formatter::write_str(f, "A"),
736 Fieldless::B => ::core::fmt::Formatter::write_str(f, "B"),
737 Fieldless::C => ::core::fmt::Formatter::write_str(f, "C"),
741 #[automatically_derived]
742 impl ::core::default::Default for Fieldless {
744 fn default() -> Fieldless { Self::A }
746 #[automatically_derived]
747 impl ::core::hash::Hash for Fieldless {
748 fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
749 let __self_tag = ::core::intrinsics::discriminant_value(self);
750 ::core::hash::Hash::hash(&__self_tag, state)
753 #[automatically_derived]
754 impl ::core::marker::StructuralPartialEq for Fieldless { }
755 #[automatically_derived]
756 impl ::core::cmp::PartialEq for Fieldless {
758 fn eq(&self, other: &Fieldless) -> bool {
759 let __self_tag = ::core::intrinsics::discriminant_value(self);
760 let __arg1_tag = ::core::intrinsics::discriminant_value(other);
761 __self_tag == __arg1_tag
764 #[automatically_derived]
765 impl ::core::marker::StructuralEq for Fieldless { }
766 #[automatically_derived]
767 impl ::core::cmp::Eq for Fieldless {
771 fn assert_receiver_is_total_eq(&self) -> () {}
773 #[automatically_derived]
774 impl ::core::cmp::PartialOrd for Fieldless {
776 fn partial_cmp(&self, other: &Fieldless)
777 -> ::core::option::Option<::core::cmp::Ordering> {
778 let __self_tag = ::core::intrinsics::discriminant_value(self);
779 let __arg1_tag = ::core::intrinsics::discriminant_value(other);
780 ::core::cmp::PartialOrd::partial_cmp(&__self_tag, &__arg1_tag)
783 #[automatically_derived]
784 impl ::core::cmp::Ord for Fieldless {
786 fn cmp(&self, other: &Fieldless) -> ::core::cmp::Ordering {
787 let __self_tag = ::core::intrinsics::discriminant_value(self);
788 let __arg1_tag = ::core::intrinsics::discriminant_value(other);
789 ::core::cmp::Ord::cmp(&__self_tag, &__arg1_tag)
793 // An enum with multiple fieldless and fielded variants.
805 #[automatically_derived]
806 impl ::core::clone::Clone for Mixed {
808 fn clone(&self) -> Mixed {
809 let _: ::core::clone::AssertParamIsClone<u32>;
810 let _: ::core::clone::AssertParamIsClone<Option<u32>>;
811 let _: ::core::clone::AssertParamIsClone<Option<i32>>;
815 #[automatically_derived]
816 impl ::core::marker::Copy for Mixed { }
817 #[automatically_derived]
818 impl ::core::fmt::Debug for Mixed {
819 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
821 Mixed::P => ::core::fmt::Formatter::write_str(f, "P"),
822 Mixed::Q => ::core::fmt::Formatter::write_str(f, "Q"),
823 Mixed::R(__self_0) =>
824 ::core::fmt::Formatter::debug_tuple_field1_finish(f, "R",
826 Mixed::S { d1: __self_0, d2: __self_1 } =>
827 ::core::fmt::Formatter::debug_struct_field2_finish(f, "S",
828 "d1", &__self_0, "d2", &__self_1),
832 #[automatically_derived]
833 impl ::core::default::Default for Mixed {
835 fn default() -> Mixed { Self::P }
837 #[automatically_derived]
838 impl ::core::hash::Hash for Mixed {
839 fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
840 let __self_tag = ::core::intrinsics::discriminant_value(self);
841 ::core::hash::Hash::hash(&__self_tag, state);
843 Mixed::R(__self_0) => ::core::hash::Hash::hash(__self_0, state),
844 Mixed::S { d1: __self_0, d2: __self_1 } => {
845 ::core::hash::Hash::hash(__self_0, state);
846 ::core::hash::Hash::hash(__self_1, state)
852 #[automatically_derived]
853 impl ::core::marker::StructuralPartialEq for Mixed { }
854 #[automatically_derived]
855 impl ::core::cmp::PartialEq for Mixed {
857 fn eq(&self, other: &Mixed) -> bool {
858 let __self_tag = ::core::intrinsics::discriminant_value(self);
859 let __arg1_tag = ::core::intrinsics::discriminant_value(other);
860 __self_tag == __arg1_tag &&
861 match (self, other) {
862 (Mixed::R(__self_0), Mixed::R(__arg1_0)) =>
863 *__self_0 == *__arg1_0,
864 (Mixed::S { d1: __self_0, d2: __self_1 }, Mixed::S {
865 d1: __arg1_0, d2: __arg1_1 }) =>
866 *__self_0 == *__arg1_0 && *__self_1 == *__arg1_1,
871 #[automatically_derived]
872 impl ::core::marker::StructuralEq for Mixed { }
873 #[automatically_derived]
874 impl ::core::cmp::Eq for Mixed {
878 fn assert_receiver_is_total_eq(&self) -> () {
879 let _: ::core::cmp::AssertParamIsEq<u32>;
880 let _: ::core::cmp::AssertParamIsEq<Option<u32>>;
881 let _: ::core::cmp::AssertParamIsEq<Option<i32>>;
884 #[automatically_derived]
885 impl ::core::cmp::PartialOrd for Mixed {
887 fn partial_cmp(&self, other: &Mixed)
888 -> ::core::option::Option<::core::cmp::Ordering> {
889 let __self_tag = ::core::intrinsics::discriminant_value(self);
890 let __arg1_tag = ::core::intrinsics::discriminant_value(other);
891 match ::core::cmp::PartialOrd::partial_cmp(&__self_tag, &__arg1_tag) {
892 ::core::option::Option::Some(::core::cmp::Ordering::Equal) =>
893 match (self, other) {
894 (Mixed::R(__self_0), Mixed::R(__arg1_0)) =>
895 ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0),
896 (Mixed::S { d1: __self_0, d2: __self_1 }, Mixed::S {
897 d1: __arg1_0, d2: __arg1_1 }) =>
898 match ::core::cmp::PartialOrd::partial_cmp(__self_0,
900 ::core::option::Option::Some(::core::cmp::Ordering::Equal)
901 => ::core::cmp::PartialOrd::partial_cmp(__self_1, __arg1_1),
905 ::core::option::Option::Some(::core::cmp::Ordering::Equal),
911 #[automatically_derived]
912 impl ::core::cmp::Ord for Mixed {
914 fn cmp(&self, other: &Mixed) -> ::core::cmp::Ordering {
915 let __self_tag = ::core::intrinsics::discriminant_value(self);
916 let __arg1_tag = ::core::intrinsics::discriminant_value(other);
917 match ::core::cmp::Ord::cmp(&__self_tag, &__arg1_tag) {
918 ::core::cmp::Ordering::Equal =>
919 match (self, other) {
920 (Mixed::R(__self_0), Mixed::R(__arg1_0)) =>
921 ::core::cmp::Ord::cmp(__self_0, __arg1_0),
922 (Mixed::S { d1: __self_0, d2: __self_1 }, Mixed::S {
923 d1: __arg1_0, d2: __arg1_1 }) =>
924 match ::core::cmp::Ord::cmp(__self_0, __arg1_0) {
925 ::core::cmp::Ordering::Equal =>
926 ::core::cmp::Ord::cmp(__self_1, __arg1_1),
929 _ => ::core::cmp::Ordering::Equal,
936 // An enum with no fieldless variants. Note that `Default` cannot be derived
938 enum Fielded { X(u32), Y(bool), Z(Option<i32>), }
939 #[automatically_derived]
940 impl ::core::clone::Clone for Fielded {
942 fn clone(&self) -> Fielded {
944 Fielded::X(__self_0) =>
945 Fielded::X(::core::clone::Clone::clone(__self_0)),
946 Fielded::Y(__self_0) =>
947 Fielded::Y(::core::clone::Clone::clone(__self_0)),
948 Fielded::Z(__self_0) =>
949 Fielded::Z(::core::clone::Clone::clone(__self_0)),
953 #[automatically_derived]
954 impl ::core::fmt::Debug for Fielded {
955 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
957 Fielded::X(__self_0) =>
958 ::core::fmt::Formatter::debug_tuple_field1_finish(f, "X",
960 Fielded::Y(__self_0) =>
961 ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Y",
963 Fielded::Z(__self_0) =>
964 ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Z",
969 #[automatically_derived]
970 impl ::core::hash::Hash for Fielded {
971 fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
972 let __self_tag = ::core::intrinsics::discriminant_value(self);
973 ::core::hash::Hash::hash(&__self_tag, state);
975 Fielded::X(__self_0) => ::core::hash::Hash::hash(__self_0, state),
976 Fielded::Y(__self_0) => ::core::hash::Hash::hash(__self_0, state),
977 Fielded::Z(__self_0) => ::core::hash::Hash::hash(__self_0, state),
981 #[automatically_derived]
982 impl ::core::marker::StructuralPartialEq for Fielded { }
983 #[automatically_derived]
984 impl ::core::cmp::PartialEq for Fielded {
986 fn eq(&self, other: &Fielded) -> bool {
987 let __self_tag = ::core::intrinsics::discriminant_value(self);
988 let __arg1_tag = ::core::intrinsics::discriminant_value(other);
989 __self_tag == __arg1_tag &&
990 match (self, other) {
991 (Fielded::X(__self_0), Fielded::X(__arg1_0)) =>
992 *__self_0 == *__arg1_0,
993 (Fielded::Y(__self_0), Fielded::Y(__arg1_0)) =>
994 *__self_0 == *__arg1_0,
995 (Fielded::Z(__self_0), Fielded::Z(__arg1_0)) =>
996 *__self_0 == *__arg1_0,
997 _ => unsafe { ::core::intrinsics::unreachable() }
1001 #[automatically_derived]
1002 impl ::core::marker::StructuralEq for Fielded { }
1003 #[automatically_derived]
1004 impl ::core::cmp::Eq for Fielded {
1008 fn assert_receiver_is_total_eq(&self) -> () {
1009 let _: ::core::cmp::AssertParamIsEq<u32>;
1010 let _: ::core::cmp::AssertParamIsEq<bool>;
1011 let _: ::core::cmp::AssertParamIsEq<Option<i32>>;
1014 #[automatically_derived]
1015 impl ::core::cmp::PartialOrd for Fielded {
1017 fn partial_cmp(&self, other: &Fielded)
1018 -> ::core::option::Option<::core::cmp::Ordering> {
1019 let __self_tag = ::core::intrinsics::discriminant_value(self);
1020 let __arg1_tag = ::core::intrinsics::discriminant_value(other);
1021 match ::core::cmp::PartialOrd::partial_cmp(&__self_tag, &__arg1_tag) {
1022 ::core::option::Option::Some(::core::cmp::Ordering::Equal) =>
1023 match (self, other) {
1024 (Fielded::X(__self_0), Fielded::X(__arg1_0)) =>
1025 ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0),
1026 (Fielded::Y(__self_0), Fielded::Y(__arg1_0)) =>
1027 ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0),
1028 (Fielded::Z(__self_0), Fielded::Z(__arg1_0)) =>
1029 ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0),
1030 _ => unsafe { ::core::intrinsics::unreachable() }
1036 #[automatically_derived]
1037 impl ::core::cmp::Ord for Fielded {
1039 fn cmp(&self, other: &Fielded) -> ::core::cmp::Ordering {
1040 let __self_tag = ::core::intrinsics::discriminant_value(self);
1041 let __arg1_tag = ::core::intrinsics::discriminant_value(other);
1042 match ::core::cmp::Ord::cmp(&__self_tag, &__arg1_tag) {
1043 ::core::cmp::Ordering::Equal =>
1044 match (self, other) {
1045 (Fielded::X(__self_0), Fielded::X(__arg1_0)) =>
1046 ::core::cmp::Ord::cmp(__self_0, __arg1_0),
1047 (Fielded::Y(__self_0), Fielded::Y(__arg1_0)) =>
1048 ::core::cmp::Ord::cmp(__self_0, __arg1_0),
1049 (Fielded::Z(__self_0), Fielded::Z(__arg1_0)) =>
1050 ::core::cmp::Ord::cmp(__self_0, __arg1_0),
1051 _ => unsafe { ::core::intrinsics::unreachable() }
1058 // A union. Most builtin traits are not derivable for unions.
1064 #[automatically_derived]
1065 impl ::core::clone::Clone for Union {
1067 fn clone(&self) -> Union {
1068 let _: ::core::clone::AssertParamIsCopy<Self>;
1072 #[automatically_derived]
1073 impl ::core::marker::Copy for Union { }