16048179719

Committed 03 Jul 2025 10:36AM UTC coverage: 58.677% (+0.04%) from 58.637%

Build # 16048179719

Build Type

Pull #836

github

Committed by

web-flow

Commit Message

Merge 06048cdaf into 83c32f8d8

Pull Request Pull Request #836: Remove various implementations for pointer types

Run Details

108 of 114 new or added lines in 1 file covered. (94.74%)

15 existing lines in 1 file now uncovered.

11577 of 19730 relevant lines covered (58.68%)

123.58 hits per line

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

88.36

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

use core::fmt;

use crate::{
    Facet, MarkerTraits, PointerType, Shape, Type, TypeParam, VTableView, ValuePointerType,
    ValueVTable,
};

// *const pointers
unsafe impl<'a, T: Facet<'a> + ?Sized> Facet<'a> for *const T {
    const VTABLE: &'static ValueVTable = &const {
        ValueVTable::builder::<Self>()
            .marker_traits(|| {
                let mut marker_traits = MarkerTraits::EQ
                    .union(MarkerTraits::COPY)
                    .union(MarkerTraits::UNPIN);

                if T::SHAPE
                    .vtable
                    .marker_traits()
                    .contains(MarkerTraits::REF_UNWIND_SAFE)
                {
                    marker_traits = marker_traits
                        .union(MarkerTraits::UNWIND_SAFE)
                        .union(MarkerTraits::REF_UNWIND_SAFE);
                }

                marker_traits
            })
            .debug(|| Some(fmt::Debug::fmt))
            .clone_into(|| Some(|src, dst| unsafe { dst.put(*src) }))
            .type_name(|f, opts| {
                if let Some(opts) = opts.for_children() {
                    write!(f, "*const ")?;
                    (T::VTABLE.type_name())(f, opts)
                } else {
                    write!(f, "*const ⋯")
                }
            })
            .build()
    };

    const SHAPE: &'static Shape<'static> = &const {
        Shape::builder_for_sized::<Self>()
            .inner(|| T::SHAPE)
            .type_identifier("*const _")
            .type_params(&[TypeParam {
                name: "T",
                shape: || T::SHAPE,
            }])
            .ty({
                let is_wide = ::core::mem::size_of::<Self>() != ::core::mem::size_of::<*const ()>();
                let vpt = ValuePointerType {
                    mutable: false,
                    wide: is_wide,
                    target: || T::SHAPE,
                };

                Type::Pointer(PointerType::Raw(vpt))
            })
            .build()
    };
}

// *mut pointers
unsafe impl<'a, T: Facet<'a> + ?Sized> Facet<'a> for *mut T {
    const VTABLE: &'static ValueVTable = &const {
        ValueVTable::builder::<Self>()
            .marker_traits(|| {
                let mut marker_traits = MarkerTraits::EQ
                    .union(MarkerTraits::COPY)
                    .union(MarkerTraits::UNPIN);

                if T::SHAPE
                    .vtable
                    .marker_traits()
                    .contains(MarkerTraits::REF_UNWIND_SAFE)
                {
                    marker_traits = marker_traits
                        .union(MarkerTraits::UNWIND_SAFE)
                        .union(MarkerTraits::REF_UNWIND_SAFE);
                }

                marker_traits
            })
            .debug(|| Some(fmt::Debug::fmt))
            .clone_into(|| Some(|src, dst| unsafe { dst.put(*src) }))
            .type_name(|f, opts| {
                if let Some(opts) = opts.for_children() {
                    write!(f, "*mut ")?;
                    (T::VTABLE.type_name())(f, opts)
                } else {
                    write!(f, "*mut ⋯")
                }
            })
            .build()
    };

    const SHAPE: &'static Shape<'static> = &const {
        Shape::builder_for_sized::<Self>()
            .inner(|| T::SHAPE)
            .type_identifier("*mut _")
            .type_params(&[TypeParam {
                name: "T",
                shape: || T::SHAPE,
            }])
            .ty({
                let is_wide = ::core::mem::size_of::<Self>() != ::core::mem::size_of::<*const ()>();
                let vpt = ValuePointerType {
                    mutable: true,
                    wide: is_wide,
                    target: || T::SHAPE,
                };

                Type::Pointer(PointerType::Raw(vpt))
            })
            .build()
    };
}

