14549273643

Committed 19 Apr 2025 12:47PM UTC coverage: 44.149% (-0.1%) from 44.272%

Build # 14549273643

Build Type

Pull #307

github

Committed by

web-flow

Commit Message

Merge b61513f3d into ea38cd7b3

Pull Request Pull Request #307: Impl `Facet` for `Rc<T>`

Run Details

0 of 31 new or added lines in 1 file covered. (0.0%)

123 existing lines in 3 files now uncovered.

4950 of 11212 relevant lines covered (44.15%)

49.92 hits per line

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

8.33

/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>())
            .type_params(&[crate::TypeParam {
                name: "T",
                shape: || T::SHAPE,
            }])
            .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>())
            .type_params(&[crate::TypeParam {
                name: "T",
                shape: || T::SHAPE,
            }])
            .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()
    };
}

unsafe impl<T: Facet> Facet for alloc::rc::Rc<T> {
    const SHAPE: &'static crate::Shape = &const {
        crate::Shape::builder()
            .id(ConstTypeId::of::<Self>())
            .layout(Layout::new::<Self>())
            .type_params(&[crate::TypeParam {
                name: "T",
                shape: || T::SHAPE,
            }])
            .def(Def::SmartPointer(
                SmartPointerDef::builder()
                    .pointee(T::SHAPE)
                    .flags(SmartPointerFlags::EMPTY)
                    .known(KnownSmartPointer::Rc)
                    .weak(|| <alloc::rc::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 rc = alloc::rc::Rc::new(t);
                                    unsafe { this.put(rc) }
                                })
                                .downgrade_fn(|strong, weak| unsafe {
                                    weak.put(alloc::rc::Rc::downgrade(strong.get::<Self>()))
                                })
                                .build()
                        },
                    )
                    .build(),
            ))
            .vtable(value_vtable!(alloc::rc::Rc<T>, |f, _opts| write!(f, "Rc")))
            .build()
    };
}

unsafe impl<T: Facet> Facet for alloc::rc::Weak<T> {
    const SHAPE: &'static crate::Shape = &const {
        crate::Shape::builder()
            .id(ConstTypeId::of::<Self>())
            .layout(Layout::new::<Self>())
            .type_params(&[crate::TypeParam {
                name: "T",
                shape: || T::SHAPE,
            }])
            .def(Def::SmartPointer(
                SmartPointerDef::builder()
                    .pointee(T::SHAPE)
                    .flags(SmartPointerFlags::WEAK)
                    .known(KnownSmartPointer::RcWeak)
                    .strong(|| <alloc::rc::Rc<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::rc::Rc<T>, |f, _opts| write!(f, "Rc")))
            .build()
    };
}

