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