Make GcRef a trait once again

Author: Techcable

libs/context/src/collector.rs

@@ -8,7 +8,7 @@ use alloc::sync::Arc;
 
 use slog::{Logger, o};
 
-use zerogc::{Gc, GcSafe, GcSystem, Trace, GcSimpleAlloc, NullTrace, TraceImmutable, GcVisitor};
+use zerogc::{GcRef, GcSafe, GcSystem, Trace, GcSimpleAlloc, NullTrace, TraceImmutable, GcVisitor};
 
 use crate::{CollectorContext};
 use crate::state::{CollectionManager, RawContext};
@@ -54,11 +54,7 @@ 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;
 
@@ -276,15 +272,6 @@ 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)
@@ -330,13 +317,21 @@ impl<C: RawCollectorImpl> WeakCollectorRef<C> {
     }
 }
 
-pub unsafe trait RawSimpleAlloc: RawCollectorImpl {
-    fn alloc<'gc, T: GcSafe + 'gc>(context: &'gc CollectorContext<Self>, value: T) -> Gc<'gc, T, CollectorId<Self>>;
+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;
 }
 unsafe impl<'gc, T, C> GcSimpleAlloc<'gc, T> for CollectorContext<C>
-    where T: GcSafe + 'gc, C: RawSimpleAlloc {
+    where T: GcSafe + 'gc, C: RawSimpleAlloc<'gc, T> {
+    type Gc = C::Gc;
     #[inline]
-    fn alloc(&'gc self, value: T) -> Gc<'gc, T, Self::Id> {
+    fn alloc(&'gc self, value: T) -> C::Gc {
         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::{Gc, WeakCollectorRef, CollectorId, CollectorContext, CollectorRef, CollectionManager};
+use crate::{GcRef, WeakCollectorRef, CollectorId, CollectorContext, CollectorRef, CollectionManager};
 use crate::collector::RawCollectorImpl;
 
 const INITIAL_HANDLE_CAPACITY: usize = 64;
@@ -23,6 +23,13 @@ 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
 ///
@@ -438,9 +445,10 @@ 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: RawHandleImpl {
+          T::Branded: GcSafe, C: RawHandleImplHack<'new_gc, T::Branded> {
+    type Gc = C::Gc;
     #[inline]
-    fn bind_to(&self, context: &'new_gc CollectorContext<C>) -> Gc<'new_gc, T::Branded, CollectorId<C>> {
+    fn bind_to(&self, context: &'new_gc CollectorContext<C>) -> Self::Gc {
         /*
          * We can safely assume the object will
          * be as valid as long as the context.
@@ -465,7 +473,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());
-            Gc::from_raw(
+            Self::Gc::from_raw(
                 collector,
                 NonNull::new_unchecked(value)
             )
@@ -597,14 +605,15 @@ 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: RawHandleImpl,
+    where C: RawHandleImplHack<'gc, T>,
           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: Gc<'gc, T, CollectorId<C>>) -> Self::Handle {
+    fn create_handle(gc: Self::Gc) -> Self::Handle {
         unsafe {
             let collector = gc.collector_id();
             let value = gc.as_raw_ptr();

libs/context/src/lib.rs

@@ -28,7 +28,6 @@ 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<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>> {
+                        #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> {
                             unsafe {
                                 let target_ptr = #field_as_ptr;
                                 let offset = target_ptr as usize - self.as_raw_ptr() as usize;

libs/simple/Cargo.toml

@@ -13,6 +13,7 @@ zerogc = { path = "../..", version = "0.2.0-alpha.2" }
 once_cell = { version = "1.5", optional = true }
 # Shared impl
 zerogc-context = { path = "../context", version = "0.2.0-alpha.2", default-features = false }
+zerogc-derive = { path = "../derive", version = "0.2.0-alpha.2" }
 # Concurrency
 parking_lot = { version = "0.11", optional = true }
 # Logging

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

@@ -0,0 +1,135 @@
+//! Our specific implementation of [::zerogc::GcRef]
+
+use std::marker::PhantomData;
+use std::ptr::NonNull;
+use std::hash::{Hash, Hasher};
+
+use zerogc::prelude::*;
+use zerogc_derive::unsafe_gc_impl;
+
+use super::CollectorId as SimpleCollectorId;
+
+/// A garbage collected smart pointer
+///
+/// This is safely copyable. It can be freely
+/// dereferenced and is guarenteed to live
+/// until the next [safepoint](::zerogc::safepoint!)
+#[repr(C)]
+pub struct Gc<'gc, T: GcSafe + 'gc> {
+    ptr: NonNull<T>,
+    id: SimpleCollectorId,
+    marker: PhantomData<&'gc T>
+}
+impl<'gc, T: GcSafe + 'gc> Gc<'gc, T> {
+    /// The value of the pointer
+    ///
+    /// This is the same as [GcRef::value](::zerogc::GcRef::value)
+    /// but is available as an inherent method for convenience.
+    #[inline(always)]
+    pub fn value(&self) -> &'gc T {
+       unsafe { &*(&self.ptr as *const NonNull<T> as *const &T) }
+    }
+}
+unsafe impl<'gc, T: GcSafe + 'gc> GcRef<'gc, T> for Gc<'gc, T> {
+    type Id = SimpleCollectorId;
+    #[inline(always)]
+    fn collector_id(&self) -> Self::Id {
+        self.id
+    }
+    #[inline(always)]
+    unsafe fn from_raw(id: SimpleCollectorId, ptr: NonNull<T>) -> Self {
+        Gc { ptr, id, marker: PhantomData }
+    }
+    #[inline(always)]
+    fn value(&self) -> &'gc T {
+       unsafe { &*(&self.ptr as *const NonNull<T> as *const &T) }
+    }
+    #[inline]
+    unsafe fn as_raw_ptr(&self) -> *mut T {
+        self.ptr.as_ptr()
+    }
+    #[inline(always)]
+    fn system(&self) -> &'_ <Self::Id as CollectorId>::System {
+        // This assumption is safe - see the docs
+        unsafe { self.id.assume_valid_system() }
+    }
+}
+unsafe impl<'gc, O, V> ::zerogc::GcDirectBarrier<'gc, Gc<'gc, O>> for Gc<'gc, V>
+    where O: GcSafe + 'gc, V: GcSafe + 'gc {
+    #[inline(always)]
+    unsafe fn write_barrier(&self, _owner: &Gc<'gc, O>, _field_offset: usize) {
+        // This is a NOP 
+    }
+}
+impl<'gc, T: GcSafe + 'gc> Copy for Gc<'gc, T> {}
+impl<'gc, T: GcSafe + 'gc> Clone for Gc<'gc, T> {
+    #[inline(always)]
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+unsafe_gc_impl!(
+    target => Gc<'gc, T>,
+    params => ['gc, T: GcSafe + 'gc],
+    null_trace => never,
+    bounds => {
+        TraceImmutable => never,
+        GcRebrand => { where T: GcRebrand<'new_gc, Id>, T::Branded: GcSafe },
+        GcErase => { where T: GcErase<'min, Id>, T::Erased: GcSafe }
+    },
+    branded_type => Gc<'new_gc, T::Branded>,
+    erased_type => Gc<'min, T::Erased>,
+    NEEDS_TRACE => true, // We're the whole point
+    NEEDS_DROP => false, // Copy
+    trace_mut => |self, visitor| {
+        unsafe { visitor.visit_gc(self) }
+    }
+);
+impl<'gc, T: GcSafe +'gc> std::ops::Deref for Gc<'gc, T> {
+    type Target = &'gc T;
+    #[inline(always)]
+    fn deref(&self) -> &&'gc T {
+        unsafe { &*(&self.ptr as *const NonNull<T> as *const &T) }
+    }
+}
+
+impl<'gc, T> PartialEq for Gc<'gc, T> 
+    where T: GcSafe + PartialEq + 'gc {
+    #[inline]
+    fn eq(&self, other: &Self) -> bool {
+        *self.value() == *other.value()
+    }
+}
+impl<'gc, T> PartialEq<T> for Gc<'gc, T> 
+    where T: GcSafe + PartialEq<T> + 'gc {
+    #[inline]
+    fn eq(&self, other: &T) -> bool {
+        *self.value() == *other
+    }
+}
+impl<'gc, T: GcSafe + Eq + 'gc> Eq for Gc<'gc, T> {}
+
+impl<'gc, T> Hash for Gc<'gc, T> where T: GcSafe + Hash + 'gc {
+    #[inline]
+    fn hash<H: Hasher>(&self, hasher: &mut H) {
+        T::hash(self.value(), hasher)
+    }
+}
+
+
+/// In order to send *references* between threads,
+/// the underlying type must be sync.
+///
+/// This is the same reason that `Arc<T>: Send` requires `T: Sync`
+#[cfg(feature = "sync")]
+unsafe impl<'gc, T> Send for Gc<'gc, T>
+    where T: GcSafe + Sync {}
+
+/// If the underlying type is `Sync`, it's safe
+/// to share garbage collected references between threads.
+///
+/// The safety of the collector itself depends on the flag `cfg!(feature = "sync")`
+/// If it is, the whole garbage collection implenentation should be as well.
+#[cfg(feature = "sync")]
+unsafe impl<'gc, T> Sync for Gc<'gc, T>
+    where T: GcSafe + Sync {}

libs/simple/src/lib.rs

@@ -31,14 +31,14 @@ use std::any::TypeId;
 
 use slog::{Logger, FnValue, debug};
 
-use zerogc::{GcSafe, Trace, GcVisitor};
+use zerogc::{GcSafe, Trace, GcVisitor, GcRef};
 
 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};
+use zerogc_context::handle::{GcHandleList, RawHandleImpl, RawHandleImplHack};
 use zerogc_context::{
     CollectionManager as AbstractCollectionManager,
     RawContext as AbstractRawContext
@@ -67,6 +67,9 @@ 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>;
@@ -81,14 +84,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 RawSimpleAlloc for RawSimpleCollector {
+unsafe impl<'gc, T: GcSafe + 'gc> RawSimpleAlloc<'gc, T> for RawSimpleCollector {
+    type Gc = Gc<'gc, T>;
     #[inline]
-    fn alloc<'gc, T>(context: &'gc SimpleCollectorContext, value: T) -> Gc<'gc, T> where T: GcSafe + 'gc {
+    fn alloc(context: &'gc SimpleCollectorContext, value: T) -> Gc<'gc, T> where T: GcSafe + 'gc {
         context.collector().heap.allocator.alloc(value)
     }
 }
@@ -116,6 +119,9 @@ 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)]
@@ -464,14 +470,6 @@ 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
@@ -673,20 +671,20 @@ unsafe impl GcVisitor for MarkVisitor<'_> {
     type Err = !;
 
     #[inline]
-    unsafe fn visit_gc<'gc, T, Id>(
-        &mut self, gc: &mut ::zerogc::Gc<'gc, T, Id>
+    unsafe fn visit_gc<'gc, T, G>(
+        &mut self, gc: &mut G
     ) -> Result<(), Self::Err>
-        where T: GcSafe + 'gc, Id: ::zerogc::CollectorId {
-        if TypeId::of::<Id>() == TypeId::of::<crate::CollectorId>() {
+        where T: GcSafe + 'gc, G: GcRef<'gc, T> {
+        if TypeId::of::<G::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 ::zerogc::Gc<'gc, T, Id>,
-                &mut ::zerogc::Gc<'gc, T, crate::CollectorId>
+                &mut G,
+                &mut crate::gc::Gc<'gc, T>
             >(gc);
             /*
              * Check the collectors match. Otherwise we're mutating