15200164445

Committed 23 May 2025 01:21AM UTC coverage: 57.288% (+0.1%) from 57.185%

Build # 15200164445

Build Type

Pull #666

github

Committed by

web-flow

Commit Message

Merge 4232978c5 into 4b41e5c8a

Pull Request Pull Request #666: Add indirection to vtable fns to fix cyclic types

Run Details

715 of 1482 new or added lines in 34 files covered. (48.25%)

14 existing lines in 5 files now uncovered.

9747 of 17014 relevant lines covered (57.29%)

132.73 hits per line

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

89.11

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

use core::alloc::Layout;

use crate::{
    Def, Facet, KnownSmartPointer, PtrConst, PtrMut, PtrUninit, Shape, ShapeLayout,
    SmartPointerDef, SmartPointerFlags, SmartPointerVTable, TryBorrowInnerError, TryFromError,
    TryIntoInnerError, Type, UserType, ValueVTable, value_vtable,
};

unsafe impl<'a, T: Facet<'a>> Facet<'a> for alloc::sync::Arc<T> {
    const VTABLE: &'static ValueVTable = &const {
        // Define the functions for transparent conversion between Arc<T> and T
        unsafe fn try_from<'a, 'shape, 'src, 'dst, T: Facet<'a> + ?Sized>(
            src_ptr: PtrConst<'src>,
            src_shape: &'shape Shape<'shape>,
            dst: PtrUninit<'dst>,
        ) -> Result<PtrMut<'dst>, TryFromError<'shape>> {
            if src_shape.id != T::SHAPE.id {
                return Err(TryFromError::UnsupportedSourceShape {
                    src_shape,
                    expected: &[T::SHAPE],
                });
            }

            if let ShapeLayout::Unsized = T::SHAPE.layout {
                panic!("can't try_from with unsized type");
            }

            use alloc::sync::Arc;

            // Get the layout for T
            let layout = match T::SHAPE.layout {
                ShapeLayout::Sized(layout) => layout,
                ShapeLayout::Unsized => panic!("Unsized type not supported"),
            };

            // We'll create a new memory location, copy the value, then create an Arc from it
            let size_of_arc_header = core::mem::size_of::<usize>() * 2;

            // Use Layout::extend to combine header and value layout with correct alignment and padding
            let header_layout =
                Layout::from_size_align(size_of_arc_header, core::mem::align_of::<usize>())
                    .unwrap();
            let (arc_layout, value_offset) = header_layout.extend(layout).unwrap();

            // To ensure that our allocation is correct for the Arc memory model,
            // round up the allocation to the next multiple of 8 (Arc's alignment)
            let adjusted_size = (arc_layout.size() + 7) & !7;
            let final_layout =
                unsafe { Layout::from_size_align_unchecked(adjusted_size, arc_layout.align()) };

            let mem = unsafe { alloc::alloc::alloc(final_layout) };

            unsafe {
                // Copy the Arc header (refcounts, vtable pointer, etc.) from a dummy Arc<()>
                let dummy_arc = Arc::new(());
                let header_start = (Arc::as_ptr(&dummy_arc) as *const u8).sub(size_of_arc_header);
                core::ptr::copy_nonoverlapping(header_start, mem, size_of_arc_header);

                // Copy the source value into the memory area at the correct value offset after the Arc header
                core::ptr::copy_nonoverlapping(
                    src_ptr.as_byte_ptr(),
                    mem.add(value_offset),
                    layout.size(),
                );
            }

            // Create an Arc from our allocated and initialized memory
            let ptr = unsafe { mem.add(value_offset) };
            let t_ptr: *mut T = unsafe { core::mem::transmute_copy(&ptr) };
            let arc = unsafe { Arc::from_raw(t_ptr) };

            // Move the Arc into the destination and return a PtrMut for it
            Ok(unsafe { dst.put(arc) })
        }

        unsafe fn try_into_inner<'a, 'src, 'dst, T: Facet<'a> + ?Sized>(
            src_ptr: PtrMut<'src>,
            dst: PtrUninit<'dst>,
        ) -> Result<PtrMut<'dst>, TryIntoInnerError> {
            use alloc::sync::Arc;

            // Read the Arc from the source pointer
            let mut arc = unsafe { src_ptr.read::<Arc<T>>() };

            // For unsized types, we need to know how many bytes to copy.
            let size = match T::SHAPE.layout {
                ShapeLayout::Sized(layout) => layout.size(),
                _ => panic!("cannot try_into_inner with unsized type"),
            };

            // Check if we have exclusive access to the Arc (strong count = 1)
            if let Some(inner_ref) = Arc::get_mut(&mut arc) {
                // We have exclusive access, so we can safely copy the inner value
                let inner_ptr = inner_ref as *const T as *const u8;

                unsafe {
                    // Copy the inner value to the destination
                    core::ptr::copy_nonoverlapping(inner_ptr, dst.as_mut_byte_ptr(), size);

                    // Prevent dropping the Arc normally which would also drop the inner value
                    // that we've already copied
                    let raw_ptr = Arc::into_raw(arc);

                    // We need to deallocate the Arc without running destructors
                    // Get the Arc layout
                    let size_of_arc_header = core::mem::size_of::<usize>() * 2;
                    let layout = match T::SHAPE.layout {
                        ShapeLayout::Sized(layout) => layout,
                        _ => unreachable!("We already checked that T is sized"),
                    };
                    let arc_layout = Layout::from_size_align_unchecked(
                        size_of_arc_header + size,
                        layout.align(),
                    );

                    // Get the start of the allocation (header is before the data)
                    let allocation_start = (raw_ptr as *mut u8).sub(size_of_arc_header);

                    // Deallocate the memory without running any destructors
                    alloc::alloc::dealloc(allocation_start, arc_layout);

                    // Return a PtrMut to the destination, which now owns the value
                    Ok(PtrMut::new(dst.as_mut_byte_ptr()))
                }
            } else {
                // Arc is shared, so we can't extract the inner value
                core::mem::forget(arc);
                Err(TryIntoInnerError::Unavailable)
            }
        }

        unsafe fn try_borrow_inner<'a, 'src, T: Facet<'a>>(
            src_ptr: PtrConst<'src>,
        ) -> Result<PtrConst<'src>, TryBorrowInnerError> {
            let arc = unsafe { src_ptr.get::<alloc::sync::Arc<T>>() };
            Ok(PtrConst::new(&**arc))
        }

        let mut vtable = value_vtable!(alloc::sync::Arc<T>, |f, opts| {
            write!(f, "Arc")?;
            if let Some(opts) = opts.for_children() {
                write!(f, "<")?;
                (T::SHAPE.vtable.type_name)(f, opts)?;
                write!(f, ">")?;
            } else {
                write!(f, "<…>")?;
            }
            Ok(())
        });

        vtable.try_from = || Some(try_from::<T>);
        vtable.try_into_inner = || Some(try_into_inner::<T>);
        vtable.try_borrow_inner = || Some(try_borrow_inner::<T>);
        vtable
    };

    const SHAPE: &'static crate::Shape<'static> = &const {
        // Function to return inner type's shape
        fn inner_shape<'a, T: Facet<'a> + ?Sized>() -> &'static Shape<'static> {
            T::SHAPE
        }

        crate::Shape::builder_for_sized::<Self>()
            .type_params(&[crate::TypeParam {
                name: "T",
                shape: || T::SHAPE,
            }])
            .ty(Type::User(UserType::Opaque))
            .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(|this| {
                                    let ptr = Self::as_ptr(unsafe { this.get() });
                                    PtrConst::new(ptr)
                                })
                                .new_into_fn(|this, ptr| {
                                    use alloc::sync::Arc;

                                    let layout = match T::SHAPE.layout {
                                        ShapeLayout::Sized(layout) => layout,
                                        ShapeLayout::Unsized => panic!("nope"),
                                    };

                                    let size_of_arc_header = core::mem::size_of::<usize>() * 2;

                                    // we don't know the layout of dummy_arc, but we can tell its size and we can copy it
                                    // in front of the `PtrMut`
                                    let arc_layout = unsafe {
                                        Layout::from_size_align_unchecked(
                                            size_of_arc_header + layout.size(),
                                            layout.align(),
                                        )
                                    };
                                    let mem = unsafe { alloc::alloc::alloc(arc_layout) };

                                    unsafe {
                                        // Copy the Arc header (including refcounts, vtable pointers, etc.) from a freshly-allocated Arc<()>
                                        // so that the struct before the T value is a valid Arc header.
                                        let dummy_arc = alloc::sync::Arc::new(());
                                        let header_start = (Arc::as_ptr(&dummy_arc) as *const u8)
                                            .sub(size_of_arc_header);
                                        core::ptr::copy_nonoverlapping(
                                            header_start,
                                            mem,
                                            size_of_arc_header,
                                        );

                                        // Copy the value for T, pointed to by `ptr`, into the bytes just after the Arc header
                                        core::ptr::copy_nonoverlapping(
                                            ptr.as_byte_ptr(),
                                            mem.add(size_of_arc_header),
                                            layout.size(),
                                        );
                                    }

                                    // Safety: `mem` is valid and contains a valid Arc header and valid T.
                                    let ptr = unsafe { mem.add(size_of_arc_header) };
                                    let t_ptr: *mut T = unsafe { core::mem::transmute_copy(&ptr) };
                                    // Safety: This is the pointer to the Arc header + value; from_raw assumes a pointer to T located immediately after the Arc header.
                                    let arc = unsafe { Arc::from_raw(t_ptr) };
                                    // Move the Arc into the destination (this) and return a PtrMut for it.
                                    unsafe { this.put(arc) }
                                })
                                .downgrade_into_fn(|strong, weak| unsafe {
                                    weak.put(alloc::sync::Arc::downgrade(strong.get::<Self>()))
                                })
                                .build()
                        },
                    )
                    .build(),
            ))
            .inner(inner_shape::<T>)
            .build()
    };
}

