18753163923

Committed 23 Oct 2025 03:14PM UTC coverage: 52.734% (-1.1%) from 53.804%

Build # 18753163923

Build Type

push

github

Committed by

fasterthanlime

Commit Message

more vtable trait impls

Run Details

154 of 467 new or added lines in 16 files covered. (32.98%)

4 existing lines in 4 files now uncovered.

4668 of 8852 relevant lines covered (52.73%)

41.45 hits per line

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

90.2

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

use core::hash::BuildHasher;
use core::ptr::NonNull;
use std::collections::HashMap;
use std::hash::RandomState;

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

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

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

// TODO: Debug, PartialEq, Eq for HashMap, HashSet
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: 'a + Default + BuildHasher,
{
    const SHAPE: &'static Shape = &const {
        Shape::builder_for_sized::<Self>()
            .vtable(
                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| {
                        write!(f, "{}<", Self::SHAPE.type_identifier)?;
                        if let Some(opts) = opts.for_children() {
                            K::SHAPE.vtable.type_name()(f, opts)?;
                            write!(f, ", ")?;
                            V::SHAPE.vtable.type_name()(f, opts)?;
                        } else {
                            write!(f, "…")?;
                        }
                        write!(f, ">")
                    })
                    .default_in_place({
                        Some(|target| unsafe { target.put(Self::default()).into() })
                    })
                    .build(),
            )
            .type_identifier("HashMap")
            .type_params(&[
                TypeParam {
                    name: "K",
                    shape: K::SHAPE,
                },
                TypeParam {
                    name: "V",
                    shape: V::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(NonNull::from(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(NonNull::new_unchecked(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(NonNull::from(key)),
                                                    PtrConst::new(NonNull::from(value)),
                                                )
                                            })
                                        })
                                        .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 SHAPE: &'static Shape = &const {
        Shape::builder_for_sized::<Self>()
            .vtable(value_vtable!((), |f, _opts| write!(
                f,
                "{}",
                Self::SHAPE.type_identifier
            )))
            .type_identifier("RandomState")
            .ty(Type::User(UserType::Opaque))
            .def(Def::Scalar)
            .build()
    };
}

1	use core::hash::BuildHasher;
2	use core::ptr::NonNull;
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, Shape, Type, TypeParam, UserType,
10	ValueVTable, value_vtable,
11	};
12
13	type HashMapIterator<'mem, K, V> = std::collections::hash_map::Iter<'mem, K, V>;
14
15	// TODO: Debug, PartialEq, Eq for HashMap, HashSet
16	unsafe impl<'a, K, V, S> Facet<'a> for HashMap<K, V, S>
17	where
18	K: Facet<'a> + core::cmp::Eq + core::hash::Hash,
19	V: Facet<'a>,
20	S: 'a + Default + BuildHasher,
21	{
22	const SHAPE: &'static Shape = &const {
23	Shape::builder_for_sized::<Self>()
24	.vtable(
25	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	.union(MarkerTraits::UNWIND_SAFE)
32	.union(MarkerTraits::REF_UNWIND_SAFE);
33	arg_dependent_traits
34	.intersection(V::SHAPE.vtable.marker_traits())
35	.intersection(K::SHAPE.vtable.marker_traits())
36	})
37	.type_name(\|f, opts\| {	2✔
38	write!(f, "{}<", Self::SHAPE.type_identifier)?;	2✔
39	if let Some(opts) = opts.for_children() {	2✔
40	K::SHAPE.vtable.type_name()(f, opts)?;	2✔
41	write!(f, ", ")?;	2✔
42	V::SHAPE.vtable.type_name()(f, opts)?;	2✔
43	} else {
NEW 44	write!(f, "…")?;	×
45	}
46	write!(f, ">")	2✔
47	})	2✔
48	.default_in_place({
49	Some(\|target\| unsafe { target.put(Self::default()).into() })	×
50	})
51	.build(),
52	)
53	.type_identifier("HashMap")
54	.type_params(&[
55	TypeParam {
56	name: "K",
57	shape: K::SHAPE,
58	},
59	TypeParam {
60	name: "V",
61	shape: V::SHAPE,
62	},
63	])
64	.ty(Type::User(UserType::Opaque))
65	.def(Def::Map(
66	MapDef::builder()
67	.k(K::SHAPE)
68	.v(V::SHAPE)
69	.vtable(
70	&const {
71	MapVTable::builder()
72	.init_in_place_with_capacity(\|uninit, capacity\| unsafe {
73	uninit	12✔
74	.put(Self::with_capacity_and_hasher(capacity, S::default()))	12✔
75	})	12✔
76	.insert(\|ptr, key, value\| unsafe {
77	let map = ptr.as_mut::<HashMap<K, V>>();	8✔
78	let key = key.read::<K>();	8✔
79	let value = value.read::<V>();	8✔
80	map.insert(key, value);	8✔
81	})	8✔
82	.len(\|ptr\| unsafe {
83	let map = ptr.get::<HashMap<K, V>>();	5✔
84	map.len()	5✔
85	})	5✔
86	.contains_key(\|ptr, key\| unsafe {
87	let map = ptr.get::<HashMap<K, V>>();	12✔
88	map.contains_key(key.get())	12✔
89	})	12✔
90	.get_value_ptr(\|ptr, key\| unsafe {
91	let map = ptr.get::<HashMap<K, V>>();	12✔
92	map.get(key.get()).map(\|v\| PtrConst::new(NonNull::from(v)))	12✔
93	})	12✔
94	.iter_vtable(
95	IterVTable::builder()
96	.init_with_value(\|ptr\| unsafe {
97	let map = ptr.get::<HashMap<K, V>>();	1✔
98	let iter: HashMapIterator<'_, K, V> = map.iter();	1✔
99	let iter_state = Box::new(iter);	1✔
100	PtrMut::new(NonNull::new_unchecked(Box::into_raw(	1✔
101	iter_state,	1✔
102	)	1✔
103	as *mut u8))	1✔
104	})	1✔
105	.next(\|iter_ptr\| unsafe {
106	let state =	3✔
107	iter_ptr.as_mut::<HashMapIterator<'_, K, V>>();	3✔
108	state.next().map(\|(key, value)\| {	3✔
109	(	2✔
110	PtrConst::new(NonNull::from(key)),	2✔
111	PtrConst::new(NonNull::from(value)),	2✔
112	)	2✔
113	})	2✔
114	})	3✔
115	.dealloc(\|iter_ptr\| unsafe {
116	drop(Box::from_raw(	1✔
117	iter_ptr.as_ptr::<HashMapIterator<'_, K, V>>()	1✔
118	as *mut HashMapIterator<'_, K, V>,	1✔
119	));
120	})	1✔
121	.build(),
122	)
123	.build()
124	},
125	)
126	.build(),
127	))
128	.build()
129	};
130	}
131
132	unsafe impl Facet<'_> for RandomState {
133	const SHAPE: &'static Shape = &const {
134	Shape::builder_for_sized::<Self>()
135	.vtable(value_vtable!((), \|f, _opts\| write!(
136	f,	×
137	"{}",	×
138	Self::SHAPE.type_identifier	×
139	)))
140	.type_identifier("RandomState")
141	.ty(Type::User(UserType::Opaque))
142	.def(Def::Scalar)
143	.build()
144	};
145	}

facet-rs / facet / 18753163923

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