15787779743

Committed 20 Jun 2025 09:01PM UTC coverage: 61.487% (+1.8%) from 59.711%

Build # 15787779743

Build Type

Pull #774

github

Committed by

web-flow

Commit Message

Merge dd04260c9 into ec93ce66e

Pull Request Pull Request #774: split up Partial::end into smaller bits

Run Details

147 of 165 new or added lines in 2 files covered. (89.09%)

1817 existing lines in 50 files now uncovered.

10564 of 17181 relevant lines covered (61.49%)

161.84 hits per line

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

85.42

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

use crate::*;

unsafe impl<'a, T, const L: usize> Facet<'a> for [T; L]
where
    T: Facet<'a>,
{
    const VTABLE: &'static ValueVTable = &const {
        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() })
                } 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()
                    })
                } 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 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, dst.field_uninit_at(idx * stride));
                        }
                        dst.assume_init()
                    })
                } else {
                    None
                }
            })
            .build()
    };

    const SHAPE: &'static Shape<'static> = &const {
        Shape::builder_for_sized::<Self>()
            .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(array.as_ptr())
                                })
                                .as_mut_ptr(|ptr| unsafe {
                                    let array = ptr.as_mut::<[T; L]>();
                                    PtrMut::new(array.as_mut_ptr())
                                })
                                .build()
                        },
                    )
                    .t(T::SHAPE)
                    .n(L)
                    .build(),
            ))
            .build()
    };
}

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

facet-rs / facet / 15787779743

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