20059345204

Committed 09 Dec 2025 09:57AM UTC coverage: 58.683% (-0.4%) from 59.082%

Build # 20059345204

Build Type

push

github

Committed by

fasterthanlime

Commit Message

Refactor VTable system: Direct/Indirect styles, OxRef/OxMut, builder patterns

Major architectural refactor of the facet vtable system for better code sharing
and reduced binary bloat.

- Remove ThinPtr/WidePtr in favor of PtrConst<'a>/PtrMut<'a>/PtrUninit<'a>
- Add OxRef<'a>/OxMut<'a> - shaped pointers bundling ptr + shape
- Add Ox<'a> enum for ownership tracking (like Cow for shaped pointers)

- VTableDirect: for concrete types, uses raw *const ()/*mut (), returns T directly
- VTableIndirect: for generic containers, uses OxRef/OxMut, returns Option<T>
- VTableErased enum wraps both styles
- Shape::call_* helpers dispatch to either style transparently

- vtable_direct! macro for sized types with compile-time known traits
- VTableIndirect::builder() for generic containers with runtime dispatch
- All container vtables (Array, Option, Result, List, Map, Set) use builders
- No more positional arguments - named builder methods only

- Hash trait is generic over H: Hasher, can't store directly in vtable
- HashProxy type-erases the hasher for vtable storage
- Enables hash support without wrapper function bloat

- impls_core/impls_alloc/impls_std -> impls/core/alloc/std/crates
- New internal/ module for facet's own types (Shape, Def, etc.)
- Cleaner separation of concerns

- Copy, Send, Sync, Eq, Unpin stored as bitflags on Shape
- Set via ShapeBuilder methods: .copy(), .send(), .sync(), .eq()

- ThinPtr -> *const () or PtrConst<'a>
- WidePtr -> OxRef<'a> or OxMut<'a>
- vtable_ref! -> vtable_direct! or VTableIndirect::builder()
- ValueVTable -> VTableDirect or VTableIndirect
- Closures in vtables -> named fn items

WIP: Some impl modules still need migration to new API.

Coverage Stats

4092 of 8007 new or added lines in 112 files covered. (51.11%)

117 existing lines in 26 files now uncovered.

26173 of 44601 relevant lines covered (58.68%)

635.02 hits per line

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

0.0

/facet-core/src/impls/crates/ordered_float.rs

#![cfg(feature = "ordered-float")]

use crate::{
    Def, Facet, FieldBuilder, Repr, Shape, ShapeBuilder, StructKind, StructType, Type,
    TypeOpsDirect, UserType, VTableDirect, type_ops_direct, vtable_direct,
};
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 SHAPE: &'static Shape = &const {
                // OrderedFloat implements Display, Debug, Hash, PartialEq, Eq, PartialOrd, Ord
                // It also implements Clone, Copy, Default, FromStr
                const VTABLE: VTableDirect = vtable_direct!(OrderedFloat<$float> =>
                    FromStr,
                    Display,
                    Debug,
                    Hash,
                    PartialEq,
                    PartialOrd,
                    Ord,
                );
                const TYPE_OPS: TypeOpsDirect = type_ops_direct!(OrderedFloat<$float> => Default, Clone);

                ShapeBuilder::for_sized::<OrderedFloat<$float>>("OrderedFloat")
                    .ty(Type::User(UserType::Struct(StructType {
                        repr: Repr::transparent(),
                        kind: StructKind::Tuple,
                        fields: &const { [FieldBuilder::new("0", crate::shape_of::<$float>, 0).build()] },
                    })))
                    .def(Def::Scalar)
                    .inner(<$float as Facet>::SHAPE)
                    .vtable_direct(&VTABLE)
                    .type_ops_direct(&TYPE_OPS)
                    .eq()
                    .copy()
                    .send()
                    .sync()
                    .build()
            };
        }

        unsafe impl<'a> Facet<'a> for NotNan<$float> {
            const SHAPE: &'static Shape = &const {
                // Custom parse function that enforces NotNan invariant
                unsafe fn parse_notnan(
                    s: &str,
                    target: *mut NotNan<$float>,
                ) -> Result<(), crate::ParseError> {
                    match s.parse::<$float>() {
                        Ok(inner) => match NotNan::new(inner) {
                            Ok(not_nan) => {
                                unsafe { target.write(not_nan) };
                                Ok(())
                            }
                            Err(_) => Err(crate::ParseError::Str("NaN is not allowed for NotNan")),
                        },
                        Err(_) => Err(crate::ParseError::Str(
                            "Failed to parse inner type for NotNan",
                        )),
                    }
                }

                // NotNan implements Display, Debug, Hash, PartialEq, Eq, PartialOrd, Ord
                // It also implements Clone, Copy, FromStr (but we override parse)
                // It does NOT implement Default (no default value for NotNan)
                const VTABLE: VTableDirect = vtable_direct!(NotNan<$float> =>
                    Display,
                    Debug,
                    Hash,
                    PartialEq,
                    PartialOrd,
                    Ord,
                    [parse = parse_notnan],
                );
                const TYPE_OPS: TypeOpsDirect = type_ops_direct!(NotNan<$float> => Clone);

                ShapeBuilder::for_sized::<NotNan<$float>>("NotNan")
                    .ty(Type::User(UserType::Opaque))
                    .def(Def::Scalar)
                    .inner(<$float as Facet>::SHAPE)
                    .vtable_direct(&VTABLE)
                    .type_ops_direct(&TYPE_OPS)
                    .eq()
                    .copy()
                    .send()
                    .sync()
                    .build()
            };
        }
    };
}

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

1	#![cfg(feature = "ordered-float")]
2
3	use crate::{
4	Def, Facet, FieldBuilder, Repr, Shape, ShapeBuilder, StructKind, StructType, Type,
5	TypeOpsDirect, UserType, VTableDirect, type_ops_direct, vtable_direct,
6	};
7	use ordered_float::{NotNan, OrderedFloat};
8
9	macro_rules! impl_facet_for_ordered_float_and_notnan {
10	($float:ty) => {
11	unsafe impl<'a> Facet<'a> for OrderedFloat<$float> {
12	const SHAPE: &'static Shape = &const {
13	// OrderedFloat implements Display, Debug, Hash, PartialEq, Eq, PartialOrd, Ord
14	// It also implements Clone, Copy, Default, FromStr
15	const VTABLE: VTableDirect = vtable_direct!(OrderedFloat<$float> =>
16	FromStr,
17	Display,
18	Debug,
19	Hash,
20	PartialEq,
21	PartialOrd,
22	Ord,
23	);
24	const TYPE_OPS: TypeOpsDirect = type_ops_direct!(OrderedFloat<$float> => Default, Clone);
25
26	ShapeBuilder::for_sized::<OrderedFloat<$float>>("OrderedFloat")
27	.ty(Type::User(UserType::Struct(StructType {
28	repr: Repr::transparent(),
29	kind: StructKind::Tuple,
30	fields: &const { [FieldBuilder::new("0", crate::shape_of::<$float>, 0).build()] },
31	})))
32	.def(Def::Scalar)
33	.inner(<$float as Facet>::SHAPE)
34	.vtable_direct(&VTABLE)
35	.type_ops_direct(&TYPE_OPS)
36	.eq()
37	.copy()
38	.send()
39	.sync()
40	.build()
41	};
42	}
43
44	unsafe impl<'a> Facet<'a> for NotNan<$float> {
45	const SHAPE: &'static Shape = &const {
46	// Custom parse function that enforces NotNan invariant
NEW 47	unsafe fn parse_notnan(	×
NEW 48	s: &str,	×
NEW 49	target: *mut NotNan<$float>,	×
NEW 50	) -> Result<(), crate::ParseError> {	×
NEW 51	match s.parse::<$float>() {	×
NEW 52	Ok(inner) => match NotNan::new(inner) {	×
NEW 53	Ok(not_nan) => {	×
NEW 54	unsafe { target.write(not_nan) };	×
NEW 55	Ok(())	×
56	}
NEW 57	Err(_) => Err(crate::ParseError::Str("NaN is not allowed for NotNan")),	×
58	},
NEW 59	Err(_) => Err(crate::ParseError::Str(	×
NEW 60	"Failed to parse inner type for NotNan",	×
NEW 61	)),	×
62	}
NEW 63	}	×
64
65	// NotNan implements Display, Debug, Hash, PartialEq, Eq, PartialOrd, Ord
66	// It also implements Clone, Copy, FromStr (but we override parse)
67	// It does NOT implement Default (no default value for NotNan)
68	const VTABLE: VTableDirect = vtable_direct!(NotNan<$float> =>
69	Display,
70	Debug,
71	Hash,
72	PartialEq,
73	PartialOrd,
74	Ord,
75	[parse = parse_notnan],
76	);
77	const TYPE_OPS: TypeOpsDirect = type_ops_direct!(NotNan<$float> => Clone);
78
79	ShapeBuilder::for_sized::<NotNan<$float>>("NotNan")
80	.ty(Type::User(UserType::Opaque))
81	.def(Def::Scalar)
82	.inner(<$float as Facet>::SHAPE)
83	.vtable_direct(&VTABLE)
84	.type_ops_direct(&TYPE_OPS)
85	.eq()
86	.copy()
87	.send()
88	.sync()
89	.build()
90	};
91	}
92	};
93	}
94
95	impl_facet_for_ordered_float_and_notnan!(f32);
96	impl_facet_for_ordered_float_and_notnan!(f64);

facet-rs / facet / 20059345204

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