unsafe impl<T> Facet for Opaque<alloc::rc::Rc<T>> {
    const SHAPE: &'static crate::Shape = &const {
        crate::Shape::builder()
            .id(ConstTypeId::of::<Self>())
            .layout(Layout::new::<Self>())
            .def(Def::SmartPointer(
                SmartPointerDef::builder()
                    .known(KnownSmartPointer::Rc)
                    .vtable(
                        &const {
                            SmartPointerVTable::builder()
                                .borrow_fn(|opaque| {
                                    let ptr = alloc::rc::Rc::<T>::as_ptr(unsafe { opaque.get() });
                                    PtrConst::new(ptr)
                                })
                                .new_into_fn(|this, ptr| {
                                    let t = unsafe { ptr.read::<T>() };
                                    let rc = alloc::rc::Rc::new(t);
                                    unsafe { this.put(rc) }
                                })
                                .build()
                        },
                    )
                    .build(),
            ))
            .vtable(value_vtable!(alloc::rc::Rc<T>, |f, _opts| write!(f, "Rc")))
            .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	.type_params(&[crate::TypeParam {
14	name: "T",
15	shape: \|\| T::SHAPE,	1✔
16	}])
17	.def(Def::SmartPointer(
18	SmartPointerDef::builder()
19	.pointee(T::SHAPE)
20	.flags(SmartPointerFlags::ATOMIC)
21	.known(KnownSmartPointer::Arc)
22	.weak(\|\| <alloc::sync::Weak<T> as Facet>::SHAPE)	×
23	.vtable(
24	&const {
25	SmartPointerVTable::builder()
26	.borrow_fn(\|opaque\| {	×
27	let ptr = Self::as_ptr(unsafe { opaque.get() });	×
28	PtrConst::new(ptr)	×
29	})	×
30	.new_into_fn(\|this, ptr\| {	×
31	let t = unsafe { ptr.read::<T>() };	×
32	let arc = alloc::sync::Arc::new(t);	×
33	unsafe { this.put(arc) }	×
34	})	×
35	.downgrade_fn(\|strong, weak\| unsafe {	×
36	weak.put(alloc::sync::Arc::downgrade(strong.get::<Self>()))	×
37	})	×
38	.build()
39	},
40	)
41	.build(),
42	))
43	.vtable(value_vtable!(alloc::sync::Arc<T>, \|f, _opts\| write!(	×
44	f,	×
45	"Arc"	×
46	)))	×
47	.build()
48	};
49	}
50
51	unsafe impl<T: Facet> Facet for alloc::sync::Weak<T> {
52	const SHAPE: &'static crate::Shape = &const {
53	crate::Shape::builder()
54	.id(ConstTypeId::of::<Self>())
55	.layout(Layout::new::<Self>())
56	.type_params(&[crate::TypeParam {
57	name: "T",
58	shape: \|\| T::SHAPE,	1✔
59	}])
60	.def(Def::SmartPointer(
61	SmartPointerDef::builder()
62	.pointee(T::SHAPE)
63	.flags(SmartPointerFlags::ATOMIC.union(SmartPointerFlags::WEAK))
64	.known(KnownSmartPointer::ArcWeak)
65	.strong(\|\| <alloc::sync::Arc<T> as Facet>::SHAPE)	×
66	.vtable(
67	&const {
68	SmartPointerVTable::builder()
69	.upgrade_into_fn(\|weak, strong\| unsafe {	×
70	Some(strong.put(weak.get::<Self>().upgrade()?))	×
71	})	×
72	.build()
73	},
74	)
75	.build(),
76	))
77	.vtable(value_vtable!(alloc::sync::Arc<T>, \|f, _opts\| write!(	×
78	f,	×
79	"Arc"	×
80	)))	×
81	.build()
82	};
83	}
84
85	unsafe impl<T> Facet for Opaque<alloc::sync::Arc<T>> {
86	const SHAPE: &'static crate::Shape = &const {
87	crate::Shape::builder()
88	.id(ConstTypeId::of::<Self>())
89	.layout(Layout::new::<Self>())
90	.def(Def::SmartPointer(
91	SmartPointerDef::builder()
92	.flags(SmartPointerFlags::ATOMIC)
93	.known(KnownSmartPointer::Arc)
94	.vtable(
95	&const {
96	SmartPointerVTable::builder()
97	.borrow_fn(\|opaque\| {	×
98	let ptr =	×
99	alloc::sync::Arc::<T>::as_ptr(unsafe { opaque.get() });	×
100	PtrConst::new(ptr)	×
101	})	×
102	.new_into_fn(\|this, ptr\| {	×
103	let t = unsafe { ptr.read::<T>() };	×
104	let arc = alloc::sync::Arc::new(t);	×
105	unsafe { this.put(arc) }	×
UNCOV 106	})	×
107	.build()
108	},
109	)
110	.build(),
111	))
112	.vtable(value_vtable!(alloc::sync::Arc<T>, \|f, _opts\| write!(	1✔
113	f,	1✔
114	"Arc"	1✔
115	)))	1✔
116	.build()
117	};
118	}
119
120	unsafe impl<T: Facet> Facet for alloc::rc::Rc<T> {
121	const SHAPE: &'static crate::Shape = &const {
122	crate::Shape::builder()
123	.id(ConstTypeId::of::<Self>())
124	.layout(Layout::new::<Self>())
125	.type_params(&[crate::TypeParam {
126	name: "T",
NEW 127	shape: \|\| T::SHAPE,	×
128	}])
129	.def(Def::SmartPointer(
130	SmartPointerDef::builder()
131	.pointee(T::SHAPE)
132	.flags(SmartPointerFlags::EMPTY)
133	.known(KnownSmartPointer::Rc)
NEW 134	.weak(\|\| <alloc::rc::Weak<T> as Facet>::SHAPE)	×
135	.vtable(
136	&const {
137	SmartPointerVTable::builder()
NEW 138	.borrow_fn(\|opaque\| {	×
NEW 139	let ptr = Self::as_ptr(unsafe { opaque.get() });	×
NEW 140	PtrConst::new(ptr)	×
NEW 141	})	×
NEW 142	.new_into_fn(\|this, ptr\| {	×
NEW 143	let t = unsafe { ptr.read::<T>() };	×
NEW 144	let rc = alloc::rc::Rc::new(t);	×
NEW 145	unsafe { this.put(rc) }	×
NEW 146	})	×
NEW 147	.downgrade_fn(\|strong, weak\| unsafe {	×
NEW 148	weak.put(alloc::rc::Rc::downgrade(strong.get::<Self>()))	×
NEW 149	})	×
150	.build()
151	},
152	)
153	.build(),
154	))
NEW 155	.vtable(value_vtable!(alloc::rc::Rc<T>, \|f, _opts\| write!(f, "Rc")))	×
156	.build()
157	};
158	}
159
160	unsafe impl<T: Facet> Facet for alloc::rc::Weak<T> {
161	const SHAPE: &'static crate::Shape = &const {
162	crate::Shape::builder()
163	.id(ConstTypeId::of::<Self>())
164	.layout(Layout::new::<Self>())
165	.type_params(&[crate::TypeParam {
166	name: "T",
NEW 167	shape: \|\| T::SHAPE,	×
168	}])
169	.def(Def::SmartPointer(
170	SmartPointerDef::builder()
171	.pointee(T::SHAPE)
172	.flags(SmartPointerFlags::WEAK)
173	.known(KnownSmartPointer::RcWeak)
NEW 174	.strong(\|\| <alloc::rc::Rc<T> as Facet>::SHAPE)	×
175	.vtable(
176	&const {
177	SmartPointerVTable::builder()
NEW 178	.upgrade_into_fn(\|weak, strong\| unsafe {	×
NEW 179	Some(strong.put(weak.get::<Self>().upgrade()?))	×
NEW 180	})	×
181	.build()
182	},
183	)
184	.build(),
185	))
NEW 186	.vtable(value_vtable!(alloc::rc::Rc<T>, \|f, _opts\| write!(f, "Rc")))	×
187	.build()
188	};
189	}
190
191	unsafe impl<T> Facet for Opaque<alloc::rc::Rc<T>> {
192	const SHAPE: &'static crate::Shape = &const {
193	crate::Shape::builder()
194	.id(ConstTypeId::of::<Self>())
195	.layout(Layout::new::<Self>())
196	.def(Def::SmartPointer(
197	SmartPointerDef::builder()
198	.known(KnownSmartPointer::Rc)
199	.vtable(
200	&const {
201	SmartPointerVTable::builder()
NEW 202	.borrow_fn(\|opaque\| {	×
NEW 203	let ptr = alloc::rc::Rc::<T>::as_ptr(unsafe { opaque.get() });	×
NEW 204	PtrConst::new(ptr)	×
NEW 205	})	×
NEW 206	.new_into_fn(\|this, ptr\| {	×
NEW 207	let t = unsafe { ptr.read::<T>() };	×
NEW 208	let rc = alloc::rc::Rc::new(t);	×
NEW 209	unsafe { this.put(rc) }	×
NEW 210	})	×
211	.build()
212	},
213	)
214	.build(),
215	))
NEW 216	.vtable(value_vtable!(alloc::rc::Rc<T>, \|f, _opts\| write!(f, "Rc")))	×
217	.build()
218	};
219	}

facet-rs / facet / 14549273643

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