14630512853

Committed 24 Apr 2025 12:10AM UTC coverage: 47.636% (-0.1%) from 47.784%

Build # 14630512853

Build Type

Pull #376

github

Committed by

web-flow

Commit Message

Merge 6da469bd9 into ef85a90c2

Pull Request Pull Request #376: Implement Facet for references and pointers

Run Details

22 of 87 new or added lines in 2 files covered. (25.29%)

286 existing lines in 7 files now uncovered.

6307 of 13240 relevant lines covered (47.64%)

58.24 hits per line

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

40.74

/facet-core/src/impls_core/refptr.rs

use core::alloc::Layout;

use crate::{
    ConstTypeId, Def, Facet, PtrConst, RefPtrDef, RefPtrMutability, RefPtrType, Shape, TypeParam,
    ValueVTable,
};

// TODO: Also implement for `T: !Sized`
// - Conflicts with `&[T]`, `&str` and `&Path`
// TODO: Also implement for `T: !Facet<'a>`
unsafe impl<'a, T: Facet<'a>> Facet<'a> for &'a T {
    const SHAPE: &'static Shape = &const {
        Shape::builder()
            .id(ConstTypeId::of::<Self>())
            .layout(Layout::new::<Self>())
            .type_params(&[TypeParam {
                name: "T",
                shape: || T::SHAPE,
            }])
            .vtable(
                &const {
                    let mut builder = ValueVTable::builder()
                        .type_name(|f, opts| {
                            if let Some(opts) = opts.for_children() {
                                write!(f, "&")?;
                                (T::SHAPE.vtable.type_name)(f, opts)
                            } else {
                                write!(f, "&⋯")
                            }
                        })
                        .drop_in_place(|value| unsafe { value.drop_in_place::<Self>() })
                        .clone_into(|src, dst| unsafe { dst.put(src.get::<Self>()) });

                    if T::SHAPE.vtable.debug.is_some() {
                        builder = builder.debug(|value, f| {
                            let v = unsafe { value.get::<Self>() };
                            let v = *v;
                            unsafe {
                                (T::SHAPE.vtable.debug.unwrap_unchecked())(PtrConst::new(v), f)
                            }
                        });
                    }

                    // TODO: More functions

                    // TODO: Marker traits
                    // builder = builder.marker_traits(traits);

                    builder.build()
                },
            )
            .def(Def::RefPtr(
                RefPtrDef::builder()
                    .typ(RefPtrType::Reference)
                    .mutability(RefPtrMutability::Const)
                    .pointee(T::SHAPE)
                    .build(),
            ))
            .build()
    };
}

unsafe impl<'a, T: Facet<'a>> Facet<'a> for &'a mut T {
    const SHAPE: &'static Shape = &const {
        Shape::builder()
            .id(ConstTypeId::of::<Self>())
            .layout(Layout::new::<Self>())
            .type_params(&[TypeParam {
                name: "T",
                shape: || T::SHAPE,
            }])
            .vtable(
                &const {
                    let mut builder = ValueVTable::builder()
                        .type_name(|f, opts| {
                            if let Some(opts) = opts.for_children() {
                                write!(f, "&mut ")?;
                                (T::SHAPE.vtable.type_name)(f, opts)
                            } else {
                                write!(f, "&mut ⋯")
                            }
                        })
                        .drop_in_place(|value| unsafe { value.drop_in_place::<Self>() })
                        .clone_into(|src, dst| unsafe { dst.put(src.get::<Self>()) });

                    if T::SHAPE.vtable.debug.is_some() {
                        builder = builder.debug(|value, f| {
                            let v = unsafe { value.get::<Self>() } as *const &mut T;
                            let v = unsafe { v.read() };
                            unsafe {
                                (T::SHAPE.vtable.debug.unwrap_unchecked())(PtrConst::new(v), f)
                            }
                        });
                    }

                    // TODO: More functions

                    // TODO: Marker traits
                    // builder = builder.marker_traits(traits);

                    builder.build()
                },
            )
            .def(Def::RefPtr(
                RefPtrDef::builder()
                    .typ(RefPtrType::Reference)
                    .mutability(RefPtrMutability::Mut)
                    .pointee(T::SHAPE)
                    .build(),
            ))
            .build()
    };
}

