Make ::zerogc::Gc a struct replacing GcRef trait

This more-specific struct simplifies things.
Now, collector-specific data is associated behind a '::zerogc::CollectorId'
For collectors with multiple instances, this should be a pointer.
However for singleton collectors it can simply be a ZST.

See issue #5

Author: Techcable

libs/derive/src/lib.rs

@@ -224,9 +224,9 @@ fn impl_extras(target: &DeriveInput) -> Result<TokenStream, Error> {
                     let barrier = quote_spanned!(field.span() => ::zerogc::GcDirectBarrier::write_barrier(&value, &self, offset));
                     extra_items.push(quote! {
                         #[inline] // TODO: Implement `GcDirectBarrier` ourselves
-                        #mutator_vis fn #mutator_name<OwningRef>(self: OwningRef, value: #value_ref_type)
-                            where OwningRef: ::zerogc::GcRef<'gc, Self>,
-                                   #value_ref_type: ::zerogc::GcDirectBarrier<'gc, OwningRef> {
+                        #mutator_vis fn #mutator_name<Id>(self: ::zerogc::Gc<'gc, Self, Id>, value: #value_ref_type)
+                            where Id: ::zerogc::CollectorId,
+                                   #value_ref_type: ::zerogc::GcDirectBarrier<'gc, ::zerogc::Gc<'gc, Self, Id>> {
                             unsafe {
                                 let target_ptr = #field_as_ptr;
                                 let offset = target_ptr as usize - self.as_raw_ptr() as usize;
@@ -306,7 +306,7 @@ fn impl_brand(target: &DeriveInput) -> Result<TokenStream, Error> {
     }
     let mut impl_generics = generics.clone();
     impl_generics.params.push(GenericParam::Lifetime(parse_quote!('new_gc)));
-    impl_generics.params.push(GenericParam::Type(parse_quote!(S: ::zerogc::GcSystem)));
+    impl_generics.params.push(GenericParam::Type(parse_quote!(S: ::zerogc::CollectorId)));
     let (_, ty_generics, where_clause) = generics.split_for_impl();
     let (impl_generics, _, _) = impl_generics.split_for_impl();
     Ok(quote! {

libs/simple/src/context/mod.rs

@@ -14,6 +14,7 @@ use zerogc::prelude::*;
 use super::{SimpleCollector, RawSimpleCollector, DynTrace};
 use std::mem::ManuallyDrop;
 use std::ptr::NonNull;
+use crate::CollectorId;
 
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
@@ -156,6 +157,7 @@ impl Drop for SimpleCollectorContext {
 }
 unsafe impl GcContext for SimpleCollectorContext {
     type System = SimpleCollector;
+    type Id = CollectorId;
 
     #[inline]
     unsafe fn basic_safepoint<T: Trace>(&mut self, value: &mut &mut T) {

libs/simple/src/context/simple.rs

@@ -3,7 +3,6 @@
 //!
 //! In exchange, there is no locking :)
 
-use std::sync::{Arc};
 use std::cell::{Cell, UnsafeCell, RefCell};
 
 use slog::{Logger, FnValue, trace, o};

libs/simple/src/handles.rs

@@ -5,8 +5,8 @@ use std::ptr::NonNull;
 use std::marker::PhantomData;
 use std::sync::atomic::{self, AtomicPtr, AtomicUsize, Ordering};
 
-use zerogc::{Trace, GcSafe, GcBindHandle, GcBrand, GcVisitor, NullTrace, TraceImmutable};
-use crate::{DynTrace, GcType, Gc, SimpleCollectorContext, SimpleCollector, MarkVisitor, GcHeader, MarkState, WeakCollectorRef};
+use zerogc::{Trace, GcSafe, GcBrand, GcVisitor, NullTrace, TraceImmutable, GcHandleSystem, GcBindHandle};
+use crate::{DynTrace, GcType, Gc, SimpleCollector, MarkVisitor, GcHeader, MarkState, WeakCollectorRef, CollectorId, SimpleCollectorContext, RawSimpleCollector};
 
 const INITIAL_HANDLE_CAPACITY: usize = 128;
 
@@ -370,7 +370,9 @@ impl<T: GcSafe> GcHandle<T> {
     }
 }
 unsafe impl<T: GcSafe> ::zerogc::GcHandle<T> for GcHandle<T> {
-    type Context = SimpleCollectorContext;
+    type System = SimpleCollector;
+    type Id = CollectorId;
+
     #[cfg(feature = "sync")]
     fn use_critical<R>(&self, func: impl FnOnce(&T) -> R) -> R {
         self.collector.ensure_valid(|collector| unsafe {
@@ -396,12 +398,10 @@ unsafe impl<T: GcSafe> ::zerogc::GcHandle<T> for GcHandle<T> {
     }
 }
 unsafe impl<'new_gc, T> GcBindHandle<'new_gc, T> for GcHandle<T>
-    where T: GcSafe, T: GcBrand<'new_gc, SimpleCollector>,
+    where T: GcSafe, T: GcBrand<'new_gc, CollectorId>,
         T::Branded: GcSafe {
-    type System = SimpleCollector;
-    type Bound = Gc<'new_gc, T::Branded>;
     #[inline]
-    fn bind_to(&self, _context: &'new_gc Self::Context) -> Self::Bound {
+    fn bind_to(&self, context: &'new_gc SimpleCollectorContext) -> Gc<'new_gc, T::Branded> {
         /*
          * We can safely assume the object will
          * be as valid as long as the context.
@@ -417,6 +417,11 @@ unsafe impl<'new_gc, T> GcBindHandle<'new_gc, T> for GcHandle<T>
          */
         unsafe {
             let collector = self.collector.assume_valid();
+            assert_eq!(
+                collector.as_ref() as *const RawSimpleCollector,
+                context.collector() as *const RawSimpleCollector,
+                "Collectors mismatch"
+            );
             let inner = self.inner.as_ref();
             let value = inner.value.load(Ordering::Acquire)
                 as *mut T as *mut T::Branded;
@@ -529,4 +534,38 @@ unsafe impl<T: GcSafe + Sync> Send for GcHandle<T> {}
 /// it's safe to share garbage collected references between threads.
 ///
 /// The collector itself is always safe
-unsafe impl<T: GcSafe + Sync> Sync for GcHandle<T> {}
+unsafe impl<T: GcSafe + Sync> Sync for GcHandle<T> {}
+
+/// We support handles
+unsafe impl<'gc, T> GcHandleSystem<'gc, T> for SimpleCollector
+    where T: GcSafe + 'gc,
+          T: GcBrand<'static, CollectorId>,
+          T::Branded: GcSafe {
+    type Handle = GcHandle<T::Branded>;
+    #[inline]
+    fn create_handle(gc: Gc<'gc, T>) -> Self::Handle {
+        use crate::StaticGcType;
+        unsafe {
+            let collector = gc.collector_id();
+            let value = gc.as_raw_ptr();
+            let raw = collector.as_ref().handle_list
+                .alloc_raw_handle(value as *mut ());
+            /*
+             * WARN: Undefined Behavior
+             * if we don't finish initializing
+             * the handle!!!
+             *
+             * TODO: Encapsulate
+             */
+            raw.type_info.store(
+                <T as StaticGcType>::STATIC_TYPE
+                    as *const GcType
+                    as *mut GcType,
+                Ordering::Release
+            );
+            raw.refcnt.store(1, Ordering::Release);
+            let weak_collector = collector.weak_ref();
+            GcHandle::new(NonNull::from(raw), weak_collector)
+        }
+    }
+}