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