unsafe impl<'a, T: Facet<'a>> Facet<'a> for *const T {
    const SHAPE: &'static Shape = &const {
        Shape::builder()
            .id(ConstTypeId::of::<Self>())
            .layout(Layout::new::<Self>())
            .type_params(&[TypeParam {
                name: "T",
                shape: || T::SHAPE,
            }])
            .vtable(
                &const {
                    let builder = ValueVTable::builder()
                        .type_name(|f, opts| {
                            if let Some(opts) = opts.for_children() {
                                write!(f, "*const ")?;
                                (T::SHAPE.vtable.type_name)(f, opts)
                            } else {
                                write!(f, "*const ⋯")
                            }
                        })
                        .debug(|value, f| {
                            let v = unsafe { value.get::<Self>() };
                            write!(f, "{v:?}")
                        });

                    // Pointers aren't guaranteed to be valid, so we can't implement most functions

                    // TODO: Marker traits
                    // builder = builder.marker_traits(traits);

                    builder.build()
                },
            )
            .def(Def::RefPtr(
                RefPtrDef::builder()
                    .typ(RefPtrType::Pointer)
                    .mutability(RefPtrMutability::Const)
                    .pointee(T::SHAPE)
                    .build(),
            ))
            .build()
    };
}

unsafe impl<'a, T: Facet<'a>> Facet<'a> for *mut T {
    const SHAPE: &'static Shape = &const {
        Shape::builder()
            .id(ConstTypeId::of::<Self>())
            .layout(Layout::new::<Self>())
            .type_params(&[TypeParam {
                name: "T",
                shape: || T::SHAPE,
            }])
            .vtable(
                &const {
                    let builder = ValueVTable::builder()
                        .type_name(|f, opts| {
                            if let Some(opts) = opts.for_children() {
                                write!(f, "*mut ")?;
                                (T::SHAPE.vtable.type_name)(f, opts)
                            } else {
                                write!(f, "*mut ⋯")
                            }
                        })
                        .debug(|value, f| {
                            let v = unsafe { value.get::<Self>() };
                            write!(f, "{v:?}")
                        });

                    // Pointers aren't guaranteed to be valid, so we can't implement most functions

                    // TODO: Marker traits
                    // builder = builder.marker_traits(traits);

                    builder.build()
                },
            )
            .def(Def::RefPtr(
                RefPtrDef::builder()
                    .typ(RefPtrType::Pointer)
                    .mutability(RefPtrMutability::Mut)
                    .pointee(T::SHAPE)
                    .build(),
            ))
            .build()
    };
}

