15040092313

Committed 15 May 2025 08:17AM UTC coverage: 57.944% (+0.08%) from 57.861%

Build # 15040092313

Build Type

Pull #618

github

Committed by

web-flow

Commit Message

Merge f0895b31d into 15876b84f

Pull Request Pull Request #618: Make `IterVTable` generic over the iteratee

Run Details

27 of 78 new or added lines in 8 files covered. (34.62%)

94 existing lines in 6 files now uncovered.

10000 of 17258 relevant lines covered (57.94%)

121.21 hits per line

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

78.69

/facet-core/src/impls_std/hashmap.rs

use alloc::collections::VecDeque;
use core::hash::{BuildHasher, Hash};
use std::collections::HashMap;
use std::hash::RandomState;

use crate::ptr::{PtrConst, PtrMut};

use crate::{
    Def, Facet, IterVTable, MapDef, MapVTable, MarkerTraits, ScalarAffinity, ScalarDef, Shape,
    Type, TypeParam, UserType, VTableView, ValueVTable, value_vtable,
};

struct HashMapIterator<'mem, K> {
    map: PtrConst<'mem>,
    keys: VecDeque<&'mem K>,
}

unsafe impl<'a, K, V, S> Facet<'a> for HashMap<K, V, S>
where
    K: Facet<'a> + core::cmp::Eq + core::hash::Hash,
    V: Facet<'a>,
    S: Facet<'a> + Default + BuildHasher,
{
    const VTABLE: &'static ValueVTable = &const {
        let mut builder = ValueVTable::builder::<Self>()
            .marker_traits({
                let arg_dependent_traits = MarkerTraits::SEND
                    .union(MarkerTraits::SYNC)
                    .union(MarkerTraits::EQ)
                    .union(MarkerTraits::UNPIN);
                arg_dependent_traits
                    .intersection(V::SHAPE.vtable.marker_traits)
                    .intersection(K::SHAPE.vtable.marker_traits)
            })
            .type_name(|f, opts| {
                if let Some(opts) = opts.for_children() {
                    write!(f, "HashMap<")?;
                    (K::SHAPE.vtable.type_name)(f, opts)?;
                    write!(f, ", ")?;
                    (V::SHAPE.vtable.type_name)(f, opts)?;
                    write!(f, ">")
                } else {
                    write!(f, "HashMap<⋯>")
                }
            });

        if K::SHAPE.vtable.debug.is_some() && V::SHAPE.vtable.debug.is_some() {
            builder = builder.debug(|value, f| {
                let k_debug = <VTableView<K>>::of().debug().unwrap();
                let v_debug = <VTableView<V>>::of().debug().unwrap();
                write!(f, "{{")?;
                for (i, (key, val)) in value.iter().enumerate() {
                    if i > 0 {
                        write!(f, ", ")?;
                    }
                    (k_debug)(key, f)?;
                    write!(f, ": ")?;
                    (v_debug)(val, f)?;
                }
                write!(f, "}}")
            });
        }

        builder = builder.default_in_place(|target| unsafe { target.put(Self::default()) });

        if V::SHAPE.vtable.clone_into.is_some() && K::SHAPE.vtable.clone_into.is_some() {
            builder = builder.clone_into(|src, dst| unsafe {
                let map = src;
                let mut new_map = HashMap::with_capacity_and_hasher(map.len(), S::default());

                let k_clone_into = <VTableView<K>>::of().clone_into().unwrap();
                let v_clone_into = <VTableView<V>>::of().clone_into().unwrap();

                for (k, v) in map {
                    use crate::TypedPtrUninit;
                    use core::mem::MaybeUninit;

                    let mut new_k = MaybeUninit::<K>::uninit();
                    let mut new_v = MaybeUninit::<V>::uninit();

                    let uninit_k = TypedPtrUninit::new(new_k.as_mut_ptr());
                    let uninit_v = TypedPtrUninit::new(new_v.as_mut_ptr());

                    (k_clone_into)(k, uninit_k);
                    (v_clone_into)(v, uninit_v);

                    new_map.insert(new_k.assume_init(), new_v.assume_init());
                }

                dst.put(new_map)
            });
        }

        if V::SHAPE.vtable.eq.is_some() {
            builder = builder.eq(|a, b| {
                let v_eq = <VTableView<V>>::of().eq().unwrap();
                a.len() == b.len()
                    && a.iter().all(|(key_a, val_a)| {
                        b.get(key_a).is_some_and(|val_b| (v_eq)(val_a, val_b))
                    })
            });
        }

        if V::SHAPE.vtable.hash.is_some() {
            builder = builder.hash(|map, hasher_this, hasher_write_fn| unsafe {
                use crate::HasherProxy;
                let v_hash = <VTableView<V>>::of().hash().unwrap();
                let mut hasher = HasherProxy::new(hasher_this, hasher_write_fn);
                map.len().hash(&mut hasher);
                for (k, v) in map {
                    k.hash(&mut hasher);
                    (v_hash)(v, hasher_this, hasher_write_fn);
                }
            });
        }

        builder.build()
    };

    const SHAPE: &'static Shape = &const {
        Shape::builder_for_sized::<Self>()
            .type_params(&[
                TypeParam {
                    name: "K",
                    shape: || K::SHAPE,
                },
                TypeParam {
                    name: "V",
                    shape: || V::SHAPE,
                },
                TypeParam {
                    name: "S",
                    shape: || S::SHAPE,
                },
            ])
            .ty(Type::User(UserType::Opaque))
            .def(Def::Map(
                MapDef::builder()
                    .k(|| K::SHAPE)
                    .v(|| V::SHAPE)
                    .vtable(
                        &const {
                            MapVTable::builder()
                                .init_in_place_with_capacity(|uninit, capacity| unsafe {
                                    uninit
                                        .put(Self::with_capacity_and_hasher(capacity, S::default()))
                                })
                                .insert(|ptr, key, value| unsafe {
                                    let map = ptr.as_mut::<HashMap<K, V>>();
                                    let key = key.read::<K>();
                                    let value = value.read::<V>();
                                    map.insert(key, value);
                                })
                                .len(|ptr| unsafe {
                                    let map = ptr.get::<HashMap<K, V>>();
                                    map.len()
                                })
                                .contains_key(|ptr, key| unsafe {
                                    let map = ptr.get::<HashMap<K, V>>();
                                    map.contains_key(key.get())
                                })
                                .get_value_ptr(|ptr, key| unsafe {
                                    let map = ptr.get::<HashMap<K, V>>();
                                    map.get(key.get()).map(|v| PtrConst::new(v))
                                })
                                .iter_vtable(
                                    IterVTable::builder()
                                        .init_with_value(|ptr| unsafe {
                                            let map = ptr.get::<HashMap<K, V>>();
                                            let keys: VecDeque<&K> = map.keys().collect();
                                            let iter_state =
                                                Box::new(HashMapIterator { map: ptr, keys });
                                            PtrMut::new(Box::into_raw(iter_state) as *mut u8)
                                        })
                                        .next(|iter_ptr| unsafe {
                                            let state = iter_ptr.as_mut::<HashMapIterator<'_, K>>();
                                            let map = state.map.get::<HashMap<K, V>>();
                                            while let Some(key) = state.keys.pop_front() {
                                                if let Some(value) = map.get(key) {
                                                    return Some((
                                                        PtrConst::new(key as *const K),
                                                        PtrConst::new(value as *const V),
                                                    ));
                                                }
                                            }

                                            None
                                        })
                                        .next_back(|iter_ptr| unsafe {
                                            let state = iter_ptr.as_mut::<HashMapIterator<'_, K>>();
                                            let map = state.map.get::<HashMap<K, V>>();
                                            while let Some(key) = state.keys.pop_back() {
                                                if let Some(value) = map.get(key) {
                                                    return Some((
                                                        PtrConst::new(key as *const K),
                                                        PtrConst::new(value as *const V),
                                                    ));
                                                }
                                            }

                                            None
                                        })
                                        .dealloc(|iter_ptr| unsafe {
                                            drop(Box::from_raw(
                                                iter_ptr.as_ptr::<HashMapIterator<'_, K>>()
                                                    as *mut HashMapIterator<'_, K>,
                                            ));
                                        })
                                        .build(),
                                )
                                .build()
                        },
                    )
                    .build(),
            ))
            .build()
    };
}

