14490918692

Committed 16 Apr 2025 10:47AM UTC coverage: 41.767% (+0.3%) from 41.467%

Build # 14490918692

Build Type

push

github

Committed by

fasterthanlime

Commit Message

Expose generic type params in derive

Closes #192

Run Details

27 of 27 new or added lines in 3 files covered. (100.0%)

226 existing lines in 12 files now uncovered.

4490 of 10750 relevant lines covered (41.77%)

55.42 hits per line

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

80.58

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

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

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

use crate::{
    ConstTypeId, Def, Facet, MapDef, MapIterVTable, MapVTable, MarkerTraits, ScalarAffinity,
    ScalarDef, Shape, TypeParam, ValueVTable, value_vtable,
};

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

unsafe impl<K, V, S> Facet for HashMap<K, V, S>
where
    K: Facet + core::cmp::Eq + core::hash::Hash + 'static,
    V: Facet + 'static,
    S: Facet + Default,
{
    const SHAPE: &'static Shape = &const {
        Shape::builder()
            .id(ConstTypeId::of::<HashMap<K, V, S>>())
            .layout(Layout::new::<HashMap<K, V>>())
            .type_params(&[
                TypeParam {
                    name: "K",
                    shape: || K::SHAPE,
                },
                TypeParam {
                    name: "V",
                    shape: || V::SHAPE,
                },
                TypeParam {
                    name: "S",
                    shape: || S::SHAPE,
                },
            ])
            .vtable(
                &const {
                    let mut builder = ValueVTable::builder()
                        .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<⋯>")
                            }
                        })
                        .drop_in_place(|value| unsafe { value.drop_in_place::<HashMap<K, V>>() });

                    if K::SHAPE.vtable.debug.is_some() && V::SHAPE.vtable.debug.is_some() {
                        builder = builder.debug(|value, f| unsafe {
                            let value = value.get::<HashMap<K, V>>();
                            let k_debug = K::SHAPE.vtable.debug.unwrap_unchecked();
                            let v_debug = V::SHAPE.vtable.debug.unwrap_unchecked();
                            write!(f, "{{")?;
                            for (i, (key, val)) in value.iter().enumerate() {
                                if i > 0 {
                                    write!(f, ", ")?;
                                }
                                (k_debug)(PtrConst::new(key as *const _), f)?;
                                write!(f, ": ")?;
                                (v_debug)(PtrConst::new(val as *const _), f)?;
                            }
                            write!(f, "}}")
                        });
                    }

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

                    builder = builder
                        .clone_into(|src, dst| unsafe { dst.put(src.get::<HashMap<K, V>>()) });

                    if V::SHAPE.vtable.eq.is_some() {
                        builder = builder.eq(|a, b| unsafe {
                            let a = a.get::<HashMap<K, V>>();
                            let b = b.get::<HashMap<K, V>>();
                            let v_eq = V::SHAPE.vtable.eq.unwrap_unchecked();
                            a.len() == b.len()
                                && a.iter().all(|(key_a, val_a)| {
                                    b.get(key_a).is_some_and(|val_b| {
                                        (v_eq)(
                                            PtrConst::new(val_a as *const _),
                                            PtrConst::new(val_b as *const _),
                                        )
                                    })
                                })
                        });
                    }

                    if V::SHAPE.vtable.hash.is_some() {
                        builder = builder.hash(|value, hasher_this, hasher_write_fn| unsafe {
                            use crate::HasherProxy;
                            let map = value.get::<HashMap<K, V>>();
                            let v_hash = V::SHAPE.vtable.hash.unwrap_unchecked();
                            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)(
                                    PtrConst::new(v as *const _),
                                    hasher_this,
                                    hasher_write_fn,
                                );
                            }
                        });
                    }

                    builder.build()
                },
            )
            .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 as *const _))
                                })
                                .iter(|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)
                                })
                                .iter_vtable(
                                    MapIterVTable::builder()
                                        .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
                                        })
                                        .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 SHAPE: &'static Shape = &const {
        Shape::builder()
            .id(ConstTypeId::of::<RandomState>())
            .layout(Layout::new::<Self>())
            .def(Def::Scalar(
                ScalarDef::builder()
                    .affinity(ScalarAffinity::opaque().build())
                    .build(),
            ))
            .vtable(value_vtable!((), |f, _opts| write!(f, "RandomState")))
            .build()
    };
}

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

facet-rs / facet / 14490918692

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