// &T references
unsafe impl<'a, T: Facet<'a> + ?Sized> Facet<'a> for &'a T {
    const VTABLE: &'static ValueVTable = &const {
        ValueVTable::builder::<Self>()
            .marker_traits(|| {
                let mut marker_traits = MarkerTraits::COPY.union(MarkerTraits::UNPIN);
                if T::SHAPE.vtable.marker_traits().contains(MarkerTraits::EQ) {
                    marker_traits = marker_traits.union(MarkerTraits::EQ);
                }
                if T::SHAPE.vtable.marker_traits().contains(MarkerTraits::SYNC) {
                    marker_traits = marker_traits
                        .union(MarkerTraits::SEND)
                        .union(MarkerTraits::SYNC);
                }
                if T::SHAPE
                    .vtable
                    .marker_traits()
                    .contains(MarkerTraits::REF_UNWIND_SAFE)
                {
                    marker_traits = marker_traits
                        .union(MarkerTraits::UNWIND_SAFE)
                        .union(MarkerTraits::REF_UNWIND_SAFE);
                }

                marker_traits
            })
            .clone_into(|| Some(|src, dst| unsafe { dst.put(core::ptr::read(src)) }))
            .debug(|| {
                if T::VTABLE.has_debug() {
                    Some(|value, f| {
                        let view = VTableView::<T>::of();
                        view.debug().unwrap()(*value, f)
                    })
                } else {
                    None
                }
            })
            .display(|| {
                if T::VTABLE.has_display() {
                    Some(|value, f| {
                        let view = VTableView::<T>::of();
                        view.display().unwrap()(*value, f)
                    })
                } else {
                    None
                }
            })
            .type_name(|f, opts| {
                if let Some(opts) = opts.for_children() {
                    write!(f, "&")?;
                    (T::VTABLE.type_name())(f, opts)
                } else {
                    write!(f, "&⋯")
                }
            })
            .build()
    };

    const SHAPE: &'static Shape<'static> = &const {
        Shape::builder_for_sized::<Self>()
            .type_identifier("&_")
            .type_params(&[TypeParam {
                name: "T",
                shape: || T::SHAPE,
            }])
            .ty({
                let is_wide = ::core::mem::size_of::<Self>() != ::core::mem::size_of::<*const ()>();
                let vpt = ValuePointerType {
                    mutable: false,
                    wide: is_wide,
                    target: || T::SHAPE,
                };

                Type::Pointer(PointerType::Reference(vpt))
            })
            .build()
    };
}

// &mut T references
unsafe impl<'a, T: Facet<'a> + ?Sized> Facet<'a> for &'a mut T {
    const VTABLE: &'static ValueVTable = &const {
        ValueVTable::builder::<Self>()
            .marker_traits(|| {
                let mut marker_traits = MarkerTraits::UNPIN;
                if T::SHAPE.vtable.marker_traits().contains(MarkerTraits::EQ) {
                    marker_traits = marker_traits.union(MarkerTraits::EQ);
                }
                if T::SHAPE.vtable.marker_traits().contains(MarkerTraits::SEND) {
                    marker_traits = marker_traits.union(MarkerTraits::SEND);
                }
                if T::SHAPE.vtable.marker_traits().contains(MarkerTraits::SYNC) {
                    marker_traits = marker_traits.union(MarkerTraits::SYNC);
                }
                if T::SHAPE
                    .vtable
                    .marker_traits()
                    .contains(MarkerTraits::REF_UNWIND_SAFE)
                {
                    marker_traits = marker_traits.union(MarkerTraits::REF_UNWIND_SAFE);
                }

                marker_traits
            })
            .debug(|| {
                if T::VTABLE.has_debug() {
                    Some(|value, f| {
                        let view = VTableView::<T>::of();
                        view.debug().unwrap()(*value, f)
                    })
                } else {
                    None
                }
            })
            .display(|| {
                if T::VTABLE.has_display() {
                    Some(|value, f| {
                        let view = VTableView::<T>::of();
                        view.display().unwrap()(*value, f)
                    })
                } else {
                    None
                }
            })
            .type_name(|f, opts| {
                if let Some(opts) = opts.for_children() {
                    write!(f, "&mut ")?;
                    (T::VTABLE.type_name())(f, opts)
                } else {
                    write!(f, "&mut ⋯")
                }
            })
            .build()
    };

    const SHAPE: &'static Shape<'static> = &const {
        Shape::builder_for_sized::<Self>()
            .type_identifier("&mut _")
            .type_params(&[TypeParam {
                name: "T",
                shape: || T::SHAPE,
            }])
            .ty({
                let is_wide = ::core::mem::size_of::<Self>() != ::core::mem::size_of::<*const ()>();
                let vpt = ValuePointerType {
                    mutable: true,
                    wide: is_wide,
                    target: || T::SHAPE,
                };

                Type::Pointer(PointerType::Reference(vpt))
            })
            .build()
    };
}

