15084260214

Committed 17 May 2025 10:22AM UTC coverage: 56.732% (-0.05%) from 56.778%

Build # 15084260214

Build Type

Pull #635

github

Committed by

web-flow

Commit Message

Merge 8cdda5d5d into 88d7d16bb

Pull Request Pull Request #635: Update list vtables to allow for more types of lists

Run Details

73 of 127 new or added lines in 4 files covered. (57.48%)

5 existing lines in 1 file now uncovered.

9097 of 16035 relevant lines covered (56.73%)

126.11 hits per line

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

59.26

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

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

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 {
        let mut builder = ValueVTable::builder::<Self>()
            .type_name(|f, opts| {
                if let Some(opts) = opts.for_children() {
                    write!(f, "Vec<")?;
                    (T::SHAPE.vtable.type_name)(f, opts)?;
                    write!(f, ">")
                } else {
                    write!(f, "Vec<⋯>")
                }
            })
            .default_in_place(|target| unsafe { target.put(Self::default()) });

        if T::SHAPE.vtable.clone_into.is_some() {
            builder = builder.clone_into(|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)
            });
        }

        if T::SHAPE.vtable.debug.is_some() {
            builder = builder.debug(|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, "]")
            });
        }

        if T::SHAPE.vtable.eq.is_some() {
            builder = builder.eq(|a, b| {
                if a.len() != b.len() {
                    return false;
                }
                for (item_a, item_b) in a.iter().zip(b.iter()) {
                    if !(<VTableView<T>>::of().eq().unwrap())(item_a, item_b) {
                        return false;
                    }
                }
                true
            });
        }

        if T::SHAPE.vtable.hash.is_some() {
            builder = builder.hash(|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);
                }
            });
        }

        let traits = MarkerTraits::SEND
            .union(MarkerTraits::SYNC)
            .union(MarkerTraits::EQ)
            .union(MarkerTraits::UNPIN)
            .intersection(T::SHAPE.vtable.marker_traits);
        builder = builder.marker_traits(traits);

        builder.build()
    };

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

facet-rs / facet / 15084260214

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