unsafe impl<'a, T: Facet<'a>> Facet<'a> for alloc::sync::Weak<T> {
    const VTABLE: &'static ValueVTable = &const {
        value_vtable!(alloc::sync::Weak<T>, |f, opts| {
            write!(f, "Weak")?;
            if let Some(opts) = opts.for_children() {
                write!(f, "<")?;
                (T::SHAPE.vtable.type_name)(f, opts)?;
                write!(f, ">")?;
            } else {
                write!(f, "<…>")?;
            }
            Ok(())
        })
    };

    const SHAPE: &'static crate::Shape<'static> = &const {
        // Function to return inner type's shape
        fn inner_shape<'a, T: Facet<'a> + ?Sized>() -> &'static Shape<'static> {
            T::SHAPE
        }

        crate::Shape::builder_for_sized::<Self>()
            .type_params(&[crate::TypeParam {
                name: "T",
                shape: || T::SHAPE,
            }])
            .ty(Type::User(UserType::Opaque))
            .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(),
            ))
            .inner(inner_shape::<T>)
            .build()
    };
}

#[cfg(test)]
mod tests {
    use alloc::string::String;
    use alloc::sync::{Arc, Weak as ArcWeak};

    use super::*;

    #[test]
    fn test_arc_type_params() {
        let [type_param_1] = <Arc<i32>>::SHAPE.type_params else {
            panic!("Arc<T> should only have 1 type param")
        };
        assert_eq!(type_param_1.shape(), i32::SHAPE);
    }

    #[test]
    fn test_arc_vtable_1_new_borrow_drop() -> eyre::Result<()> {
        facet_testhelpers::setup();

        let arc_shape = <Arc<String>>::SHAPE;
        let arc_def = arc_shape
            .def
            .into_smart_pointer()
            .expect("Arc<T> should have a smart pointer definition");

        // Allocate memory for the Arc
        let arc_uninit_ptr = arc_shape.allocate()?;

        // Get the function pointer for creating a new Arc from a value
        let new_into_fn = arc_def
            .vtable
            .new_into_fn
            .expect("Arc<T> should have new_into_fn");

        // Create the value and initialize the Arc
        let mut value = String::from("example");
        let arc_ptr = unsafe { new_into_fn(arc_uninit_ptr, PtrMut::new(&raw mut value)) };
        // The value now belongs to the Arc, prevent its drop
        core::mem::forget(value);

        // Get the function pointer for borrowing the inner value
        let borrow_fn = arc_def
            .vtable
            .borrow_fn
            .expect("Arc<T> should have borrow_fn");

        // Borrow the inner value and check it
        let borrowed_ptr = unsafe { borrow_fn(arc_ptr.as_const()) };
        // SAFETY: borrowed_ptr points to a valid String within the Arc
        assert_eq!(unsafe { borrowed_ptr.get::<String>() }, "example");

        // Get the function pointer for dropping the Arc
        let drop_fn = (arc_shape.vtable.drop_in_place)().expect("Arc<T> should have drop_in_place");

        // Drop the Arc in place
        // SAFETY: arc_ptr points to a valid Arc<String>
        unsafe { drop_fn(arc_ptr) };

        // Deallocate the memory
        // SAFETY: arc_ptr was allocated by arc_shape and is now dropped (but memory is still valid)
        unsafe { arc_shape.deallocate_mut(arc_ptr)? };

        Ok(())
    }

