15221452970

Committed 24 May 2025 12:26AM UTC coverage: 57.643% (+0.1%) from 57.538%

Build # 15221452970

Build Type

Pull #666

github

Committed by

web-flow

Commit Message

Merge e32d9af09 into 48c76b4b0

Pull Request Pull Request #666: Add indirection to vtable fns to fix cyclic types

Run Details

779 of 1499 new or added lines in 35 files covered. (51.97%)

14 existing lines in 5 files now uncovered.

9880 of 17140 relevant lines covered (57.64%)

137.68 hits per line

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

86.61

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

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

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}]")
                }
            })
            .display(|| {
                if (T::SHAPE.vtable.display)().is_some() {
                    Some(|value, f| {
                        write!(f, "[")?;

                        for (idx, value) in value.iter().enumerate() {
                            (<VTableView<T>>::of().display().unwrap())(value, f)?;
                            if idx != L - 1 {
                                write!(f, ", ")?;
                            }
                        }
                        write!(f, "]")
                    })
                } else {
                    None
                }
            })
            .debug(|| {
                if (T::SHAPE.vtable.debug)().is_some() {
                    Some(|value, f| {
                        write!(f, "[")?;

                        for (idx, value) in value.iter().enumerate() {
                            (<VTableView<T>>::of().debug().unwrap())(value, f)?;
                            if idx != L - 1 {
                                write!(f, ", ")?;
                            }
                        }
                        write!(f, "]")
                    })
                } else {
                    None
                }
            })
            .eq(|| {
                if (T::SHAPE.vtable.eq)().is_some() {
                    Some(|a, b| zip(a, b).all(|(a, b)| (<VTableView<T>>::of().eq().unwrap())(a, b)))
                } else {
                    None
                }
            })
            .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.default_in_place)().is_some() {
                    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.clone_into)().is_some() {
                    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
                }
            })
            .partial_ord(|| {
                if (T::SHAPE.vtable.partial_ord)().is_some() {
                    Some(|a, b| {
                        zip(a, b)
                            .find_map(|(a, b)| {
                                match (<VTableView<T>>::of().partial_ord().unwrap())(a, b) {
                                    Some(Ordering::Equal) => None,
                                    c => Some(c),
                                }
                            })
                            .unwrap_or(Some(Ordering::Equal))
                    })
                } else {
                    // arrays do not yet implement `Default` for > 32 elements due
                    // to specializing the `0` len case
                    None
                }
            })
            .ord(|| {
                if (T::SHAPE.vtable.ord)().is_some() {
                    Some(|a, b| {
                        zip(a, b)
                            .find_map(
                                |(a, b)| match (<VTableView<T>>::of().ord().unwrap())(a, b) {
                                    Ordering::Equal => None,
                                    c => Some(c),
                                },
                            )
                            .unwrap_or(Ordering::Equal)
                    })
                } else {
                    // arrays do not yet implement `Default` for > 32 elements due
                    // to specializing the `0` len case
                    None
                }
            })
            .hash(|| {
                if (T::SHAPE.vtable.hash)().is_some() {
                    Some(|value, state, hasher| {
                        for value in value {
                            (<VTableView<T>>::of().hash().unwrap())(value, state, hasher)
                        }
                    })
                } else {
                    // arrays do not yet implement `Default` for > 32 elements due
                    // to specializing the `0` len case
                    None
                }
            })
            .build()
    };

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

facet-rs / facet / 15221452970

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