refactor: move RootNode, Root and RootLink into separate root module

Author: shruti2522

oscars/src/collectors/mark_sweep_branded/gc.rs

@@ -1,20 +1,15 @@
 //! Core pointer types.
 
 use crate::{
-    alloc::mempool3::{PoolAllocator, PoolPointer},
+    alloc::mempool3::PoolPointer,
     collectors::mark_sweep_branded::{
         gc_box::GcBox,
-        mutation_ctx::MutationContext,
-        root_link::RootLink,
         trace::{Finalize, Trace},
     },
 };
 use core::fmt;
 use core::marker::PhantomData;
 use core::ops::Deref;
-use core::ptr::NonNull;
-
-pub(crate) type RootDropFn = unsafe fn(&mut PoolAllocator<'static>, NonNull<u8>);
 
 /// A transient pointer to a GC-managed value.
 #[derive(Debug)]
@@ -55,62 +50,6 @@ impl<'gc, T: Trace + 'gc> Deref for Gc<'gc, T> {
     }
 }
 
-/// Heap node backing a `Root`.
-#[repr(C)]
-pub(crate) struct RootNode<'id, T: Trace> {
-    /// Intrusive list link
-    pub(crate) link: RootLink,
-    /// Pointer to the allocation
-    pub(crate) gc_ptr: PoolPointer<'static, GcBox<T>>,
-    /// Type-erased drop function for freeing this RootNode
-    pub(crate) drop_fn: RootDropFn,
-    /// Raw pointer to the Collector for freeing this node
-    pub(crate) collector_ptr: *const crate::collectors::mark_sweep_branded::Collector,
-    pub(crate) _marker: PhantomData<*mut &'id ()>,
-}
-
-/// Type-erased version of [`RootNode`] for use during collection.
-///
-/// Since [`RootNode`] is `repr(C)` and `link` is always the first field,
-/// a `NonNull<RootLink>` from the sentinel iterator can be safely cast to
-/// `NonNull<ErasedRootNode>` to read `gc_ptr` without knowing `T`.
-#[repr(C)]
-pub(crate) struct ErasedRootNode {
-    pub(crate) link: RootLink,
-    pub(crate) gc_ptr: PoolPointer<'static, GcBox<()>>,
-}
-
-/// A handle that keeps a GC allocation live.
-#[must_use = "dropping a root unregisters it from the GC"]
-pub struct Root<'id, T: Trace> {
-    pub(crate) raw: NonNull<RootNode<'id, T>>,
-}
-
-impl<'id, T: Trace> Root<'id, T> {
-    /// Converts this root into a `Gc` pointer
-    pub fn get<'gc>(&self, _cx: &MutationContext<'id, 'gc>) -> Gc<'gc, T> {
-        Gc {
-            // SAFETY: `raw` is non-null and valid.
-            ptr: unsafe { self.raw.as_ref().gc_ptr },
-            _marker: PhantomData,
-        }
-    }
-}
-
-impl<'id, T: Trace> Drop for Root<'id, T> {
-    fn drop(&mut self) {
-        unsafe {
-            let node_ref = self.raw.as_ref();
-            if node_ref.link.is_linked() {
-                RootLink::unlink(NonNull::from(&node_ref.link));
-            }
-            // SAFETY: collector_ptr is valid for the lifetime of the GcContext
-            let collector = &*node_ref.collector_ptr;
-            collector.free_root_node(self.raw.cast::<u8>(), node_ref.drop_fn);
-        }
-    }
-}
-
 impl<T: Trace> Finalize for Gc<'_, T> {}
 impl<T: Trace> Trace for Gc<'_, T> {
     fn trace(&mut self, tracer: &mut crate::collectors::mark_sweep_branded::trace::Tracer) {

oscars/src/collectors/mark_sweep_branded/mod.rs

@@ -6,7 +6,7 @@ pub mod ephemeron;
 pub mod gc;
 pub mod gc_box;
 pub mod mutation_ctx;
-pub mod root_link;
+pub mod root;
 pub mod trace;
 pub mod weak;
 
@@ -15,8 +15,9 @@ mod tests;
 
 pub use cell::GcRefCell;
 pub use ephemeron::Ephemeron;
-pub use gc::{Gc, Root};
+pub use gc::Gc;
 pub use mutation_ctx::MutationContext;
+pub use root::Root;
 pub use trace::{Finalize, Trace, Tracer};
 pub use weak::WeakGc;
 
@@ -25,7 +26,7 @@ use core::cell::{Cell, RefCell};
 use core::marker::PhantomData;
 use core::ptr::NonNull;
 use gc_box::{DropFn, GcBox, GcColor};
-use root_link::RootSentinel;
+use root::RootSentinel;
 use rust_alloc::vec::Vec;
 
 /// Type-erased ephemeron registration.
@@ -70,39 +71,18 @@ impl Collector {
     }
 
     /// Allocates a RootNode from the dedicated root pool.
-    pub(crate) fn alloc_root_node<'id, T: trace::Trace>(
+    pub(crate) fn try_alloc_root_node<'id, T: trace::Trace>(
         &self,
         gc_ptr: PoolPointer<'static, GcBox<T>>,
-    ) -> NonNull<gc::RootNode<'id, T>> {
-        unsafe fn drop_and_free<T: trace::Trace>(
-            pool: &mut PoolAllocator<'static>,
-            ptr: NonNull<u8>,
-        ) {
-            use crate::alloc::mempool3::PoolItem;
-            unsafe {
-                let typed_ptr = ptr.cast::<PoolItem<gc::RootNode<'_, T>>>();
-                core::ptr::drop_in_place(typed_ptr.as_ptr());
-                pool.free_slot(ptr);
-            }
-        }
-
+    ) -> Result<NonNull<root::RootNode<'id, T>>, PoolAllocError> {
         let mut pool = self.root_pool.borrow_mut();
