15221452970

Committed 24 May 2025 12:26AM UTC coverage: 57.643% (+0.1%) from 57.538%

Build # 15221452970

Build Type

Pull #666

github

Committed by

web-flow

Commit Message

Merge e32d9af09 into 48c76b4b0

Pull Request Pull Request #666: Add indirection to vtable fns to fix cyclic types

Run Details

779 of 1499 new or added lines in 35 files covered. (51.97%)

14 existing lines in 5 files now uncovered.

9880 of 17140 relevant lines covered (57.64%)

137.68 hits per line

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

33.77

/facet-core/src/impls_bytes.rs

use alloc::boxed::Box;

use bytes::{BufMut as _, Bytes, BytesMut};

use crate::{
    Def, Facet, IterVTable, ListDef, ListVTable, PtrConst, PtrMut, PtrUninit, Shape, Type,
    UserType, ValueVTable, value_vtable,
};

type BytesIterator<'mem> = core::slice::Iter<'mem, u8>;

unsafe impl Facet<'_> for Bytes {
    const VTABLE: &'static ValueVTable = &const {
        let mut vtable = value_vtable!(Bytes, |f, _opts| write!(f, "Bytes"));
        vtable.try_from = || {
            Some(
                |source: PtrConst, source_shape: &Shape, target: PtrUninit| {
                    if source_shape.is_type::<BytesMut>() {
                        let source = unsafe { source.read::<BytesMut>() };
                        let bytes = source.freeze();
                        Ok(unsafe { target.put(bytes) })
                    } else {
                        Err(crate::TryFromError::UnsupportedSourceShape {
                            src_shape: source_shape,
                            expected: &[Bytes::SHAPE],
                        })
                    }
                },
            )
        };

        vtable
    };

    const SHAPE: &'static Shape<'static> = &const {
        Shape::builder_for_sized::<Self>()
            .ty(Type::User(UserType::Opaque))
            .inner(|| BytesMut::SHAPE)
            .def(Def::List(
                ListDef::builder()
                    .vtable(
                        &const {
                            ListVTable::builder()
                                .len(|ptr| unsafe {
                                    let bytes = ptr.get::<Self>();
                                    bytes.len()
                                })
                                .get(|ptr, index| unsafe {
                                    let bytes = ptr.get::<Self>();
                                    let item = bytes.get(index)?;
                                    Some(PtrConst::new(item))
                                })
                                .as_ptr(|ptr| unsafe {
                                    let bytes = ptr.get::<Self>();
                                    PtrConst::new(bytes.as_ptr())
                                })
                                .iter_vtable(
                                    IterVTable::builder()
                                        .init_with_value(|ptr| unsafe {
                                            let bytes = ptr.get::<Self>();
                                            let iter: BytesIterator = bytes.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::<BytesIterator<'_>>();
                                            state.next().map(|value| PtrConst::new(value))
                                        })
                                        .next_back(|iter_ptr| unsafe {
                                            let state = iter_ptr.as_mut::<BytesIterator<'_>>();
                                            state.next_back().map(|value| PtrConst::new(value))
                                        })
                                        .dealloc(|iter_ptr| unsafe {
                                            drop(Box::from_raw(
                                                iter_ptr.as_ptr::<BytesIterator<'_>>()
                                                    as *mut BytesIterator<'_>,
                                            ));
                                        })
                                        .build(),
                                )
                                .build()
                        },
                    )
                    .t(|| u8::SHAPE)
                    .build(),
            ))
            .build()
    };
}

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

    const SHAPE: &'static Shape<'static> = &const {
        Shape::builder_for_sized::<Self>()
            .ty(Type::User(UserType::Opaque))
            .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 bytes = ptr.as_mut::<Self>();
                                    let item = item.read::<u8>();
                                    (*bytes).put_u8(item);
                                })
                                .len(|ptr| unsafe {
                                    let bytes = ptr.get::<Self>();
                                    bytes.len()
                                })
                                .get(|ptr, index| unsafe {
                                    let bytes = ptr.get::<Self>();
                                    let item = bytes.get(index)?;
                                    Some(PtrConst::new(item))
                                })
                                .get_mut(|ptr, index| unsafe {
                                    let bytes = ptr.as_mut::<Self>();
                                    let item = bytes.get_mut(index)?;
                                    Some(PtrMut::new(item))
                                })
                                .as_ptr(|ptr| unsafe {
                                    let bytes = ptr.get::<Self>();
                                    PtrConst::new(bytes.as_ptr())
                                })
                                .as_mut_ptr(|ptr| unsafe {
                                    let bytes = ptr.as_mut::<Self>();
                                    PtrMut::new(bytes.as_mut_ptr())
                                })
                                .iter_vtable(
                                    IterVTable::builder()
                                        .init_with_value(|ptr| unsafe {
                                            let bytes = ptr.get::<Self>();
                                            let iter: BytesIterator = bytes.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::<BytesIterator<'_>>();
                                            state.next().map(|value| PtrConst::new(value))
                                        })
                                        .next_back(|iter_ptr| unsafe {
                                            let state = iter_ptr.as_mut::<BytesIterator<'_>>();
                                            state.next_back().map(|value| PtrConst::new(value))
                                        })
                                        .dealloc(|iter_ptr| unsafe {
                                            drop(Box::from_raw(
                                                iter_ptr.as_ptr::<BytesIterator<'_>>()
                                                    as *mut BytesIterator<'_>,
                                            ));
                                        })
                                        .build(),
                                )
                                .build()
                        },
                    )
                    .t(|| u8::SHAPE)
                    .build(),
            ))
            .build()
    };
}

