facet_trait/impls/tuples_impls.rs
1//! GENERATED: DO NOT EDIT — this file is generated from `tuples_impls.rs.j2`
2//! file in the `facet-codegen` crate.
3
4use std::{alloc::Layout, fmt};
5
6use crate::{
7 Characteristic, Def, Facet, Field, FieldFlags, MarkerTraits, OpaqueConst, Shape, StructDef,
8 StructKind, TypeNameOpts, ValueVTable,
9};
10
11#[inline(always)]
12pub fn write_type_name_list(
13 f: &mut fmt::Formatter<'_>,
14 opts: TypeNameOpts,
15 open: &'static str,
16 delimiter: &'static str,
17 close: &'static str,
18 shapes: &'static [&'static Shape],
19) -> fmt::Result {
20 f.pad(open)?;
21 if let Some(opts) = opts.for_children() {
22 for (index, shape) in shapes.iter().enumerate() {
23 if index > 0 {
24 f.pad(delimiter)?;
25 }
26 shape.write_type_name(f, opts)?;
27 }
28 } else {
29 write!(f, "⋯")?;
30 }
31 f.pad(close)?;
32 Ok(())
33}
34
35macro_rules! field {
36 ($idx:tt, $ty:ty,) => {
37 Field {
38 name: stringify!($idx),
39 shape: $crate::shape_of(&|t: $ty| t.$idx),
40 offset: std::mem::offset_of!($ty, $idx),
41 flags: FieldFlags::EMPTY,
42 }
43 };
44}
45
46unsafe impl<T0> Facet for (T0,)
47where
48 T0: Facet,
49{
50 const DUMMY: Self = (T0::DUMMY,);
51 const SHAPE: &'static Shape = &const {
52 fn type_name<T0>(f: &mut fmt::Formatter, opts: TypeNameOpts) -> fmt::Result
53 where
54 T0: Facet,
55 {
56 write_type_name_list(f, opts, "(", ", ", ")", &[T0::SHAPE])
57 }
58
59 Shape {
60 layout: Layout::new::<(T0,)>(),
61 vtable: &ValueVTable {
62 type_name: type_name::<T0>,
63 display: None,
64 debug: const {
65 if Characteristic::Eq.all(&[T0::SHAPE]) {
66 Some(|value, f| {
67 let value = unsafe { value.as_ref::<(T0,)>() };
68 write!(f, "(")?;
69 unsafe {
70 (T0::SHAPE.vtable.debug.unwrap_unchecked())(
71 OpaqueConst::from_ref(&value.0),
72 f,
73 )
74 }?;
75 write!(f, ")")
76 })
77 } else {
78 None
79 }
80 },
81 default_in_place: None,
82 clone_into: None,
83 marker_traits: MarkerTraits::empty(),
84 eq: if Characteristic::Eq.all(&[T0::SHAPE]) {
85 Some(|a, b| {
86 let a = unsafe { a.as_ref::<(T0,)>() };
87 let b = unsafe { b.as_ref::<(T0,)>() };
88
89 // Compare last element
90 unsafe {
91 (T0::SHAPE.vtable.eq.unwrap_unchecked())(
92 OpaqueConst::from_ref(&a.0),
93 OpaqueConst::from_ref(&b.0),
94 )
95 }
96 })
97 } else {
98 None
99 },
100 partial_ord: None,
101 ord: None,
102 hash: None,
103 drop_in_place: None,
104 parse: None,
105 try_from: None,
106 },
107 def: Def::Struct(StructDef {
108 kind: StructKind::Tuple,
109 fields: &const { [field!(0, (T0,),)] },
110 }),
111 }
112 };
113}
114unsafe impl<T0, T1> Facet for (T0, T1)
115where
116 T0: Facet,
117 T1: Facet,
118{
119 const DUMMY: Self = (T0::DUMMY, T1::DUMMY);
120 const SHAPE: &'static Shape = &const {
121 fn type_name<T0, T1>(f: &mut fmt::Formatter, opts: TypeNameOpts) -> fmt::Result
122 where
123 T0: Facet,
124 T1: Facet,
125 {
126 write_type_name_list(f, opts, "(", ", ", ")", &[T0::SHAPE, T1::SHAPE])
127 }
128
129 Shape {
130 layout: Layout::new::<(T0, T1)>(),
131 vtable: &ValueVTable {
132 type_name: type_name::<T0, T1>,
133 display: None,
134 debug: const {
135 if Characteristic::Eq.all(&[T0::SHAPE, T1::SHAPE]) {
136 Some(|value, f| {
137 let value = unsafe { value.as_ref::<(T0, T1)>() };
138 write!(f, "(")?;
139 unsafe {
140 (T0::SHAPE.vtable.debug.unwrap_unchecked())(
141 OpaqueConst::from_ref(&value.0),
142 f,
143 )
144 }?;
145 write!(f, ", ")?;
146 unsafe {
147 (T1::SHAPE.vtable.debug.unwrap_unchecked())(
148 OpaqueConst::from_ref(&value.1),
149 f,
150 )
151 }?;
152 write!(f, ")")
153 })
154 } else {
155 None
156 }
157 },
158 default_in_place: None,
159 clone_into: None,
160 marker_traits: MarkerTraits::empty(),
161 eq: if Characteristic::Eq.all(&[T0::SHAPE, T1::SHAPE]) {
162 Some(|a, b| {
163 let a = unsafe { a.as_ref::<(T0, T1)>() };
164 let b = unsafe { b.as_ref::<(T0, T1)>() };
165
166 // Compare element 0
167 if !unsafe {
168 (T0::SHAPE.vtable.eq.unwrap_unchecked())(
169 OpaqueConst::from_ref(&a.0),
170 OpaqueConst::from_ref(&b.0),
171 )
172 } {
173 return false;
174 }
175
176 // Compare last element
177 unsafe {
178 (T1::SHAPE.vtable.eq.unwrap_unchecked())(
179 OpaqueConst::from_ref(&a.1),
180 OpaqueConst::from_ref(&b.1),
181 )
182 }
183 })
184 } else {
185 None
186 },
187 partial_ord: None,
188 ord: None,
189 hash: None,
190 drop_in_place: None,
191 parse: None,
192 try_from: None,
193 },
194 def: Def::Struct(StructDef {
195 kind: StructKind::Tuple,
196 fields: &const { [field!(0, (T0, T1,),), field!(1, (T0, T1,),)] },
197 }),
198 }
199 };
200}
201unsafe impl<T0, T1, T2> Facet for (T0, T1, T2)
202where
203 T0: Facet,
204 T1: Facet,
205 T2: Facet,
206{
207 const DUMMY: Self = (T0::DUMMY, T1::DUMMY, T2::DUMMY);
208 const SHAPE: &'static Shape = &const {
209 fn type_name<T0, T1, T2>(f: &mut fmt::Formatter, opts: TypeNameOpts) -> fmt::Result
210 where
211 T0: Facet,
212 T1: Facet,
213 T2: Facet,
214 {
215 write_type_name_list(f, opts, "(", ", ", ")", &[T0::SHAPE, T1::SHAPE, T2::SHAPE])
216 }
217
218 Shape {
219 layout: Layout::new::<(T0, T1, T2)>(),
220 vtable: &ValueVTable {
221 type_name: type_name::<T0, T1, T2>,
222 display: None,
223 debug: const {
224 if Characteristic::Eq.all(&[T0::SHAPE, T1::SHAPE, T2::SHAPE]) {
225 Some(|value, f| {
226 let value = unsafe { value.as_ref::<(T0, T1, T2)>() };
227 write!(f, "(")?;
228 unsafe {
229 (T0::SHAPE.vtable.debug.unwrap_unchecked())(
230 OpaqueConst::from_ref(&value.0),
231 f,
232 )
233 }?;
234 write!(f, ", ")?;
235 unsafe {
236 (T1::SHAPE.vtable.debug.unwrap_unchecked())(
237 OpaqueConst::from_ref(&value.1),
238 f,
239 )
240 }?;
241 write!(f, ", ")?;
242 unsafe {
243 (T2::SHAPE.vtable.debug.unwrap_unchecked())(
244 OpaqueConst::from_ref(&value.2),
245 f,
246 )
247 }?;
248 write!(f, ")")
249 })
250 } else {
251 None
252 }
253 },
254 default_in_place: None,
255 clone_into: None,
256 marker_traits: MarkerTraits::empty(),
257 eq: if Characteristic::Eq.all(&[T0::SHAPE, T1::SHAPE, T2::SHAPE]) {
258 Some(|a, b| {
259 let a = unsafe { a.as_ref::<(T0, T1, T2)>() };
260 let b = unsafe { b.as_ref::<(T0, T1, T2)>() };
261
262 // Compare element 0
263 if !unsafe {
264 (T0::SHAPE.vtable.eq.unwrap_unchecked())(
265 OpaqueConst::from_ref(&a.0),
266 OpaqueConst::from_ref(&b.0),
267 )
268 } {
269 return false;
270 }
271
272 // Compare element 1
273 if !unsafe {
274 (T1::SHAPE.vtable.eq.unwrap_unchecked())(
275 OpaqueConst::from_ref(&a.1),
276 OpaqueConst::from_ref(&b.1),
277 )
278 } {
279 return false;
280 }
281
282 // Compare last element
283 unsafe {
284 (T2::SHAPE.vtable.eq.unwrap_unchecked())(
285 OpaqueConst::from_ref(&a.2),
286 OpaqueConst::from_ref(&b.2),
287 )
288 }
289 })
290 } else {
291 None
292 },
293 partial_ord: None,
294 ord: None,
295 hash: None,
296 drop_in_place: None,
297 parse: None,
298 try_from: None,
299 },
300 def: Def::Struct(StructDef {
301 kind: StructKind::Tuple,
302 fields: &const {
303 [
304 field!(0, (T0, T1, T2,),),
305 field!(1, (T0, T1, T2,),),
306 field!(2, (T0, T1, T2,),),
307 ]
308 },
309 }),
310 }
311 };
312}
313unsafe impl<T0, T1, T2, T3> Facet for (T0, T1, T2, T3)
314where
315 T0: Facet,
316 T1: Facet,
317 T2: Facet,
318 T3: Facet,
319{
320 const DUMMY: Self = (T0::DUMMY, T1::DUMMY, T2::DUMMY, T3::DUMMY);
321 const SHAPE: &'static Shape = &const {
322 fn type_name<T0, T1, T2, T3>(f: &mut fmt::Formatter, opts: TypeNameOpts) -> fmt::Result
323 where
324 T0: Facet,
325 T1: Facet,
326 T2: Facet,
327 T3: Facet,
328 {
329 write_type_name_list(
330 f,
331 opts,
332 "(",
333 ", ",
334 ")",
335 &[T0::SHAPE, T1::SHAPE, T2::SHAPE, T3::SHAPE],
336 )
337 }
338
339 Shape {
340 layout: Layout::new::<(T0, T1, T2, T3)>(),
341 vtable: &ValueVTable {
342 type_name: type_name::<T0, T1, T2, T3>,
343 display: None,
344 debug: const {
345 if Characteristic::Eq.all(&[T0::SHAPE, T1::SHAPE, T2::SHAPE, T3::SHAPE]) {
346 Some(|value, f| {
347 let value = unsafe { value.as_ref::<(T0, T1, T2, T3)>() };
348 write!(f, "(")?;
349 unsafe {
350 (T0::SHAPE.vtable.debug.unwrap_unchecked())(
351 OpaqueConst::from_ref(&value.0),
352 f,
353 )
354 }?;
355 write!(f, ", ")?;
356 unsafe {
357 (T1::SHAPE.vtable.debug.unwrap_unchecked())(
358 OpaqueConst::from_ref(&value.1),
359 f,
360 )
361 }?;
362 write!(f, ", ")?;
363 unsafe {
364 (T2::SHAPE.vtable.debug.unwrap_unchecked())(
365 OpaqueConst::from_ref(&value.2),
366 f,
367 )
368 }?;
369 write!(f, ", ")?;
370 unsafe {
371 (T3::SHAPE.vtable.debug.unwrap_unchecked())(
372 OpaqueConst::from_ref(&value.3),
373 f,
374 )
375 }?;
376 write!(f, ")")
377 })
378 } else {
379 None
380 }
381 },
382 default_in_place: None,
383 clone_into: None,
384 marker_traits: MarkerTraits::empty(),
385 eq: if Characteristic::Eq.all(&[T0::SHAPE, T1::SHAPE, T2::SHAPE, T3::SHAPE]) {
386 Some(|a, b| {
387 let a = unsafe { a.as_ref::<(T0, T1, T2, T3)>() };
388 let b = unsafe { b.as_ref::<(T0, T1, T2, T3)>() };
389
390 // Compare element 0
391 if !unsafe {
392 (T0::SHAPE.vtable.eq.unwrap_unchecked())(
393 OpaqueConst::from_ref(&a.0),
394 OpaqueConst::from_ref(&b.0),
395 )
396 } {
397 return false;
398 }
399
400 // Compare element 1
401 if !unsafe {
402 (T1::SHAPE.vtable.eq.unwrap_unchecked())(
403 OpaqueConst::from_ref(&a.1),
404 OpaqueConst::from_ref(&b.1),
405 )
406 } {
407 return false;
408 }
409
410 // Compare element 2
411 if !unsafe {
412 (T2::SHAPE.vtable.eq.unwrap_unchecked())(
413 OpaqueConst::from_ref(&a.2),
414 OpaqueConst::from_ref(&b.2),
415 )
416 } {
417 return false;
418 }
419
420 // Compare last element
421 unsafe {
422 (T3::SHAPE.vtable.eq.unwrap_unchecked())(
423 OpaqueConst::from_ref(&a.3),
424 OpaqueConst::from_ref(&b.3),
425 )
426 }
427 })
428 } else {
429 None
430 },
431 partial_ord: None,
432 ord: None,
433 hash: None,
434 drop_in_place: None,
435 parse: None,
436 try_from: None,
437 },
438 def: Def::Struct(StructDef {
439 kind: StructKind::Tuple,
440 fields: &const {
441 [
442 field!(0, (T0, T1, T2, T3,),),
443 field!(1, (T0, T1, T2, T3,),),
444 field!(2, (T0, T1, T2, T3,),),
445 field!(3, (T0, T1, T2, T3,),),
446 ]
447 },
448 }),
449 }
450 };
451}
452unsafe impl<T0, T1, T2, T3, T4> Facet for (T0, T1, T2, T3, T4)
453where
454 T0: Facet,
455 T1: Facet,
456 T2: Facet,
457 T3: Facet,
458 T4: Facet,
459{
460 const DUMMY: Self = (T0::DUMMY, T1::DUMMY, T2::DUMMY, T3::DUMMY, T4::DUMMY);
461 const SHAPE: &'static Shape = &const {
462 fn type_name<T0, T1, T2, T3, T4>(f: &mut fmt::Formatter, opts: TypeNameOpts) -> fmt::Result
463 where
464 T0: Facet,
465 T1: Facet,
466 T2: Facet,
467 T3: Facet,
468 T4: Facet,
469 {
470 write_type_name_list(
471 f,
472 opts,
473 "(",
474 ", ",
475 ")",
476 &[T0::SHAPE, T1::SHAPE, T2::SHAPE, T3::SHAPE, T4::SHAPE],
477 )
478 }
479
480 Shape {
481 layout: Layout::new::<(T0, T1, T2, T3, T4)>(),
482 vtable: &ValueVTable {
483 type_name: type_name::<T0, T1, T2, T3, T4>,
484 display: None,
485 debug: const {
486 if Characteristic::Eq.all(&[
487 T0::SHAPE,
488 T1::SHAPE,
489 T2::SHAPE,
490 T3::SHAPE,
491 T4::SHAPE,
492 ]) {
493 Some(|value, f| {
494 let value = unsafe { value.as_ref::<(T0, T1, T2, T3, T4)>() };
495 write!(f, "(")?;
496 unsafe {
497 (T0::SHAPE.vtable.debug.unwrap_unchecked())(
498 OpaqueConst::from_ref(&value.0),
499 f,
500 )
501 }?;
502 write!(f, ", ")?;
503 unsafe {
504 (T1::SHAPE.vtable.debug.unwrap_unchecked())(
505 OpaqueConst::from_ref(&value.1),
506 f,
507 )
508 }?;
509 write!(f, ", ")?;
510 unsafe {
511 (T2::SHAPE.vtable.debug.unwrap_unchecked())(
512 OpaqueConst::from_ref(&value.2),
513 f,
514 )
515 }?;
516 write!(f, ", ")?;
517 unsafe {
518 (T3::SHAPE.vtable.debug.unwrap_unchecked())(
519 OpaqueConst::from_ref(&value.3),
520 f,
521 )
522 }?;
523 write!(f, ", ")?;
524 unsafe {
525 (T4::SHAPE.vtable.debug.unwrap_unchecked())(
526 OpaqueConst::from_ref(&value.4),
527 f,
528 )
529 }?;
530 write!(f, ")")
531 })
532 } else {
533 None
534 }
535 },
536 default_in_place: None,
537 clone_into: None,
538 marker_traits: MarkerTraits::empty(),
539 eq: if Characteristic::Eq.all(&[
540 T0::SHAPE,
541 T1::SHAPE,
542 T2::SHAPE,
543 T3::SHAPE,
544 T4::SHAPE,
545 ]) {
546 Some(|a, b| {
547 let a = unsafe { a.as_ref::<(T0, T1, T2, T3, T4)>() };
548 let b = unsafe { b.as_ref::<(T0, T1, T2, T3, T4)>() };
549
550 // Compare element 0
551 if !unsafe {
552 (T0::SHAPE.vtable.eq.unwrap_unchecked())(
553 OpaqueConst::from_ref(&a.0),
554 OpaqueConst::from_ref(&b.0),
555 )
556 } {
557 return false;
558 }
559
560 // Compare element 1
561 if !unsafe {
562 (T1::SHAPE.vtable.eq.unwrap_unchecked())(
563 OpaqueConst::from_ref(&a.1),
564 OpaqueConst::from_ref(&b.1),
565 )
566 } {
567 return false;
568 }
569
570 // Compare element 2
571 if !unsafe {
572 (T2::SHAPE.vtable.eq.unwrap_unchecked())(
573 OpaqueConst::from_ref(&a.2),
574 OpaqueConst::from_ref(&b.2),
575 )
576 } {
577 return false;
578 }
579
580 // Compare element 3
581 if !unsafe {
582 (T3::SHAPE.vtable.eq.unwrap_unchecked())(
583 OpaqueConst::from_ref(&a.3),
584 OpaqueConst::from_ref(&b.3),
585 )
586 } {
587 return false;
588 }
589
590 // Compare last element
591 unsafe {
592 (T4::SHAPE.vtable.eq.unwrap_unchecked())(
593 OpaqueConst::from_ref(&a.4),
594 OpaqueConst::from_ref(&b.4),
595 )
596 }
597 })
598 } else {
599 None
600 },
601 partial_ord: None,
602 ord: None,
603 hash: None,
604 drop_in_place: None,
605 parse: None,
606 try_from: None,
607 },
608 def: Def::Struct(StructDef {
609 kind: StructKind::Tuple,
610 fields: &const {
611 [
612 field!(0, (T0, T1, T2, T3, T4,),),
613 field!(1, (T0, T1, T2, T3, T4,),),
614 field!(2, (T0, T1, T2, T3, T4,),),
615 field!(3, (T0, T1, T2, T3, T4,),),
616 field!(4, (T0, T1, T2, T3, T4,),),
617 ]
618 },
619 }),
620 }
621 };
622}
623unsafe impl<T0, T1, T2, T3, T4, T5> Facet for (T0, T1, T2, T3, T4, T5)
624where
625 T0: Facet,
626 T1: Facet,
627 T2: Facet,
628 T3: Facet,
629 T4: Facet,
630 T5: Facet,
631{
632 const DUMMY: Self = (
633 T0::DUMMY,
634 T1::DUMMY,
635 T2::DUMMY,
636 T3::DUMMY,
637 T4::DUMMY,
638 T5::DUMMY,
639 );
640 const SHAPE: &'static Shape = &const {
641 fn type_name<T0, T1, T2, T3, T4, T5>(
642 f: &mut fmt::Formatter,
643 opts: TypeNameOpts,
644 ) -> fmt::Result
645 where
646 T0: Facet,
647 T1: Facet,
648 T2: Facet,
649 T3: Facet,
650 T4: Facet,
651 T5: Facet,
652 {
653 write_type_name_list(
654 f,
655 opts,
656 "(",
657 ", ",
658 ")",
659 &[
660 T0::SHAPE,
661 T1::SHAPE,
662 T2::SHAPE,
663 T3::SHAPE,
664 T4::SHAPE,
665 T5::SHAPE,
666 ],
667 )
668 }
669
670 Shape {
671 layout: Layout::new::<(T0, T1, T2, T3, T4, T5)>(),
672 vtable: &ValueVTable {
673 type_name: type_name::<T0, T1, T2, T3, T4, T5>,
674 display: None,
675 debug: const {
676 if Characteristic::Eq.all(&[
677 T0::SHAPE,
678 T1::SHAPE,
679 T2::SHAPE,
680 T3::SHAPE,
681 T4::SHAPE,
682 T5::SHAPE,
683 ]) {
684 Some(|value, f| {
685 let value = unsafe { value.as_ref::<(T0, T1, T2, T3, T4, T5)>() };
686 write!(f, "(")?;
687 unsafe {
688 (T0::SHAPE.vtable.debug.unwrap_unchecked())(
689 OpaqueConst::from_ref(&value.0),
690 f,
691 )
692 }?;
693 write!(f, ", ")?;
694 unsafe {
695 (T1::SHAPE.vtable.debug.unwrap_unchecked())(
696 OpaqueConst::from_ref(&value.1),
697 f,
698 )
699 }?;
700 write!(f, ", ")?;
701 unsafe {
702 (T2::SHAPE.vtable.debug.unwrap_unchecked())(
703 OpaqueConst::from_ref(&value.2),
704 f,
705 )
706 }?;
707 write!(f, ", ")?;
708 unsafe {
709 (T3::SHAPE.vtable.debug.unwrap_unchecked())(
710 OpaqueConst::from_ref(&value.3),
711 f,
712 )
713 }?;
714 write!(f, ", ")?;
715 unsafe {
716 (T4::SHAPE.vtable.debug.unwrap_unchecked())(
717 OpaqueConst::from_ref(&value.4),
718 f,
719 )
720 }?;
721 write!(f, ", ")?;
722 unsafe {
723 (T5::SHAPE.vtable.debug.unwrap_unchecked())(
724 OpaqueConst::from_ref(&value.5),
725 f,
726 )
727 }?;
728 write!(f, ")")
729 })
730 } else {
731 None
732 }
733 },
734 default_in_place: None,
735 clone_into: None,
736 marker_traits: MarkerTraits::empty(),
737 eq: if Characteristic::Eq.all(&[
738 T0::SHAPE,
739 T1::SHAPE,
740 T2::SHAPE,
741 T3::SHAPE,
742 T4::SHAPE,
743 T5::SHAPE,
744 ]) {
745 Some(|a, b| {
746 let a = unsafe { a.as_ref::<(T0, T1, T2, T3, T4, T5)>() };
747 let b = unsafe { b.as_ref::<(T0, T1, T2, T3, T4, T5)>() };
748
749 // Compare element 0
750 if !unsafe {
751 (T0::SHAPE.vtable.eq.unwrap_unchecked())(
752 OpaqueConst::from_ref(&a.0),
753 OpaqueConst::from_ref(&b.0),
754 )
755 } {
756 return false;
757 }
758
759 // Compare element 1
760 if !unsafe {
761 (T1::SHAPE.vtable.eq.unwrap_unchecked())(
762 OpaqueConst::from_ref(&a.1),
763 OpaqueConst::from_ref(&b.1),
764 )
765 } {
766 return false;
767 }
768
769 // Compare element 2
770 if !unsafe {
771 (T2::SHAPE.vtable.eq.unwrap_unchecked())(
772 OpaqueConst::from_ref(&a.2),
773 OpaqueConst::from_ref(&b.2),
774 )
775 } {
776 return false;
777 }
778
779 // Compare element 3
780 if !unsafe {
781 (T3::SHAPE.vtable.eq.unwrap_unchecked())(
782 OpaqueConst::from_ref(&a.3),
783 OpaqueConst::from_ref(&b.3),
784 )
785 } {
786 return false;
787 }
788
789 // Compare element 4
790 if !unsafe {
791 (T4::SHAPE.vtable.eq.unwrap_unchecked())(
792 OpaqueConst::from_ref(&a.4),
793 OpaqueConst::from_ref(&b.4),
794 )
795 } {
796 return false;
797 }
798
799 // Compare last element
800 unsafe {
801 (T5::SHAPE.vtable.eq.unwrap_unchecked())(
802 OpaqueConst::from_ref(&a.5),
803 OpaqueConst::from_ref(&b.5),
804 )
805 }
806 })
807 } else {
808 None
809 },
810 partial_ord: None,
811 ord: None,
812 hash: None,
813 drop_in_place: None,
814 parse: None,
815 try_from: None,
816 },
817 def: Def::Struct(StructDef {
818 kind: StructKind::Tuple,
819 fields: &const {
820 [
821 field!(0, (T0, T1, T2, T3, T4, T5,),),
822 field!(1, (T0, T1, T2, T3, T4, T5,),),
823 field!(2, (T0, T1, T2, T3, T4, T5,),),
824 field!(3, (T0, T1, T2, T3, T4, T5,),),
825 field!(4, (T0, T1, T2, T3, T4, T5,),),
826 field!(5, (T0, T1, T2, T3, T4, T5,),),
827 ]
828 },
829 }),
830 }
831 };
832}
833unsafe impl<T0, T1, T2, T3, T4, T5, T6> Facet for (T0, T1, T2, T3, T4, T5, T6)
834where
835 T0: Facet,
836 T1: Facet,
837 T2: Facet,
838 T3: Facet,
839 T4: Facet,
840 T5: Facet,
841 T6: Facet,
842{
843 const DUMMY: Self = (
844 T0::DUMMY,
845 T1::DUMMY,
846 T2::DUMMY,
847 T3::DUMMY,
848 T4::DUMMY,
849 T5::DUMMY,
850 T6::DUMMY,
851 );
852 const SHAPE: &'static Shape = &const {
853 fn type_name<T0, T1, T2, T3, T4, T5, T6>(
854 f: &mut fmt::Formatter,
855 opts: TypeNameOpts,
856 ) -> fmt::Result
857 where
858 T0: Facet,
859 T1: Facet,
860 T2: Facet,
861 T3: Facet,
862 T4: Facet,
863 T5: Facet,
864 T6: Facet,
865 {
866 write_type_name_list(
867 f,
868 opts,
869 "(",
870 ", ",
871 ")",
872 &[
873 T0::SHAPE,
874 T1::SHAPE,
875 T2::SHAPE,
876 T3::SHAPE,
877 T4::SHAPE,
878 T5::SHAPE,
879 T6::SHAPE,
880 ],
881 )
882 }
883
884 Shape {
885 layout: Layout::new::<(T0, T1, T2, T3, T4, T5, T6)>(),
886 vtable: &ValueVTable {
887 type_name: type_name::<T0, T1, T2, T3, T4, T5, T6>,
888 display: None,
889 debug: const {
890 if Characteristic::Eq.all(&[
891 T0::SHAPE,
892 T1::SHAPE,
893 T2::SHAPE,
894 T3::SHAPE,
895 T4::SHAPE,
896 T5::SHAPE,
897 T6::SHAPE,
898 ]) {
899 Some(|value, f| {
900 let value = unsafe { value.as_ref::<(T0, T1, T2, T3, T4, T5, T6)>() };
901 write!(f, "(")?;
902 unsafe {
903 (T0::SHAPE.vtable.debug.unwrap_unchecked())(
904 OpaqueConst::from_ref(&value.0),
905 f,
906 )
907 }?;
908 write!(f, ", ")?;
909 unsafe {
910 (T1::SHAPE.vtable.debug.unwrap_unchecked())(
911 OpaqueConst::from_ref(&value.1),
912 f,
913 )
914 }?;
915 write!(f, ", ")?;
916 unsafe {
917 (T2::SHAPE.vtable.debug.unwrap_unchecked())(
918 OpaqueConst::from_ref(&value.2),
919 f,
920 )
921 }?;
922 write!(f, ", ")?;
923 unsafe {
924 (T3::SHAPE.vtable.debug.unwrap_unchecked())(
925 OpaqueConst::from_ref(&value.3),
926 f,
927 )
928 }?;
929 write!(f, ", ")?;
930 unsafe {
931 (T4::SHAPE.vtable.debug.unwrap_unchecked())(
932 OpaqueConst::from_ref(&value.4),
933 f,
934 )
935 }?;
936 write!(f, ", ")?;
937 unsafe {
938 (T5::SHAPE.vtable.debug.unwrap_unchecked())(
939 OpaqueConst::from_ref(&value.5),
940 f,
941 )
942 }?;
943 write!(f, ", ")?;
944 unsafe {
945 (T6::SHAPE.vtable.debug.unwrap_unchecked())(
946 OpaqueConst::from_ref(&value.6),
947 f,
948 )
949 }?;
950 write!(f, ")")
951 })
952 } else {
953 None
954 }
955 },
956 default_in_place: None,
957 clone_into: None,
958 marker_traits: MarkerTraits::empty(),
959 eq: if Characteristic::Eq.all(&[
960 T0::SHAPE,
961 T1::SHAPE,
962 T2::SHAPE,
963 T3::SHAPE,
964 T4::SHAPE,
965 T5::SHAPE,
966 T6::SHAPE,
967 ]) {
968 Some(|a, b| {
969 let a = unsafe { a.as_ref::<(T0, T1, T2, T3, T4, T5, T6)>() };
970 let b = unsafe { b.as_ref::<(T0, T1, T2, T3, T4, T5, T6)>() };
971
972 // Compare element 0
973 if !unsafe {
974 (T0::SHAPE.vtable.eq.unwrap_unchecked())(
975 OpaqueConst::from_ref(&a.0),
976 OpaqueConst::from_ref(&b.0),
977 )
978 } {
979 return false;
980 }
981
982 // Compare element 1
983 if !unsafe {
984 (T1::SHAPE.vtable.eq.unwrap_unchecked())(
985 OpaqueConst::from_ref(&a.1),
986 OpaqueConst::from_ref(&b.1),
987 )
988 } {
989 return false;
990 }
991
992 // Compare element 2
993 if !unsafe {
994 (T2::SHAPE.vtable.eq.unwrap_unchecked())(
995 OpaqueConst::from_ref(&a.2),
996 OpaqueConst::from_ref(&b.2),
997 )
998 } {
999 return false;
1000 }
1001
1002 // Compare element 3
1003 if !unsafe {
1004 (T3::SHAPE.vtable.eq.unwrap_unchecked())(
1005 OpaqueConst::from_ref(&a.3),
1006 OpaqueConst::from_ref(&b.3),
1007 )
1008 } {
1009 return false;
1010 }
1011
1012 // Compare element 4
1013 if !unsafe {
1014 (T4::SHAPE.vtable.eq.unwrap_unchecked())(
1015 OpaqueConst::from_ref(&a.4),
1016 OpaqueConst::from_ref(&b.4),
1017 )
1018 } {
1019 return false;
1020 }
1021
1022 // Compare element 5
1023 if !unsafe {
1024 (T5::SHAPE.vtable.eq.unwrap_unchecked())(
1025 OpaqueConst::from_ref(&a.5),
1026 OpaqueConst::from_ref(&b.5),
1027 )
1028 } {
1029 return false;
1030 }
1031
1032 // Compare last element
1033 unsafe {
1034 (T6::SHAPE.vtable.eq.unwrap_unchecked())(
1035 OpaqueConst::from_ref(&a.6),
1036 OpaqueConst::from_ref(&b.6),
1037 )
1038 }
1039 })
1040 } else {
1041 None
1042 },
1043 partial_ord: None,
1044 ord: None,
1045 hash: None,
1046 drop_in_place: None,
1047 parse: None,
1048 try_from: None,
1049 },
1050 def: Def::Struct(StructDef {
1051 kind: StructKind::Tuple,
1052 fields: &const {
1053 [
1054 field!(0, (T0, T1, T2, T3, T4, T5, T6,),),
1055 field!(1, (T0, T1, T2, T3, T4, T5, T6,),),
1056 field!(2, (T0, T1, T2, T3, T4, T5, T6,),),
1057 field!(3, (T0, T1, T2, T3, T4, T5, T6,),),
1058 field!(4, (T0, T1, T2, T3, T4, T5, T6,),),
1059 field!(5, (T0, T1, T2, T3, T4, T5, T6,),),
1060 field!(6, (T0, T1, T2, T3, T4, T5, T6,),),
1061 ]
1062 },
1063 }),
1064 }
1065 };
1066}
1067unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Facet for (T0, T1, T2, T3, T4, T5, T6, T7)
1068where
1069 T0: Facet,
1070 T1: Facet,
1071 T2: Facet,
1072 T3: Facet,
1073 T4: Facet,
1074 T5: Facet,
1075 T6: Facet,
1076 T7: Facet,
1077{
1078 const DUMMY: Self = (
1079 T0::DUMMY,
1080 T1::DUMMY,
1081 T2::DUMMY,
1082 T3::DUMMY,
1083 T4::DUMMY,
1084 T5::DUMMY,
1085 T6::DUMMY,
1086 T7::DUMMY,
1087 );
1088 const SHAPE: &'static Shape = &const {
1089 fn type_name<T0, T1, T2, T3, T4, T5, T6, T7>(
1090 f: &mut fmt::Formatter,
1091 opts: TypeNameOpts,
1092 ) -> fmt::Result
1093 where
1094 T0: Facet,
1095 T1: Facet,
1096 T2: Facet,
1097 T3: Facet,
1098 T4: Facet,
1099 T5: Facet,
1100 T6: Facet,
1101 T7: Facet,
1102 {
1103 write_type_name_list(
1104 f,
1105 opts,
1106 "(",
1107 ", ",
1108 ")",
1109 &[
1110 T0::SHAPE,
1111 T1::SHAPE,
1112 T2::SHAPE,
1113 T3::SHAPE,
1114 T4::SHAPE,
1115 T5::SHAPE,
1116 T6::SHAPE,
1117 T7::SHAPE,
1118 ],
1119 )
1120 }
1121
1122 Shape {
1123 layout: Layout::new::<(T0, T1, T2, T3, T4, T5, T6, T7)>(),
1124 vtable: &ValueVTable {
1125 type_name: type_name::<T0, T1, T2, T3, T4, T5, T6, T7>,
1126 display: None,
1127 debug: const {
1128 if Characteristic::Eq.all(&[
1129 T0::SHAPE,
1130 T1::SHAPE,
1131 T2::SHAPE,
1132 T3::SHAPE,
1133 T4::SHAPE,
1134 T5::SHAPE,
1135 T6::SHAPE,
1136 T7::SHAPE,
1137 ]) {
1138 Some(|value, f| {
1139 let value =
1140 unsafe { value.as_ref::<(T0, T1, T2, T3, T4, T5, T6, T7)>() };
1141 write!(f, "(")?;
1142 unsafe {
1143 (T0::SHAPE.vtable.debug.unwrap_unchecked())(
1144 OpaqueConst::from_ref(&value.0),
1145 f,
1146 )
1147 }?;
1148 write!(f, ", ")?;
1149 unsafe {
1150 (T1::SHAPE.vtable.debug.unwrap_unchecked())(
1151 OpaqueConst::from_ref(&value.1),
1152 f,
1153 )
1154 }?;
1155 write!(f, ", ")?;
1156 unsafe {
1157 (T2::SHAPE.vtable.debug.unwrap_unchecked())(
1158 OpaqueConst::from_ref(&value.2),
1159 f,
1160 )
1161 }?;
1162 write!(f, ", ")?;
1163 unsafe {
1164 (T3::SHAPE.vtable.debug.unwrap_unchecked())(
1165 OpaqueConst::from_ref(&value.3),
1166 f,
1167 )
1168 }?;
1169 write!(f, ", ")?;
1170 unsafe {
1171 (T4::SHAPE.vtable.debug.unwrap_unchecked())(
1172 OpaqueConst::from_ref(&value.4),
1173 f,
1174 )
1175 }?;
1176 write!(f, ", ")?;
1177 unsafe {
1178 (T5::SHAPE.vtable.debug.unwrap_unchecked())(
1179 OpaqueConst::from_ref(&value.5),
1180 f,
1181 )
1182 }?;
1183 write!(f, ", ")?;
1184 unsafe {
1185 (T6::SHAPE.vtable.debug.unwrap_unchecked())(
1186 OpaqueConst::from_ref(&value.6),
1187 f,
1188 )
1189 }?;
1190 write!(f, ", ")?;
1191 unsafe {
1192 (T7::SHAPE.vtable.debug.unwrap_unchecked())(
1193 OpaqueConst::from_ref(&value.7),
1194 f,
1195 )
1196 }?;
1197 write!(f, ")")
1198 })
1199 } else {
1200 None
1201 }
1202 },
1203 default_in_place: None,
1204 clone_into: None,
1205 marker_traits: MarkerTraits::empty(),
1206 eq: if Characteristic::Eq.all(&[
1207 T0::SHAPE,
1208 T1::SHAPE,
1209 T2::SHAPE,
1210 T3::SHAPE,
1211 T4::SHAPE,
1212 T5::SHAPE,
1213 T6::SHAPE,
1214 T7::SHAPE,
1215 ]) {
1216 Some(|a, b| {
1217 let a = unsafe { a.as_ref::<(T0, T1, T2, T3, T4, T5, T6, T7)>() };
1218 let b = unsafe { b.as_ref::<(T0, T1, T2, T3, T4, T5, T6, T7)>() };
1219
1220 // Compare element 0
1221 if !unsafe {
1222 (T0::SHAPE.vtable.eq.unwrap_unchecked())(
1223 OpaqueConst::from_ref(&a.0),
1224 OpaqueConst::from_ref(&b.0),
1225 )
1226 } {
1227 return false;
1228 }
1229
1230 // Compare element 1
1231 if !unsafe {
1232 (T1::SHAPE.vtable.eq.unwrap_unchecked())(
1233 OpaqueConst::from_ref(&a.1),
1234 OpaqueConst::from_ref(&b.1),
1235 )
1236 } {
1237 return false;
1238 }
1239
1240 // Compare element 2
1241 if !unsafe {
1242 (T2::SHAPE.vtable.eq.unwrap_unchecked())(
1243 OpaqueConst::from_ref(&a.2),
1244 OpaqueConst::from_ref(&b.2),
1245 )
1246 } {
1247 return false;
1248 }
1249
1250 // Compare element 3
1251 if !unsafe {
1252 (T3::SHAPE.vtable.eq.unwrap_unchecked())(
1253 OpaqueConst::from_ref(&a.3),
1254 OpaqueConst::from_ref(&b.3),
1255 )
1256 } {
1257 return false;
1258 }
1259
1260 // Compare element 4
1261 if !unsafe {
1262 (T4::SHAPE.vtable.eq.unwrap_unchecked())(
1263 OpaqueConst::from_ref(&a.4),
1264 OpaqueConst::from_ref(&b.4),
1265 )
1266 } {
1267 return false;
1268 }
1269
1270 // Compare element 5
1271 if !unsafe {
1272 (T5::SHAPE.vtable.eq.unwrap_unchecked())(
1273 OpaqueConst::from_ref(&a.5),
1274 OpaqueConst::from_ref(&b.5),
1275 )
1276 } {
1277 return false;
1278 }
1279
1280 // Compare element 6
1281 if !unsafe {
1282 (T6::SHAPE.vtable.eq.unwrap_unchecked())(
1283 OpaqueConst::from_ref(&a.6),
1284 OpaqueConst::from_ref(&b.6),
1285 )
1286 } {
1287 return false;
1288 }
1289
1290 // Compare last element
1291 unsafe {
1292 (T7::SHAPE.vtable.eq.unwrap_unchecked())(
1293 OpaqueConst::from_ref(&a.7),
1294 OpaqueConst::from_ref(&b.7),
1295 )
1296 }
1297 })
1298 } else {
1299 None
1300 },
1301 partial_ord: None,
1302 ord: None,
1303 hash: None,
1304 drop_in_place: None,
1305 parse: None,
1306 try_from: None,
1307 },
1308 def: Def::Struct(StructDef {
1309 kind: StructKind::Tuple,
1310 fields: &const {
1311 [
1312 field!(0, (T0, T1, T2, T3, T4, T5, T6, T7,),),
1313 field!(1, (T0, T1, T2, T3, T4, T5, T6, T7,),),
1314 field!(2, (T0, T1, T2, T3, T4, T5, T6, T7,),),
1315 field!(3, (T0, T1, T2, T3, T4, T5, T6, T7,),),
1316 field!(4, (T0, T1, T2, T3, T4, T5, T6, T7,),),
1317 field!(5, (T0, T1, T2, T3, T4, T5, T6, T7,),),
1318 field!(6, (T0, T1, T2, T3, T4, T5, T6, T7,),),
1319 field!(7, (T0, T1, T2, T3, T4, T5, T6, T7,),),
1320 ]
1321 },
1322 }),
1323 }
1324 };
1325}
1326unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Facet for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
1327where
1328 T0: Facet,
1329 T1: Facet,
1330 T2: Facet,
1331 T3: Facet,
1332 T4: Facet,
1333 T5: Facet,
1334 T6: Facet,
1335 T7: Facet,
1336 T8: Facet,
1337{
1338 const DUMMY: Self = (
1339 T0::DUMMY,
1340 T1::DUMMY,
1341 T2::DUMMY,
1342 T3::DUMMY,
1343 T4::DUMMY,
1344 T5::DUMMY,
1345 T6::DUMMY,
1346 T7::DUMMY,
1347 T8::DUMMY,
1348 );
1349 const SHAPE: &'static Shape = &const {
1350 fn type_name<T0, T1, T2, T3, T4, T5, T6, T7, T8>(
1351 f: &mut fmt::Formatter,
1352 opts: TypeNameOpts,
1353 ) -> fmt::Result
1354 where
1355 T0: Facet,
1356 T1: Facet,
1357 T2: Facet,
1358 T3: Facet,
1359 T4: Facet,
1360 T5: Facet,
1361 T6: Facet,
1362 T7: Facet,
1363 T8: Facet,
1364 {
1365 write_type_name_list(
1366 f,
1367 opts,
1368 "(",
1369 ", ",
1370 ")",
1371 &[
1372 T0::SHAPE,
1373 T1::SHAPE,
1374 T2::SHAPE,
1375 T3::SHAPE,
1376 T4::SHAPE,
1377 T5::SHAPE,
1378 T6::SHAPE,
1379 T7::SHAPE,
1380 T8::SHAPE,
1381 ],
1382 )
1383 }
1384
1385 Shape {
1386 layout: Layout::new::<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>(),
1387 vtable: &ValueVTable {
1388 type_name: type_name::<T0, T1, T2, T3, T4, T5, T6, T7, T8>,
1389 display: None,
1390 debug: const {
1391 if Characteristic::Eq.all(&[
1392 T0::SHAPE,
1393 T1::SHAPE,
1394 T2::SHAPE,
1395 T3::SHAPE,
1396 T4::SHAPE,
1397 T5::SHAPE,
1398 T6::SHAPE,
1399 T7::SHAPE,
1400 T8::SHAPE,
1401 ]) {
1402 Some(|value, f| {
1403 let value =
1404 unsafe { value.as_ref::<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>() };
1405 write!(f, "(")?;
1406 unsafe {
1407 (T0::SHAPE.vtable.debug.unwrap_unchecked())(
1408 OpaqueConst::from_ref(&value.0),
1409 f,
1410 )
1411 }?;
1412 write!(f, ", ")?;
1413 unsafe {
1414 (T1::SHAPE.vtable.debug.unwrap_unchecked())(
1415 OpaqueConst::from_ref(&value.1),
1416 f,
1417 )
1418 }?;
1419 write!(f, ", ")?;
1420 unsafe {
1421 (T2::SHAPE.vtable.debug.unwrap_unchecked())(
1422 OpaqueConst::from_ref(&value.2),
1423 f,
1424 )
1425 }?;
1426 write!(f, ", ")?;
1427 unsafe {
1428 (T3::SHAPE.vtable.debug.unwrap_unchecked())(
1429 OpaqueConst::from_ref(&value.3),
1430 f,
1431 )
1432 }?;
1433 write!(f, ", ")?;
1434 unsafe {
1435 (T4::SHAPE.vtable.debug.unwrap_unchecked())(
1436 OpaqueConst::from_ref(&value.4),
1437 f,
1438 )
1439 }?;
1440 write!(f, ", ")?;
1441 unsafe {
1442 (T5::SHAPE.vtable.debug.unwrap_unchecked())(
1443 OpaqueConst::from_ref(&value.5),
1444 f,
1445 )
1446 }?;
1447 write!(f, ", ")?;
1448 unsafe {
1449 (T6::SHAPE.vtable.debug.unwrap_unchecked())(
1450 OpaqueConst::from_ref(&value.6),
1451 f,
1452 )
1453 }?;
1454 write!(f, ", ")?;
1455 unsafe {
1456 (T7::SHAPE.vtable.debug.unwrap_unchecked())(
1457 OpaqueConst::from_ref(&value.7),
1458 f,
1459 )
1460 }?;
1461 write!(f, ", ")?;
1462 unsafe {
1463 (T8::SHAPE.vtable.debug.unwrap_unchecked())(
1464 OpaqueConst::from_ref(&value.8),
1465 f,
1466 )
1467 }?;
1468 write!(f, ")")
1469 })
1470 } else {
1471 None
1472 }
1473 },
1474 default_in_place: None,
1475 clone_into: None,
1476 marker_traits: MarkerTraits::empty(),
1477 eq: if Characteristic::Eq.all(&[
1478 T0::SHAPE,
1479 T1::SHAPE,
1480 T2::SHAPE,
1481 T3::SHAPE,
1482 T4::SHAPE,
1483 T5::SHAPE,
1484 T6::SHAPE,
1485 T7::SHAPE,
1486 T8::SHAPE,
1487 ]) {
1488 Some(|a, b| {
1489 let a = unsafe { a.as_ref::<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>() };
1490 let b = unsafe { b.as_ref::<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>() };
1491
1492 // Compare element 0
1493 if !unsafe {
1494 (T0::SHAPE.vtable.eq.unwrap_unchecked())(
1495 OpaqueConst::from_ref(&a.0),
1496 OpaqueConst::from_ref(&b.0),
1497 )
1498 } {
1499 return false;
1500 }
1501
1502 // Compare element 1
1503 if !unsafe {
1504 (T1::SHAPE.vtable.eq.unwrap_unchecked())(
1505 OpaqueConst::from_ref(&a.1),
1506 OpaqueConst::from_ref(&b.1),
1507 )
1508 } {
1509 return false;
1510 }
1511
1512 // Compare element 2
1513 if !unsafe {
1514 (T2::SHAPE.vtable.eq.unwrap_unchecked())(
1515 OpaqueConst::from_ref(&a.2),
1516 OpaqueConst::from_ref(&b.2),
1517 )
1518 } {
1519 return false;
1520 }
1521
1522 // Compare element 3
1523 if !unsafe {
1524 (T3::SHAPE.vtable.eq.unwrap_unchecked())(
1525 OpaqueConst::from_ref(&a.3),
1526 OpaqueConst::from_ref(&b.3),
1527 )
1528 } {
1529 return false;
1530 }
1531
1532 // Compare element 4
1533 if !unsafe {
1534 (T4::SHAPE.vtable.eq.unwrap_unchecked())(
1535 OpaqueConst::from_ref(&a.4),
1536 OpaqueConst::from_ref(&b.4),
1537 )
1538 } {
1539 return false;
1540 }
1541
1542 // Compare element 5
1543 if !unsafe {
1544 (T5::SHAPE.vtable.eq.unwrap_unchecked())(
1545 OpaqueConst::from_ref(&a.5),
1546 OpaqueConst::from_ref(&b.5),
1547 )
1548 } {
1549 return false;
1550 }
1551
1552 // Compare element 6
1553 if !unsafe {
1554 (T6::SHAPE.vtable.eq.unwrap_unchecked())(
1555 OpaqueConst::from_ref(&a.6),
1556 OpaqueConst::from_ref(&b.6),
1557 )
1558 } {
1559 return false;
1560 }
1561
1562 // Compare element 7
1563 if !unsafe {
1564 (T7::SHAPE.vtable.eq.unwrap_unchecked())(
1565 OpaqueConst::from_ref(&a.7),
1566 OpaqueConst::from_ref(&b.7),
1567 )
1568 } {
1569 return false;
1570 }
1571
1572 // Compare last element
1573 unsafe {
1574 (T8::SHAPE.vtable.eq.unwrap_unchecked())(
1575 OpaqueConst::from_ref(&a.8),
1576 OpaqueConst::from_ref(&b.8),
1577 )
1578 }
1579 })
1580 } else {
1581 None
1582 },
1583 partial_ord: None,
1584 ord: None,
1585 hash: None,
1586 drop_in_place: None,
1587 parse: None,
1588 try_from: None,
1589 },
1590 def: Def::Struct(StructDef {
1591 kind: StructKind::Tuple,
1592 fields: &const {
1593 [
1594 field!(0, (T0, T1, T2, T3, T4, T5, T6, T7, T8,),),
1595 field!(1, (T0, T1, T2, T3, T4, T5, T6, T7, T8,),),
1596 field!(2, (T0, T1, T2, T3, T4, T5, T6, T7, T8,),),
1597 field!(3, (T0, T1, T2, T3, T4, T5, T6, T7, T8,),),
1598 field!(4, (T0, T1, T2, T3, T4, T5, T6, T7, T8,),),
1599 field!(5, (T0, T1, T2, T3, T4, T5, T6, T7, T8,),),
1600 field!(6, (T0, T1, T2, T3, T4, T5, T6, T7, T8,),),
1601 field!(7, (T0, T1, T2, T3, T4, T5, T6, T7, T8,),),
1602 field!(8, (T0, T1, T2, T3, T4, T5, T6, T7, T8,),),
1603 ]
1604 },
1605 }),
1606 }
1607 };
1608}
1609unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Facet
1610 for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
1611where
1612 T0: Facet,
1613 T1: Facet,
1614 T2: Facet,
1615 T3: Facet,
1616 T4: Facet,
1617 T5: Facet,
1618 T6: Facet,
1619 T7: Facet,
1620 T8: Facet,
1621 T9: Facet,
1622{
1623 const DUMMY: Self = (
1624 T0::DUMMY,
1625 T1::DUMMY,
1626 T2::DUMMY,
1627 T3::DUMMY,
1628 T4::DUMMY,
1629 T5::DUMMY,
1630 T6::DUMMY,
1631 T7::DUMMY,
1632 T8::DUMMY,
1633 T9::DUMMY,
1634 );
1635 const SHAPE: &'static Shape = &const {
1636 fn type_name<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(
1637 f: &mut fmt::Formatter,
1638 opts: TypeNameOpts,
1639 ) -> fmt::Result
1640 where
1641 T0: Facet,
1642 T1: Facet,
1643 T2: Facet,
1644 T3: Facet,
1645 T4: Facet,
1646 T5: Facet,
1647 T6: Facet,
1648 T7: Facet,
1649 T8: Facet,
1650 T9: Facet,
1651 {
1652 write_type_name_list(
1653 f,
1654 opts,
1655 "(",
1656 ", ",
1657 ")",
1658 &[
1659 T0::SHAPE,
1660 T1::SHAPE,
1661 T2::SHAPE,
1662 T3::SHAPE,
1663 T4::SHAPE,
1664 T5::SHAPE,
1665 T6::SHAPE,
1666 T7::SHAPE,
1667 T8::SHAPE,
1668 T9::SHAPE,
1669 ],
1670 )
1671 }
1672
1673 Shape {
1674 layout: Layout::new::<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>(),
1675 vtable: &ValueVTable {
1676 type_name: type_name::<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>,
1677 display: None,
1678 debug: const {
1679 if Characteristic::Eq.all(&[
1680 T0::SHAPE,
1681 T1::SHAPE,
1682 T2::SHAPE,
1683 T3::SHAPE,
1684 T4::SHAPE,
1685 T5::SHAPE,
1686 T6::SHAPE,
1687 T7::SHAPE,
1688 T8::SHAPE,
1689 T9::SHAPE,
1690 ]) {
1691 Some(|value, f| {
1692 let value = unsafe {
1693 value.as_ref::<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>()
1694 };
1695 write!(f, "(")?;
1696 unsafe {
1697 (T0::SHAPE.vtable.debug.unwrap_unchecked())(
1698 OpaqueConst::from_ref(&value.0),
1699 f,
1700 )
1701 }?;
1702 write!(f, ", ")?;
1703 unsafe {
1704 (T1::SHAPE.vtable.debug.unwrap_unchecked())(
1705 OpaqueConst::from_ref(&value.1),
1706 f,
1707 )
1708 }?;
1709 write!(f, ", ")?;
1710 unsafe {
1711 (T2::SHAPE.vtable.debug.unwrap_unchecked())(
1712 OpaqueConst::from_ref(&value.2),
1713 f,
1714 )
1715 }?;
1716 write!(f, ", ")?;
1717 unsafe {
1718 (T3::SHAPE.vtable.debug.unwrap_unchecked())(
1719 OpaqueConst::from_ref(&value.3),
1720 f,
1721 )
1722 }?;
1723 write!(f, ", ")?;
1724 unsafe {
1725 (T4::SHAPE.vtable.debug.unwrap_unchecked())(
1726 OpaqueConst::from_ref(&value.4),
1727 f,
1728 )
1729 }?;
1730 write!(f, ", ")?;
1731 unsafe {
1732 (T5::SHAPE.vtable.debug.unwrap_unchecked())(
1733 OpaqueConst::from_ref(&value.5),
1734 f,
1735 )
1736 }?;
1737 write!(f, ", ")?;
1738 unsafe {
1739 (T6::SHAPE.vtable.debug.unwrap_unchecked())(
1740 OpaqueConst::from_ref(&value.6),
1741 f,
1742 )
1743 }?;
1744 write!(f, ", ")?;
1745 unsafe {
1746 (T7::SHAPE.vtable.debug.unwrap_unchecked())(
1747 OpaqueConst::from_ref(&value.7),
1748 f,
1749 )
1750 }?;
1751 write!(f, ", ")?;
1752 unsafe {
1753 (T8::SHAPE.vtable.debug.unwrap_unchecked())(
1754 OpaqueConst::from_ref(&value.8),
1755 f,
1756 )
1757 }?;
1758 write!(f, ", ")?;
1759 unsafe {
1760 (T9::SHAPE.vtable.debug.unwrap_unchecked())(
1761 OpaqueConst::from_ref(&value.9),
1762 f,
1763 )
1764 }?;
1765 write!(f, ")")
1766 })
1767 } else {
1768 None
1769 }
1770 },
1771 default_in_place: None,
1772 clone_into: None,
1773 marker_traits: MarkerTraits::empty(),
1774 eq: if Characteristic::Eq.all(&[
1775 T0::SHAPE,
1776 T1::SHAPE,
1777 T2::SHAPE,
1778 T3::SHAPE,
1779 T4::SHAPE,
1780 T5::SHAPE,
1781 T6::SHAPE,
1782 T7::SHAPE,
1783 T8::SHAPE,
1784 T9::SHAPE,
1785 ]) {
1786 Some(|a, b| {
1787 let a = unsafe { a.as_ref::<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>() };
1788 let b = unsafe { b.as_ref::<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>() };
1789
1790 // Compare element 0
1791 if !unsafe {
1792 (T0::SHAPE.vtable.eq.unwrap_unchecked())(
1793 OpaqueConst::from_ref(&a.0),
1794 OpaqueConst::from_ref(&b.0),
1795 )
1796 } {
1797 return false;
1798 }
1799
1800 // Compare element 1
1801 if !unsafe {
1802 (T1::SHAPE.vtable.eq.unwrap_unchecked())(
1803 OpaqueConst::from_ref(&a.1),
1804 OpaqueConst::from_ref(&b.1),
1805 )
1806 } {
1807 return false;
1808 }
1809
1810 // Compare element 2
1811 if !unsafe {
1812 (T2::SHAPE.vtable.eq.unwrap_unchecked())(
1813 OpaqueConst::from_ref(&a.2),
1814 OpaqueConst::from_ref(&b.2),
1815 )
1816 } {
1817 return false;
1818 }
1819
1820 // Compare element 3
1821 if !unsafe {
1822 (T3::SHAPE.vtable.eq.unwrap_unchecked())(
1823 OpaqueConst::from_ref(&a.3),
1824 OpaqueConst::from_ref(&b.3),
1825 )
1826 } {
1827 return false;
1828 }
1829
1830 // Compare element 4
1831 if !unsafe {
1832 (T4::SHAPE.vtable.eq.unwrap_unchecked())(
1833 OpaqueConst::from_ref(&a.4),
1834 OpaqueConst::from_ref(&b.4),
1835 )
1836 } {
1837 return false;
1838 }
1839
1840 // Compare element 5
1841 if !unsafe {
1842 (T5::SHAPE.vtable.eq.unwrap_unchecked())(
1843 OpaqueConst::from_ref(&a.5),
1844 OpaqueConst::from_ref(&b.5),
1845 )
1846 } {
1847 return false;
1848 }
1849
1850 // Compare element 6
1851 if !unsafe {
1852 (T6::SHAPE.vtable.eq.unwrap_unchecked())(
1853 OpaqueConst::from_ref(&a.6),
1854 OpaqueConst::from_ref(&b.6),
1855 )
1856 } {
1857 return false;
1858 }
1859
1860 // Compare element 7
1861 if !unsafe {
1862 (T7::SHAPE.vtable.eq.unwrap_unchecked())(
1863 OpaqueConst::from_ref(&a.7),
1864 OpaqueConst::from_ref(&b.7),
1865 )
1866 } {
1867 return false;
1868 }
1869
1870 // Compare element 8
1871 if !unsafe {
1872 (T8::SHAPE.vtable.eq.unwrap_unchecked())(
1873 OpaqueConst::from_ref(&a.8),
1874 OpaqueConst::from_ref(&b.8),
1875 )
1876 } {
1877 return false;
1878 }
1879
1880 // Compare last element
1881 unsafe {
1882 (T9::SHAPE.vtable.eq.unwrap_unchecked())(
1883 OpaqueConst::from_ref(&a.9),
1884 OpaqueConst::from_ref(&b.9),
1885 )
1886 }
1887 })
1888 } else {
1889 None
1890 },
1891 partial_ord: None,
1892 ord: None,
1893 hash: None,
1894 drop_in_place: None,
1895 parse: None,
1896 try_from: None,
1897 },
1898 def: Def::Struct(StructDef {
1899 kind: StructKind::Tuple,
1900 fields: &const {
1901 [
1902 field!(0, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,),),
1903 field!(1, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,),),
1904 field!(2, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,),),
1905 field!(3, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,),),
1906 field!(4, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,),),
1907 field!(5, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,),),
1908 field!(6, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,),),
1909 field!(7, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,),),
1910 field!(8, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,),),
1911 field!(9, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,),),
1912 ]
1913 },
1914 }),
1915 }
1916 };
1917}
1918unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Facet
1919 for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
1920where
1921 T0: Facet,
1922 T1: Facet,
1923 T2: Facet,
1924 T3: Facet,
1925 T4: Facet,
1926 T5: Facet,
1927 T6: Facet,
1928 T7: Facet,
1929 T8: Facet,
1930 T9: Facet,
1931 T10: Facet,
1932{
1933 const DUMMY: Self = (
1934 T0::DUMMY,
1935 T1::DUMMY,
1936 T2::DUMMY,
1937 T3::DUMMY,
1938 T4::DUMMY,
1939 T5::DUMMY,
1940 T6::DUMMY,
1941 T7::DUMMY,
1942 T8::DUMMY,
1943 T9::DUMMY,
1944 T10::DUMMY,
1945 );
1946 const SHAPE: &'static Shape = &const {
1947 fn type_name<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
1948 f: &mut fmt::Formatter,
1949 opts: TypeNameOpts,
1950 ) -> fmt::Result
1951 where
1952 T0: Facet,
1953 T1: Facet,
1954 T2: Facet,
1955 T3: Facet,
1956 T4: Facet,
1957 T5: Facet,
1958 T6: Facet,
1959 T7: Facet,
1960 T8: Facet,
1961 T9: Facet,
1962 T10: Facet,
1963 {
1964 write_type_name_list(
1965 f,
1966 opts,
1967 "(",
1968 ", ",
1969 ")",
1970 &[
1971 T0::SHAPE,
1972 T1::SHAPE,
1973 T2::SHAPE,
1974 T3::SHAPE,
1975 T4::SHAPE,
1976 T5::SHAPE,
1977 T6::SHAPE,
1978 T7::SHAPE,
1979 T8::SHAPE,
1980 T9::SHAPE,
1981 T10::SHAPE,
1982 ],
1983 )
1984 }
1985
1986 Shape {
1987 layout: Layout::new::<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>(),
1988 vtable: &ValueVTable {
1989 type_name: type_name::<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>,
1990 display: None,
1991 debug: const {
1992 if Characteristic::Eq.all(&[
1993 T0::SHAPE,
1994 T1::SHAPE,
1995 T2::SHAPE,
1996 T3::SHAPE,
1997 T4::SHAPE,
1998 T5::SHAPE,
1999 T6::SHAPE,
2000 T7::SHAPE,
2001 T8::SHAPE,
2002 T9::SHAPE,
2003 T10::SHAPE,
2004 ]) {
2005 Some(|value, f| {
2006 let value = unsafe {
2007 value.as_ref::<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>()
2008 };
2009 write!(f, "(")?;
2010 unsafe {
2011 (T0::SHAPE.vtable.debug.unwrap_unchecked())(
2012 OpaqueConst::from_ref(&value.0),
2013 f,
2014 )
2015 }?;
2016 write!(f, ", ")?;
2017 unsafe {
2018 (T1::SHAPE.vtable.debug.unwrap_unchecked())(
2019 OpaqueConst::from_ref(&value.1),
2020 f,
2021 )
2022 }?;
2023 write!(f, ", ")?;
2024 unsafe {
2025 (T2::SHAPE.vtable.debug.unwrap_unchecked())(
2026 OpaqueConst::from_ref(&value.2),
2027 f,
2028 )
2029 }?;
2030 write!(f, ", ")?;
2031 unsafe {
2032 (T3::SHAPE.vtable.debug.unwrap_unchecked())(
2033 OpaqueConst::from_ref(&value.3),
2034 f,
2035 )
2036 }?;
2037 write!(f, ", ")?;
2038 unsafe {
2039 (T4::SHAPE.vtable.debug.unwrap_unchecked())(
2040 OpaqueConst::from_ref(&value.4),
2041 f,
2042 )
2043 }?;
2044 write!(f, ", ")?;
2045 unsafe {
2046 (T5::SHAPE.vtable.debug.unwrap_unchecked())(
2047 OpaqueConst::from_ref(&value.5),
2048 f,
2049 )
2050 }?;
2051 write!(f, ", ")?;
2052 unsafe {
2053 (T6::SHAPE.vtable.debug.unwrap_unchecked())(
2054 OpaqueConst::from_ref(&value.6),
2055 f,
2056 )
2057 }?;
2058 write!(f, ", ")?;
2059 unsafe {
2060 (T7::SHAPE.vtable.debug.unwrap_unchecked())(
2061 OpaqueConst::from_ref(&value.7),
2062 f,
2063 )
2064 }?;
2065 write!(f, ", ")?;
2066 unsafe {
2067 (T8::SHAPE.vtable.debug.unwrap_unchecked())(
2068 OpaqueConst::from_ref(&value.8),
2069 f,
2070 )
2071 }?;
2072 write!(f, ", ")?;
2073 unsafe {
2074 (T9::SHAPE.vtable.debug.unwrap_unchecked())(
2075 OpaqueConst::from_ref(&value.9),
2076 f,
2077 )
2078 }?;
2079 write!(f, ", ")?;
2080 unsafe {
2081 (T10::SHAPE.vtable.debug.unwrap_unchecked())(
2082 OpaqueConst::from_ref(&value.10),
2083 f,
2084 )
2085 }?;
2086 write!(f, ")")
2087 })
2088 } else {
2089 None
2090 }
2091 },
2092 default_in_place: None,
2093 clone_into: None,
2094 marker_traits: MarkerTraits::empty(),
2095 eq: if Characteristic::Eq.all(&[
2096 T0::SHAPE,
2097 T1::SHAPE,
2098 T2::SHAPE,
2099 T3::SHAPE,
2100 T4::SHAPE,
2101 T5::SHAPE,
2102 T6::SHAPE,
2103 T7::SHAPE,
2104 T8::SHAPE,
2105 T9::SHAPE,
2106 T10::SHAPE,
2107 ]) {
2108 Some(|a, b| {
2109 let a =
2110 unsafe { a.as_ref::<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>() };
2111 let b =
2112 unsafe { b.as_ref::<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>() };
2113
2114 // Compare element 0
2115 if !unsafe {
2116 (T0::SHAPE.vtable.eq.unwrap_unchecked())(
2117 OpaqueConst::from_ref(&a.0),
2118 OpaqueConst::from_ref(&b.0),
2119 )
2120 } {
2121 return false;
2122 }
2123
2124 // Compare element 1
2125 if !unsafe {
2126 (T1::SHAPE.vtable.eq.unwrap_unchecked())(
2127 OpaqueConst::from_ref(&a.1),
2128 OpaqueConst::from_ref(&b.1),
2129 )
2130 } {
2131 return false;
2132 }
2133
2134 // Compare element 2
2135 if !unsafe {
2136 (T2::SHAPE.vtable.eq.unwrap_unchecked())(
2137 OpaqueConst::from_ref(&a.2),
2138 OpaqueConst::from_ref(&b.2),
2139 )
2140 } {
2141 return false;
2142 }
2143
2144 // Compare element 3
2145 if !unsafe {
2146 (T3::SHAPE.vtable.eq.unwrap_unchecked())(
2147 OpaqueConst::from_ref(&a.3),
2148 OpaqueConst::from_ref(&b.3),
2149 )
2150 } {
2151 return false;
2152 }
2153
2154 // Compare element 4
2155 if !unsafe {
2156 (T4::SHAPE.vtable.eq.unwrap_unchecked())(
2157 OpaqueConst::from_ref(&a.4),
2158 OpaqueConst::from_ref(&b.4),
2159 )
2160 } {
2161 return false;
2162 }
2163
2164 // Compare element 5
2165 if !unsafe {
2166 (T5::SHAPE.vtable.eq.unwrap_unchecked())(
2167 OpaqueConst::from_ref(&a.5),
2168 OpaqueConst::from_ref(&b.5),
2169 )
2170 } {
2171 return false;
2172 }
2173
2174 // Compare element 6
2175 if !unsafe {
2176 (T6::SHAPE.vtable.eq.unwrap_unchecked())(
2177 OpaqueConst::from_ref(&a.6),
2178 OpaqueConst::from_ref(&b.6),
2179 )
2180 } {
2181 return false;
2182 }
2183
2184 // Compare element 7
2185 if !unsafe {
2186 (T7::SHAPE.vtable.eq.unwrap_unchecked())(
2187 OpaqueConst::from_ref(&a.7),
2188 OpaqueConst::from_ref(&b.7),
2189 )
2190 } {
2191 return false;
2192 }
2193
2194 // Compare element 8
2195 if !unsafe {
2196 (T8::SHAPE.vtable.eq.unwrap_unchecked())(
2197 OpaqueConst::from_ref(&a.8),
2198 OpaqueConst::from_ref(&b.8),
2199 )
2200 } {
2201 return false;
2202 }
2203
2204 // Compare element 9
2205 if !unsafe {
2206 (T9::SHAPE.vtable.eq.unwrap_unchecked())(
2207 OpaqueConst::from_ref(&a.9),
2208 OpaqueConst::from_ref(&b.9),
2209 )
2210 } {
2211 return false;
2212 }
2213
2214 // Compare last element
2215 unsafe {
2216 (T10::SHAPE.vtable.eq.unwrap_unchecked())(
2217 OpaqueConst::from_ref(&a.10),
2218 OpaqueConst::from_ref(&b.10),
2219 )
2220 }
2221 })
2222 } else {
2223 None
2224 },
2225 partial_ord: None,
2226 ord: None,
2227 hash: None,
2228 drop_in_place: None,
2229 parse: None,
2230 try_from: None,
2231 },
2232 def: Def::Struct(StructDef {
2233 kind: StructKind::Tuple,
2234 fields: &const {
2235 [
2236 field!(0, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,),),
2237 field!(1, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,),),
2238 field!(2, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,),),
2239 field!(3, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,),),
2240 field!(4, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,),),
2241 field!(5, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,),),
2242 field!(6, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,),),
2243 field!(7, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,),),
2244 field!(8, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,),),
2245 field!(9, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,),),
2246 field!(10, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,),),
2247 ]
2248 },
2249 }),
2250 }
2251 };
2252}
2253unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Facet
2254 for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
2255where
2256 T0: Facet,
2257 T1: Facet,
2258 T2: Facet,
2259 T3: Facet,
2260 T4: Facet,
2261 T5: Facet,
2262 T6: Facet,
2263 T7: Facet,
2264 T8: Facet,
2265 T9: Facet,
2266 T10: Facet,
2267 T11: Facet,
2268{
2269 const DUMMY: Self = (
2270 T0::DUMMY,
2271 T1::DUMMY,
2272 T2::DUMMY,
2273 T3::DUMMY,
2274 T4::DUMMY,
2275 T5::DUMMY,
2276 T6::DUMMY,
2277 T7::DUMMY,
2278 T8::DUMMY,
2279 T9::DUMMY,
2280 T10::DUMMY,
2281 T11::DUMMY,
2282 );
2283 const SHAPE: &'static Shape = &const {
2284 fn type_name<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(
2285 f: &mut fmt::Formatter,
2286 opts: TypeNameOpts,
2287 ) -> fmt::Result
2288 where
2289 T0: Facet,
2290 T1: Facet,
2291 T2: Facet,
2292 T3: Facet,
2293 T4: Facet,
2294 T5: Facet,
2295 T6: Facet,
2296 T7: Facet,
2297 T8: Facet,
2298 T9: Facet,
2299 T10: Facet,
2300 T11: Facet,
2301 {
2302 write_type_name_list(
2303 f,
2304 opts,
2305 "(",
2306 ", ",
2307 ")",
2308 &[
2309 T0::SHAPE,
2310 T1::SHAPE,
2311 T2::SHAPE,
2312 T3::SHAPE,
2313 T4::SHAPE,
2314 T5::SHAPE,
2315 T6::SHAPE,
2316 T7::SHAPE,
2317 T8::SHAPE,
2318 T9::SHAPE,
2319 T10::SHAPE,
2320 T11::SHAPE,
2321 ],
2322 )
2323 }
2324
2325 Shape {
2326 layout: Layout::new::<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>(),
2327 vtable: &ValueVTable {
2328 type_name: type_name::<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>,
2329 display: None,
2330 debug: const {
2331 if Characteristic::Eq.all(&[
2332 T0::SHAPE,
2333 T1::SHAPE,
2334 T2::SHAPE,
2335 T3::SHAPE,
2336 T4::SHAPE,
2337 T5::SHAPE,
2338 T6::SHAPE,
2339 T7::SHAPE,
2340 T8::SHAPE,
2341 T9::SHAPE,
2342 T10::SHAPE,
2343 T11::SHAPE,
2344 ]) {
2345 Some(|value, f| {
2346 let value = unsafe {
2347 value.as_ref::<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>()
2348 };
2349 write!(f, "(")?;
2350 unsafe {
2351 (T0::SHAPE.vtable.debug.unwrap_unchecked())(
2352 OpaqueConst::from_ref(&value.0),
2353 f,
2354 )
2355 }?;
2356 write!(f, ", ")?;
2357 unsafe {
2358 (T1::SHAPE.vtable.debug.unwrap_unchecked())(
2359 OpaqueConst::from_ref(&value.1),
2360 f,
2361 )
2362 }?;
2363 write!(f, ", ")?;
2364 unsafe {
2365 (T2::SHAPE.vtable.debug.unwrap_unchecked())(
2366 OpaqueConst::from_ref(&value.2),
2367 f,
2368 )
2369 }?;
2370 write!(f, ", ")?;
2371 unsafe {
2372 (T3::SHAPE.vtable.debug.unwrap_unchecked())(
2373 OpaqueConst::from_ref(&value.3),
2374 f,
2375 )
2376 }?;
2377 write!(f, ", ")?;
2378 unsafe {
2379 (T4::SHAPE.vtable.debug.unwrap_unchecked())(
2380 OpaqueConst::from_ref(&value.4),
2381 f,
2382 )
2383 }?;
2384 write!(f, ", ")?;
2385 unsafe {
2386 (T5::SHAPE.vtable.debug.unwrap_unchecked())(
2387 OpaqueConst::from_ref(&value.5),
2388 f,
2389 )
2390 }?;
2391 write!(f, ", ")?;
2392 unsafe {
2393 (T6::SHAPE.vtable.debug.unwrap_unchecked())(
2394 OpaqueConst::from_ref(&value.6),
2395 f,
2396 )
2397 }?;
2398 write!(f, ", ")?;
2399 unsafe {
2400 (T7::SHAPE.vtable.debug.unwrap_unchecked())(
2401 OpaqueConst::from_ref(&value.7),
2402 f,
2403 )
2404 }?;
2405 write!(f, ", ")?;
2406 unsafe {
2407 (T8::SHAPE.vtable.debug.unwrap_unchecked())(
2408 OpaqueConst::from_ref(&value.8),
2409 f,
2410 )
2411 }?;
2412 write!(f, ", ")?;
2413 unsafe {
2414 (T9::SHAPE.vtable.debug.unwrap_unchecked())(
2415 OpaqueConst::from_ref(&value.9),
2416 f,
2417 )
2418 }?;
2419 write!(f, ", ")?;
2420 unsafe {
2421 (T10::SHAPE.vtable.debug.unwrap_unchecked())(
2422 OpaqueConst::from_ref(&value.10),
2423 f,
2424 )
2425 }?;
2426 write!(f, ", ")?;
2427 unsafe {
2428 (T11::SHAPE.vtable.debug.unwrap_unchecked())(
2429 OpaqueConst::from_ref(&value.11),
2430 f,
2431 )
2432 }?;
2433 write!(f, ")")
2434 })
2435 } else {
2436 None
2437 }
2438 },
2439 default_in_place: None,
2440 clone_into: None,
2441 marker_traits: MarkerTraits::empty(),
2442 eq: if Characteristic::Eq.all(&[
2443 T0::SHAPE,
2444 T1::SHAPE,
2445 T2::SHAPE,
2446 T3::SHAPE,
2447 T4::SHAPE,
2448 T5::SHAPE,
2449 T6::SHAPE,
2450 T7::SHAPE,
2451 T8::SHAPE,
2452 T9::SHAPE,
2453 T10::SHAPE,
2454 T11::SHAPE,
2455 ]) {
2456 Some(|a, b| {
2457 let a = unsafe {
2458 a.as_ref::<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>()
2459 };
2460 let b = unsafe {
2461 b.as_ref::<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>()
2462 };
2463
2464 // Compare element 0
2465 if !unsafe {
2466 (T0::SHAPE.vtable.eq.unwrap_unchecked())(
2467 OpaqueConst::from_ref(&a.0),
2468 OpaqueConst::from_ref(&b.0),
2469 )
2470 } {
2471 return false;
2472 }
2473
2474 // Compare element 1
2475 if !unsafe {
2476 (T1::SHAPE.vtable.eq.unwrap_unchecked())(
2477 OpaqueConst::from_ref(&a.1),
2478 OpaqueConst::from_ref(&b.1),
2479 )
2480 } {
2481 return false;
2482 }
2483
2484 // Compare element 2
2485 if !unsafe {
2486 (T2::SHAPE.vtable.eq.unwrap_unchecked())(
2487 OpaqueConst::from_ref(&a.2),
2488 OpaqueConst::from_ref(&b.2),
2489 )
2490 } {
2491 return false;
2492 }
2493
2494 // Compare element 3
2495 if !unsafe {
2496 (T3::SHAPE.vtable.eq.unwrap_unchecked())(
2497 OpaqueConst::from_ref(&a.3),
2498 OpaqueConst::from_ref(&b.3),
2499 )
2500 } {
2501 return false;
2502 }
2503
2504 // Compare element 4
2505 if !unsafe {
2506 (T4::SHAPE.vtable.eq.unwrap_unchecked())(
2507 OpaqueConst::from_ref(&a.4),
2508 OpaqueConst::from_ref(&b.4),
2509 )
2510 } {
2511 return false;
2512 }
2513
2514 // Compare element 5
2515 if !unsafe {
2516 (T5::SHAPE.vtable.eq.unwrap_unchecked())(
2517 OpaqueConst::from_ref(&a.5),
2518 OpaqueConst::from_ref(&b.5),
2519 )
2520 } {
2521 return false;
2522 }
2523
2524 // Compare element 6
2525 if !unsafe {
2526 (T6::SHAPE.vtable.eq.unwrap_unchecked())(
2527 OpaqueConst::from_ref(&a.6),
2528 OpaqueConst::from_ref(&b.6),
2529 )
2530 } {
2531 return false;
2532 }
2533
2534 // Compare element 7
2535 if !unsafe {
2536 (T7::SHAPE.vtable.eq.unwrap_unchecked())(
2537 OpaqueConst::from_ref(&a.7),
2538 OpaqueConst::from_ref(&b.7),
2539 )
2540 } {
2541 return false;
2542 }
2543
2544 // Compare element 8
2545 if !unsafe {
2546 (T8::SHAPE.vtable.eq.unwrap_unchecked())(
2547 OpaqueConst::from_ref(&a.8),
2548 OpaqueConst::from_ref(&b.8),
2549 )
2550 } {
2551 return false;
2552 }
2553
2554 // Compare element 9
2555 if !unsafe {
2556 (T9::SHAPE.vtable.eq.unwrap_unchecked())(
2557 OpaqueConst::from_ref(&a.9),
2558 OpaqueConst::from_ref(&b.9),
2559 )
2560 } {
2561 return false;
2562 }
2563
2564 // Compare element 10
2565 if !unsafe {
2566 (T10::SHAPE.vtable.eq.unwrap_unchecked())(
2567 OpaqueConst::from_ref(&a.10),
2568 OpaqueConst::from_ref(&b.10),
2569 )
2570 } {
2571 return false;
2572 }
2573
2574 // Compare last element
2575 unsafe {
2576 (T11::SHAPE.vtable.eq.unwrap_unchecked())(
2577 OpaqueConst::from_ref(&a.11),
2578 OpaqueConst::from_ref(&b.11),
2579 )
2580 }
2581 })
2582 } else {
2583 None
2584 },
2585 partial_ord: None,
2586 ord: None,
2587 hash: None,
2588 drop_in_place: None,
2589 parse: None,
2590 try_from: None,
2591 },
2592 def: Def::Struct(StructDef {
2593 kind: StructKind::Tuple,
2594 fields: &const {
2595 [
2596 field!(0, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,),),
2597 field!(1, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,),),
2598 field!(2, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,),),
2599 field!(3, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,),),
2600 field!(4, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,),),
2601 field!(5, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,),),
2602 field!(6, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,),),
2603 field!(7, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,),),
2604 field!(8, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,),),
2605 field!(9, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,),),
2606 field!(10, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,),),
2607 field!(11, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,),),
2608 ]
2609 },
2610 }),
2611 }
2612 };
2613}