16047486957

Committed 03 Jul 2025 10:03AM UTC coverage: 58.637%. Remained the same

Build # 16047486957

Build Type

push

github

Committed by

fasterthanlime

Commit Message

Revert "Add inner types for reference"

This reverts commit 7b9b86667.

Run Details

11602 of 19786 relevant lines covered (58.64%)

123.57 hits per line

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

77.72

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

use core::{fmt, hash::Hash};

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

macro_rules! impl_facet_for_pointer {
    ($variant:ident: $type:ty => $shape:expr => $vtable_builder:expr => $ptr_type:ident, $mutable:expr) => {
        unsafe impl<'a, T: Facet<'a> + ?Sized> Facet<'a> for $type {
            const VTABLE: &'static ValueVTable = &const {
                $vtable_builder
                    .type_name(|f, opts| {
                        if let Some(opts) = opts.for_children() {
                            if stringify!($ptr_type) == "Raw" {
                                if $mutable {
                                    write!(f, "*mut ")?;
                                } else {
                                    write!(f, "*const ")?;
                                }
                            } else {
                                write!(f, "&")?;
                                if $mutable {
                                    write!(f, "mut ")?;
                                }
                            }
                            (T::VTABLE.type_name())(f, opts)
                        } else {
                            if stringify!($ptr_type) == "Raw" {
                                if $mutable {
                                    write!(f, "*mut ⋯")
                                } else {
                                    write!(f, "*const ⋯")
                                }
                            } else {
                                write!(f, "&")?;
                                if $mutable {
                                    write!(f, "mut ⋯")
                                } else {
                                    write!(f, "⋯")
                                }
                            }
                        }
                    })
                    .build()
            };

            const SHAPE: &'static Shape<'static> = &const {
                $shape
                    .type_identifier(
                        const {
                            let ptr_type = stringify!($ptr_type);
                            let is_raw = ptr_type.len() == 3
                                && ptr_type.as_bytes()[0] == b'R'
                                && ptr_type.as_bytes()[1] == b'a'
                                && ptr_type.as_bytes()[2] == b'w';
                            if is_raw {
                                if $mutable { "*mut _" } else { "*const _" }
                            } else {
                                if $mutable { "&mut _" } else { "&_" }
                            }
                        },
                    )
                    .type_params(&[TypeParam {
                        name: "T",
                        shape: || T::SHAPE,
                    }])
                    .ty({
                        let is_wide =
                            ::core::mem::size_of::<$type>() != ::core::mem::size_of::<*const ()>();
                        let vpt = ValuePointerType {
                            mutable: $mutable,
                            wide: is_wide,
                            target: || T::SHAPE,
                        };

                        Type::Pointer(PointerType::$ptr_type(vpt))
                    })
                    .build()
            };
        }
    };
}

// *const pointers
impl_facet_for_pointer!(
    Raw: *const T
        => Shape::builder_for_sized::<Self>()
            .inner(|| T::SHAPE)
        => 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) }))
            .partial_eq(|| Some(|&left, &right| core::ptr::eq(left, right)))
            .partial_ord(|| Some(|&left, &right| {
                // https://github.com/rust-lang/rust/issues/141510
                #[allow(ambiguous_wide_pointer_comparisons)]
                left.partial_cmp(&right)
            }))
            .ord(|| Some(|&left, &right| {
                #[allow(ambiguous_wide_pointer_comparisons)]
                left.cmp(&right)
            }))
            .hash(|| Some(|value, hasher_this, hasher_write_fn| {
                value.hash(&mut unsafe {
                    HasherProxy::new(hasher_this, hasher_write_fn)
                })
            }))
        => Raw, false
);

// *mut pointers
impl_facet_for_pointer!(
    Raw: *mut T
        => Shape::builder_for_sized::<Self>()
            .inner(|| T::SHAPE)
        => 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) }))
            .partial_eq(|| Some(|&left, &right| core::ptr::eq(left, right)))
            .partial_ord(|| Some(|&left, &right| {
                // https://github.com/rust-lang/rust/issues/141510
                #[allow(ambiguous_wide_pointer_comparisons)]
                left.partial_cmp(&right)
            }))
            .ord(|| Some(|&left, &right| {
                #[allow(ambiguous_wide_pointer_comparisons)]
                left.cmp(&right)
            }))
            .hash(|| Some(|value, hasher_this, hasher_write_fn| {
                value.hash(&mut unsafe {
                    HasherProxy::new(hasher_this, hasher_write_fn)
                })
            }))
        => Raw, true
);

// &T references
impl_facet_for_pointer!(
    Reference: &'a T
        => Shape::builder_for_sized::<Self>()
        => {
            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
                    }
                })
                .partial_eq(|| {
                    if T::VTABLE.has_partial_eq() {
                        Some(|a, b| {
                            let view = VTableView::<T>::of();
                            view.partial_eq().unwrap()(*a, *b)
                        })
                    } else {
                        None
                    }
                })
                .partial_ord(|| {
                    if T::VTABLE.has_partial_ord() {
                        Some(|a, b| {
                            let view = VTableView::<T>::of();
                            view.partial_ord().unwrap()(*a, *b)
                        })
                    } else {
                        None
                    }
                })
                .ord(|| {
                    if T::VTABLE.has_ord() {
                        Some(|a, b| {
                            let view = VTableView::<T>::of();
                            view.ord().unwrap()(*a, *b)
                        })
                    } else {
                        None
                    }
                })
                .hash(|| {
                    if T::VTABLE.has_hash() {
                        Some(|value, hasher_this, hasher_write_fn| {
                            let view = VTableView::<T>::of();
                            view.hash().unwrap()(*value, hasher_this, hasher_write_fn)
                        })
                    } else {
                        None
                    }
                })
        }
        => Reference, false
);

// &mut T references
impl_facet_for_pointer!(
    Reference: &'a mut T
        => Shape::builder_for_sized::<Self>()
        => {
            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
                    }
                })
                .partial_eq(|| {
                    if T::VTABLE.has_partial_eq() {
                        Some(|a, b| {
                            let view = VTableView::<T>::of();
                            view.partial_eq().unwrap()(*a, *b)
                        })
                    } else {
                        None
                    }
                })
                .partial_ord(|| {
                    if T::VTABLE.has_partial_ord() {
                        Some(|a, b| {
                            let view = VTableView::<T>::of();
                            view.partial_ord().unwrap()(*a, *b)
                        })
                    } else {
                        None
                    }
                })
                .ord(|| {
                    if T::VTABLE.has_ord() {
                        Some(|a, b| {
                            let view = VTableView::<T>::of();
                            view.ord().unwrap()(*a, *b)
                        })
                    } else {
                        None
                    }
                })
                .hash(|| {
                    if T::VTABLE.has_hash() {
                        Some(|value, hasher_this, hasher_write_fn| {
                            let view = VTableView::<T>::of();
                            view.hash().unwrap()(*value, hasher_this, hasher_write_fn)
                        })
                    } else {
                        None
                    }
                })
        }
        => Reference, true
);

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

facet-rs / facet / 16047486957

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