Revert "Attempt Significant API redesign"

This reverts commit 08cb933.

Boy, that was bad.
I think there might be some stuff I can salvage,
but I definitely wasted a day or two.

Oh well ^_^

Author: Techcable

libs/context/src/collector.rs

@@ -8,9 +8,9 @@ use core::sync::atomic::{self, AtomicPtr, AtomicUsize, Ordering};
 use alloc::boxed::Box;
 use alloc::vec::Vec;
 
-use zerogc::{Trace, GcSafe, GcErase, GcRebrand, GcVisitor, NullTrace, TraceImmutable, GcHandleSystem, GcBindHandle, Gc};
-use crate::{WeakCollectorRef, CollectorId, CollectorContext, GarbageCollector, CollectionManager};
-use crate::collector::{RawCollectorImpl, CollectorPtr};
+use zerogc::{Trace, GcSafe, GcErase, GcRebrand, GcVisitor, NullTrace, TraceImmutable, GcHandleSystem, GcBindHandle};
+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
 ///
@@ -414,7 +421,7 @@ impl<T: GcSafe, C: RawHandleImpl> GcHandle<T, C> {
     }
 }
 unsafe impl<T: GcSafe, C: RawHandleImpl> ::zerogc::GcHandle<T> for GcHandle<T, C> {
-    type System = GarbageCollector<C>;
+    type System = CollectorRef<C>;
     type Id = CollectorId<C>;
 
     fn use_critical<R>(&self, func: impl FnOnce(&T) -> R) -> R {
@@ -428,7 +435,7 @@ unsafe impl<T: GcSafe, C: RawHandleImpl> ::zerogc::GcHandle<T> for GcHandle<T, C
              * This is preferable to using `recursive_read`,
              * since that could starve writers (collectors).
              */
-            C::Manager::prevent_collection(&*collector.as_ptr(), || {
+            C::Manager::prevent_collection(collector.as_ref(), || {
                 let value = self.inner.as_ref().value
                     .load(Ordering::Acquire) as *mut T;
                 func(&*value)
@@ -437,10 +444,11 @@ 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>>, C: RawHandleImpl,
-          T::Branded: GcSafe {
+    where T: GcSafe, T: GcRebrand<'new_gc, CollectorId<C>>,
+          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.
@@ -457,16 +465,16 @@ unsafe impl<'new_gc, T, C> GcBindHandle<'new_gc, T> for GcHandle<T, C>
         unsafe {
             let collector = self.collector.assume_valid();
             assert_eq!(
-                collector.as_ptr() as *const C,
+                collector.as_ref() as *const C,
                 context.collector() as *const C,
                 "Collectors mismatch"
             );
             let inner = self.inner.as_ref();
             let value = inner.value.load(Ordering::Acquire)
                 as *mut T as *mut T::Branded;
             debug_assert!(!value.is_null());
-            Gc::from_raw(
-                CollectorId { collector },
+            Self::Gc::from_raw(
+                collector,
                 NonNull::new_unchecked(value)
             )
         }
@@ -494,9 +502,7 @@ impl<T: GcSafe, C: RawHandleImpl> Clone for GcHandle<T, C> {
     fn clone(&self) -> Self {
         // NOTE: Dead collector -> invalid handle
         let collector = self.collector
-            .ensure_valid(|id| unsafe { WeakCollectorRef {
-                weak: id.create_weak()
-            } });
+            .ensure_valid(|id| unsafe { id.weak_ref() });
         let inner = unsafe { self.inner.as_ref() };
         debug_assert!(
             !inner.value
@@ -507,7 +513,7 @@ impl<T: GcSafe, C: RawHandleImpl> Clone for GcHandle<T, C> {
         let mut old_refcnt = inner.refcnt.load(Ordering::Relaxed);
         loop {
             assert_ne!(
-                old_refcnt, isize::MAX as usize,
+                old_refcnt, isize::max_value() as usize,
                 "Reference count overflow"
             );
             /*
@@ -546,7 +552,7 @@ impl<T: GcSafe, C: RawHandleImpl> Drop for GcHandle<T, C> {
                      */
                     return;
                 },
-                Some(ref id) => unsafe { &*id.as_ptr() },
+                Some(ref id) => unsafe { id.as_ref() },
             };
             let inner = unsafe { self.inner.as_ref() };
             debug_assert!(!inner.value
@@ -598,19 +604,20 @@ unsafe impl<T: GcSafe + Sync, C: RawHandleImpl + Sync> Send for GcHandle<T, C> {
 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 GarbageCollector<C>
-    where C: RawHandleImpl,
+unsafe impl<'gc, 'a, T, C> GcHandleSystem<'gc, 'a, T> for CollectorRef<C>
+    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.system();
+            let collector = gc.collector_id();
             let value = gc.as_raw_ptr();
-            let raw = collector.as_raw().handle_list()
+            let raw = collector.as_ref().handle_list()
                 .alloc_raw_handle(value as *mut ());
             /*
              * WARN: Undefined Behavior
@@ -624,7 +631,7 @@ unsafe impl<'gc, 'a, T, C> GcHandleSystem<'gc, 'a, T> for GarbageCollector<C>
                 Ordering::Release
             );
             raw.refcnt.store(1, Ordering::Release);
-            let weak_collector = collector.as_ref().create_weak();
+            let weak_collector = collector.weak_ref();
             GcHandle::new(NonNull::from(raw), weak_collector)
         }
     }

libs/context/src/handle.rs

@@ -34,8 +34,7 @@ pub mod handle;
 
 use crate::collector::{RawCollectorImpl};
 
-pub(crate) use crate::collector::WeakCollectorRef;
-pub use crate::collector::{GarbageCollector, CollectorId};
+pub use crate::collector::{WeakCollectorRef, CollectorRef, CollectorId};
 pub use crate::state::{CollectionManager, RawContext};
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
@@ -115,7 +114,7 @@ pub struct CollectorContext<C: RawCollectorImpl> {
     root: bool
 }
 impl<C: RawCollectorImpl> CollectorContext<C> {
-    pub(crate) unsafe fn register_root(collector: &GarbageCollector<C>) -> Self {
+    pub(crate) unsafe fn register_root(collector: &CollectorRef<C>) -> Self {
         CollectorContext {
             raw: Box::into_raw(ManuallyDrop::into_inner(
                 C::RawContext::register_new(&collector)
@@ -163,7 +162,7 @@ impl<C: RawCollectorImpl> Drop for CollectorContext<C> {
     }
 }
 unsafe impl<C: RawCollectorImpl> GcContext for CollectorContext<C> {
-    type System = GarbageCollector<C>;
+    type System = CollectorRef<C>;
     type Id = CollectorId<C>;
 
     #[inline]

libs/context/src/lib.rs

@@ -1,5 +1,5 @@
 use crate::collector::RawCollectorImpl;
-use crate::{ContextState, ShadowStack, GarbageCollector};
+use crate::{ContextState, ShadowStack, CollectorRef};
 
 use core::mem::ManuallyDrop;
 use core::fmt::Debug;
@@ -47,7 +47,7 @@ pub unsafe trait CollectionManager<C>: self::sealed::Sealed
 /// even if the collector supports multi-threading.
 pub unsafe trait RawContext<C>: Debug + self::sealed::Sealed
     where C: RawCollectorImpl<RawContext=Self> {
-    unsafe fn register_new(collector: &GarbageCollector<C>) -> ManuallyDrop<Box<Self>>;
+    unsafe fn register_new(collector: &CollectorRef<C>) -> ManuallyDrop<Box<Self>>;
     /// Trigger a safepoint for this context.
     ///
     /// This implicitly attempts a collection,

libs/context/src/state/mod.rs

@@ -14,16 +14,16 @@ use alloc::boxed::Box;
 
 use slog::{Logger, FnValue, trace, o};
 
-use crate::{GarbageCollector, ShadowStack, ContextState};
-use crate::collector::{RawCollectorImpl, CollectorRef};
+use crate::{CollectorRef, ShadowStack, ContextState};
+use crate::collector::RawCollectorImpl;
 
 /// Manages coordination of garbage collections
 ///
 /// This is factored out of the main code mainly due to
 /// differences from single-threaded collection
 pub struct CollectionManager<C: RawCollectorImpl> {
     /// Implicit collector ref
-    _marker: PhantomData<GarbageCollector<C>>,
+    _marker: PhantomData<CollectorRef<C>>,
     /// Access to the internal state
     state: RefCell<CollectorState>,
     /// Whether a collection is currently in progress
@@ -87,7 +87,7 @@ pub struct RawContext<C: RawCollectorImpl> {
     /// Since we're the only context, we should (logically)
     /// be the only owner.
     ///
-    /// This may still be an Arc for easier use alongside the
+    /// This is still an Arc for easier use alongside the
     /// thread-safe implementation
     pub(crate) collector: CollectorRef<C>,
     // NOTE: We are Send, not Sync
@@ -115,7 +115,7 @@ impl<C: RawCollectorImpl> Debug for RawContext<C> {
 impl<C: RawCollectorImpl> super::sealed::Sealed for RawContext<C> {}
 unsafe impl<C> super::RawContext<C> for RawContext<C>
     where C: RawCollectorImpl<RawContext=Self, Manager=CollectionManager<C>> {
-    unsafe fn register_new(collector: &GarbageCollector<C>) -> ManuallyDrop<Box<Self>> {
+    unsafe fn register_new(collector: &CollectorRef<C>) -> ManuallyDrop<Box<Self>> {
         assert!(!C::SYNC);
         // NOTE: Nosync collector must have only **ONE** context
         assert!(
@@ -124,7 +124,7 @@ unsafe impl<C> super::RawContext<C> for RawContext<C>
             "Already created a context for the collector!"
         );
         // Assume ownership
-        let collector = collector.as_ref().clone();
+        let collector = collector.clone_internal();
         let logger = collector.as_raw().logger().new(o!());
         let context = ManuallyDrop::new(Box::new(RawContext {
             logger: logger.clone(), collector,
@@ -179,7 +179,7 @@ unsafe impl<C> super::RawContext<C> for RawContext<C>
             self.state.replace(ContextState::Active),
             ContextState::SafePoint { collection_id }
         );
-        assert!((&*self.collector.as_raw()).manager().collecting.replace(false));
+        assert!(self.collector.as_raw().manager().collecting.replace(false));
     }
 
     #[inline]

libs/context/src/state/nosync.rs

@@ -13,9 +13,9 @@ use parking_lot::{Mutex, RwLockReadGuard, RwLockUpgradableReadGuard, RwLockWrite
 use slog::{Logger, FnValue, trace, Drain, o};
 
 use super::{ShadowStack, ContextState};
-use crate::{RawCollectorImpl, GarbageCollector};
+use crate::{RawCollectorImpl, CollectorRef};
 use crate::utils::ThreadId;
-use crate::collector::{SyncCollector, CollectorRef};
+use crate::collector::SyncCollector;
 
 /// Manages coordination of garbage collections
 ///
@@ -104,7 +104,7 @@ unsafe impl<C> super::CollectionManager<C> for CollectionManager<C>
          * context's shadow stack, so unfreezing it while in progress
          * could trigger undefined behavior!!!!!
          */
-        (&*context.collector.as_raw()).prevent_collection(|_| {
+        context.collector.as_raw().prevent_collection(|_| {
             assert_eq!(context.state.get(), ContextState::Frozen);
             context.state.set(ContextState::Active);
         })
@@ -150,14 +150,14 @@ impl<C: RawCollectorImpl> Debug for RawContext<C> {
 impl<C: SyncCollector> super::sealed::Sealed for RawContext<C> {}
 unsafe impl<C> super::RawContext<C> for RawContext<C>
     where C: SyncCollector<RawContext=Self, Manager=CollectionManager<C>> {
-    unsafe fn register_new(collector: &GarbageCollector<C>) -> ManuallyDrop<Box<Self>> {
+    unsafe fn register_new(collector: &CollectorRef<C>) -> ManuallyDrop<Box<Self>> {
         let original_thread = if collector.as_raw().logger().is_trace_enabled() {
             ThreadId::current()
         } else {
             ThreadId::Nop
         };
         let mut context = ManuallyDrop::new(Box::new(RawContext {
-            collector: collector.as_ref().clone(),
+            collector: collector.clone_internal(),
             original_thread: original_thread.clone(),
             logger: collector.as_raw().logger().new(o!(
                 "original_thread" => original_thread.clone()
@@ -297,7 +297,7 @@ unsafe impl<C> super::RawContext<C> for RawContext<C>
 
     #[inline]
     unsafe fn collector(&self) -> &C {
-        &*self.collector.as_raw()
+        self.collector.as_raw()
     }
 
     #[inline]