15787779743

Committed 20 Jun 2025 09:01PM UTC coverage: 61.487% (+1.8%) from 59.711%

Build # 15787779743

Build Type

Pull #774

github

Committed by

web-flow

Commit Message

Merge dd04260c9 into ec93ce66e

Pull Request Pull Request #774: split up Partial::end into smaller bits

Run Details

147 of 165 new or added lines in 2 files covered. (89.09%)

1817 existing lines in 50 files now uncovered.

10564 of 17181 relevant lines covered (61.49%)

161.84 hits per line

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

77.19

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

use core::hash::BuildHasher;
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>;

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)
                }
            })
            .default_in_place(|| Some(|target| unsafe { target.put(Self::default()) }))
            .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)
            .build()
    };
}

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

facet-rs / facet / 15787779743

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