14480003827

Committed 15 Apr 2025 09:46PM UTC coverage: 41.604% (+0.1%) from 41.494%

Build # 14480003827

Build Type

Pull #244

github

Committed by

web-flow

Commit Message

Merge 243b71c3e into 30d90e89b

Pull Request Pull Request #244: Generic bounds (#223)

Run Details

13 of 20 new or added lines in 10 files covered. (65.0%)

193 existing lines in 11 files now uncovered.

4447 of 10689 relevant lines covered (41.6%)

55.18 hits per line

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

20.51

/facet-core/src/impls_alloc/smartptr.rs

use core::alloc::Layout;

use crate::{
    ConstTypeId, Def, Facet, KnownSmartPointer, Opaque, PtrConst, SmartPointerDef,
    SmartPointerFlags, SmartPointerVTable, value_vtable,
};

unsafe impl<T: Facet> Facet for alloc::sync::Arc<T> {
    const SHAPE: &'static crate::Shape = &const {
        crate::Shape::builder()
            .id(ConstTypeId::of::<Self>())
            .layout(Layout::new::<Self>())
            .def(Def::SmartPointer(
                SmartPointerDef::builder()
                    .pointee(T::SHAPE)
                    .flags(SmartPointerFlags::ATOMIC)
                    .known(KnownSmartPointer::Arc)
                    .weak(|| <alloc::sync::Weak<T> as Facet>::SHAPE)
                    .vtable(
                        &const {
                            SmartPointerVTable::builder()
                                .borrow_fn(|opaque| {
                                    let ptr = Self::as_ptr(unsafe { opaque.get() });
                                    PtrConst::new(ptr)
                                })
                                .new_into_fn(|this, ptr| {
                                    let t = unsafe { ptr.read::<T>() };
                                    let arc = alloc::sync::Arc::new(t);
                                    unsafe { this.put(arc) }
                                })
                                .downgrade_fn(|strong, weak| unsafe {
                                    weak.put(alloc::sync::Arc::downgrade(strong.get::<Self>()))
                                })
                                .build()
                        },
                    )
                    .build(),
            ))
            .vtable(value_vtable!(alloc::sync::Arc<T>, |f, _opts| write!(
                f,
                "Arc"
            )))
            .build()
    };
}

unsafe impl<T: Facet> Facet for alloc::sync::Weak<T> {
    const SHAPE: &'static crate::Shape = &const {
        crate::Shape::builder()
            .id(ConstTypeId::of::<Self>())
            .layout(Layout::new::<Self>())
            .def(Def::SmartPointer(
                SmartPointerDef::builder()
                    .pointee(T::SHAPE)
                    .flags(SmartPointerFlags::ATOMIC.union(SmartPointerFlags::WEAK))
                    .known(KnownSmartPointer::ArcWeak)
                    .strong(|| <alloc::sync::Arc<T> as Facet>::SHAPE)
                    .vtable(
                        &const {
                            SmartPointerVTable::builder()
                                .upgrade_into_fn(|weak, strong| unsafe {
                                    Some(strong.put(weak.get::<Self>().upgrade()?))
                                })
                                .build()
                        },
                    )
                    .build(),
            ))
            .vtable(value_vtable!(alloc::sync::Arc<T>, |f, _opts| write!(
                f,
                "Arc"
            )))
            .build()
    };
}

unsafe impl<T> Facet for Opaque<alloc::sync::Arc<T>> {
    const SHAPE: &'static crate::Shape = &const {
        crate::Shape::builder()
            .id(ConstTypeId::of::<Self>())
            .layout(Layout::new::<Self>())
            .def(Def::SmartPointer(
                SmartPointerDef::builder()
                    .flags(SmartPointerFlags::ATOMIC)
                    .known(KnownSmartPointer::Arc)
                    .vtable(
                        &const {
                            SmartPointerVTable::builder()
                                .borrow_fn(|opaque| {
                                    let ptr =
                                        alloc::sync::Arc::<T>::as_ptr(unsafe { opaque.get() });
                                    PtrConst::new(ptr)
                                })
                                .new_into_fn(|this, ptr| {
                                    let t = unsafe { ptr.read::<T>() };
                                    let arc = alloc::sync::Arc::new(t);
                                    unsafe { this.put(arc) }
                                })
                                .build()
                        },
                    )
                    .build(),
            ))
            .vtable(value_vtable!(alloc::sync::Arc<T>, |f, _opts| write!(
                f,
                "Arc"
            )))
            .build()
    };
}