1	use core::alloc::Layout;
2
3	use crate::{
4	ConstTypeId, Def, Facet, PtrConst, RefPtrDef, RefPtrMutability, RefPtrType, Shape, TypeParam,
5	ValueVTable,
6	};
7
8	// TODO: Also implement for `T: !Sized`
9	// - Conflicts with `&[T]`, `&str` and `&Path`
10	// TODO: Also implement for `T: !Facet<'a>`
11	unsafe impl<'a, T: Facet<'a>> Facet<'a> for &'a T {
12	const SHAPE: &'static Shape = &const {
13	Shape::builder()
14	.id(ConstTypeId::of::<Self>())
15	.layout(Layout::new::<Self>())
16	.type_params(&[TypeParam {
17	name: "T",
NEW 18	shape: \|\| T::SHAPE,	×
19	}])
20	.vtable(
21	&const {
22	let mut builder = ValueVTable::builder()
NEW 23	.type_name(\|f, opts\| {	×
NEW 24	if let Some(opts) = opts.for_children() {	×
NEW 25	write!(f, "&")?;	×
NEW 26	(T::SHAPE.vtable.type_name)(f, opts)	×
27	} else {
NEW 28	write!(f, "&⋯")	×
29	}
NEW 30	})	×
NEW 31	.drop_in_place(\|value\| unsafe { value.drop_in_place::<Self>() })	×
NEW 32	.clone_into(\|src, dst\| unsafe { dst.put(src.get::<Self>()) });	×
33
34	if T::SHAPE.vtable.debug.is_some() {
35	builder = builder.debug(\|value, f\| {	1✔
36	let v = unsafe { value.get::<Self>() };	1✔
37	let v = *v;	1✔
38	unsafe {	1✔
39	(T::SHAPE.vtable.debug.unwrap_unchecked())(PtrConst::new(v), f)	1✔
40	}	1✔
41	});	1✔
42	}
43
44	// TODO: More functions
45
46	// TODO: Marker traits
47	// builder = builder.marker_traits(traits);
48
49	builder.build()
50	},
51	)
52	.def(Def::RefPtr(
53	RefPtrDef::builder()
54	.typ(RefPtrType::Reference)
55	.mutability(RefPtrMutability::Const)
56	.pointee(T::SHAPE)
57	.build(),
58	))
59	.build()
60	};
61	}
62
63	unsafe impl<'a, T: Facet<'a>> Facet<'a> for &'a mut T {
64	const SHAPE: &'static Shape = &const {
65	Shape::builder()
66	.id(ConstTypeId::of::<Self>())
67	.layout(Layout::new::<Self>())
68	.type_params(&[TypeParam {
69	name: "T",
NEW 70	shape: \|\| T::SHAPE,	×
71	}])
72	.vtable(
73	&const {
74	let mut builder = ValueVTable::builder()
NEW 75	.type_name(\|f, opts\| {	×
NEW 76	if let Some(opts) = opts.for_children() {	×
NEW 77	write!(f, "&mut ")?;	×
NEW 78	(T::SHAPE.vtable.type_name)(f, opts)	×
79	} else {
NEW 80	write!(f, "&mut ⋯")	×
81	}
NEW 82	})	×
NEW 83	.drop_in_place(\|value\| unsafe { value.drop_in_place::<Self>() })	×
NEW 84	.clone_into(\|src, dst\| unsafe { dst.put(src.get::<Self>()) });	×
85
86	if T::SHAPE.vtable.debug.is_some() {
87	builder = builder.debug(\|value, f\| {	1✔
88	let v = unsafe { value.get::<Self>() } as *const &mut T;	1✔
89	let v = unsafe { v.read() };	1✔
90	unsafe {	1✔
91	(T::SHAPE.vtable.debug.unwrap_unchecked())(PtrConst::new(v), f)	1✔
92	}	1✔
93	});	1✔
94	}
95
96	// TODO: More functions
97
98	// TODO: Marker traits
99	// builder = builder.marker_traits(traits);
100
101	builder.build()
102	},
103	)
104	.def(Def::RefPtr(
105	RefPtrDef::builder()
106	.typ(RefPtrType::Reference)
107	.mutability(RefPtrMutability::Mut)
108	.pointee(T::SHAPE)
109	.build(),
110	))
111	.build()
112	};
113	}
114
115	unsafe impl<'a, T: Facet<'a>> Facet<'a> for *const T {
116	const SHAPE: &'static Shape = &const {
117	Shape::builder()
118	.id(ConstTypeId::of::<Self>())
119	.layout(Layout::new::<Self>())
120	.type_params(&[TypeParam {
121	name: "T",
NEW 122	shape: \|\| T::SHAPE,	×
123	}])
124	.vtable(
125	&const {
126	let builder = ValueVTable::builder()
NEW 127	.type_name(\|f, opts\| {	×
NEW 128	if let Some(opts) = opts.for_children() {	×
NEW 129	write!(f, "*const ")?;	×
NEW 130	(T::SHAPE.vtable.type_name)(f, opts)	×
131	} else {
NEW 132	write!(f, "*const ⋯")	×
133	}
NEW 134	})	×
135	.debug(\|value, f\| {	1✔
136	let v = unsafe { value.get::<Self>() };	1✔
137	write!(f, "{v:?}")	1✔
138	});	1✔
139
140	// Pointers aren't guaranteed to be valid, so we can't implement most functions
141
142	// TODO: Marker traits
143	// builder = builder.marker_traits(traits);
144
145	builder.build()
146	},
147	)
148	.def(Def::RefPtr(
149	RefPtrDef::builder()
150	.typ(RefPtrType::Pointer)
151	.mutability(RefPtrMutability::Const)
152	.pointee(T::SHAPE)
153	.build(),
154	))
155	.build()
156	};
157	}
158
159	unsafe impl<'a, T: Facet<'a>> Facet<'a> for *mut T {
160	const SHAPE: &'static Shape = &const {
161	Shape::builder()
162	.id(ConstTypeId::of::<Self>())
163	.layout(Layout::new::<Self>())
164	.type_params(&[TypeParam {
165	name: "T",
NEW 166	shape: \|\| T::SHAPE,	×
167	}])
168	.vtable(
169	&const {
170	let builder = ValueVTable::builder()
NEW 171	.type_name(\|f, opts\| {	×
NEW 172	if let Some(opts) = opts.for_children() {	×
NEW 173	write!(f, "*mut ")?;	×
NEW 174	(T::SHAPE.vtable.type_name)(f, opts)	×
175	} else {
NEW 176	write!(f, "*mut ⋯")	×
177	}
NEW 178	})	×
179	.debug(\|value, f\| {	1✔
180	let v = unsafe { value.get::<Self>() };	1✔
181	write!(f, "{v:?}")	1✔
182	});	1✔
183
184	// Pointers aren't guaranteed to be valid, so we can't implement most functions
185
186	// TODO: Marker traits
187	// builder = builder.marker_traits(traits);
188
189	builder.build()
190	},
191	)
192	.def(Def::RefPtr(
193	RefPtrDef::builder()
194	.typ(RefPtrType::Pointer)
195	.mutability(RefPtrMutability::Mut)
196	.pointee(T::SHAPE)
197	.build(),
198	))
199	.build()
200	};
201	}

facet-rs / facet / 14630512853

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