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