14459841398

Committed 15 Apr 2025 02:20AM UTC coverage: 30.835% (+0.7%) from 30.122%

Build # 14459841398

Build Type

push

github

Committed by

web-flow

Commit Message

Rename opaque to ptr, closes #221 (#222)

Run Details

47 of 344 new or added lines in 20 files covered. (13.66%)

1 existing line in 1 file now uncovered.

2032 of 6590 relevant lines covered (30.83%)

25.82 hits per line

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

59.04

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

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

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

facet-rs / facet / 14459841398

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