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