#[cfg(test)]
mod test {
    use core::panic::{RefUnwindSafe, UnwindSafe};
    use impls::impls;

    #[allow(unused)]
    const fn assert_impls_unwind_safe<T: UnwindSafe>() {}
    #[allow(unused)]
    const fn assert_impls_ref_unwind_safe<T: RefUnwindSafe>() {}

    #[allow(unused)]
    const fn ref_unwind_safe<T: RefUnwindSafe>() {
        assert_impls_unwind_safe::<&T>();
        assert_impls_ref_unwind_safe::<&T>();

        assert_impls_ref_unwind_safe::<&mut T>();

        assert_impls_unwind_safe::<*const T>();
        assert_impls_ref_unwind_safe::<*const T>();

        assert_impls_unwind_safe::<*mut T>();
        assert_impls_ref_unwind_safe::<*mut T>();
    }

    #[test]
    fn mut_ref_not_unwind_safe() {
        assert!(impls!(&mut (): !UnwindSafe));
    }
}

1	use core::fmt;
2
3	use crate::{
4	Facet, MarkerTraits, PointerType, Shape, Type, TypeParam, VTableView, ValuePointerType,
5	ValueVTable,
6	};
7
8	// *const pointers
9	unsafe impl<'a, T: Facet<'a> + ?Sized> Facet<'a> for *const T {
10	const VTABLE: &'static ValueVTable = &const {
11	ValueVTable::builder::<Self>()
12	.marker_traits(\|\| {	22✔
13	let mut marker_traits = MarkerTraits::EQ	22✔
14	.union(MarkerTraits::COPY)	22✔
15	.union(MarkerTraits::UNPIN);	22✔
16
17	if T::SHAPE	22✔
18	.vtable	22✔
19	.marker_traits()	22✔
20	.contains(MarkerTraits::REF_UNWIND_SAFE)	22✔
21	{	20✔
22	marker_traits = marker_traits	20✔
23	.union(MarkerTraits::UNWIND_SAFE)	20✔
24	.union(MarkerTraits::REF_UNWIND_SAFE);	20✔
25	}	20✔
26
27	marker_traits	22✔
28	})	22✔
29	.debug(\|\| Some(fmt::Debug::fmt))	28✔
30	.clone_into(\|\| Some(\|src, dst\| unsafe { dst.put(*src) }))	4✔
31	.type_name(\|f, opts\| {	12✔
32	if let Some(opts) = opts.for_children() {	12✔
33	write!(f, "*const ")?;	12✔
34	(T::VTABLE.type_name())(f, opts)	12✔
35	} else {
NEW 36	write!(f, "*const ⋯")	×
37	}
38	})	12✔
39	.build()
40	};
41
42	const SHAPE: &'static Shape<'static> = &const {
43	Shape::builder_for_sized::<Self>()
44	.inner(\|\| T::SHAPE)
45	.type_identifier("*const _")
46	.type_params(&[TypeParam {
47	name: "T",
48	shape: \|\| T::SHAPE,
49	}])
50	.ty({
51	let is_wide = ::core::mem::size_of::<Self>() != ::core::mem::size_of::<*const ()>();
52	let vpt = ValuePointerType {
53	mutable: false,
54	wide: is_wide,
55	target: \|\| T::SHAPE,
56	};
57
58	Type::Pointer(PointerType::Raw(vpt))
59	})
60	.build()
61	};
62	}
63
64	// *mut pointers
65	unsafe impl<'a, T: Facet<'a> + ?Sized> Facet<'a> for *mut T {
66	const VTABLE: &'static ValueVTable = &const {
67	ValueVTable::builder::<Self>()
68	.marker_traits(\|\| {	8✔
69	let mut marker_traits = MarkerTraits::EQ	8✔
70	.union(MarkerTraits::COPY)	8✔
71	.union(MarkerTraits::UNPIN);	8✔
72
73	if T::SHAPE	8✔
74	.vtable	8✔
75	.marker_traits()	8✔
76	.contains(MarkerTraits::REF_UNWIND_SAFE)	8✔
77	{	6✔
78	marker_traits = marker_traits	6✔
79	.union(MarkerTraits::UNWIND_SAFE)	6✔
80	.union(MarkerTraits::REF_UNWIND_SAFE);	6✔
81	}	6✔
82
83	marker_traits	8✔
84	})	8✔
85	.debug(\|\| Some(fmt::Debug::fmt))	16✔
86	.clone_into(\|\| Some(\|src, dst\| unsafe { dst.put(*src) }))	4✔
87	.type_name(\|f, opts\| {	8✔
88	if let Some(opts) = opts.for_children() {	8✔
89	write!(f, "*mut ")?;	8✔
90	(T::VTABLE.type_name())(f, opts)	8✔
91	} else {
NEW 92	write!(f, "*mut ⋯")	×
93	}
94	})	8✔
95	.build()
96	};
97
98	const SHAPE: &'static Shape<'static> = &const {
99	Shape::builder_for_sized::<Self>()
100	.inner(\|\| T::SHAPE)
101	.type_identifier("*mut _")
102	.type_params(&[TypeParam {
103	name: "T",
104	shape: \|\| T::SHAPE,
105	}])
106	.ty({
107	let is_wide = ::core::mem::size_of::<Self>() != ::core::mem::size_of::<*const ()>();
108	let vpt = ValuePointerType {
109	mutable: true,
110	wide: is_wide,
111	target: \|\| T::SHAPE,
112	};
113
114	Type::Pointer(PointerType::Raw(vpt))
115	})
116	.build()
117	};
118	}
119
120	// &T references
121	unsafe impl<'a, T: Facet<'a> + ?Sized> Facet<'a> for &'a T {
122	const VTABLE: &'static ValueVTable = &const {
123	ValueVTable::builder::<Self>()
124	.marker_traits(\|\| {	20✔
125	let mut marker_traits = MarkerTraits::COPY.union(MarkerTraits::UNPIN);	20✔
126	if T::SHAPE.vtable.marker_traits().contains(MarkerTraits::EQ) {	20✔
127	marker_traits = marker_traits.union(MarkerTraits::EQ);	18✔
128	}	18✔
129	if T::SHAPE.vtable.marker_traits().contains(MarkerTraits::SYNC) {	20✔
130	marker_traits = marker_traits	16✔
131	.union(MarkerTraits::SEND)	16✔
132	.union(MarkerTraits::SYNC);	16✔
133	}	16✔
134	if T::SHAPE	20✔
135	.vtable	20✔
136	.marker_traits()	20✔
137	.contains(MarkerTraits::REF_UNWIND_SAFE)	20✔
138	{	18✔
139	marker_traits = marker_traits	18✔
140	.union(MarkerTraits::UNWIND_SAFE)	18✔
141	.union(MarkerTraits::REF_UNWIND_SAFE);	18✔
142	}	18✔
143
144	marker_traits	20✔
145	})	20✔
146	.clone_into(\|\| Some(\|src, dst\| unsafe { dst.put(core::ptr::read(src)) }))	6✔
147	.debug(\|\| {	42✔
148	if T::VTABLE.has_debug() {	42✔
149	Some(\|value, f\| {	21✔
150	let view = VTableView::<T>::of();	21✔
151	view.debug().unwrap()(*value, f)	21✔
152	})	21✔
153	} else {
NEW UNCOV 154	None	×
155	}
156	})	42✔
157	.display(\|\| {	29✔
158	if T::VTABLE.has_display() {	29✔
159	Some(\|value, f\| {	10✔
160	let view = VTableView::<T>::of();	10✔
161	view.display().unwrap()(*value, f)	10✔
162	})	10✔
163	} else {
164	None	15✔
165	}
166	})	29✔
167	.type_name(\|f, opts\| {	111✔
168	if let Some(opts) = opts.for_children() {	111✔
169	write!(f, "&")?;	111✔
170	(T::VTABLE.type_name())(f, opts)	111✔
171	} else {
NEW UNCOV 172	write!(f, "&⋯")	×
173	}
174	})	111✔
175	.build()
176	};
177
178	const SHAPE: &'static Shape<'static> = &const {
179	Shape::builder_for_sized::<Self>()
180	.type_identifier("&_")
181	.type_params(&[TypeParam {
182	name: "T",
183	shape: \|\| T::SHAPE,
184	}])
185	.ty({
186	let is_wide = ::core::mem::size_of::<Self>() != ::core::mem::size_of::<*const ()>();
187	let vpt = ValuePointerType {
188	mutable: false,
189	wide: is_wide,
190	target: \|\| T::SHAPE,
191	};
192
193	Type::Pointer(PointerType::Reference(vpt))
194	})
195	.build()
196	};
197	}
198
199	// &mut T references
200	unsafe impl<'a, T: Facet<'a> + ?Sized> Facet<'a> for &'a mut T {
201	const VTABLE: &'static ValueVTable = &const {
202	ValueVTable::builder::<Self>()
203	.marker_traits(\|\| {	6✔
204	let mut marker_traits = MarkerTraits::UNPIN;	6✔
205	if T::SHAPE.vtable.marker_traits().contains(MarkerTraits::EQ) {	6✔
206	marker_traits = marker_traits.union(MarkerTraits::EQ);	4✔
207	}	4✔
208	if T::SHAPE.vtable.marker_traits().contains(MarkerTraits::SEND) {	6✔
209	marker_traits = marker_traits.union(MarkerTraits::SEND);	2✔
210	}	4✔
211	if T::SHAPE.vtable.marker_traits().contains(MarkerTraits::SYNC) {	6✔
212	marker_traits = marker_traits.union(MarkerTraits::SYNC);	2✔
213	}	4✔
214	if T::SHAPE	6✔
215	.vtable	6✔
216	.marker_traits()	6✔
217	.contains(MarkerTraits::REF_UNWIND_SAFE)	6✔
218	{	4✔
219	marker_traits = marker_traits.union(MarkerTraits::REF_UNWIND_SAFE);	4✔
220	}	4✔
221
222	marker_traits	6✔
223	})	6✔
224	.debug(\|\| {	12✔
225	if T::VTABLE.has_debug() {	12✔
226	Some(\|value, f\| {	6✔
227	let view = VTableView::<T>::of();	6✔
228	view.debug().unwrap()(*value, f)	6✔
229	})	6✔
230	} else {
NEW UNCOV 231	None	×
232	}
233	})	12✔
234	.display(\|\| {	14✔
235	if T::VTABLE.has_display() {	14✔
236	Some(\|value, f\| {	6✔
237	let view = VTableView::<T>::of();	6✔
238	view.display().unwrap()(*value, f)	6✔
239	})	6✔
240	} else {
241	None	6✔
242	}
243	})	14✔
244	.type_name(\|f, opts\| {	6✔
245	if let Some(opts) = opts.for_children() {	6✔
246	write!(f, "&mut ")?;	6✔
247	(T::VTABLE.type_name())(f, opts)	6✔
248	} else {
NEW UNCOV 249	write!(f, "&mut ⋯")	×
250	}
251	})	6✔
252	.build()
253	};
254
255	const SHAPE: &'static Shape<'static> = &const {
256	Shape::builder_for_sized::<Self>()
257	.type_identifier("&mut _")
258	.type_params(&[TypeParam {
259	name: "T",
260	shape: \|\| T::SHAPE,
261	}])
262	.ty({
263	let is_wide = ::core::mem::size_of::<Self>() != ::core::mem::size_of::<*const ()>();
264	let vpt = ValuePointerType {
265	mutable: true,
266	wide: is_wide,
267	target: \|\| T::SHAPE,
268	};
269
270	Type::Pointer(PointerType::Reference(vpt))
271	})
272	.build()
273	};
274	}
275
276	#[cfg(test)]
277	mod test {
278	use core::panic::{RefUnwindSafe, UnwindSafe};
279	use impls::impls;
280
281	#[allow(unused)]
UNCOV 282	const fn assert_impls_unwind_safe<T: UnwindSafe>() {}	×
283	#[allow(unused)]
UNCOV 284	const fn assert_impls_ref_unwind_safe<T: RefUnwindSafe>() {}	×
285
286	#[allow(unused)]
UNCOV 287	const fn ref_unwind_safe<T: RefUnwindSafe>() {	×
UNCOV 288	assert_impls_unwind_safe::<&T>();	×
UNCOV 289	assert_impls_ref_unwind_safe::<&T>();	×
290
UNCOV 291	assert_impls_ref_unwind_safe::<&mut T>();	×
292
UNCOV 293	assert_impls_unwind_safe::<*const T>();	×
UNCOV 294	assert_impls_ref_unwind_safe::<*const T>();	×
295
UNCOV 296	assert_impls_unwind_safe::<*mut T>();	×
UNCOV 297	assert_impls_ref_unwind_safe::<*mut T>();	×
UNCOV 298	}	×
299
300	#[test]
301	fn mut_ref_not_unwind_safe() {	1✔
302	assert!(impls!(&mut (): !UnwindSafe));	1✔
303	}	1✔
304	}

facet-rs / facet / 16048179719

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