18681425512

Committed 21 Oct 2025 10:48AM UTC coverage: 54.052% (-0.1%) from 54.168%

Build # 18681425512

Build Type

push

github

Committed by

fasterthanlime

Commit Message

use a more descriptive ReflectError variant

Run Details

2 of 12 new or added lines in 1 file covered. (16.67%)

1350 existing lines in 33 files now uncovered.

4762 of 8810 relevant lines covered (54.05%)

40.65 hits per line

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

78.33

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

use core::fmt;

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

// *const pointers
unsafe impl<'a, T: Facet<'a> + ?Sized> Facet<'a> for *const T {
    const SHAPE: &'static Shape = &const {
        Shape::builder_for_sized::<Self>()
            .vtable(
                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(|p, f| fmt::Debug::fmt(p.get(), f)))
                    .clone_into(|| Some(|src, dst| unsafe { dst.put(*src.get()).into() }))
                    .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 ⋯")
                        }
                    })
                    .build(),
            )
            .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 SHAPE: &'static Shape = &const {
        Shape::builder_for_sized::<Self>()
            .vtable(
                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(|p, f| fmt::Debug::fmt(p.get(), f)))
                    .clone_into(|| Some(|src, dst| unsafe { dst.put(*src.get()).into() }))
                    .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 ⋯")
                        }
                    })
                    .build(),
            )
            .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()
    };
}

#[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, ValuePointerType, ValueVTable,
5	};
6
7	// *const pointers
8	unsafe impl<'a, T: Facet<'a> + ?Sized> Facet<'a> for *const T {
9	const SHAPE: &'static Shape = &const {
10	Shape::builder_for_sized::<Self>()
11	.vtable(
12	ValueVTable::builder::<Self>()
13	.marker_traits(\|\| {	20✔
14	let mut marker_traits = MarkerTraits::EQ	20✔
15	.union(MarkerTraits::COPY)	20✔
16	.union(MarkerTraits::UNPIN);	20✔
17
18	if T::SHAPE	20✔
19	.vtable	20✔
20	.marker_traits()	20✔
21	.contains(MarkerTraits::REF_UNWIND_SAFE)	20✔
22	{	18✔
23	marker_traits = marker_traits	18✔
24	.union(MarkerTraits::UNWIND_SAFE)	18✔
25	.union(MarkerTraits::REF_UNWIND_SAFE);	18✔
26	}	18✔
27
28	marker_traits	20✔
29	})	20✔
30	.debug(\|\| Some(\|p, f\| fmt::Debug::fmt(p.get(), f)))	12✔
31	.clone_into(\|\| Some(\|src, dst\| unsafe { dst.put(*src.get()).into() }))	4✔
32	.type_name(\|f, opts\| {	12✔
33	if let Some(opts) = opts.for_children() {	12✔
34	write!(f, "*const ")?;	12✔
35	(T::SHAPE.vtable.type_name())(f, opts)	12✔
36	} else {
UNCOV 37	write!(f, "*const ⋯")	×
38	}
39	})	12✔
40	.build(),
41	)
42	.inner(\|\| T::SHAPE)
43	.type_identifier("*const _")
44	.type_params(&[TypeParam {
45	name: "T",
46	shape: \|\| T::SHAPE,
47	}])
48	.ty({
49	let is_wide = ::core::mem::size_of::<Self>() != ::core::mem::size_of::<*const ()>();
50	let vpt = ValuePointerType {
51	mutable: false,
52	wide: is_wide,
53	target: \|\| T::SHAPE,
54	};
55
56	Type::Pointer(PointerType::Raw(vpt))
57	})
58	.build()
59	};
60	}
61
62	// *mut pointers
63	unsafe impl<'a, T: Facet<'a> + ?Sized> Facet<'a> for *mut T {
64	const SHAPE: &'static Shape = &const {
65	Shape::builder_for_sized::<Self>()
66	.vtable(
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(\|p, f\| fmt::Debug::fmt(p.get(), f)))	8✔
86	.clone_into(\|\| Some(\|src, dst\| unsafe { dst.put(*src.get()).into() }))	4✔
87	.type_name(\|f, opts\| {	8✔
88	if let Some(opts) = opts.for_children() {	8✔
89	write!(f, "*mut ")?;	8✔
90	(T::SHAPE.vtable.type_name())(f, opts)	8✔
91	} else {
UNCOV 92	write!(f, "*mut ⋯")	×
93	}
94	})	8✔
95	.build(),
96	)
97	.inner(\|\| T::SHAPE)
98	.type_identifier("*mut _")
99	.type_params(&[TypeParam {
100	name: "T",
101	shape: \|\| T::SHAPE,
102	}])
103	.ty({
104	let is_wide = ::core::mem::size_of::<Self>() != ::core::mem::size_of::<*const ()>();
105	let vpt = ValuePointerType {
106	mutable: true,
107	wide: is_wide,
108	target: \|\| T::SHAPE,
109	};
110
111	Type::Pointer(PointerType::Raw(vpt))
112	})
113	.build()
114	};
115	}
116
117	#[cfg(test)]
118	mod test {
119	use core::panic::{RefUnwindSafe, UnwindSafe};
120	use impls::impls;
121
122	#[allow(unused)]
UNCOV 123	const fn assert_impls_unwind_safe<T: UnwindSafe>() {}	×
124	#[allow(unused)]
125	const fn assert_impls_ref_unwind_safe<T: RefUnwindSafe>() {}	×
126
127	#[allow(unused)]
UNCOV 128	const fn ref_unwind_safe<T: RefUnwindSafe>() {	×
UNCOV 129	assert_impls_unwind_safe::<&T>();	×
130	assert_impls_ref_unwind_safe::<&T>();	×
131
132	assert_impls_ref_unwind_safe::<&mut T>();	×
133
134	assert_impls_unwind_safe::<*const T>();	×
UNCOV 135	assert_impls_ref_unwind_safe::<*const T>();	×
136
137	assert_impls_unwind_safe::<*mut T>();	×
UNCOV 138	assert_impls_ref_unwind_safe::<*mut T>();	×
139	}	×
140
141	#[test]
142	fn mut_ref_not_unwind_safe() {	1✔
143	assert!(impls!(&mut (): !UnwindSafe));	1✔
144	}	1✔
145	}

facet-rs / facet / 18681425512

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