unsafe impl Facet<'_> for RandomState {
    const VTABLE: &'static ValueVTable =
        &const { value_vtable!((), |f, _opts| write!(f, "RandomState")) };

    const SHAPE: &'static Shape = &const {
        Shape::builder_for_sized::<Self>()
            .ty(Type::User(UserType::Opaque))
            .def(Def::Scalar(
                ScalarDef::builder()
                    .affinity(ScalarAffinity::opaque().build())
                    .build(),
            ))
            .build()
    };
}

1	use alloc::collections::VecDeque;
2	use core::hash::{BuildHasher, Hash};
3	use std::collections::HashMap;
4	use std::hash::RandomState;
5
6	use crate::ptr::{PtrConst, PtrMut};
7
8	use crate::{
9	Def, Facet, IterVTable, MapDef, MapVTable, MarkerTraits, ScalarAffinity, ScalarDef, Shape,
10	Type, TypeParam, UserType, VTableView, ValueVTable, value_vtable,
11	};
12
13	struct HashMapIterator<'mem, K> {
14	map: PtrConst<'mem>,
15	keys: VecDeque<&'mem K>,
16	}
17
18	unsafe impl<'a, K, V, S> Facet<'a> for HashMap<K, V, S>
19	where
20	K: Facet<'a> + core::cmp::Eq + core::hash::Hash,
21	V: Facet<'a>,
22	S: Facet<'a> + Default + BuildHasher,
23	{
24	const VTABLE: &'static ValueVTable = &const {
25	let mut builder = ValueVTable::builder::<Self>()
26	.marker_traits({
27	let arg_dependent_traits = MarkerTraits::SEND
28	.union(MarkerTraits::SYNC)
29	.union(MarkerTraits::EQ)
30	.union(MarkerTraits::UNPIN);
31	arg_dependent_traits
32	.intersection(V::SHAPE.vtable.marker_traits)
33	.intersection(K::SHAPE.vtable.marker_traits)
34	})
35	.type_name(\|f, opts\| {	27✔
36	if let Some(opts) = opts.for_children() {	27✔
37	write!(f, "HashMap<")?;	27✔
38	(K::SHAPE.vtable.type_name)(f, opts)?;	27✔
39	write!(f, ", ")?;	27✔
40	(V::SHAPE.vtable.type_name)(f, opts)?;	27✔
41	write!(f, ">")	27✔
42	} else {
43	write!(f, "HashMap<⋯>")	×
44	}
45	});	27✔
46
47	if K::SHAPE.vtable.debug.is_some() && V::SHAPE.vtable.debug.is_some() {
48	builder = builder.debug(\|value, f\| {	10✔
49	let k_debug = <VTableView<K>>::of().debug().unwrap();	10✔
50	let v_debug = <VTableView<V>>::of().debug().unwrap();	10✔
51	write!(f, "{{")?;	10✔
52	for (i, (key, val)) in value.iter().enumerate() {	16✔
53	if i > 0 {	16✔
54	write!(f, ", ")?;	8✔
55	}	8✔
56	(k_debug)(key, f)?;	16✔
57	write!(f, ": ")?;	16✔
58	(v_debug)(val, f)?;	16✔
59	}
60	write!(f, "}}")	10✔
61	});	10✔
62	}
63
64	builder = builder.default_in_place(\|target\| unsafe { target.put(Self::default()) });	44✔
65
66	if V::SHAPE.vtable.clone_into.is_some() && K::SHAPE.vtable.clone_into.is_some() {
67	builder = builder.clone_into(\|src, dst\| unsafe {	1✔
68	let map = src;	1✔
69	let mut new_map = HashMap::with_capacity_and_hasher(map.len(), S::default());	1✔
70		1✔
71	let k_clone_into = <VTableView<K>>::of().clone_into().unwrap();	1✔
72	let v_clone_into = <VTableView<V>>::of().clone_into().unwrap();	1✔
73
74	for (k, v) in map {	2✔
75	use crate::TypedPtrUninit;
76	use core::mem::MaybeUninit;
77
78	let mut new_k = MaybeUninit::<K>::uninit();	1✔
79	let mut new_v = MaybeUninit::<V>::uninit();	1✔
80		1✔
81	let uninit_k = TypedPtrUninit::new(new_k.as_mut_ptr());	1✔
82	let uninit_v = TypedPtrUninit::new(new_v.as_mut_ptr());	1✔
83		1✔
84	(k_clone_into)(k, uninit_k);	1✔
85	(v_clone_into)(v, uninit_v);	1✔
86		1✔
87	new_map.insert(new_k.assume_init(), new_v.assume_init());	1✔
88	}
89
90	dst.put(new_map)	1✔
91	});	1✔
92	}
93
94	if V::SHAPE.vtable.eq.is_some() {
95	builder = builder.eq(\|a, b\| {	2✔
96	let v_eq = <VTableView<V>>::of().eq().unwrap();	2✔
97	a.len() == b.len()	2✔
98	&& a.iter().all(\|(key_a, val_a)\| {	3✔
99	b.get(key_a).is_some_and(\|val_b\| (v_eq)(val_a, val_b))	3✔
100	})	3✔
101	});	2✔
102	}
103
104	if V::SHAPE.vtable.hash.is_some() {
105	builder = builder.hash(\|map, hasher_this, hasher_write_fn\| unsafe {
106	use crate::HasherProxy;
107	let v_hash = <VTableView<V>>::of().hash().unwrap();	×
108	let mut hasher = HasherProxy::new(hasher_this, hasher_write_fn);	×
109	map.len().hash(&mut hasher);	×
110	for (k, v) in map {	×
111	k.hash(&mut hasher);	×
112	(v_hash)(v, hasher_this, hasher_write_fn);	×
113	}	×
114	});	×
115	}
116
117	builder.build()
118	};
119
120	const SHAPE: &'static Shape = &const {
121	Shape::builder_for_sized::<Self>()
122	.type_params(&[
123	TypeParam {
124	name: "K",
125	shape: \|\| K::SHAPE,	1✔
126	},
127	TypeParam {
128	name: "V",
129	shape: \|\| V::SHAPE,	1✔
130	},
131	TypeParam {
132	name: "S",
133	shape: \|\| S::SHAPE,	1✔
134	},
135	])
136	.ty(Type::User(UserType::Opaque))
137	.def(Def::Map(
138	MapDef::builder()
139	.k(\|\| K::SHAPE)	80✔
140	.v(\|\| V::SHAPE)	83✔
141	.vtable(
142	&const {
143	MapVTable::builder()
144	.init_in_place_with_capacity(\|uninit, capacity\| unsafe {	×
145	uninit	×
146	.put(Self::with_capacity_and_hasher(capacity, S::default()))	×
147	})	×
148	.insert(\|ptr, key, value\| unsafe {	44✔
149	let map = ptr.as_mut::<HashMap<K, V>>();	44✔
150	let key = key.read::<K>();	44✔
151	let value = value.read::<V>();	44✔
152	map.insert(key, value);	44✔
153	})	44✔
154	.len(\|ptr\| unsafe {	16✔
155	let map = ptr.get::<HashMap<K, V>>();	16✔
156	map.len()	16✔
157	})	16✔
158	.contains_key(\|ptr, key\| unsafe {	8✔
159	let map = ptr.get::<HashMap<K, V>>();	8✔
160	map.contains_key(key.get())	8✔
161	})	8✔
162	.get_value_ptr(\|ptr, key\| unsafe {	8✔
163	let map = ptr.get::<HashMap<K, V>>();	8✔
164	map.get(key.get()).map(\|v\| PtrConst::new(v))	8✔
165	})	8✔
166	.iter_vtable(
167	IterVTable::builder()
168	.init_with_value(\|ptr\| unsafe {	18✔
169	let map = ptr.get::<HashMap<K, V>>();	18✔
170	let keys: VecDeque<&K> = map.keys().collect();	18✔
171	let iter_state =	18✔
172	Box::new(HashMapIterator { map: ptr, keys });	18✔
173	PtrMut::new(Box::into_raw(iter_state) as *mut u8)	18✔
174	})	18✔
175	.next(\|iter_ptr\| unsafe {	45✔
176	let state = iter_ptr.as_mut::<HashMapIterator<'_, K>>();	45✔
177	let map = state.map.get::<HashMap<K, V>>();	45✔
178	while let Some(key) = state.keys.pop_front() {	45✔
179	if let Some(value) = map.get(key) {	27✔
180	return Some((	27✔
181	PtrConst::new(key as *const K),	27✔
182	PtrConst::new(value as *const V),	27✔
183	));	27✔
UNCOV 184	}	×
185	}
186
187	None	18✔
188	})	45✔
189	.next_back(\|iter_ptr\| unsafe {	×
190	let state = iter_ptr.as_mut::<HashMapIterator<'_, K>>();	×
191	let map = state.map.get::<HashMap<K, V>>();	×
192	while let Some(key) = state.keys.pop_back() {	×
193	if let Some(value) = map.get(key) {	×
194	return Some((	×
195	PtrConst::new(key as *const K),	×
196	PtrConst::new(value as *const V),	×
197	));	×
UNCOV 198	}	×
199	}
200
201	None	×
UNCOV 202	})	×
203	.dealloc(\|iter_ptr\| unsafe {	18✔
204	drop(Box::from_raw(	18✔
205	iter_ptr.as_ptr::<HashMapIterator<'_, K>>()	18✔
206	as *mut HashMapIterator<'_, K>,	18✔
207	));	18✔
208	})	18✔
209	.build(),
210	)
211	.build()
212	},
213	)
214	.build(),
215	))
216	.build()
217	};
218	}
219
220	unsafe impl Facet<'_> for RandomState {
221	const VTABLE: &'static ValueVTable =
222	&const { value_vtable!((), \|f, _opts\| write!(f, "RandomState")) };	1✔
223
224	const SHAPE: &'static Shape = &const {
225	Shape::builder_for_sized::<Self>()
226	.ty(Type::User(UserType::Opaque))
227	.def(Def::Scalar(
228	ScalarDef::builder()
229	.affinity(ScalarAffinity::opaque().build())
230	.build(),
231	))
232	.build()
233	};
234	}

facet-rs / facet / 15040092313

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