14679327171

Committed 26 Apr 2025 08:07AM UTC coverage: 58.07% (+0.05%) from 58.016%

Build # 14679327171

Build Type

push

github

Committed by

Veykril

Commit Message

Automatically populate `drop_in_place` when vtable building

Opposed to manually filling it out

Coverage Stats

9 of 31 new or added lines in 6 files covered. (29.03%)

6753 of 11629 relevant lines covered (58.07%)

76.75 hits per line

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

76.47

/facet-core/src/impls_alloc/vec.rs

use crate::*;
use core::hash::Hash as _;

use alloc::vec::Vec;

unsafe impl<'a, T> Facet<'a> for Vec<T>
where
    T: Facet<'a>,
{
    const SHAPE: &'static Shape = &const {
        Shape::builder_for_sized::<Self>()
            .type_params(&[
                TypeParam {
                    name: "T",
                    shape: || T::SHAPE,
                }
            ])
            .vtable(
                &const {
                    let mut builder = ValueVTable::builder::<Self>()
                        .type_name(|f, opts| {
                            if let Some(opts) = opts.for_children() {
                                write!(f, "Vec<")?;
                                (T::SHAPE.vtable.type_name)(f, opts)?;
                                write!(f, ">")
                            } else {
                                write!(f, "Vec<⋯>")
                            }
                        })
                        .default_in_place(|target| unsafe { target.put(Self::default()) })
                        .clone_into(|src, dst| unsafe { dst.put(src.get::<Self>()) });

                    if T::SHAPE.vtable.debug.is_some() {
                        builder = builder.debug(|value, f| {
                            let value = unsafe { value.get::<Self>() };
                            write!(f, "[")?;
                            for (i, item) in value.iter().enumerate() {
                                if i > 0 {
                                    write!(f, ", ")?;
                                }
                                unsafe {
                                    (T::SHAPE.vtable.debug.unwrap_unchecked())(
                                        PtrConst::new(item),
                                        f,
                                    )?;
                                }
                            }
                            write!(f, "]")
                        });
                    }

                    if T::SHAPE.vtable.eq.is_some() {
                        builder = builder.eq(|a, b| unsafe {
                            let a = a.get::<Self>();
                            let b = b.get::<Self>();
                            if a.len() != b.len() {
                                return false;
                            }
                            for (item_a, item_b) in a.iter().zip(b.iter()) {
                                if !(T::SHAPE.vtable.eq.unwrap_unchecked())(
                                    PtrConst::new(item_a),
                                    PtrConst::new(item_b),
                                ) {
                                    return false;
                                }
                            }
                            true
                        });
                    }

                    if T::SHAPE.vtable.hash.is_some() {
                        builder = builder.hash(|value, hasher_this, hasher_write_fn| unsafe {
                            use crate::HasherProxy;
                            let vec = value.get::<Self>();
                            let t_hash = T::SHAPE.vtable.hash.unwrap_unchecked();
                            let mut hasher = HasherProxy::new(hasher_this, hasher_write_fn);
                            vec.len().hash(&mut hasher);
                            for item in vec {
                                (t_hash)(PtrConst::new(item), hasher_this, hasher_write_fn);
                            }
                        });
                    }

                    let traits = MarkerTraits::SEND
                        .union(MarkerTraits::SYNC)
                        .union(MarkerTraits::EQ)
                        .union(MarkerTraits::UNPIN)
                        .intersection(T::SHAPE.vtable.marker_traits);
                    builder = builder.marker_traits(traits);

                    builder.build()
                },
            )
            .def(Def::List(
                ListDef::builder()
                    .vtable(
                        &const {
                            ListVTable::builder()
                                .init_in_place_with_capacity(|data, capacity| unsafe {
                                    data.put(Self::with_capacity(capacity))
                                })
                                .push(|ptr, item| unsafe {
                                    let vec = ptr.as_mut::<Self>();
                                    let item = item.read::<T>();
                                    (*vec).push(item);
                                })
                                .len(|ptr| unsafe {
                                    let vec = ptr.get::<Self>();
                                    vec.len()
                                })
                                .get_item_ptr(|ptr, index| unsafe {
                                    let vec = ptr.get::<Self>();
                                    let len = vec.len();
                                    if index >= len {
                                        panic!(
                                            "Index out of bounds: the len is {len} but the index is {index}"
                                        );
                                    }
                                    PtrConst::new(vec.as_ptr().add(index))
                                })
                                .build()
                        },
                    )
                    .t(|| T::SHAPE)
                    .build(),
            ))
            .build()
    };
}

