15085921060

Committed 17 May 2025 02:00PM UTC coverage: 56.937% (+0.2%) from 56.732%

Build # 15085921060

Build Type

push

github

Committed by

fasterthanlime

Commit Message

Introduce `'shape` lifetime, allowing non-'static shapes.

Closes #455.

Run Details

402 of 615 new or added lines in 70 files covered. (65.37%)

31 existing lines in 3 files now uncovered.

9176 of 16116 relevant lines covered (56.94%)

126.52 hits per line

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

23.91

/facet-core/src/impls_ordered_float.rs

use crate::{
    Characteristic, Def, Facet, PtrConst, PtrMut, PtrUninit, Repr, ScalarAffinity, ScalarDef,
    Shape, StructType, TryBorrowInnerError, TryFromError, TryIntoInnerError, Type, UserType,
    ValueVTable, field_in_type, value_vtable,
};
use ordered_float::{NotNan, OrderedFloat};

macro_rules! impl_facet_for_ordered_float_and_notnan {
    ($float:ty) => {
        unsafe impl<'a> Facet<'a> for OrderedFloat<$float> {
            const VTABLE: &'static ValueVTable = &const {
                // Define conversion functions for transparency
                unsafe fn try_from<'shape, 'dst>(
                    src_ptr: PtrConst<'_>,
                    src_shape: &'shape Shape<'shape>,
                    dst: PtrUninit<'dst>,
                ) -> Result<PtrMut<'dst>, TryFromError<'shape>> {
                    if src_shape == <$float as Facet>::SHAPE {
                        // Get the inner value and wrap as OrderedFloat
                        let value = unsafe { src_ptr.get::<$float>() };
                        let ord = OrderedFloat(*value);
                        Ok(unsafe { dst.put(ord) })
                    } else {
                        let inner_try_from = <$float as Facet>::SHAPE.vtable.try_from.ok_or(
                            TryFromError::UnsupportedSourceShape {
                                src_shape,
                                expected: &[<$float as Facet>::SHAPE],
                            },
                        )?;
                        // fallback to inner's try_from
                        // This relies on the fact that `dst` is the same size as `OrderedFloat<$float>`
                        // which should be true because `OrderedFloat` is `repr(transparent)`
                        let inner_result = unsafe { (inner_try_from)(src_ptr, src_shape, dst) };
                        match inner_result {
                            Ok(result) => {
                                // After conversion to inner type, wrap as OrderedFloat
                                let value = unsafe { result.read::<$float>() };
                                let ord = OrderedFloat(value);
                                Ok(unsafe { dst.put(ord) })
                            }
                            Err(e) => Err(e),
                        }
                    }
                }

                // Conversion back to inner float type
                unsafe fn try_into_inner<'dst>(
                    src_ptr: PtrMut<'_>,
                    dst: PtrUninit<'dst>,
                ) -> Result<PtrMut<'dst>, TryIntoInnerError> {
                    let v = unsafe { src_ptr.read::<OrderedFloat<$float>>() };
                    Ok(unsafe { dst.put(v.0) })
                }

                // Borrow inner float type
                unsafe fn try_borrow_inner(
                    src_ptr: PtrConst<'_>,
                ) -> Result<PtrConst<'_>, TryBorrowInnerError> {
                    let v = unsafe { src_ptr.get::<OrderedFloat<$float>>() };
                    Ok(PtrConst::new((&v.0) as *const $float as *const u8))
                }

                let mut vtable = value_vtable!((), |f, _opts| write!(f, "OrderedFloat"));
                if <$float as Facet>::SHAPE.is(Characteristic::FromStr) {
                    let inner_parse =
                        unsafe { <$float as Facet>::SHAPE.vtable.parse.unwrap_unchecked() };
                    // `OrderedFloat` is `repr(transparent)`
                    vtable.parse = Some(inner_parse);
                }
                vtable.try_from = Some(try_from);
                vtable.try_into_inner = Some(try_into_inner);
                vtable.try_borrow_inner = Some(try_borrow_inner);
                vtable
            };

            const SHAPE: &'static Shape<'static> = &const {
                fn inner_shape() -> &'static Shape<'static> {
                    <$float as Facet>::SHAPE
                }

                Shape::builder_for_sized::<Self>()
                    .ty(Type::User(UserType::Struct(
                        StructType::builder()
                            .repr(Repr::transparent())
                            .fields(&const { [field_in_type!(Self, 0)] })
                            .kind(crate::StructKind::Tuple)
                            .build(),
                    )))
                    .def(Def::Scalar(
                        ScalarDef::builder()
                            // Affinity: use number affinity as inner's
                            .affinity(&const { ScalarAffinity::opaque().build() })
                            .build(),
                    ))
                    .inner(inner_shape)
                    .build()
            };
        }

        unsafe impl<'a> Facet<'a> for NotNan<$float> {
            const VTABLE: &'static ValueVTable = &const {
                // Conversion from inner float type to NotNan<$float>
                unsafe fn try_from<'shape, 'dst>(
                    src_ptr: PtrConst<'_>,
                    src_shape: &'shape Shape<'shape>,
                    dst: PtrUninit<'dst>,
                ) -> Result<PtrMut<'dst>, TryFromError<'shape>> {
                    if src_shape == <$float as Facet>::SHAPE {
                        // Get the inner value and check that it's not NaN
                        let value = unsafe { *src_ptr.get::<$float>() };
                        let nn =
                            NotNan::new(value).map_err(|_| TryFromError::Generic("was NaN"))?;
                        Ok(unsafe { dst.put(nn) })
                    } else {
                        let inner_try_from = <$float as Facet>::SHAPE.vtable.try_from.ok_or(
                            TryFromError::UnsupportedSourceShape {
                                src_shape,
                                expected: &[<$float as Facet>::SHAPE],
                            },
                        )?;

                        // fallback to inner's try_from
                        // This relies on the fact that `dst` is the same size as `NotNan<$float>`
                        // which should be true because `NotNan` is `repr(transparent)`
                        let inner_result = unsafe { (inner_try_from)(src_ptr, src_shape, dst) };
                        match inner_result {
                            Ok(result) => {
                                // After conversion to inner type, wrap as NotNan
                                let value = unsafe { *result.get::<$float>() };
                                let nn = NotNan::new(value)
                                    .map_err(|_| TryFromError::Generic("was NaN"))?;
                                Ok(unsafe { dst.put(nn) })
                            }
                            Err(e) => Err(e),
                        }
                    }
                }

                // Conversion back to inner float type
                unsafe fn try_into_inner<'dst>(
                    src_ptr: PtrMut<'_>,
                    dst: PtrUninit<'dst>,
                ) -> Result<PtrMut<'dst>, TryIntoInnerError> {
                    let v = unsafe { src_ptr.read::<NotNan<$float>>() };
                    Ok(unsafe { dst.put(v.into_inner()) })
                }

                // Borrow inner float type
                unsafe fn try_borrow_inner(
                    src_ptr: PtrConst<'_>,
                ) -> Result<PtrConst<'_>, TryBorrowInnerError> {
                    let v = unsafe { src_ptr.get::<NotNan<$float>>() };
                    Ok(PtrConst::new(
                        (&v.into_inner()) as *const $float as *const u8,
                    ))
                }

                let mut vtable = value_vtable!((), |f, _opts| write!(f, "NotNan"));
                // Accept parsing as inner T, but enforce NotNan invariant
                vtable.parse = Some(|s, target| match s.parse::<$float>() {
                    Ok(inner) => match NotNan::new(inner) {
                        Ok(not_nan) => Ok(unsafe { target.put(not_nan) }),
                        Err(_) => Err(crate::ParseError::Generic("NaN is not allowed for NotNan")),
                    },
                    Err(_) => Err(crate::ParseError::Generic(
                        "Failed to parse inner type for NotNan",
                    )),
                });
                vtable.try_from = Some(try_from);
                vtable.try_into_inner = Some(try_into_inner);
                vtable.try_borrow_inner = Some(try_borrow_inner);
                vtable
            };

            const SHAPE: &'static Shape<'static> = &const {
                fn inner_shape() -> &'static Shape<'static> {
                    <$float as Facet>::SHAPE
                }

                Shape::builder_for_sized::<Self>()
                    .ty(Type::User(UserType::Opaque))
                    .def(Def::Scalar(
                        ScalarDef::builder()
                            .affinity(&const { ScalarAffinity::opaque().build() })
                            .build(),
                    ))
                    .inner(inner_shape)
                    .build()
            };
        }
    };
}

