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

86.21

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

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,
};

type HashMapIterator<'mem, K, V> = std::collections::hash_map::Iter<'mem, K, V>;

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 {
        ValueVTable::builder::<Self>()
            .marker_traits(|| {
                let arg_dependent_traits = MarkerTraits::SEND
                    .union(MarkerTraits::SYNC)
                    .union(MarkerTraits::EQ)
                    .union(MarkerTraits::UNPIN)
                    .union(MarkerTraits::UNWIND_SAFE)
                    .union(MarkerTraits::REF_UNWIND_SAFE);
                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, "{}<", Self::SHAPE.type_identifier)?;
                    K::SHAPE.vtable.type_name()(f, opts)?;
                    write!(f, ", ")?;
                    V::SHAPE.vtable.type_name()(f, opts)?;
                    write!(f, ">")
                } else {
                    write!(f, "{}<⋯>", Self::SHAPE.type_identifier)
                }
            })
            .debug(|| {
                if K::SHAPE.vtable.has_debug() && V::SHAPE.vtable.has_debug() {
                    Some(|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, "}}")
                    })
                } else {
                    None
                }
            })
            .default_in_place(|| Some(|target| unsafe { target.put(Self::default()) }))
            .clone_into(|| {
                if K::SHAPE.vtable.has_clone_into() && V::SHAPE.vtable.has_clone_into() {
                    Some(|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)
                    })
                } else {
                    None
                }
            })
            .partial_eq(|| {
                if V::SHAPE.vtable.has_partial_eq() {
                    Some(|a, b| {
                        let v_eq = <VTableView<V>>::of().partial_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))
                            })
                    })
                } else {
                    None
                }
            })
            .hash(|| {
                if V::SHAPE.vtable.has_hash() {
                    Some(|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);
                        }
                    })
                } else {
                    None
                }
            })
            .build()
    };

    const SHAPE: &'static Shape<'static> = &const {
        Shape::builder_for_sized::<Self>()
            .type_identifier("HashMap")
            .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 iter: HashMapIterator<'_, K, V> = map.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::<HashMapIterator<'_, K, V>>();
                                            state.next().map(|(key, value)| {
                                                (
                                                    PtrConst::new(key as *const K),
                                                    PtrConst::new(value as *const V),
                                                )
                                            })
                                        })
                                        .dealloc(|iter_ptr| unsafe {
                                            drop(Box::from_raw(
                                                iter_ptr.as_ptr::<HashMapIterator<'_, K, V>>()
                                                    as *mut HashMapIterator<'_, K, V>,
                                            ));
                                        })
                                        .build(),
                                )
                                .build()
                        },
                    )
                    .build(),
            ))
            .build()
    };
}

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

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

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

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