1	use crate::*;
2	use core::hash::Hash as _;
3
4	use alloc::vec::Vec;
5
6	unsafe impl<'a, T> Facet<'a> for Vec<T>
7	where
8	T: Facet<'a>,
9	{
10	const SHAPE: &'static Shape = &const {
11	Shape::builder_for_sized::<Self>()
12	.type_params(&[
13	TypeParam {
14	name: "T",
15	shape: \|\| T::SHAPE,	1✔
16	}
17	])
18	.vtable(
19	&const {
20	let mut builder = ValueVTable::builder::<Self>()
21	.type_name(\|f, opts\| {	28✔
22	if let Some(opts) = opts.for_children() {	28✔
23	write!(f, "Vec<")?;	28✔
24	(T::SHAPE.vtable.type_name)(f, opts)?;	28✔
25	write!(f, ">")	28✔
26	} else {
27	write!(f, "Vec<⋯>")	×
28	}
29	})	28✔
30	.default_in_place(\|target\| unsafe { target.put(Self::default()) })	58✔
NEW 31	.clone_into(\|src, dst\| unsafe { dst.put(src.get::<Self>()) });	×
32
33	if T::SHAPE.vtable.debug.is_some() {
34	builder = builder.debug(\|value, f\| {	20✔
35	let value = unsafe { value.get::<Self>() };	20✔
36	write!(f, "[")?;	20✔
37	for (i, item) in value.iter().enumerate() {	40✔
38	if i > 0 {	40✔
39	write!(f, ", ")?;	24✔
40	}	16✔
41	unsafe {
42	(T::SHAPE.vtable.debug.unwrap_unchecked())(	40✔
43	PtrConst::new(item),	40✔
44	f,	40✔
45	)?;	40✔
46	}
47	}
48	write!(f, "]")	20✔
49	});	20✔
50	}
51
52	if T::SHAPE.vtable.eq.is_some() {
53	builder = builder.eq(\|a, b\| unsafe {	4✔
54	let a = a.get::<Self>();	4✔
55	let b = b.get::<Self>();	4✔
56	if a.len() != b.len() {	4✔
57	return false;	×
58	}	4✔
59	for (item_a, item_b) in a.iter().zip(b.iter()) {	7✔
60	if !(T::SHAPE.vtable.eq.unwrap_unchecked())(	7✔
61	PtrConst::new(item_a),	7✔
62	PtrConst::new(item_b),	7✔
63	) {	7✔
64	return false;	2✔
65	}	5✔
66	}
67	true	2✔
68	});	4✔
69	}
70
71	if T::SHAPE.vtable.hash.is_some() {
72	builder = builder.hash(\|value, hasher_this, hasher_write_fn\| unsafe {
73	use crate::HasherProxy;
NEW 74	let vec = value.get::<Self>();	×
75	let t_hash = T::SHAPE.vtable.hash.unwrap_unchecked();	×
76	let mut hasher = HasherProxy::new(hasher_this, hasher_write_fn);	×
77	vec.len().hash(&mut hasher);	×
78	for item in vec {	×
79	(t_hash)(PtrConst::new(item), hasher_this, hasher_write_fn);	×
80	}	×
81	});	×
82	}
83
84	let traits = MarkerTraits::SEND
85	.union(MarkerTraits::SYNC)
86	.union(MarkerTraits::EQ)
87	.union(MarkerTraits::UNPIN)
88	.intersection(T::SHAPE.vtable.marker_traits);
89	builder = builder.marker_traits(traits);
90
91	builder.build()
92	},
93	)
94	.def(Def::List(
95	ListDef::builder()
96	.vtable(
97	&const {
98	ListVTable::builder()
99	.init_in_place_with_capacity(\|data, capacity\| unsafe {	×
100	data.put(Self::with_capacity(capacity))	×
101	})	×
102	.push(\|ptr, item\| unsafe {	74✔
103	let vec = ptr.as_mut::<Self>();	74✔
104	let item = item.read::<T>();	74✔
105	(*vec).push(item);	74✔
106	})	74✔
107	.len(\|ptr\| unsafe {	13✔
108	let vec = ptr.get::<Self>();	13✔
109	vec.len()	13✔
110	})	13✔
111	.get_item_ptr(\|ptr, index\| unsafe {	8✔
112	let vec = ptr.get::<Self>();	8✔
113	let len = vec.len();	8✔
114	if index >= len {	8✔
115	panic!(	×
116	"Index out of bounds: the len is {len} but the index is {index}"	×
117	);
118	}	8✔
119	PtrConst::new(vec.as_ptr().add(index))	8✔
120	})	8✔
121	.build()
122	},
123	)
124	.t(\|\| T::SHAPE)	95✔
125	.build(),
126	))
127	.build()
128	};
129	}

facet-rs / facet / 14679327171

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