    #[test]
    fn test_arc_vtable_2_downgrade_upgrade_drop() -> eyre::Result<()> {
        facet_testhelpers::setup();

        let arc_shape = <Arc<String>>::SHAPE;
        let arc_def = arc_shape
            .def
            .into_smart_pointer()
            .expect("Arc<T> should have a smart pointer definition");

        let weak_shape = <ArcWeak<String>>::SHAPE;
        let weak_def = weak_shape
            .def
            .into_smart_pointer()
            .expect("ArcWeak<T> should have a smart pointer definition");

        // 1. Create the first Arc (arc1)
        let arc1_uninit_ptr = arc_shape.allocate()?;
        let new_into_fn = arc_def.vtable.new_into_fn.unwrap();
        let mut value = String::from("example");
        let arc1_ptr = unsafe { new_into_fn(arc1_uninit_ptr, PtrMut::new(&raw mut value)) };
        core::mem::forget(value); // Value now owned by arc1

        // 2. Downgrade arc1 to create a weak pointer (weak1)
        let weak1_uninit_ptr = weak_shape.allocate()?;
        let downgrade_into_fn = arc_def.vtable.downgrade_into_fn.unwrap();
        // SAFETY: arc1_ptr points to a valid Arc, weak1_uninit_ptr is allocated for a Weak
        let weak1_ptr = unsafe { downgrade_into_fn(arc1_ptr, weak1_uninit_ptr) };

        // 3. Upgrade weak1 to create a second Arc (arc2)
        let arc2_uninit_ptr = arc_shape.allocate()?;
        let upgrade_into_fn = weak_def.vtable.upgrade_into_fn.unwrap();
        // SAFETY: weak1_ptr points to a valid Weak, arc2_uninit_ptr is allocated for an Arc.
        // Upgrade should succeed as arc1 still exists.
        let arc2_ptr = unsafe { upgrade_into_fn(weak1_ptr, arc2_uninit_ptr) }
            .expect("Upgrade should succeed while original Arc exists");

        // Check the content of the upgraded Arc
        let borrow_fn = arc_def.vtable.borrow_fn.unwrap();
        // SAFETY: arc2_ptr points to a valid Arc<String>
        let borrowed_ptr = unsafe { borrow_fn(arc2_ptr.as_const()) };
        // SAFETY: borrowed_ptr points to a valid String
        assert_eq!(unsafe { borrowed_ptr.get::<String>() }, "example");

        // 4. Drop everything and free memory
        let arc_drop_fn = (arc_shape.vtable.drop_in_place)().unwrap();
        let weak_drop_fn = (weak_shape.vtable.drop_in_place)().unwrap();

        unsafe {
            // Drop Arcs
            arc_drop_fn(arc1_ptr);
            arc_shape.deallocate_mut(arc1_ptr)?;
            arc_drop_fn(arc2_ptr);
            arc_shape.deallocate_mut(arc2_ptr)?;

            // Drop Weak
            weak_drop_fn(weak1_ptr);
            weak_shape.deallocate_mut(weak1_ptr)?;
        }

        Ok(())
    }

    #[test]
    fn test_arc_vtable_3_downgrade_drop_try_upgrade() -> eyre::Result<()> {
        facet_testhelpers::setup();

        let arc_shape = <Arc<String>>::SHAPE;
        let arc_def = arc_shape
            .def
            .into_smart_pointer()
            .expect("Arc<T> should have a smart pointer definition");

        let weak_shape = <ArcWeak<String>>::SHAPE;
        let weak_def = weak_shape
            .def
            .into_smart_pointer()
            .expect("ArcWeak<T> should have a smart pointer definition");

        // 1. Create the strong Arc (arc1)
        let arc1_uninit_ptr = arc_shape.allocate()?;
        let new_into_fn = arc_def.vtable.new_into_fn.unwrap();
        let mut value = String::from("example");
        let arc1_ptr = unsafe { new_into_fn(arc1_uninit_ptr, PtrMut::new(&raw mut value)) };
        core::mem::forget(value);

        // 2. Downgrade arc1 to create a weak pointer (weak1)
        let weak1_uninit_ptr = weak_shape.allocate()?;
        let downgrade_into_fn = arc_def.vtable.downgrade_into_fn.unwrap();
        // SAFETY: arc1_ptr is valid, weak1_uninit_ptr is allocated for Weak
        let weak1_ptr = unsafe { downgrade_into_fn(arc1_ptr, weak1_uninit_ptr) };

        // 3. Drop and free the strong pointer (arc1)
        let arc_drop_fn = (arc_shape.vtable.drop_in_place)().unwrap();
        unsafe {
            arc_drop_fn(arc1_ptr);
            arc_shape.deallocate_mut(arc1_ptr)?;
        }

        // 4. Attempt to upgrade the weak pointer (weak1)
        let upgrade_into_fn = weak_def.vtable.upgrade_into_fn.unwrap();
        let arc2_uninit_ptr = arc_shape.allocate()?;
        // SAFETY: weak1_ptr is valid (though points to dropped data), arc2_uninit_ptr is allocated for Arc
        let upgrade_result = unsafe { upgrade_into_fn(weak1_ptr, arc2_uninit_ptr) };

        // Assert that the upgrade failed
        assert!(
            upgrade_result.is_none(),
            "Upgrade should fail after the strong Arc is dropped"
        );

        // 5. Clean up: Deallocate the memory intended for the failed upgrade and drop/deallocate the weak pointer
        let weak_drop_fn = (weak_shape.vtable.drop_in_place)().unwrap();
        unsafe {
            // Deallocate the *uninitialized* memory allocated for the failed upgrade attempt
            arc_shape.deallocate_uninit(arc2_uninit_ptr)?;

            // Drop and deallocate the weak pointer
            weak_drop_fn(weak1_ptr);
            weak_shape.deallocate_mut(weak1_ptr)?;
        }

        Ok(())
    }

