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