1	use alloc::boxed::Box;
2
3	use bytes::{BufMut as _, Bytes, BytesMut};
4
5	use crate::{
6	Def, Facet, IterVTable, ListDef, ListVTable, PtrConst, PtrMut, PtrUninit, Shape, Type,
7	UserType, ValueVTable, value_vtable,
8	};
9
10	type BytesIterator<'mem> = core::slice::Iter<'mem, u8>;
11
12	unsafe impl Facet<'_> for Bytes {
13	const VTABLE: &'static ValueVTable = &const {
14	let mut vtable = value_vtable!(Bytes, \|f, _opts\| write!(f, "Bytes"));	4✔
15	vtable.try_from = \|\| {	1✔
16	Some(
17	\|source: PtrConst, source_shape: &Shape, target: PtrUninit\| {	1✔
18	if source_shape.is_type::<BytesMut>() {	1✔
19	let source = unsafe { source.read::<BytesMut>() };	1✔
20	let bytes = source.freeze();	1✔
21	Ok(unsafe { target.put(bytes) })	1✔
22	} else {
NEW 23	Err(crate::TryFromError::UnsupportedSourceShape {	×
NEW 24	src_shape: source_shape,	×
NEW 25	expected: &[Bytes::SHAPE],	×
NEW 26	})	×
27	}
28	},	1✔
29	)
30	};	1✔
31
32	vtable
33	};
34
35	const SHAPE: &'static Shape<'static> = &const {
36	Shape::builder_for_sized::<Self>()
37	.ty(Type::User(UserType::Opaque))
38	.inner(\|\| BytesMut::SHAPE)
39	.def(Def::List(
40	ListDef::builder()
41	.vtable(
42	&const {
43	ListVTable::builder()
44	.len(\|ptr\| unsafe {
45	let bytes = ptr.get::<Self>();	1✔
46	bytes.len()	1✔
47	})	1✔
48	.get(\|ptr, index\| unsafe {
49	let bytes = ptr.get::<Self>();	×
50	let item = bytes.get(index)?;	×
51	Some(PtrConst::new(item))	×
52	})	×
53	.as_ptr(\|ptr\| unsafe {
54	let bytes = ptr.get::<Self>();	1✔
55	PtrConst::new(bytes.as_ptr())	1✔
56	})	1✔
57	.iter_vtable(
58	IterVTable::builder()
59	.init_with_value(\|ptr\| unsafe {
60	let bytes = ptr.get::<Self>();	×
61	let iter: BytesIterator = bytes.iter();	×
62	let iter_state = Box::new(iter);	×
63	PtrMut::new(Box::into_raw(iter_state) as *mut u8)	×
64	})	×
65	.next(\|iter_ptr\| unsafe {
66	let state = iter_ptr.as_mut::<BytesIterator<'_>>();	×
67	state.next().map(\|value\| PtrConst::new(value))	×
68	})	×
69	.next_back(\|iter_ptr\| unsafe {
70	let state = iter_ptr.as_mut::<BytesIterator<'_>>();	×
71	state.next_back().map(\|value\| PtrConst::new(value))	×
72	})	×
73	.dealloc(\|iter_ptr\| unsafe {
74	drop(Box::from_raw(	×
75	iter_ptr.as_ptr::<BytesIterator<'_>>()	×
76	as *mut BytesIterator<'_>,	×
77	));
78	})	×
79	.build(),
80	)
81	.build()
82	},
83	)
84	.t(\|\| u8::SHAPE)
85	.build(),
86	))
87	.build()
88	};
89	}
90
91	unsafe impl Facet<'_> for BytesMut {
92	const VTABLE: &'static ValueVTable =
93	&const { value_vtable!(BytesMut, \|f, _opts\| write!(f, "BytesMut")) };	20✔
94
95	const SHAPE: &'static Shape<'static> = &const {
96	Shape::builder_for_sized::<Self>()
97	.ty(Type::User(UserType::Opaque))
98	.def(Def::List(
99	ListDef::builder()
100	.vtable(
101	&const {
102	ListVTable::builder()
103	.init_in_place_with_capacity(\|data, capacity\| unsafe {
104	data.put(Self::with_capacity(capacity))	×
105	})	×
106	.push(\|ptr, item\| unsafe {
107	let bytes = ptr.as_mut::<Self>();	10✔
108	let item = item.read::<u8>();	10✔
109	(*bytes).put_u8(item);	10✔
110	})	10✔
111	.len(\|ptr\| unsafe {
112	let bytes = ptr.get::<Self>();	1✔
113	bytes.len()	1✔
114	})	1✔
115	.get(\|ptr, index\| unsafe {
116	let bytes = ptr.get::<Self>();	×
117	let item = bytes.get(index)?;	×
118	Some(PtrConst::new(item))	×
119	})	×
120	.get_mut(\|ptr, index\| unsafe {
121	let bytes = ptr.as_mut::<Self>();	×
122	let item = bytes.get_mut(index)?;	×
123	Some(PtrMut::new(item))	×
124	})	×
125	.as_ptr(\|ptr\| unsafe {
126	let bytes = ptr.get::<Self>();	1✔
127	PtrConst::new(bytes.as_ptr())	1✔
128	})	1✔
129	.as_mut_ptr(\|ptr\| unsafe {
130	let bytes = ptr.as_mut::<Self>();	×
131	PtrMut::new(bytes.as_mut_ptr())	×
132	})	×
133	.iter_vtable(
134	IterVTable::builder()
135	.init_with_value(\|ptr\| unsafe {
136	let bytes = ptr.get::<Self>();	×
137	let iter: BytesIterator = bytes.iter();	×
138	let iter_state = Box::new(iter);	×
139	PtrMut::new(Box::into_raw(iter_state) as *mut u8)	×
140	})	×
141	.next(\|iter_ptr\| unsafe {
142	let state = iter_ptr.as_mut::<BytesIterator<'_>>();	×
143	state.next().map(\|value\| PtrConst::new(value))	×
144	})	×
145	.next_back(\|iter_ptr\| unsafe {
146	let state = iter_ptr.as_mut::<BytesIterator<'_>>();	×
147	state.next_back().map(\|value\| PtrConst::new(value))	×
148	})	×
149	.dealloc(\|iter_ptr\| unsafe {
150	drop(Box::from_raw(	×
151	iter_ptr.as_ptr::<BytesIterator<'_>>()	×
152	as *mut BytesIterator<'_>,	×
153	));
154	})	×
155	.build(),
156	)
157	.build()
158	},
159	)
160	.t(\|\| u8::SHAPE)
161	.build(),
162	))
163	.build()
164	};
165	}

facet-rs / facet / 15221452970

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