19992185644

Committed 06 Dec 2025 05:57PM UTC coverage: 58.742% (-0.005%) from 58.747%

Build # 19992185644

Build Type

Pull #1118

github

Committed by

web-flow

Commit Message

Merge 46640849d into 45a8cb1c3

Pull Request Pull Request #1118: Reduce/cordon bloat in facet, introduce bloatbench

Run Details

1142 of 3107 new or added lines in 61 files covered. (36.76%)

533 existing lines in 29 files now uncovered.

24225 of 41240 relevant lines covered (58.74%)

502.5 hits per line

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

88.37

/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 {
            id: Shape::id_of::<Self>(),
            layout: Shape::layout_of::<Self>(),
            vtable: ValueVTable {
                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}]")
                    }
                },
                drop_in_place: ValueVTable::drop_in_place_for::<Self>(),
                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(|target| unsafe {
                            let t_dip = T::SHAPE.vtable.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, dst| unsafe {
                            let src = src.get::<Self>();
                            let t_cip = T::SHAPE.vtable.clone_into.unwrap();
                            let stride = T::SHAPE
                                .layout
                                .sized_layout()
                                .unwrap()
                                .pad_to_align()
                                .size();
                            for (idx, src) in src.iter().enumerate() {
                                (t_cip)(
                                    PtrConst::new(NonNull::from(src)),
                                    dst.field_uninit_at(idx * stride),
                                );
                            }
                            dst.assume_init()
                        })
                    } else {
                        None
                    }
                },
                ..ValueVTable::new(|_, _| Ok(()))
            },
            ty: Type::Sequence(SequenceType::Array(ArrayType { t: T::SHAPE, n: L })),
            def: Def::Array(ArrayDef::new(
                &const {
                    ArrayVTable::new(
                        |ptr| unsafe {
                            let array = ptr.get::<[T; L]>();
                            PtrConst::new(NonNull::from(array))
                        },
                        |ptr| unsafe {
                            let array = ptr.as_mut::<[T; L]>();
                            PtrMut::new(NonNull::from(array))
                        },
                    )
                },
                T::SHAPE,
                L,
            )),
            type_identifier: "&[_; _]",
            type_params: &[TypeParam {
                name: "T",
                shape: T::SHAPE,
            }],
            doc: &[],
            attributes: &[],
            type_tag: None,
            inner: None,
        }
    };
}

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

facet-rs / facet / 19992185644

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