15487210020

Committed 06 Jun 2025 09:19AM UTC coverage: 59.521% (+0.06%) from 59.46%

Build # 15487210020

Build Type

push

github

Committed by

fasterthanlime

Commit Message

Introduced sized/unsized ValueVTable variants

Co-Authored-By: Asger Hautop Drewsen <asger@tyilo.com>

Run Details

375 of 811 new or added lines in 32 files covered. (46.24%)

9 existing lines in 4 files now uncovered.

10537 of 17703 relevant lines covered (59.52%)

150.52 hits per line

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

63.81

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

use crate::*;
use core::hash::Hash as _;

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 VTABLE: &'static ValueVTable = &const {
        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()) }))
            .clone_into(|| {
                if T::SHAPE.vtable.has_clone_into() {
                    Some(|src, dst| unsafe {
                        let mut new_vec = Vec::with_capacity(src.len());

                        let t_clone_into = <VTableView<T>>::of().clone_into().unwrap();

                        for item in src {
                            use crate::TypedPtrUninit;
                            use core::mem::MaybeUninit;

                            let mut new_item = MaybeUninit::<T>::uninit();
                            let uninit_item = TypedPtrUninit::new(new_item.as_mut_ptr());

                            (t_clone_into)(item, uninit_item);

                            new_vec.push(new_item.assume_init());
                        }

                        dst.put(new_vec)
                    })
                } else {
                    None
                }
            })
            .debug(|| {
                if T::SHAPE.vtable.has_debug() {
                    Some(|value, f| {
                        write!(f, "[")?;
                        for (i, item) in value.iter().enumerate() {
                            if i > 0 {
                                write!(f, ", ")?;
                            }
                            (<VTableView<T>>::of().debug().unwrap())(item, f)?;
                        }
                        write!(f, "]")
                    })
                } else {
                    None
                }
            })
            .partial_eq(|| {
                if T::SHAPE.vtable.has_partial_eq() {
                    Some(|a, b| {
                        if a.len() != b.len() {
                            return false;
                        }
                        for (item_a, item_b) in a.iter().zip(b.iter()) {
                            if !(<VTableView<T>>::of().partial_eq().unwrap())(item_a, item_b) {
                                return false;
                            }
                        }
                        true
                    })
                } else {
                    None
                }
            })
            .hash(|| {
                if T::SHAPE.vtable.has_hash() {
                    Some(|vec, hasher_this, hasher_write_fn| unsafe {
                        use crate::HasherProxy;
                        let t_hash = <VTableView<T>>::of().hash().unwrap_unchecked();
                        let mut hasher = HasherProxy::new(hasher_this, hasher_write_fn);
                        vec.len().hash(&mut hasher);
                        for item in vec {
                            (t_hash)(item, hasher_this, hasher_write_fn);
                        }
                    })
                } else {
                    None
                }
            })
            .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()
    };

    const SHAPE: &'static Shape<'static> = &const {
        Shape::builder_for_sized::<Self>()
            .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(item))
                                })
                                .get_mut(|ptr, index| unsafe {
                                    let vec = ptr.as_mut::<Self>();
                                    let item = vec.get_mut(index)?;
                                    Some(PtrMut::new(item))
                                })
                                .as_ptr(|ptr| unsafe {
                                    let vec = ptr.get::<Self>();
                                    PtrConst::new(vec.as_ptr())
                                })
                                .as_mut_ptr(|ptr| unsafe {
                                    let vec = ptr.as_mut::<Self>();
                                    PtrMut::new(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(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(value))
                                        })
                                        .next_back(|iter_ptr| unsafe {
                                            let state = iter_ptr.as_mut::<VecIterator<'_, T>>();
                                            state.next_back().map(|value| PtrConst::new(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 crate::*;
2	use core::hash::Hash as _;
3
4	use alloc::boxed::Box;
5	use alloc::vec::Vec;
6
7	type VecIterator<'mem, T> = core::slice::Iter<'mem, T>;
8
9	unsafe impl<'a, T> Facet<'a> for Vec<T>
10	where
11	T: Facet<'a>,
12	{
13	const VTABLE: &'static ValueVTable = &const {
14	ValueVTable::builder::<Self>()
15	.type_name(\|f, opts\| {	546✔
16	if let Some(opts) = opts.for_children() {	546✔
17	write!(f, "{}<", Self::SHAPE.type_identifier)?;	546✔
18	T::SHAPE.vtable.type_name()(f, opts)?;	546✔
19	write!(f, ">")	546✔
20	} else {
21	write!(f, "{}<⋯>", Self::SHAPE.type_identifier)	×
22	}
23	})	546✔
24	.default_in_place(\|\| Some(\|target\| unsafe { target.put(Self::default()) }))	35✔
25	.clone_into(\|\| {	17✔
26	if T::SHAPE.vtable.has_clone_into() {	17✔
27	Some(\|src, dst\| unsafe {
28	let mut new_vec = Vec::with_capacity(src.len());	5✔
29
30	let t_clone_into = <VTableView<T>>::of().clone_into().unwrap();	5✔
31
32	for item in src {	16✔
33	use crate::TypedPtrUninit;
34	use core::mem::MaybeUninit;
35
36	let mut new_item = MaybeUninit::<T>::uninit();	11✔
37	let uninit_item = TypedPtrUninit::new(new_item.as_mut_ptr());	11✔
38
39	(t_clone_into)(item, uninit_item);	11✔
40
41	new_vec.push(new_item.assume_init());	11✔
42	}
43
44	dst.put(new_vec)	5✔
45	})	5✔
46	} else {
47	None	×
48	}
49	})	17✔
50	.debug(\|\| {	52✔
51	if T::SHAPE.vtable.has_debug() {	52✔
52	Some(\|value, f\| {	36✔
53	write!(f, "[")?;	36✔
54	for (i, item) in value.iter().enumerate() {	80✔
55	if i > 0 {	80✔
56	write!(f, ", ")?;	48✔
57	}	32✔
58	(<VTableView<T>>::of().debug().unwrap())(item, f)?;	80✔
59	}
60	write!(f, "]")	36✔
61	})	36✔
62	} else {
63	None	×
64	}
65	})	52✔
66	.partial_eq(\|\| {	16✔
67	if T::SHAPE.vtable.has_partial_eq() {	16✔
68	Some(\|a, b\| {	8✔
69	if a.len() != b.len() {	8✔
70	return false;	×
71	}	8✔
72	for (item_a, item_b) in a.iter().zip(b.iter()) {	14✔
73	if !(<VTableView<T>>::of().partial_eq().unwrap())(item_a, item_b) {	14✔
74	return false;	4✔
75	}	10✔
76	}
77	true	4✔
78	})	8✔
79	} else {
80	None	×
81	}
82	})	16✔
83	.hash(\|\| {	×
NEW 84	if T::SHAPE.vtable.has_hash() {	×
85	Some(\|vec, hasher_this, hasher_write_fn\| unsafe {
86	use crate::HasherProxy;
87	let t_hash = <VTableView<T>>::of().hash().unwrap_unchecked();	×
88	let mut hasher = HasherProxy::new(hasher_this, hasher_write_fn);	×
89	vec.len().hash(&mut hasher);	×
90	for item in vec {	×
91	(t_hash)(item, hasher_this, hasher_write_fn);	×
92	}	×
93	})	×
94	} else {
95	None	×
96	}
97	})	×
98	.marker_traits(\|\| {	8✔
99	MarkerTraits::SEND
100	.union(MarkerTraits::SYNC)	8✔
101	.union(MarkerTraits::EQ)	8✔
102	.union(MarkerTraits::UNPIN)	8✔
103	.union(MarkerTraits::UNWIND_SAFE)	8✔
104	.union(MarkerTraits::REF_UNWIND_SAFE)	8✔
105	.intersection(T::SHAPE.vtable.marker_traits())	8✔
106	})	8✔
107	.build()
108	};
109
110	const SHAPE: &'static Shape<'static> = &const {
111	Shape::builder_for_sized::<Self>()
112	.type_identifier("Vec")
113	.type_params(&[TypeParam {
114	name: "T",
115	shape: \|\| T::SHAPE,
116	}])
117	.ty(Type::User(UserType::Opaque))
118	.def(Def::List(
119	ListDef::builder()
120	.vtable(
121	&const {
122	ListVTable::builder()
123	.init_in_place_with_capacity(\|data, capacity\| unsafe {
124	data.put(Self::with_capacity(capacity))	116✔
125	})	116✔
126	.push(\|ptr, item\| unsafe {
127	let vec = ptr.as_mut::<Self>();	507✔
128	let item = item.read::<T>();	507✔
129	(*vec).push(item);	507✔
130	})	507✔
131	.len(\|ptr\| unsafe {
132	let vec = ptr.get::<Self>();	27✔
133	vec.len()	27✔
134	})	27✔
135	.get(\|ptr, index\| unsafe {
136	let vec = ptr.get::<Self>();	17✔
137	let item = vec.get(index)?;	17✔
138	Some(PtrConst::new(item))	14✔
139	})	17✔
140	.get_mut(\|ptr, index\| unsafe {
141	let vec = ptr.as_mut::<Self>();	×
142	let item = vec.get_mut(index)?;	×
143	Some(PtrMut::new(item))	×
144	})	×
145	.as_ptr(\|ptr\| unsafe {
146	let vec = ptr.get::<Self>();	12✔
147	PtrConst::new(vec.as_ptr())	12✔
148	})	12✔
149	.as_mut_ptr(\|ptr\| unsafe {
150	let vec = ptr.as_mut::<Self>();	×
151	PtrMut::new(vec.as_mut_ptr())	×
152	})	×
153	.iter_vtable(
154	IterVTable::builder()
155	.init_with_value(\|ptr\| unsafe {
156	let vec = ptr.get::<Self>();	×
157	let iter: VecIterator<T> = vec.iter();	×
158	let iter_state = Box::new(iter);	×
159	PtrMut::new(Box::into_raw(iter_state) as *mut u8)	×
160	})	×
161	.next(\|iter_ptr\| unsafe {
162	let state = iter_ptr.as_mut::<VecIterator<'_, T>>();	×
163	state.next().map(\|value\| PtrConst::new(value))	×
164	})	×
165	.next_back(\|iter_ptr\| unsafe {
166	let state = iter_ptr.as_mut::<VecIterator<'_, T>>();	×
167	state.next_back().map(\|value\| PtrConst::new(value))	×
168	})	×
169	.dealloc(\|iter_ptr\| unsafe {
170	drop(Box::from_raw(	×
171	iter_ptr.as_ptr::<VecIterator<'_, T>>()	×
172	as *mut VecIterator<'_, T>,	×
173	));
174	})	×
175	.build(),
176	)
177	.build()
178	},
179	)
180	.t(\|\| T::SHAPE)
181	.build(),
182	))
183	.build()
184	};
185	}

facet-rs / facet / 15487210020

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