18753214047

Committed 23 Oct 2025 03:14PM UTC coverage: 52.734% (-1.1%) from 53.804%

Build # 18753214047

Build Type

push

github

Committed by

fasterthanlime

Commit Message

more vtable trait impls

Run Details

154 of 467 new or added lines in 16 files covered. (32.98%)

4 existing lines in 4 files now uncovered.

4668 of 8852 relevant lines covered (52.73%)

41.45 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.18

/facet-core/src/impls_core/array.rs

use core::ptr::NonNull;

use crate::*;

unsafe impl<'a, T, const L: usize> Facet<'a> for [T; L]
where
    T: Facet<'a>,
{
    const SHAPE: &'static Shape = &const {
        Shape::builder_for_sized::<Self>()
            .vtable(
                ValueVTable::builder::<Self>()
                    .marker_traits(T::SHAPE.vtable.marker_traits())
                    .type_name(|f, opts| {
                        if let Some(opts) = opts.for_children() {
                            write!(f, "[")?;
                            (T::SHAPE.vtable.type_name())(f, opts)?;
                            write!(f, "; {L}]")
                        } else {
                            write!(f, "[…; {L}]")
                        }
                    })
                    .default_in_place({
                        if L == 0 {
                            // Zero-length arrays implement `Default` irrespective of the element type
                            Some(|target| unsafe { target.assume_init().into() })
                        } else if L <= 32 && T::SHAPE.vtable.has_default_in_place() {
                            Some(|mut target| unsafe {
                                let t_dip = <VTableView<T>>::of().default_in_place().unwrap();
                                let stride = T::SHAPE
                                    .layout
                                    .sized_layout()
                                    .unwrap()
                                    .pad_to_align()
                                    .size();
                                for idx in 0..L {
                                    t_dip(target.field_uninit_at(idx * stride));
                                }
                                target.assume_init().into()
                            })
                        } else {
                            // arrays do not yet implement `Default` for > 32 elements due
                            // to specializing the `0` len case
                            None
                        }
                    })
                    .clone_into({
                        if T::SHAPE.vtable.has_clone_into() {
                            Some(|src, mut dst| unsafe {
                                let src = src.get();
                                let t_cip = <VTableView<T>>::of().clone_into().unwrap();
                                let stride = T::SHAPE
                                    .layout
                                    .sized_layout()
                                    .unwrap()
                                    .pad_to_align()
                                    .size();
                                for (idx, src) in src.iter().enumerate() {
                                    (t_cip)(src.into(), dst.field_uninit_at(idx * stride));
                                }
                                dst.assume_init().into()
                            })
                        } else {
                            None
                        }
                    })
                    .build(),
            )
            .type_identifier("&[_; _]")
            .type_params(&[TypeParam {
                name: "T",
                shape: T::SHAPE,
            }])
            .ty(Type::Sequence(SequenceType::Array(ArrayType {
                t: T::SHAPE,
                n: L,
            })))
            .def(Def::Array(
                ArrayDef::builder()
                    .vtable(
                        &const {
                            ArrayVTable::builder()
                                .as_ptr(|ptr| unsafe {
                                    let array = ptr.get::<[T; L]>();
                                    PtrConst::new(NonNull::from(array))
                                })
                                .as_mut_ptr(|ptr| unsafe {
                                    let array = ptr.as_mut::<[T; L]>();
                                    PtrMut::new(NonNull::from(array))
                                })
                                .build()
                        },
                    )
                    .t(T::SHAPE)
                    .n(L)
                    .build(),
            ))
            .build()
    };
}

1	use core::ptr::NonNull;
2
3	use crate::*;
4
5	unsafe impl<'a, T, const L: usize> Facet<'a> for [T; L]
6	where
7	T: Facet<'a>,
8	{
9	const SHAPE: &'static Shape = &const {
10	Shape::builder_for_sized::<Self>()
11	.vtable(
12	ValueVTable::builder::<Self>()
13	.marker_traits(T::SHAPE.vtable.marker_traits())
14	.type_name(\|f, opts\| {	3✔
15	if let Some(opts) = opts.for_children() {	3✔
16	write!(f, "[")?;	3✔
17	(T::SHAPE.vtable.type_name())(f, opts)?;	3✔
18	write!(f, "; {L}]")	3✔
19	} else {
NEW 20	write!(f, "[…; {L}]")	×
21	}
22	})	3✔
23	.default_in_place({
24	if L == 0 {
25	// Zero-length arrays implement `Default` irrespective of the element type
26	Some(\|target\| unsafe { target.assume_init().into() })	×
27	} else if L <= 32 && T::SHAPE.vtable.has_default_in_place() {
28	Some(\|mut target\| unsafe {
29	let t_dip = <VTableView<T>>::of().default_in_place().unwrap();	1✔
30	let stride = T::SHAPE	1✔
31	.layout	1✔
32	.sized_layout()	1✔
33	.unwrap()	1✔
34	.pad_to_align()	1✔
35	.size();	1✔
36	for idx in 0..L {	2✔
37	t_dip(target.field_uninit_at(idx * stride));	1✔
38	}	1✔
39	target.assume_init().into()	1✔
40	})	1✔
41	} else {
42	// arrays do not yet implement `Default` for > 32 elements due
43	// to specializing the `0` len case
44	None
45	}
46	})
47	.clone_into({
48	if T::SHAPE.vtable.has_clone_into() {
49	Some(\|src, mut dst\| unsafe {
50	let src = src.get();	1✔
51	let t_cip = <VTableView<T>>::of().clone_into().unwrap();	1✔
52	let stride = T::SHAPE	1✔
53	.layout	1✔
54	.sized_layout()	1✔
55	.unwrap()	1✔
56	.pad_to_align()	1✔
57	.size();	1✔
58	for (idx, src) in src.iter().enumerate() {	1✔
59	(t_cip)(src.into(), dst.field_uninit_at(idx * stride));	1✔
60	}	1✔
61	dst.assume_init().into()	1✔
62	})	1✔
63	} else {
64	None
65	}
66	})
67	.build(),
68	)
69	.type_identifier("&[_; _]")
70	.type_params(&[TypeParam {
71	name: "T",
72	shape: T::SHAPE,
73	}])
74	.ty(Type::Sequence(SequenceType::Array(ArrayType {
75	t: T::SHAPE,
76	n: L,
77	})))
78	.def(Def::Array(
79	ArrayDef::builder()
80	.vtable(
81	&const {
82	ArrayVTable::builder()
83	.as_ptr(\|ptr\| unsafe {
84	let array = ptr.get::<[T; L]>();	3✔
85	PtrConst::new(NonNull::from(array))	3✔
86	})	3✔
87	.as_mut_ptr(\|ptr\| unsafe {
88	let array = ptr.as_mut::<[T; L]>();	×
89	PtrMut::new(NonNull::from(array))	×
90	})	×
91	.build()
92	},
93	)
94	.t(T::SHAPE)
95	.n(L)
96	.build(),
97	))
98	.build()
99	};
100	}

facet-rs / facet / 18753214047

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous