14649136746

Committed 24 Apr 2025 06:37PM UTC coverage: 49.28% (-0.2%) from 49.489%

Build # 14649136746

Build Type

Pull #385

github

Committed by

web-flow

Commit Message

Merge be2eaf36c into 5888a23c2

Pull Request Pull Request #385: Add support for `!Sized` types

Run Details

70 of 129 new or added lines in 14 files covered. (54.26%)

2 existing lines in 1 file now uncovered.

6299 of 12782 relevant lines covered (49.28%)

61.59 hits per line

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

61.68

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

use crate::*;
use core::alloc::Layout;
use core::{cmp::Ordering, iter::zip};

unsafe impl<'a, T, const L: usize> Facet<'a> for [T; L]
where
    T: Facet<'a>,
{
    const SHAPE: &'static Shape = &const {
        Shape::builder()
            .id(ConstTypeId::of::<[T; L]>())
            .layout(Layout::new::<[T; L]>())
            .type_params(&[
                TypeParam {
                    name: "T",
                    shape: || T::SHAPE,
                }
            ])
            .vtable(
                &const {
                    let mut builder = ValueVTable::builder()
                        .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}]")
                            }
                        })
                        .drop_in_place(|value| unsafe { value.drop_in_place::<[T; L]>() });
                    if T::SHAPE.vtable.display.is_some() {
                        builder = builder.display(|value, f| {
                            let value = unsafe { value.get::<[T; L]>() };
                            write!(f, "[")?;

                            for (idx, value) in value.iter().enumerate() {
                                unsafe {
                                    (T::SHAPE.vtable.display.unwrap_unchecked())(
                                        PtrConst::new(value),
                                        f,
                                    )?
                                };
                                if idx != L - 1 {
                                    write!(f, ", ")?;
                                }
                            }
                            write!(f, "]")
                        });
                    }
                    if T::SHAPE.vtable.debug.is_some() {
                        builder = builder.debug(|value, f| {
                            let value = unsafe { value.get::<[T; L]>() };
                            write!(f, "[")?;

                            for (idx, value) in value.iter().enumerate() {
                                unsafe {
                                    (T::SHAPE.vtable.debug.unwrap_unchecked())(
                                        PtrConst::new(value),
                                        f,
                                    )?
                                };
                                if idx != L - 1 {
                                    write!(f, ", ")?;
                                }
                            }
                            write!(f, "]")
                        });
                    }
                    if T::SHAPE.vtable.eq.is_some() {
                        builder = builder.eq(|a, b| {
                            let a = unsafe { a.get::<[T; L]>() };
                            let b = unsafe { b.get::<[T; L]>() };
                            zip(a, b).all(|(a, b)| unsafe {
                                (T::SHAPE.vtable.eq.unwrap_unchecked())(
                                    PtrConst::new(a),
                                    PtrConst::new(b),
                                )
                            })
                        });
                    }
                    if L == 0 {
                        // Zero-length arrays implement `Default` irrespective of the element type
                        builder =
                            builder.default_in_place(|target| unsafe { target.assume_init() });
                    } else if L <= 32 && T::SHAPE.vtable.default_in_place.is_some() {
                        builder = builder.default_in_place(|target| unsafe {
                            let t_dip = T::SHAPE.vtable.default_in_place.unwrap_unchecked();
                            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
                    }
                    if T::SHAPE.vtable.clone_into.is_some() {
                        builder = builder.clone_into(|src, dst| unsafe {
                            let t_cip = T::SHAPE.vtable.clone_into.unwrap_unchecked();
                            let src = src.get::<[T; L]>();
                            let stride = T::SHAPE.layout.sized_layout().unwrap().pad_to_align().size();
                            for (idx, src) in src.iter().enumerate() {
                                (t_cip)(PtrConst::new(src), dst.field_uninit_at(idx * stride));
                            }
                            dst.assume_init()
                        });
                    }
                    if T::SHAPE.vtable.partial_ord.is_some() {
                        builder = builder.partial_ord(|a, b| {
                            let a = unsafe { a.get::<[T; L]>() };
                            let b = unsafe { b.get::<[T; L]>() };
                            zip(a, b)
                                .find_map(|(a, b)| unsafe {
                                    match (T::SHAPE.vtable.partial_ord.unwrap_unchecked())(
                                        PtrConst::new(a),
                                        PtrConst::new(b),
                                    ) {
                                        Some(Ordering::Equal) => None,
                                        c => Some(c),
                                    }
                                })
                                .unwrap_or(Some(Ordering::Equal))
                        });
                    }
                    if T::SHAPE.vtable.ord.is_some() {
                        builder = builder.ord(|a, b| {
                            let a = unsafe { a.get::<[T; L]>() };
                            let b = unsafe { b.get::<[T; L]>() };
                            zip(a, b)
                                .find_map(|(a, b)| unsafe {
                                    match (T::SHAPE.vtable.ord.unwrap_unchecked())(
                                        PtrConst::new(a),
                                        PtrConst::new(b),
                                    ) {
                                        Ordering::Equal => None,
                                        c => Some(c),
                                    }
                                })
                                .unwrap_or(Ordering::Equal)
                        });
                    }
                    if T::SHAPE.vtable.hash.is_some() {
                        builder = builder.hash(|value, state, hasher| {
                            let value = unsafe { value.get::<[T; L]>() };
                            for value in value {
                                unsafe {
                                    (T::SHAPE.vtable.hash.unwrap_unchecked())(
                                        PtrConst::new(value),
                                        state,
                                        hasher,
                                    )
                                }
                            }
                        });
                    }
                    builder.build()
                },
            )
            .def(Def::Array(
                ArrayDef::builder()
                    .vtable(
                        &const {
                            ArrayVTable::builder()
                                .get_item_ptr(|ptr, index| unsafe {
                                    if index >= L {
                                        panic!(
                                            "Index out of bounds: the len is {L} but the index is {index}"
                                        );
                                    }
                                    PtrConst::new(ptr.as_ptr::<[T; L]>())
                                })
                                .build()
                        },
                    )
                    .n(L)
                    .t(|| T::SHAPE)
                    .build(),
            ))
            .build()
    };
}

1	use crate::*;
2	use core::alloc::Layout;
3	use core::{cmp::Ordering, iter::zip};
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()
11	.id(ConstTypeId::of::<[T; L]>())
12	.layout(Layout::new::<[T; L]>())
13	.type_params(&[
14	TypeParam {
15	name: "T",
16	shape: \|\| T::SHAPE,	1✔
17	}
18	])
19	.vtable(
20	&const {
21	let mut builder = ValueVTable::builder()
22	.marker_traits(T::SHAPE.vtable.marker_traits)
23	.type_name(\|f, opts\| {	10✔
24	if let Some(opts) = opts.for_children() {	10✔
25	write!(f, "[")?;	10✔
26	(T::SHAPE.vtable.type_name)(f, opts)?;	10✔
27	write!(f, "; {L}]")	10✔
28	} else {
29	write!(f, "[⋯; {L}]")	×
30	}
31	})	10✔
32	.drop_in_place(\|value\| unsafe { value.drop_in_place::<[T; L]>() });	4✔
33	if T::SHAPE.vtable.display.is_some() {
34	builder = builder.display(\|value, f\| {	10✔
35	let value = unsafe { value.get::<[T; L]>() };	10✔
36	write!(f, "[")?;	10✔
37
38	for (idx, value) in value.iter().enumerate() {	74✔
39	unsafe {
40	(T::SHAPE.vtable.display.unwrap_unchecked())(	74✔
41	PtrConst::new(value),	74✔
42	f,	74✔
43	)?	74✔
44	};
45	if idx != L - 1 {	74✔
46	write!(f, ", ")?;	66✔
47	}	8✔
48	}
49	write!(f, "]")	10✔
50	});	10✔
51	}
52	if T::SHAPE.vtable.debug.is_some() {
53	builder = builder.debug(\|value, f\| {	34✔
54	let value = unsafe { value.get::<[T; L]>() };	34✔
55	write!(f, "[")?;	34✔
56
57	for (idx, value) in value.iter().enumerate() {	226✔
58	unsafe {
59	(T::SHAPE.vtable.debug.unwrap_unchecked())(	226✔
60	PtrConst::new(value),	226✔
61	f,	226✔
62	)?	226✔
63	};
64	if idx != L - 1 {	226✔
65	write!(f, ", ")?;	199✔
66	}	27✔
67	}
68	write!(f, "]")	34✔
69	});	34✔
70	}
71	if T::SHAPE.vtable.eq.is_some() {
72	builder = builder.eq(\|a, b\| {	5✔
73	let a = unsafe { a.get::<[T; L]>() };	5✔
74	let b = unsafe { b.get::<[T; L]>() };	5✔
75	zip(a, b).all(\|(a, b)\| unsafe {	37✔
76	(T::SHAPE.vtable.eq.unwrap_unchecked())(	37✔
77	PtrConst::new(a),	37✔
78	PtrConst::new(b),	37✔
79	)	37✔
80	})	37✔
81	});	5✔
82	}
83	if L == 0 {
84	// Zero-length arrays implement `Default` irrespective of the element type
85	builder =
86	builder.default_in_place(\|target\| unsafe { target.assume_init() });	1✔
87	} else if L <= 32 && T::SHAPE.vtable.default_in_place.is_some() {
88	builder = builder.default_in_place(\|target\| unsafe {	3✔
89	let t_dip = T::SHAPE.vtable.default_in_place.unwrap_unchecked();	3✔
90	let stride = T::SHAPE.layout.sized_layout().unwrap().pad_to_align().size();	3✔
91	for idx in 0..L {	7✔
92	t_dip(target.field_uninit_at(idx * stride));	4✔
93	}	4✔
94	target.assume_init()	3✔
95	});	3✔
96	} else {
97	// arrays do not yet implement `Default` for > 32 elements due to
98	// specializing the `0` len case
99	}
100	if T::SHAPE.vtable.clone_into.is_some() {
101	builder = builder.clone_into(\|src, dst\| unsafe {	×
102	let t_cip = T::SHAPE.vtable.clone_into.unwrap_unchecked();	×
103	let src = src.get::<[T; L]>();	×
NEW 104	let stride = T::SHAPE.layout.sized_layout().unwrap().pad_to_align().size();	×
105	for (idx, src) in src.iter().enumerate() {	×
106	(t_cip)(PtrConst::new(src), dst.field_uninit_at(idx * stride));	×
107	}	×
108	dst.assume_init()	×
109	});	×
110	}
111	if T::SHAPE.vtable.partial_ord.is_some() {
112	builder = builder.partial_ord(\|a, b\| {	5✔
113	let a = unsafe { a.get::<[T; L]>() };	5✔
114	let b = unsafe { b.get::<[T; L]>() };	5✔
115	zip(a, b)	5✔
116	.find_map(\|(a, b)\| unsafe {	37✔
117	match (T::SHAPE.vtable.partial_ord.unwrap_unchecked())(	37✔
118	PtrConst::new(a),	37✔
119	PtrConst::new(b),	37✔
120	) {
121	Some(Ordering::Equal) => None,	34✔
122	c => Some(c),	3✔
123	}
124	})	37✔
125	.unwrap_or(Some(Ordering::Equal))	5✔
126	});	5✔
127	}
128	if T::SHAPE.vtable.ord.is_some() {
129	builder = builder.ord(\|a, b\| {	×
130	let a = unsafe { a.get::<[T; L]>() };	×
131	let b = unsafe { b.get::<[T; L]>() };	×
132	zip(a, b)	×
133	.find_map(\|(a, b)\| unsafe {	×
134	match (T::SHAPE.vtable.ord.unwrap_unchecked())(	×
135	PtrConst::new(a),	×
136	PtrConst::new(b),	×
137	) {	×
138	Ordering::Equal => None,	×
139	c => Some(c),	×
140	}
141	})	×
142	.unwrap_or(Ordering::Equal)	×
143	});	×
144	}
145	if T::SHAPE.vtable.hash.is_some() {
146	builder = builder.hash(\|value, state, hasher\| {	×
147	let value = unsafe { value.get::<[T; L]>() };	×
148	for value in value {	×
149	unsafe {
150	(T::SHAPE.vtable.hash.unwrap_unchecked())(	×
151	PtrConst::new(value),	×
152	state,	×
153	hasher,	×
154	)	×
155	}
156	}
157	});	×
158	}
159	builder.build()
160	},
161	)
162	.def(Def::Array(
163	ArrayDef::builder()
164	.vtable(
165	&const {
166	ArrayVTable::builder()
167	.get_item_ptr(\|ptr, index\| unsafe {	×
168	if index >= L {	×
169	panic!(	×
170	"Index out of bounds: the len is {L} but the index is {index}"	×
171	);
172	}	×
173	PtrConst::new(ptr.as_ptr::<[T; L]>())	×
174	})	×
175	.build()
176	},
177	)
178	.n(L)
179	.t(\|\| T::SHAPE)	×
180	.build(),
181	))
182	.build()
183	};
184	}

facet-rs / facet / 14649136746

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