18681425512

Committed 21 Oct 2025 10:48AM UTC coverage: 54.052% (-0.1%) from 54.168%

Build # 18681425512

Build Type

push

github

Committed by

fasterthanlime

Commit Message

use a more descriptive ReflectError variant

Run Details

2 of 12 new or added lines in 1 file covered. (16.67%)

1350 existing lines in 33 files now uncovered.

4762 of 8810 relevant lines covered (54.05%)

40.65 hits per line

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

52.38

/facet-core/src/impls_alloc/vec.rs

use core::ptr::NonNull;

use crate::*;

use alloc::boxed::Box;
use alloc::vec::Vec;

type VecIterator<'mem, T> = core::slice::Iter<'mem, T>;

unsafe impl<'a, T> Facet<'a> for Vec<T>
where
    T: Facet<'a>,
{
    const SHAPE: &'static Shape = &const {
        Shape::builder_for_sized::<Self>()
            .vtable({
                ValueVTable::builder::<Self>()
                    .type_name(|f, opts| {
                        if let Some(opts) = opts.for_children() {
                            write!(f, "{}<", Self::SHAPE.type_identifier)?;
                            T::SHAPE.vtable.type_name()(f, opts)?;
                            write!(f, ">")
                        } else {
                            write!(f, "{}<⋯>", Self::SHAPE.type_identifier)
                        }
                    })
                    .default_in_place(|| {
                        Some(|target| unsafe { target.put(Self::default()).into() })
                    })
                    .marker_traits(|| {
                        MarkerTraits::SEND
                            .union(MarkerTraits::SYNC)
                            .union(MarkerTraits::EQ)
                            .union(MarkerTraits::UNPIN)
                            .union(MarkerTraits::UNWIND_SAFE)
                            .union(MarkerTraits::REF_UNWIND_SAFE)
                            .intersection(T::SHAPE.vtable.marker_traits())
                    })
                    .build()
            })
            .type_identifier("Vec")
            .type_params(&[TypeParam {
                name: "T",
                shape: || T::SHAPE,
            }])
            .ty(Type::User(UserType::Opaque))
            .def(Def::List(
                ListDef::builder()
                    .vtable(
                        &const {
                            ListVTable::builder()
                                .init_in_place_with_capacity(|data, capacity| unsafe {
                                    data.put(Self::with_capacity(capacity))
                                })
                                .push(|ptr, item| unsafe {
                                    let vec = ptr.as_mut::<Self>();
                                    let item = item.read::<T>();
                                    (*vec).push(item);
                                })
                                .len(|ptr| unsafe {
                                    let vec = ptr.get::<Self>();
                                    vec.len()
                                })
                                .get(|ptr, index| unsafe {
                                    let vec = ptr.get::<Self>();
                                    let item = vec.get(index)?;
                                    Some(PtrConst::new(NonNull::from(item)))
                                })
                                .get_mut(|ptr, index| unsafe {
                                    let vec = ptr.as_mut::<Self>();
                                    let item = vec.get_mut(index)?;
                                    Some(PtrMut::new(NonNull::from(item)))
                                })
                                .as_ptr(|ptr| unsafe {
                                    let vec = ptr.get::<Self>();
                                    PtrConst::new(NonNull::new_unchecked(vec.as_ptr() as *mut T))
                                })
                                .as_mut_ptr(|ptr| unsafe {
                                    let vec = ptr.as_mut::<Self>();
                                    PtrMut::new(NonNull::new_unchecked(vec.as_mut_ptr()))
                                })
                                .iter_vtable(
                                    IterVTable::builder()
                                        .init_with_value(|ptr| unsafe {
                                            let vec = ptr.get::<Self>();
                                            let iter: VecIterator<T> = vec.iter();
                                            let iter_state = Box::new(iter);
                                            PtrMut::new(NonNull::new_unchecked(Box::into_raw(
                                                iter_state,
                                            )
                                                as *mut u8))
                                        })
                                        .next(|iter_ptr| unsafe {
                                            let state = iter_ptr.as_mut::<VecIterator<'_, T>>();
                                            state
                                                .next()
                                                .map(|value| PtrConst::new(NonNull::from(value)))
                                        })
                                        .next_back(|iter_ptr| unsafe {
                                            let state = iter_ptr.as_mut::<VecIterator<'_, T>>();
                                            state
                                                .next_back()
                                                .map(|value| PtrConst::new(NonNull::from(value)))
                                        })
                                        .dealloc(|iter_ptr| unsafe {
                                            drop(Box::from_raw(
                                                iter_ptr.as_ptr::<VecIterator<'_, T>>()
                                                    as *mut VecIterator<'_, T>,
                                            ));
                                        })
                                        .build(),
                                )
                                .build()
                        },
                    )
                    .t(|| T::SHAPE)
                    .build(),
            ))
            .build()
    };
}

