Revert "Make GcRef a trait once again"

This reverts commit d2ab662.

We all make mistakes, don't we? ;)

Author: Techcable

libs/context/src/collector.rs

@@ -8,7 +8,7 @@ use alloc::sync::Arc;
 
 use slog::{Logger, o};
 
-use zerogc::{GcRef, GcSafe, GcSystem, Trace, GcSimpleAlloc, NullTrace, TraceImmutable, GcVisitor};
+use zerogc::{Gc, GcSafe, GcSystem, Trace, GcSimpleAlloc, NullTrace, TraceImmutable, GcVisitor};
 
 use crate::{CollectorContext};
 use crate::state::{CollectionManager, RawContext};
@@ -54,7 +54,11 @@ pub unsafe trait RawCollectorImpl: 'static + Sized {
     fn id(&self) -> CollectorId<Self> {
         CollectorId { ptr: unsafe { Self::Ptr::from_raw(self as *const _ as *mut _) } }
     }
-
+    unsafe fn gc_write_barrier<'gc, T, V>(
+        owner: &Gc<'gc, T, CollectorId<Self>>,
+        value: &Gc<'gc, V, CollectorId<Self>>,
+        field_offset: usize
+    ) where T: GcSafe + ?Sized + 'gc, V: GcSafe + ?Sized + 'gc;
     /// The logger associated with this collector
     fn logger(&self) -> &Logger;
 