impl_facet_for_ordered_float_and_notnan!(f32);
impl_facet_for_ordered_float_and_notnan!(f64);

1	use crate::{
2	Characteristic, Def, Facet, PtrConst, PtrMut, PtrUninit, Repr, ScalarAffinity, ScalarDef,
3	Shape, StructType, TryBorrowInnerError, TryFromError, TryIntoInnerError, Type, UserType,
4	ValueVTable, field_in_type, value_vtable,
5	};
6	use ordered_float::{NotNan, OrderedFloat};
7
8	macro_rules! impl_facet_for_ordered_float_and_notnan {
9	($float:ty) => {
10	unsafe impl<'a> Facet<'a> for OrderedFloat<$float> {
11	const VTABLE: &'static ValueVTable = &const {
12	// Define conversion functions for transparency
13	unsafe fn try_from<'shape, 'dst>(	1✔
14	src_ptr: PtrConst<'_>,	1✔
15	src_shape: &'shape Shape<'shape>,	1✔
16	dst: PtrUninit<'dst>,	1✔
17	) -> Result<PtrMut<'dst>, TryFromError<'shape>> {	1✔
18	if src_shape == <$float as Facet>::SHAPE {	1✔
19	// Get the inner value and wrap as OrderedFloat
20	let value = unsafe { src_ptr.get::<$float>() };	×
21	let ord = OrderedFloat(*value);	×
22	Ok(unsafe { dst.put(ord) })	×
23	} else {
24	let inner_try_from = <$float as Facet>::SHAPE.vtable.try_from.ok_or(	1✔
25	TryFromError::UnsupportedSourceShape {	1✔
26	src_shape,	1✔
27	expected: &[<$float as Facet>::SHAPE],	1✔
28	},	1✔
29	)?;	×
30	// fallback to inner's try_from
31	// This relies on the fact that `dst` is the same size as `OrderedFloat<$float>`
32	// which should be true because `OrderedFloat` is `repr(transparent)`
33	let inner_result = unsafe { (inner_try_from)(src_ptr, src_shape, dst) };	1✔
34	match inner_result {	1✔
35	Ok(result) => {	1✔
36	// After conversion to inner type, wrap as OrderedFloat
37	let value = unsafe { result.read::<$float>() };	1✔
38	let ord = OrderedFloat(value);	1✔
39	Ok(unsafe { dst.put(ord) })	1✔
40	}
41	Err(e) => Err(e),	×
42	}
43	}
44	}	1✔
45
46	// Conversion back to inner float type
47	unsafe fn try_into_inner<'dst>(	×
48	src_ptr: PtrMut<'_>,	×
49	dst: PtrUninit<'dst>,	×
50	) -> Result<PtrMut<'dst>, TryIntoInnerError> {	×
51	let v = unsafe { src_ptr.read::<OrderedFloat<$float>>() };	×
52	Ok(unsafe { dst.put(v.0) })	×
53	}	×
54
55	// Borrow inner float type
56	unsafe fn try_borrow_inner(	×
57	src_ptr: PtrConst<'_>,	×
58	) -> Result<PtrConst<'_>, TryBorrowInnerError> {	×
59	let v = unsafe { src_ptr.get::<OrderedFloat<$float>>() };	×
60	Ok(PtrConst::new((&v.0) as const $float as const u8))	×
61	}	×
62
63	let mut vtable = value_vtable!((), \|f, _opts\| write!(f, "OrderedFloat"));	1✔
64	if <$float as Facet>::SHAPE.is(Characteristic::FromStr) {
65	let inner_parse =
66	unsafe { <$float as Facet>::SHAPE.vtable.parse.unwrap_unchecked() };
67	// `OrderedFloat` is `repr(transparent)`
68	vtable.parse = Some(inner_parse);
69	}
70	vtable.try_from = Some(try_from);
71	vtable.try_into_inner = Some(try_into_inner);
72	vtable.try_borrow_inner = Some(try_borrow_inner);
73	vtable
74	};
75
76	const SHAPE: &'static Shape<'static> = &const {
77	fn inner_shape() -> &'static Shape<'static> {	2✔
78	<$float as Facet>::SHAPE	2✔
79	}	2✔
80
81	Shape::builder_for_sized::<Self>()
82	.ty(Type::User(UserType::Struct(
83	StructType::builder()
84	.repr(Repr::transparent())
85	.fields(&const { [field_in_type!(Self, 0)] })
86	.kind(crate::StructKind::Tuple)
87	.build(),
88	)))
89	.def(Def::Scalar(
90	ScalarDef::builder()
91	// Affinity: use number affinity as inner's
92	.affinity(&const { ScalarAffinity::opaque().build() })
93	.build(),
94	))
95	.inner(inner_shape)
96	.build()
97	};
98	}
99
100	unsafe impl<'a> Facet<'a> for NotNan<$float> {
101	const VTABLE: &'static ValueVTable = &const {
102	// Conversion from inner float type to NotNan<$float>
NEW 103	unsafe fn try_from<'shape, 'dst>(	×
104	src_ptr: PtrConst<'_>,	×
NEW 105	src_shape: &'shape Shape<'shape>,	×
106	dst: PtrUninit<'dst>,	×
NEW 107	) -> Result<PtrMut<'dst>, TryFromError<'shape>> {	×
108	if src_shape == <$float as Facet>::SHAPE {	×
109	// Get the inner value and check that it's not NaN
110	let value = unsafe { *src_ptr.get::<$float>() };	×
111	let nn =	×
112	NotNan::new(value).map_err(\|_\| TryFromError::Generic("was NaN"))?;	×
113	Ok(unsafe { dst.put(nn) })	×
114	} else {
115	let inner_try_from = <$float as Facet>::SHAPE.vtable.try_from.ok_or(	×
116	TryFromError::UnsupportedSourceShape {	×
117	src_shape,	×
118	expected: &[<$float as Facet>::SHAPE],	×
119	},	×
120	)?;	×
121
122	// fallback to inner's try_from
123	// This relies on the fact that `dst` is the same size as `NotNan<$float>`
124	// which should be true because `NotNan` is `repr(transparent)`
125	let inner_result = unsafe { (inner_try_from)(src_ptr, src_shape, dst) };	×
126	match inner_result {	×
127	Ok(result) => {	×
128	// After conversion to inner type, wrap as NotNan
129	let value = unsafe { *result.get::<$float>() };	×
130	let nn = NotNan::new(value)	×
131	.map_err(\|_\| TryFromError::Generic("was NaN"))?;	×
132	Ok(unsafe { dst.put(nn) })	×
133	}
134	Err(e) => Err(e),	×
135	}
136	}
137	}	×
138
139	// Conversion back to inner float type
140	unsafe fn try_into_inner<'dst>(	×
141	src_ptr: PtrMut<'_>,	×
142	dst: PtrUninit<'dst>,	×
143	) -> Result<PtrMut<'dst>, TryIntoInnerError> {	×
144	let v = unsafe { src_ptr.read::<NotNan<$float>>() };	×
145	Ok(unsafe { dst.put(v.into_inner()) })	×
146	}	×
147
148	// Borrow inner float type
149	unsafe fn try_borrow_inner(	×
150	src_ptr: PtrConst<'_>,	×
151	) -> Result<PtrConst<'_>, TryBorrowInnerError> {	×
152	let v = unsafe { src_ptr.get::<NotNan<$float>>() };	×
153	Ok(PtrConst::new(	×
154	(&v.into_inner()) as const $float as const u8,	×
155	))	×
156	}	×
157
158	let mut vtable = value_vtable!((), \|f, _opts\| write!(f, "NotNan"));	×
159	// Accept parsing as inner T, but enforce NotNan invariant
160	vtable.parse = Some(\|s, target\| match s.parse::<$float>() {	×
161	Ok(inner) => match NotNan::new(inner) {	×
162	Ok(not_nan) => Ok(unsafe { target.put(not_nan) }),	×
163	Err(_) => Err(crate::ParseError::Generic("NaN is not allowed for NotNan")),	×
164	},
165	Err(_) => Err(crate::ParseError::Generic(	×
166	"Failed to parse inner type for NotNan",	×
167	)),	×
168	});	×
169	vtable.try_from = Some(try_from);
170	vtable.try_into_inner = Some(try_into_inner);
171	vtable.try_borrow_inner = Some(try_borrow_inner);
172	vtable
173	};
174
175	const SHAPE: &'static Shape<'static> = &const {
NEW 176	fn inner_shape() -> &'static Shape<'static> {	×
177	<$float as Facet>::SHAPE	×
178	}	×
179
180	Shape::builder_for_sized::<Self>()
181	.ty(Type::User(UserType::Opaque))
182	.def(Def::Scalar(
183	ScalarDef::builder()
184	.affinity(&const { ScalarAffinity::opaque().build() })
185	.build(),
186	))
187	.inner(inner_shape)
188	.build()
189	};
190	}
191	};
192	}
193
194	impl_facet_for_ordered_float_and_notnan!(f32);
195	impl_facet_for_ordered_float_and_notnan!(f64);

facet-rs / facet / 15085921060

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