1use core::{alloc::Layout, fmt};
5
6use crate::{
7 ConstTypeId, Def, Facet, FunctionAbi, FunctionPointerDef, Shape, TypeNameOpts, TypeParam,
8 value_vtable,
9};
10
11#[inline(always)]
12pub fn write_type_name_list(
13 f: &mut fmt::Formatter<'_>,
14 opts: TypeNameOpts,
15 abi: FunctionAbi,
16 params: &'static [&'static Shape],
17 ret_type: &'static Shape,
18) -> fmt::Result {
19 if abi != FunctionAbi::Rust {
20 f.pad("extern \"")?;
21 if let Some(abi) = abi.as_abi_str() {
22 f.pad(abi)?;
23 }
24 f.pad("\" ")?;
25 }
26 f.pad("fn")?;
27 f.pad("(")?;
28 if let Some(opts) = opts.for_children() {
29 for (index, shape) in params.iter().enumerate() {
30 if index > 0 {
31 f.pad(", ")?;
32 }
33 shape.write_type_name(f, opts)?;
34 }
35 } else {
36 write!(f, "⋯")?;
37 }
38 f.pad(") -> ")?;
39 ret_type.write_type_name(f, opts)?;
40 Ok(())
41}
42
43unsafe impl<'facet, R> Facet<'facet> for fn() -> R
44where
45 R: Facet<'facet>,
46{
47 const SHAPE: &'static Shape = &const {
48 fn type_name<'facet, R>(f: &mut fmt::Formatter, opts: TypeNameOpts) -> fmt::Result
49 where
50 R: Facet<'facet>,
51 {
52 write_type_name_list(f, opts, FunctionAbi::Rust, &[], R::SHAPE)
53 }
54
55 Shape::builder()
56 .id(ConstTypeId::of::<Self>())
57 .layout(Layout::new::<Self>())
58 .vtable(value_vtable!(Self, type_name::<R>))
59 .type_params(&[])
60 .def(Def::FunctionPointer({
61 FunctionPointerDef::builder()
62 .parameter_types(&const { [] })
63 .return_type(|| R::SHAPE)
64 .abi(FunctionAbi::Rust)
65 .build()
66 }))
67 .build()
68 };
69}
70unsafe impl<'facet, R, T0> Facet<'facet> for fn(T0) -> R
71where
72 T0: Facet<'facet>,
73 R: Facet<'facet>,
74{
75 const SHAPE: &'static Shape = &const {
76 fn type_name<'facet, R, T0>(f: &mut fmt::Formatter, opts: TypeNameOpts) -> fmt::Result
77 where
78 T0: Facet<'facet>,
79 R: Facet<'facet>,
80 {
81 write_type_name_list(f, opts, FunctionAbi::Rust, &[T0::SHAPE], R::SHAPE)
82 }
83
84 Shape::builder()
85 .id(ConstTypeId::of::<Self>())
86 .layout(Layout::new::<Self>())
87 .vtable(value_vtable!(Self, type_name::<R, T0>))
88 .type_params(&[TypeParam {
89 name: "T0",
90 shape: || T0::SHAPE,
91 }])
92 .def(Def::FunctionPointer({
93 FunctionPointerDef::builder()
94 .parameter_types(&const { [|| T0::SHAPE] })
95 .return_type(|| R::SHAPE)
96 .abi(FunctionAbi::Rust)
97 .build()
98 }))
99 .build()
100 };
101}
102unsafe impl<'facet, R, T0, T1> Facet<'facet> for fn(T0, T1) -> R
103where
104 T0: Facet<'facet>,
105 T1: Facet<'facet>,
106 R: Facet<'facet>,
107{
108 const SHAPE: &'static Shape = &const {
109 fn type_name<'facet, R, T0, T1>(f: &mut fmt::Formatter, opts: TypeNameOpts) -> fmt::Result
110 where
111 T0: Facet<'facet>,
112 T1: Facet<'facet>,
113 R: Facet<'facet>,
114 {
115 write_type_name_list(
116 f,
117 opts,
118 FunctionAbi::Rust,
119 &[T0::SHAPE, T1::SHAPE],
120 R::SHAPE,
121 )
122 }
123
124 Shape::builder()
125 .id(ConstTypeId::of::<Self>())
126 .layout(Layout::new::<Self>())
127 .vtable(value_vtable!(Self, type_name::<R, T0, T1>))
128 .type_params(&[
129 TypeParam {
130 name: "T0",
131 shape: || T0::SHAPE,
132 },
133 TypeParam {
134 name: "T1",
135 shape: || T1::SHAPE,
136 },
137 ])
138 .def(Def::FunctionPointer({
139 FunctionPointerDef::builder()
140 .parameter_types(&const { [|| T0::SHAPE, || T1::SHAPE] })
141 .return_type(|| R::SHAPE)
142 .abi(FunctionAbi::Rust)
143 .build()
144 }))
145 .build()
146 };
147}
148unsafe impl<'facet, R, T0, T1, T2> Facet<'facet> for fn(T0, T1, T2) -> R
149where
150 T0: Facet<'facet>,
151 T1: Facet<'facet>,
152 T2: Facet<'facet>,
153 R: Facet<'facet>,
154{
155 const SHAPE: &'static Shape = &const {
156 fn type_name<'facet, R, T0, T1, T2>(
157 f: &mut fmt::Formatter,
158 opts: TypeNameOpts,
159 ) -> fmt::Result
160 where
161 T0: Facet<'facet>,
162 T1: Facet<'facet>,
163 T2: Facet<'facet>,
164 R: Facet<'facet>,
165 {
166 write_type_name_list(
167 f,
168 opts,
169 FunctionAbi::Rust,
170 &[T0::SHAPE, T1::SHAPE, T2::SHAPE],
171 R::SHAPE,
172 )
173 }
174
175 Shape::builder()
176 .id(ConstTypeId::of::<Self>())
177 .layout(Layout::new::<Self>())
178 .vtable(value_vtable!(Self, type_name::<R, T0, T1, T2>))
179 .type_params(&[
180 TypeParam {
181 name: "T0",
182 shape: || T0::SHAPE,
183 },
184 TypeParam {
185 name: "T1",
186 shape: || T1::SHAPE,
187 },
188 TypeParam {
189 name: "T2",
190 shape: || T2::SHAPE,
191 },
192 ])
193 .def(Def::FunctionPointer({
194 FunctionPointerDef::builder()
195 .parameter_types(&const { [|| T0::SHAPE, || T1::SHAPE, || T2::SHAPE] })
196 .return_type(|| R::SHAPE)
197 .abi(FunctionAbi::Rust)
198 .build()
199 }))
200 .build()
201 };
202}
203unsafe impl<'facet, R, T0, T1, T2, T3> Facet<'facet> for fn(T0, T1, T2, T3) -> R
204where
205 T0: Facet<'facet>,
206 T1: Facet<'facet>,
207 T2: Facet<'facet>,
208 T3: Facet<'facet>,
209 R: Facet<'facet>,
210{
211 const SHAPE: &'static Shape = &const {
212 fn type_name<'facet, R, T0, T1, T2, T3>(
213 f: &mut fmt::Formatter,
214 opts: TypeNameOpts,
215 ) -> fmt::Result
216 where
217 T0: Facet<'facet>,
218 T1: Facet<'facet>,
219 T2: Facet<'facet>,
220 T3: Facet<'facet>,
221 R: Facet<'facet>,
222 {
223 write_type_name_list(
224 f,
225 opts,
226 FunctionAbi::Rust,
227 &[T0::SHAPE, T1::SHAPE, T2::SHAPE, T3::SHAPE],
228 R::SHAPE,
229 )
230 }
231
232 Shape::builder()
233 .id(ConstTypeId::of::<Self>())
234 .layout(Layout::new::<Self>())
235 .vtable(value_vtable!(Self, type_name::<R, T0, T1, T2, T3>))
236 .type_params(&[
237 TypeParam {
238 name: "T0",
239 shape: || T0::SHAPE,
240 },
241 TypeParam {
242 name: "T1",
243 shape: || T1::SHAPE,
244 },
245 TypeParam {
246 name: "T2",
247 shape: || T2::SHAPE,
248 },
249 TypeParam {
250 name: "T3",
251 shape: || T3::SHAPE,
252 },
253 ])
254 .def(Def::FunctionPointer({
255 FunctionPointerDef::builder()
256 .parameter_types(
257 &const { [|| T0::SHAPE, || T1::SHAPE, || T2::SHAPE, || T3::SHAPE] },
258 )
259 .return_type(|| R::SHAPE)
260 .abi(FunctionAbi::Rust)
261 .build()
262 }))
263 .build()
264 };
265}
266unsafe impl<'facet, R, T0, T1, T2, T3, T4> Facet<'facet> for fn(T0, T1, T2, T3, T4) -> R
267where
268 T0: Facet<'facet>,
269 T1: Facet<'facet>,
270 T2: Facet<'facet>,
271 T3: Facet<'facet>,
272 T4: Facet<'facet>,
273 R: Facet<'facet>,
274{
275 const SHAPE: &'static Shape = &const {
276 fn type_name<'facet, R, T0, T1, T2, T3, T4>(
277 f: &mut fmt::Formatter,
278 opts: TypeNameOpts,
279 ) -> fmt::Result
280 where
281 T0: Facet<'facet>,
282 T1: Facet<'facet>,
283 T2: Facet<'facet>,
284 T3: Facet<'facet>,
285 T4: Facet<'facet>,
286 R: Facet<'facet>,
287 {
288 write_type_name_list(
289 f,
290 opts,
291 FunctionAbi::Rust,
292 &[T0::SHAPE, T1::SHAPE, T2::SHAPE, T3::SHAPE, T4::SHAPE],
293 R::SHAPE,
294 )
295 }
296
297 Shape::builder()
298 .id(ConstTypeId::of::<Self>())
299 .layout(Layout::new::<Self>())
300 .vtable(value_vtable!(Self, type_name::<R, T0, T1, T2, T3, T4>))
301 .type_params(&[
302 TypeParam {
303 name: "T0",
304 shape: || T0::SHAPE,
305 },
306 TypeParam {
307 name: "T1",
308 shape: || T1::SHAPE,
309 },
310 TypeParam {
311 name: "T2",
312 shape: || T2::SHAPE,
313 },
314 TypeParam {
315 name: "T3",
316 shape: || T3::SHAPE,
317 },
318 TypeParam {
319 name: "T4",
320 shape: || T4::SHAPE,
321 },
322 ])
323 .def(Def::FunctionPointer({
324 FunctionPointerDef::builder()
325 .parameter_types(
326 &const {
327 [
328 || T0::SHAPE,
329 || T1::SHAPE,
330 || T2::SHAPE,
331 || T3::SHAPE,
332 || T4::SHAPE,
333 ]
334 },
335 )
336 .return_type(|| R::SHAPE)
337 .abi(FunctionAbi::Rust)
338 .build()
339 }))
340 .build()
341 };
342}
343unsafe impl<'facet, R, T0, T1, T2, T3, T4, T5> Facet<'facet> for fn(T0, T1, T2, T3, T4, T5) -> R
344where
345 T0: Facet<'facet>,
346 T1: Facet<'facet>,
347 T2: Facet<'facet>,
348 T3: Facet<'facet>,
349 T4: Facet<'facet>,
350 T5: Facet<'facet>,
351 R: Facet<'facet>,
352{
353 const SHAPE: &'static Shape = &const {
354 fn type_name<'facet, R, T0, T1, T2, T3, T4, T5>(
355 f: &mut fmt::Formatter,
356 opts: TypeNameOpts,
357 ) -> fmt::Result
358 where
359 T0: Facet<'facet>,
360 T1: Facet<'facet>,
361 T2: Facet<'facet>,
362 T3: Facet<'facet>,
363 T4: Facet<'facet>,
364 T5: Facet<'facet>,
365 R: Facet<'facet>,
366 {
367 write_type_name_list(
368 f,
369 opts,
370 FunctionAbi::Rust,
371 &[
372 T0::SHAPE,
373 T1::SHAPE,
374 T2::SHAPE,
375 T3::SHAPE,
376 T4::SHAPE,
377 T5::SHAPE,
378 ],
379 R::SHAPE,
380 )
381 }
382
383 Shape::builder()
384 .id(ConstTypeId::of::<Self>())
385 .layout(Layout::new::<Self>())
386 .vtable(value_vtable!(Self, type_name::<R, T0, T1, T2, T3, T4, T5>))
387 .type_params(&[
388 TypeParam {
389 name: "T0",
390 shape: || T0::SHAPE,
391 },
392 TypeParam {
393 name: "T1",
394 shape: || T1::SHAPE,
395 },
396 TypeParam {
397 name: "T2",
398 shape: || T2::SHAPE,
399 },
400 TypeParam {
401 name: "T3",
402 shape: || T3::SHAPE,
403 },
404 TypeParam {
405 name: "T4",
406 shape: || T4::SHAPE,
407 },
408 TypeParam {
409 name: "T5",
410 shape: || T5::SHAPE,
411 },
412 ])
413 .def(Def::FunctionPointer({
414 FunctionPointerDef::builder()
415 .parameter_types(
416 &const {
417 [
418 || T0::SHAPE,
419 || T1::SHAPE,
420 || T2::SHAPE,
421 || T3::SHAPE,
422 || T4::SHAPE,
423 || T5::SHAPE,
424 ]
425 },
426 )
427 .return_type(|| R::SHAPE)
428 .abi(FunctionAbi::Rust)
429 .build()
430 }))
431 .build()
432 };
433}
434unsafe impl<'facet, R> Facet<'facet> for extern "C" fn() -> R
435where
436 R: Facet<'facet>,
437{
438 const SHAPE: &'static Shape = &const {
439 fn type_name<'facet, R>(f: &mut fmt::Formatter, opts: TypeNameOpts) -> fmt::Result
440 where
441 R: Facet<'facet>,
442 {
443 write_type_name_list(f, opts, FunctionAbi::C, &[], R::SHAPE)
444 }
445
446 Shape::builder()
447 .id(ConstTypeId::of::<Self>())
448 .layout(Layout::new::<Self>())
449 .vtable(value_vtable!(Self, type_name::<R>))
450 .type_params(&[])
451 .def(Def::FunctionPointer({
452 FunctionPointerDef::builder()
453 .parameter_types(&const { [] })
454 .return_type(|| R::SHAPE)
455 .abi(FunctionAbi::C)
456 .build()
457 }))
458 .build()
459 };
460}
461unsafe impl<'facet, R, T0> Facet<'facet> for extern "C" fn(T0) -> R
462where
463 T0: Facet<'facet>,
464 R: Facet<'facet>,
465{
466 const SHAPE: &'static Shape = &const {
467 fn type_name<'facet, R, T0>(f: &mut fmt::Formatter, opts: TypeNameOpts) -> fmt::Result
468 where
469 T0: Facet<'facet>,
470 R: Facet<'facet>,
471 {
472 write_type_name_list(f, opts, FunctionAbi::C, &[T0::SHAPE], R::SHAPE)
473 }
474
475 Shape::builder()
476 .id(ConstTypeId::of::<Self>())
477 .layout(Layout::new::<Self>())
478 .vtable(value_vtable!(Self, type_name::<R, T0>))
479 .type_params(&[TypeParam {
480 name: "T0",
481 shape: || T0::SHAPE,
482 }])
483 .def(Def::FunctionPointer({
484 FunctionPointerDef::builder()
485 .parameter_types(&const { [|| T0::SHAPE] })
486 .return_type(|| R::SHAPE)
487 .abi(FunctionAbi::C)
488 .build()
489 }))
490 .build()
491 };
492}
493unsafe impl<'facet, R, T0, T1> Facet<'facet> for extern "C" fn(T0, T1) -> R
494where
495 T0: Facet<'facet>,
496 T1: Facet<'facet>,
497 R: Facet<'facet>,
498{
499 const SHAPE: &'static Shape = &const {
500 fn type_name<'facet, R, T0, T1>(f: &mut fmt::Formatter, opts: TypeNameOpts) -> fmt::Result
501 where
502 T0: Facet<'facet>,
503 T1: Facet<'facet>,
504 R: Facet<'facet>,
505 {
506 write_type_name_list(f, opts, FunctionAbi::C, &[T0::SHAPE, T1::SHAPE], R::SHAPE)
507 }
508
509 Shape::builder()
510 .id(ConstTypeId::of::<Self>())
511 .layout(Layout::new::<Self>())
512 .vtable(value_vtable!(Self, type_name::<R, T0, T1>))
513 .type_params(&[
514 TypeParam {
515 name: "T0",
516 shape: || T0::SHAPE,
517 },
518 TypeParam {
519 name: "T1",
520 shape: || T1::SHAPE,
521 },
522 ])
523 .def(Def::FunctionPointer({
524 FunctionPointerDef::builder()
525 .parameter_types(&const { [|| T0::SHAPE, || T1::SHAPE] })
526 .return_type(|| R::SHAPE)
527 .abi(FunctionAbi::C)
528 .build()
529 }))
530 .build()
531 };
532}
533unsafe impl<'facet, R, T0, T1, T2> Facet<'facet> for extern "C" fn(T0, T1, T2) -> R
534where
535 T0: Facet<'facet>,
536 T1: Facet<'facet>,
537 T2: Facet<'facet>,
538 R: Facet<'facet>,
539{
540 const SHAPE: &'static Shape = &const {
541 fn type_name<'facet, R, T0, T1, T2>(
542 f: &mut fmt::Formatter,
543 opts: TypeNameOpts,
544 ) -> fmt::Result
545 where
546 T0: Facet<'facet>,
547 T1: Facet<'facet>,
548 T2: Facet<'facet>,
549 R: Facet<'facet>,
550 {
551 write_type_name_list(
552 f,
553 opts,
554 FunctionAbi::C,
555 &[T0::SHAPE, T1::SHAPE, T2::SHAPE],
556 R::SHAPE,
557 )
558 }
559
560 Shape::builder()
561 .id(ConstTypeId::of::<Self>())
562 .layout(Layout::new::<Self>())
563 .vtable(value_vtable!(Self, type_name::<R, T0, T1, T2>))
564 .type_params(&[
565 TypeParam {
566 name: "T0",
567 shape: || T0::SHAPE,
568 },
569 TypeParam {
570 name: "T1",
571 shape: || T1::SHAPE,
572 },
573 TypeParam {
574 name: "T2",
575 shape: || T2::SHAPE,
576 },
577 ])
578 .def(Def::FunctionPointer({
579 FunctionPointerDef::builder()
580 .parameter_types(&const { [|| T0::SHAPE, || T1::SHAPE, || T2::SHAPE] })
581 .return_type(|| R::SHAPE)
582 .abi(FunctionAbi::C)
583 .build()
584 }))
585 .build()
586 };
587}
588unsafe impl<'facet, R, T0, T1, T2, T3> Facet<'facet> for extern "C" fn(T0, T1, T2, T3) -> R
589where
590 T0: Facet<'facet>,
591 T1: Facet<'facet>,
592 T2: Facet<'facet>,
593 T3: Facet<'facet>,
594 R: Facet<'facet>,
595{
596 const SHAPE: &'static Shape = &const {
597 fn type_name<'facet, R, T0, T1, T2, T3>(
598 f: &mut fmt::Formatter,
599 opts: TypeNameOpts,
600 ) -> fmt::Result
601 where
602 T0: Facet<'facet>,
603 T1: Facet<'facet>,
604 T2: Facet<'facet>,
605 T3: Facet<'facet>,
606 R: Facet<'facet>,
607 {
608 write_type_name_list(
609 f,
610 opts,
611 FunctionAbi::C,
612 &[T0::SHAPE, T1::SHAPE, T2::SHAPE, T3::SHAPE],
613 R::SHAPE,
614 )
615 }
616
617 Shape::builder()
618 .id(ConstTypeId::of::<Self>())
619 .layout(Layout::new::<Self>())
620 .vtable(value_vtable!(Self, type_name::<R, T0, T1, T2, T3>))
621 .type_params(&[
622 TypeParam {
623 name: "T0",
624 shape: || T0::SHAPE,
625 },
626 TypeParam {
627 name: "T1",
628 shape: || T1::SHAPE,
629 },
630 TypeParam {
631 name: "T2",
632 shape: || T2::SHAPE,
633 },
634 TypeParam {
635 name: "T3",
636 shape: || T3::SHAPE,
637 },
638 ])
639 .def(Def::FunctionPointer({
640 FunctionPointerDef::builder()
641 .parameter_types(
642 &const { [|| T0::SHAPE, || T1::SHAPE, || T2::SHAPE, || T3::SHAPE] },
643 )
644 .return_type(|| R::SHAPE)
645 .abi(FunctionAbi::C)
646 .build()
647 }))
648 .build()
649 };
650}
651unsafe impl<'facet, R, T0, T1, T2, T3, T4> Facet<'facet> for extern "C" fn(T0, T1, T2, T3, T4) -> R
652where
653 T0: Facet<'facet>,
654 T1: Facet<'facet>,
655 T2: Facet<'facet>,
656 T3: Facet<'facet>,
657 T4: Facet<'facet>,
658 R: Facet<'facet>,
659{
660 const SHAPE: &'static Shape = &const {
661 fn type_name<'facet, R, T0, T1, T2, T3, T4>(
662 f: &mut fmt::Formatter,
663 opts: TypeNameOpts,
664 ) -> fmt::Result
665 where
666 T0: Facet<'facet>,
667 T1: Facet<'facet>,
668 T2: Facet<'facet>,
669 T3: Facet<'facet>,
670 T4: Facet<'facet>,
671 R: Facet<'facet>,
672 {
673 write_type_name_list(
674 f,
675 opts,
676 FunctionAbi::C,
677 &[T0::SHAPE, T1::SHAPE, T2::SHAPE, T3::SHAPE, T4::SHAPE],
678 R::SHAPE,
679 )
680 }
681
682 Shape::builder()
683 .id(ConstTypeId::of::<Self>())
684 .layout(Layout::new::<Self>())
685 .vtable(value_vtable!(Self, type_name::<R, T0, T1, T2, T3, T4>))
686 .type_params(&[
687 TypeParam {
688 name: "T0",
689 shape: || T0::SHAPE,
690 },
691 TypeParam {
692 name: "T1",
693 shape: || T1::SHAPE,
694 },
695 TypeParam {
696 name: "T2",
697 shape: || T2::SHAPE,
698 },
699 TypeParam {
700 name: "T3",
701 shape: || T3::SHAPE,
702 },
703 TypeParam {
704 name: "T4",
705 shape: || T4::SHAPE,
706 },
707 ])
708 .def(Def::FunctionPointer({
709 FunctionPointerDef::builder()
710 .parameter_types(
711 &const {
712 [
713 || T0::SHAPE,
714 || T1::SHAPE,
715 || T2::SHAPE,
716 || T3::SHAPE,
717 || T4::SHAPE,
718 ]
719 },
720 )
721 .return_type(|| R::SHAPE)
722 .abi(FunctionAbi::C)
723 .build()
724 }))
725 .build()
726 };
727}
728unsafe impl<'facet, R, T0, T1, T2, T3, T4, T5> Facet<'facet>
729 for extern "C" fn(T0, T1, T2, T3, T4, T5) -> R
730where
731 T0: Facet<'facet>,
732 T1: Facet<'facet>,
733 T2: Facet<'facet>,
734 T3: Facet<'facet>,
735 T4: Facet<'facet>,
736 T5: Facet<'facet>,
737 R: Facet<'facet>,
738{
739 const SHAPE: &'static Shape = &const {
740 fn type_name<'facet, R, T0, T1, T2, T3, T4, T5>(
741 f: &mut fmt::Formatter,
742 opts: TypeNameOpts,
743 ) -> fmt::Result
744 where
745 T0: Facet<'facet>,
746 T1: Facet<'facet>,
747 T2: Facet<'facet>,
748 T3: Facet<'facet>,
749 T4: Facet<'facet>,
750 T5: Facet<'facet>,
751 R: Facet<'facet>,
752 {
753 write_type_name_list(
754 f,
755 opts,
756 FunctionAbi::C,
757 &[
758 T0::SHAPE,
759 T1::SHAPE,
760 T2::SHAPE,
761 T3::SHAPE,
762 T4::SHAPE,
763 T5::SHAPE,
764 ],
765 R::SHAPE,
766 )
767 }
768
769 Shape::builder()
770 .id(ConstTypeId::of::<Self>())
771 .layout(Layout::new::<Self>())
772 .vtable(value_vtable!(Self, type_name::<R, T0, T1, T2, T3, T4, T5>))
773 .type_params(&[
774 TypeParam {
775 name: "T0",
776 shape: || T0::SHAPE,
777 },
778 TypeParam {
779 name: "T1",
780 shape: || T1::SHAPE,
781 },
782 TypeParam {
783 name: "T2",
784 shape: || T2::SHAPE,
785 },
786 TypeParam {
787 name: "T3",
788 shape: || T3::SHAPE,
789 },
790 TypeParam {
791 name: "T4",
792 shape: || T4::SHAPE,
793 },
794 TypeParam {
795 name: "T5",
796 shape: || T5::SHAPE,
797 },
798 ])
799 .def(Def::FunctionPointer({
800 FunctionPointerDef::builder()
801 .parameter_types(
802 &const {
803 [
804 || T0::SHAPE,
805 || T1::SHAPE,
806 || T2::SHAPE,
807 || T3::SHAPE,
808 || T4::SHAPE,
809 || T5::SHAPE,
810 ]
811 },
812 )
813 .return_type(|| R::SHAPE)
814 .abi(FunctionAbi::C)
815 .build()
816 }))
817 .build()
818 };
819}