facet_core/impls/alloc/
rc.rs

1use core::ptr::NonNull;
2
3use alloc::boxed::Box;
4use alloc::rc::{Rc, Weak};
5use alloc::vec::Vec;
6
7use crate::{
8    Def, Facet, KnownPointer, OxPtrConst, OxPtrMut, PointerDef, PointerFlags, PointerVTable,
9    PtrConst, PtrMut, PtrUninit, Shape, ShapeBuilder, SliceBuilderVTable, Type, TypeNameOpts,
10    TypeOpsIndirect, UserType, VTableIndirect,
11};
12
13//////////////////////////////////////////////////////////////////////
14// Rc<T>
15//////////////////////////////////////////////////////////////////////
16
17/// Type name formatter for `Rc<T>`
18fn rc_type_name<'a, T: Facet<'a>>(
19    _shape: &'static Shape,
20    f: &mut core::fmt::Formatter<'_>,
21    opts: TypeNameOpts,
22) -> core::fmt::Result {
23    write!(f, "Rc")?;
24    if let Some(opts) = opts.for_children() {
25        write!(f, "<")?;
26        T::SHAPE.write_type_name(f, opts)?;
27        write!(f, ">")?;
28    } else {
29        write!(f, "<…>")?;
30    }
31    Ok(())
32}
33
34/// Drop function for `Rc<T>`
35unsafe fn rc_drop<T>(ox: OxPtrMut) {
36    unsafe {
37        core::ptr::drop_in_place(ox.ptr().as_ptr::<Rc<T>>() as *mut Rc<T>);
38    }
39}
40
41/// Debug function for `Rc<T>`
42unsafe fn rc_debug<'a, T: Facet<'a>>(
43    ox: OxPtrConst,
44    f: &mut core::fmt::Formatter<'_>,
45) -> Option<core::fmt::Result> {
46    let rc = unsafe { ox.get::<Rc<T>>() };
47
48    // Try to debug the inner value if T has debug
49    let inner_ptr = PtrConst::new(NonNull::from(&**rc).as_ptr());
50    if let Some(result) = unsafe { T::SHAPE.call_debug(inner_ptr, f) } {
51        return Some(result);
52    }
53
54    // Fallback: just show it's an Rc
55    Some(write!(f, "Rc(...)"))
56}
57
58/// Borrow function for PointerVTable
59unsafe fn rc_borrow_fn<T>(this: PtrConst) -> PtrConst {
60    let ptr = unsafe { Rc::<T>::as_ptr(this.get()) };
61    PtrConst::new(ptr)
62}
63
64/// New into function for PointerVTable
65unsafe fn rc_new_into_fn<'a, 'ptr, T: Facet<'a>>(this: PtrUninit, ptr: PtrMut) -> PtrMut {
66    let t = unsafe { ptr.read::<T>() };
67    let rc = Rc::new(t);
68    unsafe { this.put(rc) }
69}
70
71/// Downgrade into function for PointerVTable
72unsafe fn rc_downgrade_into_fn<'a, 'ptr, T: Facet<'a>>(strong: PtrMut, weak: PtrUninit) -> PtrMut {
73    unsafe { weak.put(Rc::downgrade(strong.get::<Rc<T>>())) }
74}
75
76unsafe impl<'a, T: Facet<'a>> Facet<'a> for Rc<T> {
77    const SHAPE: &'static Shape = &const {
78        ShapeBuilder::for_sized::<Rc<T>>("Rc")
79            .type_name(rc_type_name::<T>)
80            .ty(Type::User(UserType::Opaque))
81            .def(Def::Pointer(PointerDef {
82                vtable: &const {
83                    PointerVTable {
84                        borrow_fn: Some(rc_borrow_fn::<T>),
85                        new_into_fn: Some(rc_new_into_fn::<T>),
86                        downgrade_into_fn: Some(|strong, weak| unsafe {
87                            rc_downgrade_into_fn::<T>(strong, weak)
88                        }),
89                        ..PointerVTable::new()
90                    }
91                },
92                pointee: Some(T::SHAPE),
93                weak: Some(|| <Weak<T> as Facet>::SHAPE),
94                strong: None,
95                flags: PointerFlags::EMPTY,
96                known: Some(KnownPointer::Rc),
97            }))
98            .type_params(&[crate::TypeParam {
99                name: "T",
100                shape: T::SHAPE,
101            }])
102            .inner(T::SHAPE)
103            // Rc<T> propagates T's variance
104            .variance(Shape::computed_variance)
105            .vtable_indirect(
106                &const {
107                    VTableIndirect {
108                        debug: Some(rc_debug::<T>),
109                        display: None,
110                        hash: None,
111                        invariants: None,
112                        parse: None,
113                        try_from: None,
114                        try_into_inner: None,
115                        try_borrow_inner: None,
116                        partial_eq: None,
117                        partial_cmp: None,
118                        cmp: None,
119                    }
120                },
121            )
122            .type_ops_indirect(
123                &const {
124                    TypeOpsIndirect {
125                        drop_in_place: rc_drop::<T>,
126                        default_in_place: None,
127                        clone_into: None,
128                        is_truthy: None,
129                    }
130                },
131            )
132            .build()
133    };
134}
135
136//////////////////////////////////////////////////////////////////////
137// Rc<str>
138//////////////////////////////////////////////////////////////////////
139
140/// Type name formatter for `Rc<str>`
141fn rc_str_type_name(
142    _shape: &'static Shape,
143    f: &mut core::fmt::Formatter<'_>,
144    opts: TypeNameOpts,
145) -> core::fmt::Result {
146    write!(f, "Rc")?;
147    if let Some(opts) = opts.for_children() {
148        write!(f, "<")?;
149        str::SHAPE.write_type_name(f, opts)?;
150        write!(f, ">")?;
151    } else {
152        write!(f, "<…>")?;
153    }
154    Ok(())
155}
156
157/// Drop function for `Rc<str>`
158unsafe fn rc_str_drop(ox: OxPtrMut) {
159    unsafe {
160        core::ptr::drop_in_place(ox.ptr().as_ptr::<Rc<str>>() as *mut Rc<str>);
161    }
162}
163
164/// Clone function for `Rc<str>`
165unsafe fn rc_str_clone(src: OxPtrConst, dst: OxPtrMut) {
166    unsafe {
167        let value = src.get::<Rc<str>>().clone();
168        (dst.ptr().as_ptr::<Rc<str>>() as *mut Rc<str>).write(value);
169    }
170}
171
172/// Debug function for `Rc<str>`
173unsafe fn rc_str_debug(
174    ox: OxPtrConst,
175    f: &mut core::fmt::Formatter<'_>,
176) -> Option<core::fmt::Result> {
177    let rc = unsafe { ox.get::<Rc<str>>() };
178    let s: &str = rc;
179    Some(write!(f, "Rc({s:?})"))
180}
181
182/// Borrow function for `Rc<str>`
183unsafe fn rc_str_borrow_fn(this: PtrConst) -> PtrConst {
184    unsafe {
185        let concrete = this.get::<Rc<str>>();
186        let s: &str = concrete;
187        PtrConst::new(NonNull::from(s).as_ptr())
188    }
189}
190
191/// Downgrade into function for `Rc<str>`
192unsafe fn rc_str_downgrade_into_fn(strong: PtrMut, weak: PtrUninit) -> PtrMut {
193    unsafe { weak.put(Rc::downgrade(strong.get::<Rc<str>>())) }
194}
195
196unsafe impl<'a> Facet<'a> for Rc<str> {
197    const SHAPE: &'static Shape = &const {
198        const VTABLE: VTableIndirect = VTableIndirect {
199            debug: Some(rc_str_debug),
200            display: None,
201            hash: None,
202            invariants: None,
203            parse: None,
204            try_from: None,
205            try_into_inner: None,
206            try_borrow_inner: None,
207            partial_eq: None,
208            partial_cmp: None,
209            cmp: None,
210        };
211
212        const TYPE_OPS: TypeOpsIndirect = TypeOpsIndirect {
213            drop_in_place: rc_str_drop,
214            default_in_place: None,
215            clone_into: Some(rc_str_clone),
216            is_truthy: None,
217        };
218
219        ShapeBuilder::for_sized::<Rc<str>>("Rc")
220            .type_name(rc_str_type_name)
221            .ty(Type::User(UserType::Opaque))
222            .def(Def::Pointer(PointerDef {
223                vtable: &const {
224                    PointerVTable {
225                        borrow_fn: Some(rc_str_borrow_fn),
226                        downgrade_into_fn: Some(|strong, weak| unsafe {
227                            rc_str_downgrade_into_fn(strong, weak)
228                        }),
229                        ..PointerVTable::new()
230                    }
231                },
232                pointee: Some(str::SHAPE),
233                weak: Some(|| <Weak<str> as Facet>::SHAPE),
234                strong: None,
235                flags: PointerFlags::EMPTY,
236                known: Some(KnownPointer::Rc),
237            }))
238            .type_params(&[crate::TypeParam {
239                name: "T",
240                shape: str::SHAPE,
241            }])
242            .vtable_indirect(&VTABLE)
243            .type_ops_indirect(&TYPE_OPS)
244            .build()
245    };
246}
247
248//////////////////////////////////////////////////////////////////////
249// Rc<[U]>
250//////////////////////////////////////////////////////////////////////
251
252fn slice_builder_new<'a, U: Facet<'a>>() -> PtrMut {
253    let v = Box::new(Vec::<U>::new());
254    let raw = Box::into_raw(v);
255    PtrMut::new(unsafe { NonNull::new_unchecked(raw as *mut u8) }.as_ptr())
256}
257
258fn slice_builder_push<'a, U: Facet<'a>>(builder: PtrMut, item: PtrMut) {
259    unsafe {
260        let vec = builder.as_mut::<Vec<U>>();
261        let value = item.read::<U>();
262        vec.push(value);
263    }
264}
265
266fn slice_builder_convert<'a, U: Facet<'a>>(builder: PtrMut) -> PtrConst {
267    unsafe {
268        let vec_box = Box::from_raw(builder.as_ptr::<Vec<U>>() as *mut Vec<U>);
269        let rc: Rc<[U]> = (*vec_box).into();
270        let rc_box = Box::new(rc);
271        PtrConst::new(NonNull::new_unchecked(Box::into_raw(rc_box) as *mut u8).as_ptr())
272    }
273}
274
275fn slice_builder_free<'a, U: Facet<'a>>(builder: PtrMut) {
276    unsafe {
277        let _ = Box::from_raw(builder.as_ptr::<Vec<U>>() as *mut Vec<U>);
278    }
279}
280
281/// Type name formatter for `Rc<[U]>`
282fn rc_slice_type_name<'a, U: Facet<'a>>(
283    _shape: &'static Shape,
284    f: &mut core::fmt::Formatter<'_>,
285    opts: TypeNameOpts,
286) -> core::fmt::Result {
287    write!(f, "Rc")?;
288    if let Some(opts) = opts.for_children() {
289        write!(f, "<")?;
290        <[U]>::SHAPE.write_type_name(f, opts)?;
291        write!(f, ">")?;
292    } else {
293        write!(f, "<…>")?;
294    }
295    Ok(())
296}
297
298/// Drop function for `Rc<[U]>`
299unsafe fn rc_slice_drop<U>(ox: OxPtrMut) {
300    unsafe {
301        core::ptr::drop_in_place(ox.ptr().as_ptr::<Rc<[U]>>() as *mut Rc<[U]>);
302    }
303}
304
305/// Debug function for `Rc<[U]>`
306unsafe fn rc_slice_debug<'a, U: Facet<'a>>(
307    ox: OxPtrConst,
308    f: &mut core::fmt::Formatter<'_>,
309) -> Option<core::fmt::Result> {
310    let rc = unsafe { ox.get::<Rc<[U]>>() };
311    let slice: &[U] = rc;
312
313    // Try to debug the slice if U has debug
314    let slice_ptr = PtrConst::new(NonNull::from(slice).as_ptr());
315    if let Some(result) = unsafe { <[U]>::SHAPE.call_debug(slice_ptr, f) } {
316        return Some(result);
317    }
318
319    Some(write!(f, "Rc([...])"))
320}
321
322/// Borrow function for `Rc<[U]>`
323unsafe fn rc_slice_borrow_fn<U>(this: PtrConst) -> PtrConst {
324    unsafe {
325        let concrete = this.get::<Rc<[U]>>();
326        let s: &[U] = concrete;
327        PtrConst::new(NonNull::from(s).as_ptr())
328    }
329}
330
331/// Downgrade into function for `Rc<[U]>`
332unsafe fn rc_slice_downgrade_into_fn<'a, 'ptr, U: Facet<'a>>(
333    strong: PtrMut,
334    weak: PtrUninit,
335) -> PtrMut {
336    unsafe { weak.put(Rc::downgrade(strong.get::<Rc<[U]>>())) }
337}
338
339unsafe impl<'a, U: Facet<'a>> Facet<'a> for Rc<[U]> {
340    const SHAPE: &'static Shape = &const {
341        ShapeBuilder::for_sized::<Rc<[U]>>("Rc")
342            .type_name(rc_slice_type_name::<U>)
343            .ty(Type::User(UserType::Opaque))
344            .def(Def::Pointer(PointerDef {
345                vtable: &const {
346                    PointerVTable {
347                        borrow_fn: Some(rc_slice_borrow_fn::<U>),
348                        downgrade_into_fn: Some(|strong, weak| unsafe {
349                            rc_slice_downgrade_into_fn::<U>(strong, weak)
350                        }),
351                        slice_builder_vtable: Some(
352                            &const {
353                                SliceBuilderVTable::new(
354                                    slice_builder_new::<U>,
355                                    slice_builder_push::<U>,
356                                    slice_builder_convert::<U>,
357                                    slice_builder_free::<U>,
358                                )
359                            },
360                        ),
361                        ..PointerVTable::new()
362                    }
363                },
364                pointee: Some(<[U]>::SHAPE),
365                weak: Some(|| <Weak<[U]> as Facet>::SHAPE),
366                strong: None,
367                flags: PointerFlags::EMPTY,
368                known: Some(KnownPointer::Rc),
369            }))
370            .type_params(&[crate::TypeParam {
371                name: "T",
372                shape: <[U]>::SHAPE,
373            }])
374            .vtable_indirect(
375                &const {
376                    VTableIndirect {
377                        debug: Some(rc_slice_debug::<U>),
378                        display: None,
379                        hash: None,
380                        invariants: None,
381                        parse: None,
382                        try_from: None,
383                        try_into_inner: None,
384                        try_borrow_inner: None,
385                        partial_eq: None,
386                        partial_cmp: None,
387                        cmp: None,
388                    }
389                },
390            )
391            .type_ops_indirect(
392                &const {
393                    TypeOpsIndirect {
394                        drop_in_place: rc_slice_drop::<U>,
395                        default_in_place: None,
396                        clone_into: None,
397                        is_truthy: None,
398                    }
399                },
400            )
401            .build()
402    };
403}
404
405//////////////////////////////////////////////////////////////////////
406// Weak<T>
407//////////////////////////////////////////////////////////////////////
408
409/// Type name formatter for `Weak<T>`
410fn weak_type_name<'a, T: Facet<'a>>(
411    _shape: &'static Shape,
412    f: &mut core::fmt::Formatter<'_>,
413    opts: TypeNameOpts,
414) -> core::fmt::Result {
415    write!(f, "Weak")?;
416    if let Some(opts) = opts.for_children() {
417        write!(f, "<")?;
418        T::SHAPE.write_type_name(f, opts)?;
419        write!(f, ">")?;
420    } else {
421        write!(f, "<…>")?;
422    }
423    Ok(())
424}
425
426/// Drop function for `Weak<T>`
427unsafe fn weak_drop<T>(ox: OxPtrMut) {
428    unsafe {
429        core::ptr::drop_in_place(ox.ptr().as_ptr::<Weak<T>>() as *mut Weak<T>);
430    }
431}
432
433/// Default function for `Weak<T>`
434unsafe fn weak_default<T>(ox: OxPtrMut) {
435    unsafe {
436        (ox.ptr().as_ptr::<Weak<T>>() as *mut Weak<T>).write(Weak::<T>::new());
437    }
438}
439
440/// Clone function for `Weak<T>`
441unsafe fn weak_clone<T>(src: OxPtrConst, dst: OxPtrMut) {
442    unsafe {
443        let value = src.get::<Weak<T>>().clone();
444        (dst.ptr().as_ptr::<Weak<T>>() as *mut Weak<T>).write(value);
445    }
446}
447
448/// Debug function for `Weak<T>`
449unsafe fn weak_debug(
450    _ox: OxPtrConst,
451    f: &mut core::fmt::Formatter<'_>,
452) -> Option<core::fmt::Result> {
453    Some(write!(f, "(Weak)"))
454}
455
456/// Upgrade into function for `Weak<T>`
457unsafe fn weak_upgrade_into_fn<'a, 'ptr, T: Facet<'a>>(
458    weak: PtrMut,
459    strong: PtrUninit,
460) -> Option<PtrMut> {
461    unsafe { Some(strong.put(weak.get::<Weak<T>>().upgrade()?)) }
462}
463
464unsafe impl<'a, T: Facet<'a>> Facet<'a> for Weak<T> {
465    const SHAPE: &'static Shape = &const {
466        ShapeBuilder::for_sized::<Weak<T>>("Weak")
467            .type_name(weak_type_name::<T>)
468            .ty(Type::User(UserType::Opaque))
469            .def(Def::Pointer(PointerDef {
470                vtable: &const {
471                    PointerVTable {
472                        upgrade_into_fn: Some(|weak, strong| unsafe {
473                            weak_upgrade_into_fn::<T>(weak, strong)
474                        }),
475                        ..PointerVTable::new()
476                    }
477                },
478                pointee: Some(T::SHAPE),
479                weak: None,
480                strong: Some(<Rc<T> as Facet>::SHAPE),
481                flags: PointerFlags::WEAK,
482                known: Some(KnownPointer::RcWeak),
483            }))
484            .type_params(&[crate::TypeParam {
485                name: "T",
486                shape: T::SHAPE,
487            }])
488            .inner(T::SHAPE)
489            // Weak<T> propagates T's variance
490            .variance(Shape::computed_variance)
491            .vtable_indirect(
492                &const {
493                    VTableIndirect {
494                        debug: Some(weak_debug),
495                        display: None,
496                        hash: None,
497                        invariants: None,
498                        parse: None,
499                        try_from: None,
500                        try_into_inner: None,
501                        try_borrow_inner: None,
502                        partial_eq: None,
503                        partial_cmp: None,
504                        cmp: None,
505                    }
506                },
507            )
508            .type_ops_indirect(
509                &const {
510                    TypeOpsIndirect {
511                        drop_in_place: weak_drop::<T>,
512                        default_in_place: Some(weak_default::<T>),
513                        clone_into: Some(weak_clone::<T>),
514                        is_truthy: None,
515                    }
516                },
517            )
518            .build()
519    };
520}
521
522//////////////////////////////////////////////////////////////////////
523// Weak<str>
524//////////////////////////////////////////////////////////////////////
525
526/// Type name formatter for `Weak<str>`
527fn weak_str_type_name(
528    _shape: &'static Shape,
529    f: &mut core::fmt::Formatter<'_>,
530    opts: TypeNameOpts,
531) -> core::fmt::Result {
532    write!(f, "Weak")?;
533    if let Some(opts) = opts.for_children() {
534        write!(f, "<")?;
535        str::SHAPE.write_type_name(f, opts)?;
536        write!(f, ">")?;
537    } else {
538        write!(f, "<…>")?;
539    }
540    Ok(())
541}
542
543/// Drop function for `Weak<str>`
544unsafe fn weak_str_drop(ox: OxPtrMut) {
545    unsafe {
546        core::ptr::drop_in_place(ox.ptr().as_ptr::<Weak<str>>() as *mut Weak<str>);
547    }
548}
549
550/// Clone function for `Weak<str>`
551unsafe fn weak_str_clone(src: OxPtrConst, dst: OxPtrMut) {
552    unsafe {
553        let value = src.get::<Weak<str>>().clone();
554        (dst.ptr().as_ptr::<Weak<str>>() as *mut Weak<str>).write(value);
555    }
556}
557
558/// Upgrade into function for `Weak<str>`
559unsafe fn weak_str_upgrade_into_fn(weak: PtrMut, strong: PtrUninit) -> Option<PtrMut> {
560    unsafe { Some(strong.put(weak.get::<Weak<str>>().upgrade()?)) }
561}
562
563unsafe impl<'a> Facet<'a> for Weak<str> {
564    const SHAPE: &'static Shape = &const {
565        const VTABLE: VTableIndirect = VTableIndirect {
566            debug: Some(weak_debug),
567            display: None,
568            hash: None,
569            invariants: None,
570            parse: None,
571            try_from: None,
572            try_into_inner: None,
573            try_borrow_inner: None,
574            partial_eq: None,
575            partial_cmp: None,
576            cmp: None,
577        };
578
579        const TYPE_OPS: TypeOpsIndirect = TypeOpsIndirect {
580            drop_in_place: weak_str_drop,
581            default_in_place: None,
582            clone_into: Some(weak_str_clone),
583            is_truthy: None,
584        };
585
586        ShapeBuilder::for_sized::<Weak<str>>("Weak")
587            .type_name(weak_str_type_name)
588            .ty(Type::User(UserType::Opaque))
589            .def(Def::Pointer(PointerDef {
590                vtable: &const {
591                    PointerVTable {
592                        upgrade_into_fn: Some(|weak, strong| unsafe {
593                            weak_str_upgrade_into_fn(weak, strong)
594                        }),
595                        ..PointerVTable::new()
596                    }
597                },
598                pointee: Some(str::SHAPE),
599                weak: None,
600                strong: Some(<Rc<str> as Facet>::SHAPE),
601                flags: PointerFlags::WEAK,
602                known: Some(KnownPointer::RcWeak),
603            }))
604            .type_params(&[crate::TypeParam {
605                name: "T",
606                shape: str::SHAPE,
607            }])
608            .vtable_indirect(&VTABLE)
609            .type_ops_indirect(&TYPE_OPS)
610            .build()
611    };
612}
613
614//////////////////////////////////////////////////////////////////////
615// Weak<[U]>
616//////////////////////////////////////////////////////////////////////
617
618/// Type name formatter for `Weak<[U]>`
619fn weak_slice_type_name<'a, U: Facet<'a>>(
620    _shape: &'static Shape,
621    f: &mut core::fmt::Formatter<'_>,
622    opts: TypeNameOpts,
623) -> core::fmt::Result {
624    write!(f, "Weak")?;
625    if let Some(opts) = opts.for_children() {
626        write!(f, "<")?;
627        <[U]>::SHAPE.write_type_name(f, opts)?;
628        write!(f, ">")?;
629    } else {
630        write!(f, "<…>")?;
631    }
632    Ok(())
633}
634
635/// Drop function for `Weak<[U]>`
636unsafe fn weak_slice_drop<U>(ox: OxPtrMut) {
637    unsafe {
638        core::ptr::drop_in_place(ox.ptr().as_ptr::<Weak<[U]>>() as *mut Weak<[U]>);
639    }
640}
641
642/// Clone function for `Weak<[U]>`
643unsafe fn weak_slice_clone<U>(src: OxPtrConst, dst: OxPtrMut) {
644    unsafe {
645        let value = src.get::<Weak<[U]>>().clone();
646        (dst.ptr().as_ptr::<Weak<[U]>>() as *mut Weak<[U]>).write(value);
647    }
648}
649
650/// Upgrade into function for `Weak<[U]>`
651unsafe fn weak_slice_upgrade_into_fn<'a, 'ptr, U: Facet<'a>>(
652    weak: PtrMut,
653    strong: PtrUninit,
654) -> Option<PtrMut> {
655    unsafe { Some(strong.put(weak.get::<Weak<[U]>>().upgrade()?)) }
656}
657
658unsafe impl<'a, U: Facet<'a>> Facet<'a> for Weak<[U]> {
659    const SHAPE: &'static Shape = &const {
660        ShapeBuilder::for_sized::<Weak<[U]>>("Weak")
661            .type_name(weak_slice_type_name::<U>)
662            .ty(Type::User(UserType::Opaque))
663            .def(Def::Pointer(PointerDef {
664                vtable: &const {
665                    PointerVTable {
666                        upgrade_into_fn: Some(|weak, strong| unsafe {
667                            weak_slice_upgrade_into_fn::<U>(weak, strong)
668                        }),
669                        ..PointerVTable::new()
670                    }
671                },
672                pointee: Some(<[U]>::SHAPE),
673                weak: None,
674                strong: Some(<Rc<[U]> as Facet>::SHAPE),
675                flags: PointerFlags::WEAK,
676                known: Some(KnownPointer::RcWeak),
677            }))
678            .type_params(&[crate::TypeParam {
679                name: "T",
680                shape: <[U]>::SHAPE,
681            }])
682            .vtable_indirect(
683                &const {
684                    VTableIndirect {
685                        debug: Some(weak_debug),
686                        display: None,
687                        hash: None,
688                        invariants: None,
689                        parse: None,
690                        try_from: None,
691                        try_into_inner: None,
692                        try_borrow_inner: None,
693                        partial_eq: None,
694                        partial_cmp: None,
695                        cmp: None,
696                    }
697                },
698            )
699            .type_ops_indirect(
700                &const {
701                    TypeOpsIndirect {
702                        drop_in_place: weak_slice_drop::<U>,
703                        default_in_place: None,
704                        clone_into: Some(weak_slice_clone::<U>),
705                        is_truthy: None,
706                    }
707                },
708            )
709            .build()
710    };
711}
712
713#[cfg(test)]
714mod tests {
715    use core::mem::ManuallyDrop;
716
717    use alloc::rc::{Rc, Weak as RcWeak};
718    use alloc::string::String;
719
720    use super::*;
721
722    #[test]
723    fn test_rc_type_params() {
724        let [type_param_1] = <Rc<i32>>::SHAPE.type_params else {
725            panic!("Rc<T> should only have 1 type param")
726        };
727        assert_eq!(type_param_1.shape(), i32::SHAPE);
728    }
729
730    #[test]
731    fn test_rc_vtable_1_new_borrow_drop() {
732        facet_testhelpers::setup();
733
734        let rc_shape = <Rc<String>>::SHAPE;
735        let rc_def = rc_shape
736            .def
737            .into_pointer()
738            .expect("Rc<T> should have a smart pointer definition");
739
740        // Allocate memory for the Rc
741        let rc_uninit_ptr = rc_shape.allocate().unwrap();
742
743        // Get the function pointer for creating a new Rc from a value
744        let new_into_fn = rc_def
745            .vtable
746            .new_into_fn
747            .expect("Rc<T> should have new_into_fn");
748
749        // Create the value and initialize the Rc
750        let mut value = ManuallyDrop::new(String::from("example"));
751        let rc_ptr = unsafe {
752            new_into_fn(
753                rc_uninit_ptr,
754                PtrMut::new(NonNull::from(&mut value).as_ptr()),
755            )
756        };
757
758        // Get the function pointer for borrowing the inner value
759        let borrow_fn = rc_def
760            .vtable
761            .borrow_fn
762            .expect("Rc<T> should have borrow_fn");
763
764        // Borrow the inner value and check it
765        let borrowed_ptr = unsafe { borrow_fn(rc_ptr.as_const()) };
766        // SAFETY: borrowed_ptr points to a valid String within the Rc
767        assert_eq!(unsafe { borrowed_ptr.get::<String>() }, "example");
768
769        // Drop the Rc in place
770        // SAFETY: rc_ptr points to a valid Rc<String>
771        unsafe {
772            rc_shape
773                .call_drop_in_place(rc_ptr)
774                .expect("Rc<T> should have drop_in_place");
775        }
776
777        // Deallocate the memory
778        // SAFETY: rc_ptr was allocated by rc_shape and is now dropped (but memory is still valid)
779        unsafe { rc_shape.deallocate_mut(rc_ptr).unwrap() };
780    }
781
782    #[test]
783    fn test_rc_vtable_2_downgrade_upgrade_drop() {
784        facet_testhelpers::setup();
785
786        let rc_shape = <Rc<String>>::SHAPE;
787        let rc_def = rc_shape
788            .def
789            .into_pointer()
790            .expect("Rc<T> should have a smart pointer definition");
791
792        let weak_shape = <RcWeak<String>>::SHAPE;
793        let weak_def = weak_shape
794            .def
795            .into_pointer()
796            .expect("RcWeak<T> should have a smart pointer definition");
797
798        // 1. Create the first Rc (rc1)
799        let rc1_uninit_ptr = rc_shape.allocate().unwrap();
800        let new_into_fn = rc_def.vtable.new_into_fn.unwrap();
801        let mut value = ManuallyDrop::new(String::from("example"));
802        let rc1_ptr = unsafe {
803            new_into_fn(
804                rc1_uninit_ptr,
805                PtrMut::new(NonNull::from(&mut value).as_ptr()),
806            )
807        };
808
809        // 2. Downgrade rc1 to create a weak pointer (weak1)
810        let weak1_uninit_ptr = weak_shape.allocate().unwrap();
811        let downgrade_into_fn = rc_def.vtable.downgrade_into_fn.unwrap();
812        // SAFETY: rc1_ptr points to a valid Rc, weak1_uninit_ptr is allocated for a Weak
813        let weak1_ptr = unsafe { downgrade_into_fn(rc1_ptr, weak1_uninit_ptr) };
814
815        // 3. Upgrade weak1 to create a second Rc (rc2)
816        let rc2_uninit_ptr = rc_shape.allocate().unwrap();
817        let upgrade_into_fn = weak_def.vtable.upgrade_into_fn.unwrap();
818        // SAFETY: weak1_ptr points to a valid Weak, rc2_uninit_ptr is allocated for an Rc.
819        // Upgrade should succeed as rc1 still exists.
820        let rc2_ptr = unsafe { upgrade_into_fn(weak1_ptr, rc2_uninit_ptr) }
821            .expect("Upgrade should succeed while original Rc exists");
822
823        // Check the content of the upgraded Rc
824        let borrow_fn = rc_def.vtable.borrow_fn.unwrap();
825        // SAFETY: rc2_ptr points to a valid Rc<String>
826        let borrowed_ptr = unsafe { borrow_fn(rc2_ptr.as_const()) };
827        // SAFETY: borrowed_ptr points to a valid String
828        assert_eq!(unsafe { borrowed_ptr.get::<String>() }, "example");
829
830        // 4. Drop everything and free memory
831        unsafe {
832            // Drop Rcs
833            rc_shape.call_drop_in_place(rc1_ptr).unwrap();
834            rc_shape.deallocate_mut(rc1_ptr).unwrap();
835
836            rc_shape.call_drop_in_place(rc2_ptr).unwrap();
837            rc_shape.deallocate_mut(rc2_ptr).unwrap();
838
839            // Drop Weak
840            weak_shape.call_drop_in_place(weak1_ptr).unwrap();
841            weak_shape.deallocate_mut(weak1_ptr).unwrap();
842        }
843    }
844
845    #[test]
846    fn test_rc_vtable_3_downgrade_drop_try_upgrade() {
847        facet_testhelpers::setup();
848
849        let rc_shape = <Rc<String>>::SHAPE;
850        let rc_def = rc_shape
851            .def
852            .into_pointer()
853            .expect("Rc<T> should have a smart pointer definition");
854
855        let weak_shape = <RcWeak<String>>::SHAPE;
856        let weak_def = weak_shape
857            .def
858            .into_pointer()
859            .expect("RcWeak<T> should have a smart pointer definition");
860
861        // 1. Create the strong Rc (rc1)
862        let rc1_uninit_ptr = rc_shape.allocate().unwrap();
863        let new_into_fn = rc_def.vtable.new_into_fn.unwrap();
864        let mut value = ManuallyDrop::new(String::from("example"));
865        let rc1_ptr = unsafe {
866            new_into_fn(
867                rc1_uninit_ptr,
868                PtrMut::new(NonNull::from(&mut value).as_ptr()),
869            )
870        };
871
872        // 2. Downgrade rc1 to create a weak pointer (weak1)
873        let weak1_uninit_ptr = weak_shape.allocate().unwrap();
874        let downgrade_into_fn = rc_def.vtable.downgrade_into_fn.unwrap();
875        // SAFETY: rc1_ptr is valid, weak1_uninit_ptr is allocated for Weak
876        let weak1_ptr = unsafe { downgrade_into_fn(rc1_ptr, weak1_uninit_ptr) };
877
878        // 3. Drop and free the strong pointer (rc1)
879        unsafe {
880            rc_shape.call_drop_in_place(rc1_ptr).unwrap();
881            rc_shape.deallocate_mut(rc1_ptr).unwrap();
882        }
883
884        // 4. Attempt to upgrade the weak pointer (weak1)
885        let upgrade_into_fn = weak_def.vtable.upgrade_into_fn.unwrap();
886        let rc2_uninit_ptr = rc_shape.allocate().unwrap();
887        // SAFETY: weak1_ptr is valid (though points to dropped data), rc2_uninit_ptr is allocated for Rc
888        let upgrade_result = unsafe { upgrade_into_fn(weak1_ptr, rc2_uninit_ptr) };
889
890        // Assert that the upgrade failed
891        assert!(
892            upgrade_result.is_none(),
893            "Upgrade should fail after the strong Rc is dropped"
894        );
895
896        // 5. Clean up: Deallocate the memory intended for the failed upgrade and drop/deallocate the weak pointer
897        unsafe {
898            // Deallocate the *uninitialized* memory allocated for the failed upgrade attempt
899            rc_shape.deallocate_uninit(rc2_uninit_ptr).unwrap();
900
901            // Drop and deallocate the weak pointer
902            weak_shape.call_drop_in_place(weak1_ptr).unwrap();
903            weak_shape.deallocate_mut(weak1_ptr).unwrap();
904        }
905    }
906}
facet_core/impls/alloc/rc.rs

facet_core/impls/alloc/
rc.rs