-        let ptr = pool
-            .try_alloc(gc::RootNode {
-                link: root_link::RootLink::new(),
-                gc_ptr,
-                drop_fn: drop_and_free::<T>,
-                collector_ptr: self as *const Collector,
-                _marker: PhantomData,
-            })
-            .expect("root pool allocation failed");
-
+        let ptr = pool.try_alloc(root::RootNode::new_in(gc_ptr, self))?;
         // SAFETY: PoolItem<T> is repr(transparent) over T; pointer address is identical.
-        ptr.as_ptr().cast::<gc::RootNode<'id, T>>()
+        Ok(ptr.as_ptr().cast::<root::RootNode<'id, T>>())
     }
 
     /// Frees a RootNode back to the root pool.
-    pub(crate) fn free_root_node(&self, ptr: NonNull<u8>, drop_fn: gc::RootDropFn) {
+    pub(crate) fn free_root_node(&self, ptr: NonNull<u8>, drop_fn: root::RootDropFn) {
         let mut pool = self.root_pool.borrow_mut();
         unsafe {
             (drop_fn)(&mut pool, ptr);
@@ -172,7 +152,7 @@ impl Collector {
                 // SAFETY: link_ptr points to the `link` field which is first in repr(C) RootNode.
                 // Casting to ErasedRootNode (also repr(C), same first two fields) lets us read
                 // gc_ptr without knowing T, avoiding manual offset arithmetic.
-                let erased = link_ptr.cast::<gc::ErasedRootNode>();
+                let erased = link_ptr.cast::<root::ErasedRootNode>();
                 tracer.mark_raw((*erased.as_ptr()).gc_ptr.as_ptr().cast::<u8>());
             }
         }
@@ -244,12 +224,12 @@ impl Drop for Collector {
         use crate::alloc::mempool3::PoolItem;
 
         // Free all root nodes first
-        let all_roots: Vec<(NonNull<u8>, gc::RootDropFn)> = self
+        let all_roots: Vec<(NonNull<u8>, root::RootDropFn)> = self
             .root_pool
             .borrow()
             .iter_live_slots()
             .map(|ptr| unsafe {
-                let drop_fn = (*ptr.cast::<PoolItem<gc::RootNode<'_, ()>>>().as_ptr())
+                let drop_fn = (*ptr.cast::<PoolItem<root::RootNode<'_, ()>>>().as_ptr())
                     .0
                     .drop_fn;
                 (ptr, drop_fn)

oscars/src/collectors/mark_sweep_branded/mutation_ctx.rs

@@ -5,9 +5,9 @@ use crate::{
     collectors::mark_sweep_branded::{
         Collector,
         ephemeron::Ephemeron,
-        gc::{Gc, Root},
+        gc::Gc,
         gc_box::GcBox,
-        root_link::RootLink,
+        root::{Root, RootLink},
         trace::{Finalize, Trace},
         weak::WeakGc,
     },
@@ -37,8 +37,11 @@ impl<'id, 'gc> MutationContext<'id, 'gc> {
     }
 
     /// Promotes a `Gc` pointer to a `Root`
-    pub fn root<T: Trace + Finalize + 'gc>(&self, gc: Gc<'gc, T>) -> Root<'id, T> {
-        let raw = self.collector.alloc_root_node(gc.ptr);
+    pub fn root<T: Trace + Finalize + 'gc>(
+        &self,
+        gc: Gc<'gc, T>,
+    ) -> Result<Root<'id, T>, PoolAllocError> {
+        let raw = self.collector.try_alloc_root_node(gc.ptr)?;
 
         // SAFETY: `raw` points to a stable `RootNode`.
         unsafe {
@@ -47,7 +50,7 @@ impl<'id, 'gc> MutationContext<'id, 'gc> {
             RootLink::link_after(sentinel_ptr, link_ptr);
         }
 
-        Root { raw }
+        Ok(Root { raw })
     }
 
     /// Creates an ephemeron binding `key` to `value`.