1	use core::alloc::Layout;
2
3	use crate::{
4	ConstTypeId, Def, Facet, KnownSmartPointer, Opaque, PtrConst, SmartPointerDef,
5	SmartPointerFlags, SmartPointerVTable, value_vtable,
6	};
7
8	unsafe impl<T: Facet> Facet for alloc::sync::Arc<T> {
9	const SHAPE: &'static crate::Shape = &const {
10	crate::Shape::builder()
11	.id(ConstTypeId::of::<Self>())
12	.layout(Layout::new::<Self>())
13	.def(Def::SmartPointer(
14	SmartPointerDef::builder()
15	.pointee(T::SHAPE)
16	.flags(SmartPointerFlags::ATOMIC)
17	.known(KnownSmartPointer::Arc)
UNCOV 18	.weak(\|\| <alloc::sync::Weak<T> as Facet>::SHAPE)	×
19	.vtable(
20	&const {
21	SmartPointerVTable::builder()
22	.borrow_fn(\|opaque\| {	×
UNCOV 23	let ptr = Self::as_ptr(unsafe { opaque.get() });	×
UNCOV 24	PtrConst::new(ptr)	×
UNCOV 25	})	×
26	.new_into_fn(\|this, ptr\| {	×
27	let t = unsafe { ptr.read::<T>() };	×
28	let arc = alloc::sync::Arc::new(t);	×
29	unsafe { this.put(arc) }	×
30	})	×
31	.downgrade_fn(\|strong, weak\| unsafe {	×
32	weak.put(alloc::sync::Arc::downgrade(strong.get::<Self>()))	×
33	})	×
34	.build()
35	},
36	)
37	.build(),
38	))
39	.vtable(value_vtable!(alloc::sync::Arc<T>, \|f, _opts\| write!(	2✔
40	f,	2✔
41	"Arc"	2✔
42	)))	2✔
43	.build()
44	};
45	}
46
47	unsafe impl<T: Facet> Facet for alloc::sync::Weak<T> {
48	const SHAPE: &'static crate::Shape = &const {
49	crate::Shape::builder()
50	.id(ConstTypeId::of::<Self>())
51	.layout(Layout::new::<Self>())
52	.def(Def::SmartPointer(
53	SmartPointerDef::builder()
54	.pointee(T::SHAPE)
55	.flags(SmartPointerFlags::ATOMIC.union(SmartPointerFlags::WEAK))
56	.known(KnownSmartPointer::ArcWeak)
NEW 57	.strong(\|\| <alloc::sync::Arc<T> as Facet>::SHAPE)	×
58	.vtable(
59	&const {
60	SmartPointerVTable::builder()
UNCOV 61	.upgrade_into_fn(\|weak, strong\| unsafe {	×
UNCOV 62	Some(strong.put(weak.get::<Self>().upgrade()?))	×
UNCOV 63	})	×
64	.build()
65	},
66	)
67	.build(),
68	))
69	.vtable(value_vtable!(alloc::sync::Arc<T>, \|f, _opts\| write!(	×
70	f,	×
71	"Arc"	×
UNCOV 72	)))	×
73	.build()
74	};
75	}
76
77	unsafe impl<T> Facet for Opaque<alloc::sync::Arc<T>> {
78	const SHAPE: &'static crate::Shape = &const {
79	crate::Shape::builder()
80	.id(ConstTypeId::of::<Self>())
81	.layout(Layout::new::<Self>())
82	.def(Def::SmartPointer(
83	SmartPointerDef::builder()
84	.flags(SmartPointerFlags::ATOMIC)
85	.known(KnownSmartPointer::Arc)
86	.vtable(
87	&const {
88	SmartPointerVTable::builder()
UNCOV 89	.borrow_fn(\|opaque\| {	×
UNCOV 90	let ptr =	×
UNCOV 91	alloc::sync::Arc::<T>::as_ptr(unsafe { opaque.get() });	×
UNCOV 92	PtrConst::new(ptr)	×
UNCOV 93	})	×
UNCOV 94	.new_into_fn(\|this, ptr\| {	×
UNCOV 95	let t = unsafe { ptr.read::<T>() };	×
UNCOV 96	let arc = alloc::sync::Arc::new(t);	×
97	unsafe { this.put(arc) }	×
98	})	×
99	.build()
100	},
101	)
102	.build(),
103	))
104	.vtable(value_vtable!(alloc::sync::Arc<T>, \|f, _opts\| write!(	1✔
105	f,	1✔
106	"Arc"	1✔
107	)))	1✔
108	.build()
109	};
110	}

facet-rs / facet / 14480003827

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