    #[test]
    fn test_arc_vtable_4_try_from() -> eyre::Result<()> {
        facet_testhelpers::setup();

        // Get the shapes we'll be working with
        let string_shape = <String>::SHAPE;
        let arc_shape = <Arc<String>>::SHAPE;
        let arc_def = arc_shape
            .def
            .into_smart_pointer()
            .expect("Arc<T> should have a smart pointer definition");

        // 1. Create a String value
        let value = String::from("try_from test");
        let value_ptr = PtrConst::new(&value as *const String as *const u8);

        // 2. Allocate memory for the Arc<String>
        let arc_uninit_ptr = arc_shape.allocate()?;

        // 3. Get the try_from function from the Arc<String> shape's ValueVTable
        let try_from_fn = (arc_shape.vtable.try_from)().expect("Arc<T> should have try_from");

        // 4. Try to convert String to Arc<String>
        let arc_ptr = unsafe { try_from_fn(value_ptr, string_shape, arc_uninit_ptr) }
            .expect("try_from should succeed");
        core::mem::forget(value);

        // 5. Borrow the inner value and verify it's correct
        let borrow_fn = arc_def
            .vtable
            .borrow_fn
            .expect("Arc<T> should have borrow_fn");
        let borrowed_ptr = unsafe { borrow_fn(arc_ptr.as_const()) };

        // SAFETY: borrowed_ptr points to a valid String within the Arc
        assert_eq!(unsafe { borrowed_ptr.get::<String>() }, "try_from test");

        // 6. Clean up
        let drop_fn = (arc_shape.vtable.drop_in_place)().expect("Arc<T> should have drop_in_place");

        unsafe {
            drop_fn(arc_ptr);
            arc_shape.deallocate_mut(arc_ptr)?;
        }

        Ok(())
    }

    #[test]
    fn test_arc_vtable_5_try_into_inner() -> eyre::Result<()> {
        facet_testhelpers::setup();

        // Get the shapes we'll be working with
        let string_shape = <String>::SHAPE;
        let arc_shape = <Arc<String>>::SHAPE;
        let arc_def = arc_shape
            .def
            .into_smart_pointer()
            .expect("Arc<T> should have a smart pointer definition");

        // 1. Create an Arc<String>
        let arc_uninit_ptr = arc_shape.allocate()?;
        let new_into_fn = arc_def
            .vtable
            .new_into_fn
            .expect("Arc<T> should have new_into_fn");

        let mut value = String::from("try_into_inner test");
        let arc_ptr = unsafe { new_into_fn(arc_uninit_ptr, PtrMut::new(&raw mut value)) };
        core::mem::forget(value); // Value now owned by arc

        // 2. Allocate memory for the extracted String
        let string_uninit_ptr = string_shape.allocate()?;

        // 3. Get the try_into_inner function from the Arc<String>'s ValueVTable
        let try_into_inner_fn =
            (arc_shape.vtable.try_into_inner)().expect("Arc<T> Shape should have try_into_inner");

        // 4. Try to extract the String from the Arc<String>
        // This should succeed because we have exclusive access to the Arc (strong count = 1)
        let string_ptr = unsafe { try_into_inner_fn(arc_ptr, string_uninit_ptr) }
            .expect("try_into_inner should succeed with exclusive access");

        // 5. Verify the extracted String
        assert_eq!(
            unsafe { string_ptr.as_const().get::<String>() },
            "try_into_inner test"
        );

        // 6. Clean up
        let string_drop_fn =
            (string_shape.vtable.drop_in_place)().expect("String should have drop_in_place");

        unsafe {
            // The Arc should already be dropped by try_into_inner
            // But we still need to deallocate its memory
            arc_shape.deallocate_mut(arc_ptr)?;

            // Drop and deallocate the extracted String
            string_drop_fn(string_ptr);
            string_shape.deallocate_mut(string_ptr)?;
        }

        Ok(())
    }
}