@@ -272,6 +276,15 @@ impl<C: RawCollectorImpl> CollectorId<C> {
 unsafe impl<C: RawCollectorImpl> ::zerogc::CollectorId for CollectorId<C> {
     type System = CollectorRef<C>;
 
+    #[inline(always)]
+    unsafe fn gc_write_barrier<'gc, T, V>(
+        owner: &Gc<'gc, T, Self>,
+        value: &Gc<'gc, V, Self>,
+        field_offset: usize
+    ) where T: GcSafe + ?Sized + 'gc, V: GcSafe + ?Sized + 'gc {
+        C::gc_write_barrier(owner, value, field_offset)
+    }
+
     #[inline]
     unsafe fn assume_valid_system(&self) -> &Self::System {
         // TODO: Make the API nicer? (avoid borrowing and indirection)
@@ -317,21 +330,13 @@ impl<C: RawCollectorImpl> WeakCollectorRef<C> {
     }
 }
 
-pub unsafe trait RawSimpleAlloc<'gc, T>: RawCollectorImpl 
-    where T: GcSafe + 'gc {
-    /// The type of GC references that are returned
-    type Gc: GcRef<'gc, T, Id=CollectorId<Self>>;
-    /// Allocate a new garbage collected reference
-    fn alloc(
-        context: &'gc CollectorContext<Self>,
-        value: T
-    ) -> Self::Gc;
+pub unsafe trait RawSimpleAlloc: RawCollectorImpl {
+    fn alloc<'gc, T: GcSafe + 'gc>(context: &'gc CollectorContext<Self>, value: T) -> Gc<'gc, T, CollectorId<Self>>;
 }
 unsafe impl<'gc, T, C> GcSimpleAlloc<'gc, T> for CollectorContext<C>
-    where T: GcSafe + 'gc, C: RawSimpleAlloc<'gc, T> {
-    type Gc = C::Gc;
+    where T: GcSafe + 'gc, C: RawSimpleAlloc {
     #[inline]
-    fn alloc(&'gc self, value: T) -> C::Gc {
+    fn alloc(&'gc self, value: T) -> Gc<'gc, T, Self::Id> {
         C::alloc(self, value)
     }
 }

libs/context/src/handle.rs

@@ -9,7 +9,7 @@ use alloc::boxed::Box;
 use alloc::vec::Vec;
 
 use zerogc::{Trace, GcSafe, GcErase, GcRebrand, GcVisitor, NullTrace, TraceImmutable, GcHandleSystem, GcBindHandle};
-use crate::{GcRef, WeakCollectorRef, CollectorId, CollectorContext, CollectorRef, CollectionManager};
+use crate::{Gc, WeakCollectorRef, CollectorId, CollectorContext, CollectorRef, CollectionManager};
 use crate::collector::RawCollectorImpl;
 
 const INITIAL_HANDLE_CAPACITY: usize = 64;
@@ -23,13 +23,6 @@ pub unsafe trait RawHandleImpl: RawCollectorImpl {
 
     fn handle_list(&self) -> &GcHandleList<Self>;
 }
-/// A type hack on [RawHandleImpl] to get the associated type
-/// of [::zerogc::GcRef]
-///
-/// This is needed because we don't have generic associated types (yet)
-pub trait RawHandleImplHack<'gc, T: GcSafe + 'gc>: RawHandleImpl {
-    type Gc: GcRef<'gc, T, Id=CollectorId<Self>>;
-}
 
 /// Concurrent list of [GcHandle]s
 ///
@@ -445,10 +438,9 @@ unsafe impl<T: GcSafe, C: RawHandleImpl> ::zerogc::GcHandle<T> for GcHandle<T, C
 }
 unsafe impl<'new_gc, T, C> GcBindHandle<'new_gc, T> for GcHandle<T, C>
     where T: GcSafe, T: GcRebrand<'new_gc, CollectorId<C>>,
-          T::Branded: GcSafe, C: RawHandleImplHack<'new_gc, T::Branded> {
-    type Gc = C::Gc;
+          T::Branded: GcSafe, C: RawHandleImpl {
     #[inline]
-    fn bind_to(&self, context: &'new_gc CollectorContext<C>) -> Self::Gc {
+    fn bind_to(&self, context: &'new_gc CollectorContext<C>) -> Gc<'new_gc, T::Branded, CollectorId<C>> {
         /*
          * We can safely assume the object will
          * be as valid as long as the context.
@@ -473,7 +465,7 @@ unsafe impl<'new_gc, T, C> GcBindHandle<'new_gc, T> for GcHandle<T, C>
             let value = inner.value.load(Ordering::Acquire)
                 as *mut T as *mut T::Branded;
             debug_assert!(!value.is_null());
-            Self::Gc::from_raw(
+            Gc::from_raw(
                 collector,
                 NonNull::new_unchecked(value)
             )
@@ -605,15 +597,14 @@ unsafe impl<T: GcSafe + Sync, C: RawHandleImpl + Sync> Sync for GcHandle<T, C> {
 
 /// We support handles
 unsafe impl<'gc, 'a, T, C> GcHandleSystem<'gc, 'a, T> for CollectorRef<C>
-    where C: RawHandleImplHack<'gc, T>,
+    where C: RawHandleImpl,
           T: GcSafe + 'gc,
           T: GcErase<'a, CollectorId<C>>,
           T::Erased: GcSafe {
-    type Gc = C::Gc;
     type Handle = GcHandle<T::Erased, C>;
 
     #[inline]
-    fn create_handle(gc: Self::Gc) -> Self::Handle {
+    fn create_handle(gc: Gc<'gc, T, CollectorId<C>>) -> Self::Handle {
         unsafe {
             let collector = gc.collector_id();
             let value = gc.as_raw_ptr();

libs/context/src/lib.rs

@@ -28,6 +28,7 @@ use alloc::vec::Vec;
 use zerogc::prelude::*;
 
 pub mod state;
+
 pub mod utils;
 pub mod collector;
 pub mod handle;

libs/derive/src/lib.rs

@@ -601,9 +601,9 @@ fn impl_extras(target: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStream, E
                     let barrier = quote_spanned!(field.span() => #zerogc_crate::GcDirectBarrier::write_barrier(&value, &self, offset));
                     extra_items.push(quote! {
                         #[inline] // TODO: Implement `GcDirectBarrier` ourselves
-                        #mutator_vis fn #mutator_name<G>(self: G, value: #value_ref_type)
-                            where G: #zerogc_crate::GcRef<#gc_lifetime, Self>,
-                                   #value_ref_type: #zerogc_crate::GcDirectBarrier<#gc_lifetime, G> {
+                        #mutator_vis fn #mutator_name<Id>(self: #zerogc_crate::Gc<#gc_lifetime, Self, Id>, value: #value_ref_type)
+                            where Id: #zerogc_crate::CollectorId,
+                                   #value_ref_type: #zerogc_crate::GcDirectBarrier<#gc_lifetime, #zerogc_crate::Gc<#gc_lifetime, Self, Id>> {
                             unsafe {
                                 let target_ptr = #field_as_ptr;
                                 let offset = target_ptr as usize - self.as_raw_ptr() as usize;

libs/simple/examples/binary_trees.rs

@@ -69,7 +69,7 @@ fn main() {
 
     let long_lived_tree = bottom_up_tree(&gc, max_depth);
 
-    let (long_lived_tree, ()) = safepoint_recurse!(gc, long_lived_tree, |gc, _long_lived_tree| {
+    let (long_lived_tree, ()) = safepoint_recurse!(gc, long_lived_tree, |gc, long_lived_tree| {
         (min_depth / 2..max_depth / 2 + 1).into_iter().for_each(|half_depth| {
             let depth = half_depth * 2;
             let iterations = 1 << ((max_depth - depth + min_depth) as u32);

libs/simple/src/gc.rs

@@ -31,14 +31,14 @@ use std::any::TypeId;
 
 use slog::{Logger, FnValue, debug};
 
-use zerogc::{GcSafe, Trace, GcVisitor, GcRef};
+use zerogc::{GcSafe, Trace, GcVisitor};
 
 use zerogc_context::utils::{ThreadId, AtomicCell, MemorySize};
 
 use crate::alloc::{SmallArenaList, small_object_size};
 
 use zerogc_context::collector::{RawSimpleAlloc};
-use zerogc_context::handle::{GcHandleList, RawHandleImpl, RawHandleImplHack};
+use zerogc_context::handle::{GcHandleList, RawHandleImpl};
 use zerogc_context::{
     CollectionManager as AbstractCollectionManager,
     RawContext as AbstractRawContext
@@ -67,9 +67,6 @@ mod alloc {
         pub fn find<T>(&self) -> Option<FakeArena> { None }
     }
 }
-mod gc;
-
-pub use self::gc::Gc;
 
 #[cfg(feature = "sync")]
 type RawContext<C> = zerogc_context::state::sync::RawContext<C>;
@@ -84,14 +81,14 @@ type CollectionManager<C> = zerogc_context::state::nosync::CollectionManager<C>;
 pub type SimpleCollector = ::zerogc_context::CollectorRef<RawSimpleCollector>;
 pub type SimpleCollectorContext = ::zerogc_context::CollectorContext<RawSimpleCollector>;
 pub type CollectorId = ::zerogc_context::CollectorId<RawSimpleCollector>;
+pub type Gc<'gc, T> = ::zerogc::Gc<'gc, T, CollectorId>;
 
 #[cfg(not(feature = "multiple-collectors"))]
 static GLOBAL_COLLECTOR: AtomicPtr<RawSimpleCollector> = AtomicPtr::new(std::ptr::null_mut());
 
-unsafe impl<'gc, T: GcSafe + 'gc> RawSimpleAlloc<'gc, T> for RawSimpleCollector {
-    type Gc = Gc<'gc, T>;
+unsafe impl RawSimpleAlloc for RawSimpleCollector {
     #[inline]
-    fn alloc(context: &'gc SimpleCollectorContext, value: T) -> Gc<'gc, T> where T: GcSafe + 'gc {
+    fn alloc<'gc, T>(context: &'gc SimpleCollectorContext, value: T) -> Gc<'gc, T> where T: GcSafe + 'gc {
         context.collector().heap.allocator.alloc(value)
     }
 }
@@ -119,9 +116,6 @@ unsafe impl RawHandleImpl for RawSimpleCollector {
         &self.handle_list
     }
 }
-impl<'gc, T: GcSafe + 'gc> RawHandleImplHack<'gc, T> for RawSimpleCollector {
-    type Gc = Gc<'gc, T>;
-}
 
 /// A wrapper for [GcHandleList] that implements [DynTrace]
 #[repr(transparent)]
@@ -473,6 +467,14 @@ unsafe impl ::zerogc_context::collector::RawCollectorImpl for RawSimpleCollector
         raw_ptr
     }
 
+    #[inline(always)]
+    unsafe fn gc_write_barrier<'gc, T, V>(
+        _owner: &Gc<'gc, T>,
+        _value: &Gc<'gc, V>,
+        _field_offset: usize
+    ) where T: GcSafe + ?Sized + 'gc, V: GcSafe + ?Sized + 'gc {
+        // Simple GC doesn't need write barriers
+    }
     #[inline]
     fn logger(&self) -> &Logger {
         &self.logger
@@ -674,20 +676,20 @@ unsafe impl GcVisitor for MarkVisitor<'_> {
     type Err = !;
 
     #[inline]
-    unsafe fn visit_gc<'gc, T, G>(
-        &mut self, gc: &mut G
+    unsafe fn visit_gc<'gc, T, Id>(
+        &mut self, gc: &mut ::zerogc::Gc<'gc, T, Id>
     ) -> Result<(), Self::Err>
-        where T: GcSafe + 'gc, G: GcRef<'gc, T> {
-        if TypeId::of::<G::Id>() == TypeId::of::<crate::CollectorId>() {
+        where T: GcSafe + 'gc, Id: ::zerogc::CollectorId {
+        if TypeId::of::<Id>() == TypeId::of::<crate::CollectorId>() {
             /*
              * Since the `TypeId`s match, we know the generic `Id`
              * matches our own `crate::CollectorId`.
              * Therefore its safe to specific the generic `Id` into the
              * `Gc` into its more specific type.
              */
             let gc = std::mem::transmute::<
-                &mut G,
-                &mut crate::gc::Gc<'gc, T>
+                &mut ::zerogc::Gc<'gc, T, Id>,
+                &mut ::zerogc::Gc<'gc, T, crate::CollectorId>
             >(gc);
             /*
              * Check the collectors match. Otherwise we're mutating