1	use core::ptr::NonNull;
2
3	use crate::*;
4
5	use alloc::boxed::Box;
6	use alloc::vec::Vec;
7
8	type VecIterator<'mem, T> = core::slice::Iter<'mem, T>;
9
10	unsafe impl<'a, T> Facet<'a> for Vec<T>
11	where
12	T: Facet<'a>,
13	{
14	const SHAPE: &'static Shape = &const {
15	Shape::builder_for_sized::<Self>()
16	.vtable({
17	ValueVTable::builder::<Self>()
18	.type_name(\|f, opts\| {	5✔
19	if let Some(opts) = opts.for_children() {	5✔
20	write!(f, "{}<", Self::SHAPE.type_identifier)?;	5✔
21	T::SHAPE.vtable.type_name()(f, opts)?;	5✔
22	write!(f, ">")	5✔
23	} else {
UNCOV 24	write!(f, "{}<⋯>", Self::SHAPE.type_identifier)	×
25	}
26	})	5✔
27	.default_in_place(\|\| {	2✔
28	Some(\|target\| unsafe { target.put(Self::default()).into() })	1✔
29	})	2✔
30	.marker_traits(\|\| {	2✔
31	MarkerTraits::SEND
32	.union(MarkerTraits::SYNC)	2✔
33	.union(MarkerTraits::EQ)	2✔
34	.union(MarkerTraits::UNPIN)	2✔
35	.union(MarkerTraits::UNWIND_SAFE)	2✔
36	.union(MarkerTraits::REF_UNWIND_SAFE)	2✔
37	.intersection(T::SHAPE.vtable.marker_traits())	2✔
38	})	2✔
39	.build()
40	})
41	.type_identifier("Vec")
42	.type_params(&[TypeParam {
43	name: "T",
44	shape: \|\| T::SHAPE,
45	}])
46	.ty(Type::User(UserType::Opaque))
47	.def(Def::List(
48	ListDef::builder()
49	.vtable(
50	&const {
51	ListVTable::builder()
52	.init_in_place_with_capacity(\|data, capacity\| unsafe {
53	data.put(Self::with_capacity(capacity))	25✔
54	})	25✔
55	.push(\|ptr, item\| unsafe {
56	let vec = ptr.as_mut::<Self>();	51✔
57	let item = item.read::<T>();	51✔
58	(*vec).push(item);	51✔
59	})	51✔
60	.len(\|ptr\| unsafe {
61	let vec = ptr.get::<Self>();	4✔
62	vec.len()	4✔
63	})	4✔
64	.get(\|ptr, index\| unsafe {
65	let vec = ptr.get::<Self>();	8✔
66	let item = vec.get(index)?;	8✔
67	Some(PtrConst::new(NonNull::from(item)))	6✔
68	})	8✔
69	.get_mut(\|ptr, index\| unsafe {
70	let vec = ptr.as_mut::<Self>();	×
UNCOV 71	let item = vec.get_mut(index)?;	×
UNCOV 72	Some(PtrMut::new(NonNull::from(item)))	×
UNCOV 73	})	×
74	.as_ptr(\|ptr\| unsafe {
75	let vec = ptr.get::<Self>();	1✔
76	PtrConst::new(NonNull::new_unchecked(vec.as_ptr() as *mut T))	1✔
77	})	1✔
78	.as_mut_ptr(\|ptr\| unsafe {
UNCOV 79	let vec = ptr.as_mut::<Self>();	×
UNCOV 80	PtrMut::new(NonNull::new_unchecked(vec.as_mut_ptr()))	×
UNCOV 81	})	×
82	.iter_vtable(
83	IterVTable::builder()
84	.init_with_value(\|ptr\| unsafe {
85	let vec = ptr.get::<Self>();	×
86	let iter: VecIterator<T> = vec.iter();	×
UNCOV 87	let iter_state = Box::new(iter);	×
88	PtrMut::new(NonNull::new_unchecked(Box::into_raw(	×
89	iter_state,	×
90	)	×
UNCOV 91	as *mut u8))	×
92	})	×
93	.next(\|iter_ptr\| unsafe {
94	let state = iter_ptr.as_mut::<VecIterator<'_, T>>();	×
UNCOV 95	state	×
96	.next()	×
97	.map(\|value\| PtrConst::new(NonNull::from(value)))	×
98	})	×
99	.next_back(\|iter_ptr\| unsafe {
100	let state = iter_ptr.as_mut::<VecIterator<'_, T>>();	×
UNCOV 101	state	×
UNCOV 102	.next_back()	×
UNCOV 103	.map(\|value\| PtrConst::new(NonNull::from(value)))	×
UNCOV 104	})	×
105	.dealloc(\|iter_ptr\| unsafe {
UNCOV 106	drop(Box::from_raw(	×
UNCOV 107	iter_ptr.as_ptr::<VecIterator<'_, T>>()	×
UNCOV 108	as *mut VecIterator<'_, T>,	×
109	));
UNCOV 110	})	×
111	.build(),
112	)
113	.build()
114	},
115	)
116	.t(\|\| T::SHAPE)
117	.build(),
118	))
119	.build()
120	};
121	}

facet-rs / facet / 18681425512

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