1	use core::alloc::Layout;
2
3	use crate::{
4	Def, Facet, KnownSmartPointer, PtrConst, PtrMut, PtrUninit, Shape, ShapeLayout,
5	SmartPointerDef, SmartPointerFlags, SmartPointerVTable, TryBorrowInnerError, TryFromError,
6	TryIntoInnerError, Type, UserType, ValueVTable, value_vtable,
7	};
8
9	unsafe impl<'a, T: Facet<'a>> Facet<'a> for alloc::sync::Arc<T> {
10	const VTABLE: &'static ValueVTable = &const {
11	// Define the functions for transparent conversion between Arc<T> and T
12	unsafe fn try_from<'a, 'shape, 'src, 'dst, T: Facet<'a> + ?Sized>(	4✔
13	src_ptr: PtrConst<'src>,	4✔
14	src_shape: &'shape Shape<'shape>,	4✔
15	dst: PtrUninit<'dst>,	4✔
16	) -> Result<PtrMut<'dst>, TryFromError<'shape>> {	4✔
17	if src_shape.id != T::SHAPE.id {	4✔
18	return Err(TryFromError::UnsupportedSourceShape {	×
19	src_shape,	×
20	expected: &[T::SHAPE],	×
21	});	×
22	}	4✔
23
24	if let ShapeLayout::Unsized = T::SHAPE.layout {	4✔
25	panic!("can't try_from with unsized type");	×
26	}	4✔
27
28	use alloc::sync::Arc;
29
30	// Get the layout for T
31	let layout = match T::SHAPE.layout {	4✔
32	ShapeLayout::Sized(layout) => layout,	4✔
33	ShapeLayout::Unsized => panic!("Unsized type not supported"),	×
34	};
35
36	// We'll create a new memory location, copy the value, then create an Arc from it
37	let size_of_arc_header = core::mem::size_of::<usize>() * 2;	4✔
38
39	// Use Layout::extend to combine header and value layout with correct alignment and padding
40	let header_layout =	4✔
41	Layout::from_size_align(size_of_arc_header, core::mem::align_of::<usize>())	4✔
42	.unwrap();	4✔
43	let (arc_layout, value_offset) = header_layout.extend(layout).unwrap();	4✔
44
45	// To ensure that our allocation is correct for the Arc memory model,
46	// round up the allocation to the next multiple of 8 (Arc's alignment)
47	let adjusted_size = (arc_layout.size() + 7) & !7;	4✔
48	let final_layout =	4✔
49	unsafe { Layout::from_size_align_unchecked(adjusted_size, arc_layout.align()) };	4✔
50
51	let mem = unsafe { alloc::alloc::alloc(final_layout) };	4✔
52
53	unsafe {	4✔
54	// Copy the Arc header (refcounts, vtable pointer, etc.) from a dummy Arc<()>	4✔
55	let dummy_arc = Arc::new(());	4✔
56	let header_start = (Arc::as_ptr(&dummy_arc) as *const u8).sub(size_of_arc_header);	4✔
57	core::ptr::copy_nonoverlapping(header_start, mem, size_of_arc_header);	4✔
58		4✔
59	// Copy the source value into the memory area at the correct value offset after the Arc header	4✔
60	core::ptr::copy_nonoverlapping(	4✔
61	src_ptr.as_byte_ptr(),	4✔
62	mem.add(value_offset),	4✔
63	layout.size(),	4✔
64	);	4✔
65	}	4✔
66
67	// Create an Arc from our allocated and initialized memory
68	let ptr = unsafe { mem.add(value_offset) };	4✔
69	let t_ptr: *mut T = unsafe { core::mem::transmute_copy(&ptr) };	4✔
70	let arc = unsafe { Arc::from_raw(t_ptr) };	4✔
71
72	// Move the Arc into the destination and return a PtrMut for it
73	Ok(unsafe { dst.put(arc) })	4✔
74	}	4✔
75
76	unsafe fn try_into_inner<'a, 'src, 'dst, T: Facet<'a> + ?Sized>(	1✔
77	src_ptr: PtrMut<'src>,	1✔
78	dst: PtrUninit<'dst>,	1✔
79	) -> Result<PtrMut<'dst>, TryIntoInnerError> {	1✔
80	use alloc::sync::Arc;
81
82	// Read the Arc from the source pointer
83	let mut arc = unsafe { src_ptr.read::<Arc<T>>() };	1✔
84
85	// For unsized types, we need to know how many bytes to copy.
86	let size = match T::SHAPE.layout {	1✔
87	ShapeLayout::Sized(layout) => layout.size(),	1✔
88	_ => panic!("cannot try_into_inner with unsized type"),	×
89	};
90
91	// Check if we have exclusive access to the Arc (strong count = 1)
92	if let Some(inner_ref) = Arc::get_mut(&mut arc) {	1✔
93	// We have exclusive access, so we can safely copy the inner value
94	let inner_ptr = inner_ref as const T as const u8;	1✔
95
96	unsafe {
97	// Copy the inner value to the destination
98	core::ptr::copy_nonoverlapping(inner_ptr, dst.as_mut_byte_ptr(), size);	1✔
99
100	// Prevent dropping the Arc normally which would also drop the inner value
101	// that we've already copied
102	let raw_ptr = Arc::into_raw(arc);	1✔
103
104	// We need to deallocate the Arc without running destructors
105	// Get the Arc layout
106	let size_of_arc_header = core::mem::size_of::<usize>() * 2;	1✔
107	let layout = match T::SHAPE.layout {	1✔
108	ShapeLayout::Sized(layout) => layout,	1✔
109	_ => unreachable!("We already checked that T is sized"),	×
110	};
111	let arc_layout = Layout::from_size_align_unchecked(	1✔
112	size_of_arc_header + size,	1✔
113	layout.align(),	1✔
114	);
115
116	// Get the start of the allocation (header is before the data)
117	let allocation_start = (raw_ptr as *mut u8).sub(size_of_arc_header);	1✔
118
119	// Deallocate the memory without running any destructors
120	alloc::alloc::dealloc(allocation_start, arc_layout);	1✔
121
122	// Return a PtrMut to the destination, which now owns the value
123	Ok(PtrMut::new(dst.as_mut_byte_ptr()))	1✔
124	}
125	} else {
126	// Arc is shared, so we can't extract the inner value
127	core::mem::forget(arc);	×
128	Err(TryIntoInnerError::Unavailable)	×
129	}
130	}	1✔
131
132	unsafe fn try_borrow_inner<'a, 'src, T: Facet<'a>>(	×
133	src_ptr: PtrConst<'src>,	×
134	) -> Result<PtrConst<'src>, TryBorrowInnerError> {	×
135	let arc = unsafe { src_ptr.get::<alloc::sync::Arc<T>>() };	×
136	Ok(PtrConst::new(&**arc))	×
137	}	×
138
139	let mut vtable = value_vtable!(alloc::sync::Arc<T>, \|f, opts\| {	7✔
140	write!(f, "Arc")?;	7✔
141	if let Some(opts) = opts.for_children() {	7✔
142	write!(f, "<")?;	7✔
143	(T::SHAPE.vtable.type_name)(f, opts)?;	7✔
144	write!(f, ">")?;	7✔
145	} else {
146	write!(f, "<…>")?;	×
147	}
148	Ok(())	7✔
149	});	7✔
150
151	vtable.try_from = \|\| Some(try_from::<T>);	4✔
152	vtable.try_into_inner = \|\| Some(try_into_inner::<T>);	1✔
NEW 153	vtable.try_borrow_inner = \|\| Some(try_borrow_inner::<T>);	×
154	vtable
155	};
156
157	const SHAPE: &'static crate::Shape<'static> = &const {
158	// Function to return inner type's shape
159	fn inner_shape<'a, T: Facet<'a> + ?Sized>() -> &'static Shape<'static> {	7✔
160	T::SHAPE	7✔
161	}	7✔
162
163	crate::Shape::builder_for_sized::<Self>()
164	.type_params(&[crate::TypeParam {
165	name: "T",
166	shape: \|\| T::SHAPE,
167	}])
168	.ty(Type::User(UserType::Opaque))
169	.def(Def::SmartPointer(
170	SmartPointerDef::builder()
171	.pointee(\|\| T::SHAPE)
172	.flags(SmartPointerFlags::ATOMIC)
173	.known(KnownSmartPointer::Arc)
174	.weak(\|\| <alloc::sync::Weak<T> as Facet>::SHAPE)
175	.vtable(
176	&const {
177	SmartPointerVTable::builder()
178	.borrow_fn(\|this\| {	3✔
179	let ptr = Self::as_ptr(unsafe { this.get() });	3✔
180	PtrConst::new(ptr)	3✔
181	})	3✔
182	.new_into_fn(\|this, ptr\| {	4✔
183	use alloc::sync::Arc;
184
185	let layout = match T::SHAPE.layout {	4✔
186	ShapeLayout::Sized(layout) => layout,	4✔
187	ShapeLayout::Unsized => panic!("nope"),	×
188	};
189
190	let size_of_arc_header = core::mem::size_of::<usize>() * 2;	4✔
191
192	// we don't know the layout of dummy_arc, but we can tell its size and we can copy it
193	// in front of the `PtrMut`
194	let arc_layout = unsafe {	4✔
195	Layout::from_size_align_unchecked(	4✔
196	size_of_arc_header + layout.size(),	4✔
197	layout.align(),	4✔
198	)
199	};
200	let mem = unsafe { alloc::alloc::alloc(arc_layout) };	4✔
201
202	unsafe {	4✔
203	// Copy the Arc header (including refcounts, vtable pointers, etc.) from a freshly-allocated Arc<()>	4✔
204	// so that the struct before the T value is a valid Arc header.	4✔
205	let dummy_arc = alloc::sync::Arc::new(());	4✔
206	let header_start = (Arc::as_ptr(&dummy_arc) as *const u8)	4✔
207	.sub(size_of_arc_header);	4✔
208	core::ptr::copy_nonoverlapping(	4✔
209	header_start,	4✔
210	mem,	4✔
211	size_of_arc_header,	4✔
212	);	4✔
213		4✔
214	// Copy the value for T, pointed to by `ptr`, into the bytes just after the Arc header	4✔
215	core::ptr::copy_nonoverlapping(	4✔
216	ptr.as_byte_ptr(),	4✔
217	mem.add(size_of_arc_header),	4✔
218	layout.size(),	4✔
219	);	4✔
220	}	4✔
221
222	// Safety: `mem` is valid and contains a valid Arc header and valid T.
223	let ptr = unsafe { mem.add(size_of_arc_header) };	4✔
224	let t_ptr: *mut T = unsafe { core::mem::transmute_copy(&ptr) };	4✔
225	// Safety: This is the pointer to the Arc header + value; from_raw assumes a pointer to T located immediately after the Arc header.
226	let arc = unsafe { Arc::from_raw(t_ptr) };	4✔
227	// Move the Arc into the destination (this) and return a PtrMut for it.
228	unsafe { this.put(arc) }	4✔
229	})	4✔
230	.downgrade_into_fn(\|strong, weak\| unsafe {
231	weak.put(alloc::sync::Arc::downgrade(strong.get::<Self>()))	2✔
232	})	2✔
233	.build()
234	},
235	)
236	.build(),
237	))
238	.inner(inner_shape::<T>)
239	.build()
240	};
241	}
242
243	unsafe impl<'a, T: Facet<'a>> Facet<'a> for alloc::sync::Weak<T> {
244	const VTABLE: &'static ValueVTable = &const {
245	value_vtable!(alloc::sync::Weak<T>, \|f, opts\| {	×
246	write!(f, "Weak")?;	×
247	if let Some(opts) = opts.for_children() {	×
248	write!(f, "<")?;	×
249	(T::SHAPE.vtable.type_name)(f, opts)?;	×
250	write!(f, ">")?;	×
251	} else {
252	write!(f, "<…>")?;	×
253	}
254	Ok(())	×
255	})	×
256	};
257
258	const SHAPE: &'static crate::Shape<'static> = &const {
259	// Function to return inner type's shape
260	fn inner_shape<'a, T: Facet<'a> + ?Sized>() -> &'static Shape<'static> {	×
261	T::SHAPE	×
262	}	×
263
264	crate::Shape::builder_for_sized::<Self>()
265	.type_params(&[crate::TypeParam {
266	name: "T",
267	shape: \|\| T::SHAPE,
268	}])
269	.ty(Type::User(UserType::Opaque))
270	.def(Def::SmartPointer(
271	SmartPointerDef::builder()
272	.pointee(\|\| T::SHAPE)
273	.flags(SmartPointerFlags::ATOMIC.union(SmartPointerFlags::WEAK))
274	.known(KnownSmartPointer::ArcWeak)
275	.strong(\|\| <alloc::sync::Arc<T> as Facet>::SHAPE)
276	.vtable(
277	&const {
278	SmartPointerVTable::builder()
279	.upgrade_into_fn(\|weak, strong\| unsafe {
280	Some(strong.put(weak.get::<Self>().upgrade()?))	2✔
281	})	2✔
282	.build()
283	},
284	)
285	.build(),
286	))
287	.inner(inner_shape::<T>)
288	.build()
289	};
290	}
291
292	#[cfg(test)]
293	mod tests {
294	use alloc::string::String;
295	use alloc::sync::{Arc, Weak as ArcWeak};
296
297	use super::*;
298
299	#[test]
300	fn test_arc_type_params() {	1✔
301	let [type_param_1] = <Arc<i32>>::SHAPE.type_params else {	1✔
302	panic!("Arc<T> should only have 1 type param")	×
303	};
304	assert_eq!(type_param_1.shape(), i32::SHAPE);	1✔
305	}	1✔
306
307	#[test]
308	fn test_arc_vtable_1_new_borrow_drop() -> eyre::Result<()> {	1✔
309	facet_testhelpers::setup();	1✔
310
311	let arc_shape = <Arc<String>>::SHAPE;	1✔
312	let arc_def = arc_shape	1✔
313	.def	1✔
314	.into_smart_pointer()	1✔
315	.expect("Arc<T> should have a smart pointer definition");	1✔
316
317	// Allocate memory for the Arc
318	let arc_uninit_ptr = arc_shape.allocate()?;	1✔
319
320	// Get the function pointer for creating a new Arc from a value
321	let new_into_fn = arc_def	1✔
322	.vtable	1✔
323	.new_into_fn	1✔
324	.expect("Arc<T> should have new_into_fn");	1✔
325
326	// Create the value and initialize the Arc
327	let mut value = String::from("example");	1✔
328	let arc_ptr = unsafe { new_into_fn(arc_uninit_ptr, PtrMut::new(&raw mut value)) };	1✔
329	// The value now belongs to the Arc, prevent its drop
330	core::mem::forget(value);	1✔
331
332	// Get the function pointer for borrowing the inner value
333	let borrow_fn = arc_def	1✔
334	.vtable	1✔
335	.borrow_fn	1✔
336	.expect("Arc<T> should have borrow_fn");	1✔
337
338	// Borrow the inner value and check it
339	let borrowed_ptr = unsafe { borrow_fn(arc_ptr.as_const()) };	1✔
340	// SAFETY: borrowed_ptr points to a valid String within the Arc
341	assert_eq!(unsafe { borrowed_ptr.get::<String>() }, "example");	1✔
342
343	// Get the function pointer for dropping the Arc
344	let drop_fn = (arc_shape.vtable.drop_in_place)().expect("Arc<T> should have drop_in_place");	1✔
345
346	// Drop the Arc in place
347	// SAFETY: arc_ptr points to a valid Arc<String>
348	unsafe { drop_fn(arc_ptr) };	1✔
349
350	// Deallocate the memory
351	// SAFETY: arc_ptr was allocated by arc_shape and is now dropped (but memory is still valid)
352	unsafe { arc_shape.deallocate_mut(arc_ptr)? };	1✔
353
354	Ok(())	1✔
355	}	1✔
356
357	#[test]
358	fn test_arc_vtable_2_downgrade_upgrade_drop() -> eyre::Result<()> {	1✔
359	facet_testhelpers::setup();	1✔
360
361	let arc_shape = <Arc<String>>::SHAPE;	1✔
362	let arc_def = arc_shape	1✔
363	.def	1✔
364	.into_smart_pointer()	1✔
365	.expect("Arc<T> should have a smart pointer definition");	1✔
366
367	let weak_shape = <ArcWeak<String>>::SHAPE;	1✔
368	let weak_def = weak_shape	1✔
369	.def	1✔
370	.into_smart_pointer()	1✔
371	.expect("ArcWeak<T> should have a smart pointer definition");	1✔
372
373	// 1. Create the first Arc (arc1)
374	let arc1_uninit_ptr = arc_shape.allocate()?;	1✔
375	let new_into_fn = arc_def.vtable.new_into_fn.unwrap();	1✔
376	let mut value = String::from("example");	1✔
377	let arc1_ptr = unsafe { new_into_fn(arc1_uninit_ptr, PtrMut::new(&raw mut value)) };	1✔
378	core::mem::forget(value); // Value now owned by arc1	1✔
379
380	// 2. Downgrade arc1 to create a weak pointer (weak1)
381	let weak1_uninit_ptr = weak_shape.allocate()?;	1✔
382	let downgrade_into_fn = arc_def.vtable.downgrade_into_fn.unwrap();	1✔
383	// SAFETY: arc1_ptr points to a valid Arc, weak1_uninit_ptr is allocated for a Weak
384	let weak1_ptr = unsafe { downgrade_into_fn(arc1_ptr, weak1_uninit_ptr) };	1✔
385
386	// 3. Upgrade weak1 to create a second Arc (arc2)
387	let arc2_uninit_ptr = arc_shape.allocate()?;	1✔
388	let upgrade_into_fn = weak_def.vtable.upgrade_into_fn.unwrap();	1✔
389	// SAFETY: weak1_ptr points to a valid Weak, arc2_uninit_ptr is allocated for an Arc.
390	// Upgrade should succeed as arc1 still exists.
391	let arc2_ptr = unsafe { upgrade_into_fn(weak1_ptr, arc2_uninit_ptr) }	1✔
392	.expect("Upgrade should succeed while original Arc exists");	1✔
393
394	// Check the content of the upgraded Arc
395	let borrow_fn = arc_def.vtable.borrow_fn.unwrap();	1✔
396	// SAFETY: arc2_ptr points to a valid Arc<String>
397	let borrowed_ptr = unsafe { borrow_fn(arc2_ptr.as_const()) };	1✔
398	// SAFETY: borrowed_ptr points to a valid String
399	assert_eq!(unsafe { borrowed_ptr.get::<String>() }, "example");	1✔
400
401	// 4. Drop everything and free memory
402	let arc_drop_fn = (arc_shape.vtable.drop_in_place)().unwrap();	1✔
403	let weak_drop_fn = (weak_shape.vtable.drop_in_place)().unwrap();	1✔
404
405	unsafe {
406	// Drop Arcs
407	arc_drop_fn(arc1_ptr);	1✔
408	arc_shape.deallocate_mut(arc1_ptr)?;	1✔
409	arc_drop_fn(arc2_ptr);	1✔
410	arc_shape.deallocate_mut(arc2_ptr)?;	1✔
411
412	// Drop Weak
413	weak_drop_fn(weak1_ptr);	1✔
414	weak_shape.deallocate_mut(weak1_ptr)?;	1✔
415	}
416
417	Ok(())	1✔
418	}	1✔
419
420	#[test]
421	fn test_arc_vtable_3_downgrade_drop_try_upgrade() -> eyre::Result<()> {	1✔
422	facet_testhelpers::setup();	1✔
423
424	let arc_shape = <Arc<String>>::SHAPE;	1✔
425	let arc_def = arc_shape	1✔
426	.def	1✔
427	.into_smart_pointer()	1✔
428	.expect("Arc<T> should have a smart pointer definition");	1✔
429
430	let weak_shape = <ArcWeak<String>>::SHAPE;	1✔
431	let weak_def = weak_shape	1✔
432	.def	1✔
433	.into_smart_pointer()	1✔
434	.expect("ArcWeak<T> should have a smart pointer definition");	1✔
435
436	// 1. Create the strong Arc (arc1)
437	let arc1_uninit_ptr = arc_shape.allocate()?;	1✔
438	let new_into_fn = arc_def.vtable.new_into_fn.unwrap();	1✔
439	let mut value = String::from("example");	1✔
440	let arc1_ptr = unsafe { new_into_fn(arc1_uninit_ptr, PtrMut::new(&raw mut value)) };	1✔
441	core::mem::forget(value);	1✔
442
443	// 2. Downgrade arc1 to create a weak pointer (weak1)
444	let weak1_uninit_ptr = weak_shape.allocate()?;	1✔
445	let downgrade_into_fn = arc_def.vtable.downgrade_into_fn.unwrap();	1✔
446	// SAFETY: arc1_ptr is valid, weak1_uninit_ptr is allocated for Weak
447	let weak1_ptr = unsafe { downgrade_into_fn(arc1_ptr, weak1_uninit_ptr) };	1✔
448
449	// 3. Drop and free the strong pointer (arc1)
450	let arc_drop_fn = (arc_shape.vtable.drop_in_place)().unwrap();	1✔
451	unsafe {
452	arc_drop_fn(arc1_ptr);	1✔
453	arc_shape.deallocate_mut(arc1_ptr)?;	1✔
454	}
455
456	// 4. Attempt to upgrade the weak pointer (weak1)
457	let upgrade_into_fn = weak_def.vtable.upgrade_into_fn.unwrap();	1✔
458	let arc2_uninit_ptr = arc_shape.allocate()?;	1✔
459	// SAFETY: weak1_ptr is valid (though points to dropped data), arc2_uninit_ptr is allocated for Arc
460	let upgrade_result = unsafe { upgrade_into_fn(weak1_ptr, arc2_uninit_ptr) };	1✔
461
462	// Assert that the upgrade failed
463	assert!(	1✔
464	upgrade_result.is_none(),	1✔
465	"Upgrade should fail after the strong Arc is dropped"	×
466	);
467
468	// 5. Clean up: Deallocate the memory intended for the failed upgrade and drop/deallocate the weak pointer
469	let weak_drop_fn = (weak_shape.vtable.drop_in_place)().unwrap();	1✔
470	unsafe {
471	// Deallocate the uninitialized memory allocated for the failed upgrade attempt
472	arc_shape.deallocate_uninit(arc2_uninit_ptr)?;	1✔
473
474	// Drop and deallocate the weak pointer
475	weak_drop_fn(weak1_ptr);	1✔
476	weak_shape.deallocate_mut(weak1_ptr)?;	1✔
477	}
478
479	Ok(())	1✔
480	}	1✔
481
482	#[test]
483	fn test_arc_vtable_4_try_from() -> eyre::Result<()> {	1✔
484	facet_testhelpers::setup();	1✔
485
486	// Get the shapes we'll be working with
487	let string_shape = <String>::SHAPE;	1✔
488	let arc_shape = <Arc<String>>::SHAPE;	1✔
489	let arc_def = arc_shape	1✔
490	.def	1✔
491	.into_smart_pointer()	1✔
492	.expect("Arc<T> should have a smart pointer definition");	1✔
493
494	// 1. Create a String value
495	let value = String::from("try_from test");	1✔
496	let value_ptr = PtrConst::new(&value as const String as const u8);	1✔
497
498	// 2. Allocate memory for the Arc<String>
499	let arc_uninit_ptr = arc_shape.allocate()?;	1✔
500
501	// 3. Get the try_from function from the Arc<String> shape's ValueVTable
502	let try_from_fn = (arc_shape.vtable.try_from)().expect("Arc<T> should have try_from");	1✔
503
504	// 4. Try to convert String to Arc<String>
505	let arc_ptr = unsafe { try_from_fn(value_ptr, string_shape, arc_uninit_ptr) }	1✔
506	.expect("try_from should succeed");	1✔
507	core::mem::forget(value);	1✔
508
509	// 5. Borrow the inner value and verify it's correct
510	let borrow_fn = arc_def	1✔
511	.vtable	1✔
512	.borrow_fn	1✔
513	.expect("Arc<T> should have borrow_fn");	1✔
514	let borrowed_ptr = unsafe { borrow_fn(arc_ptr.as_const()) };	1✔
515
516	// SAFETY: borrowed_ptr points to a valid String within the Arc
517	assert_eq!(unsafe { borrowed_ptr.get::<String>() }, "try_from test");	1✔
518
519	// 6. Clean up
520	let drop_fn = (arc_shape.vtable.drop_in_place)().expect("Arc<T> should have drop_in_place");	1✔
521
522	unsafe {
523	drop_fn(arc_ptr);	1✔
524	arc_shape.deallocate_mut(arc_ptr)?;	1✔
525	}
526
527	Ok(())	1✔
528	}	1✔
529
530	#[test]
531	fn test_arc_vtable_5_try_into_inner() -> eyre::Result<()> {	1✔
532	facet_testhelpers::setup();	1✔
533
534	// Get the shapes we'll be working with
535	let string_shape = <String>::SHAPE;	1✔
536	let arc_shape = <Arc<String>>::SHAPE;	1✔
537	let arc_def = arc_shape	1✔
538	.def	1✔
539	.into_smart_pointer()	1✔
540	.expect("Arc<T> should have a smart pointer definition");	1✔
541
542	// 1. Create an Arc<String>
543	let arc_uninit_ptr = arc_shape.allocate()?;	1✔
544	let new_into_fn = arc_def	1✔
545	.vtable	1✔
546	.new_into_fn	1✔
547	.expect("Arc<T> should have new_into_fn");	1✔
548
549	let mut value = String::from("try_into_inner test");	1✔
550	let arc_ptr = unsafe { new_into_fn(arc_uninit_ptr, PtrMut::new(&raw mut value)) };	1✔
551	core::mem::forget(value); // Value now owned by arc	1✔
552
553	// 2. Allocate memory for the extracted String
554	let string_uninit_ptr = string_shape.allocate()?;	1✔
555
556	// 3. Get the try_into_inner function from the Arc<String>'s ValueVTable
557	let try_into_inner_fn =	1✔
558	(arc_shape.vtable.try_into_inner)().expect("Arc<T> Shape should have try_into_inner");	1✔
559
560	// 4. Try to extract the String from the Arc<String>
561	// This should succeed because we have exclusive access to the Arc (strong count = 1)
562	let string_ptr = unsafe { try_into_inner_fn(arc_ptr, string_uninit_ptr) }	1✔
563	.expect("try_into_inner should succeed with exclusive access");	1✔
564
565	// 5. Verify the extracted String
566	assert_eq!(	1✔
567	unsafe { string_ptr.as_const().get::<String>() },	1✔
568	"try_into_inner test"
569	);
570
571	// 6. Clean up
572	let string_drop_fn =	1✔
573	(string_shape.vtable.drop_in_place)().expect("String should have drop_in_place");	1✔
574
575	unsafe {
576	// The Arc should already be dropped by try_into_inner
577	// But we still need to deallocate its memory
578	arc_shape.deallocate_mut(arc_ptr)?;	1✔
579
580	// Drop and deallocate the extracted String
581	string_drop_fn(string_ptr);	1✔
582	string_shape.deallocate_mut(string_ptr)?;	1✔
583	}
584
585	Ok(())	1✔
586	}	1✔
587	}

facet-rs / facet / 15200164445

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