Parameterize GcSafe by 'gc and CollectorId

We now have a very specific way to indicate that we expect a specific gc
lifetime, beyond just T: 'gc. This will also allow us to begin to relax
the `T: 'gc` requirement to allow short-lied references in GC types...
This also gives us a clearer handling of mixing multiple collectors.

Derive code is now broken....

Author: Techcable

libs/context/src/collector.rs

@@ -9,7 +9,7 @@ use alloc::sync::Arc;
 
 use slog::{Logger, o};
 
-use zerogc::{Gc, GcSafe, GcSystem, Trace, GcSimpleAlloc, NullTrace, TraceImmutable, GcVisitor, GcArray};
+use zerogc::{Gc, GcSafe, GcSystem, Trace, GcSimpleAlloc, NullTrace, TraceImmutable, GcVisitor, GcArray, TrustedDrop};
 
 use crate::{CollectorContext};
 use crate::state::{CollectionManager, RawContext};
@@ -37,7 +37,7 @@ pub unsafe trait RawCollectorImpl: 'static + Sized {
     /// The context
     type RawContext: RawContext<Self>;
     /// The raw representation of a vec
-    type RawVecRepr: GcVecRepr;
+    type RawVecRepr<'gc>: GcVecRepr<'gc, Id=CollectorId<Self>>;
 
     /// True if this collector is a singleton
     ///
@@ -49,13 +49,13 @@ pub unsafe trait RawCollectorImpl: 'static + Sized {
     const SYNC: bool;
 
     fn id_for_gc<'a, 'gc, T>(gc: &'a Gc<'gc, T, CollectorId<Self>>) -> &'a CollectorId<Self>
-        where 'gc: 'a, T: GcSafe + ?Sized + 'gc;
+        where 'gc: 'a, T: GcSafe<'gc, CollectorId<Self>> + ?Sized + 'gc;
 
     fn id_for_array<'a, 'gc, T>(gc: &'a GcArray<'gc, T, CollectorId<Self>>) -> &'a CollectorId<Self>
-        where 'gc: 'a, T: GcSafe + 'gc;
+        where 'gc: 'a, T: GcSafe<'gc, CollectorId<Self>> + 'gc;
 
     fn resolve_array_len<'gc, T>(gc: GcArray<'gc, T, CollectorId<Self>>) -> usize
-        where T: GcSafe + 'gc;
+        where T: GcSafe<'gc, CollectorId<Self>> + 'gc;
 
     /// Convert the specified value into a dyn pointer
     unsafe fn as_dyn_trace_pointer<T: Trace>(t: *mut T) -> Self::DynTracePtr;
@@ -74,7 +74,7 @@ pub unsafe trait RawCollectorImpl: 'static + Sized {
         owner: &Gc<'gc, O, CollectorId<Self>>,
         value: &Gc<'gc, V, CollectorId<Self>>,
         field_offset: usize
-    ) where O: GcSafe + ?Sized + 'gc, V: GcSafe + ?Sized + 'gc;
+    ) where O: GcSafe<'gc, CollectorId<Self>> + ?Sized + 'gc, V: GcSafe<'gc, CollectorId<Self>> + ?Sized + 'gc;
     /// The logger associated with this collector
     fn logger(&self) -> &Logger;
 
@@ -283,20 +283,20 @@ impl<C: RawCollectorImpl> CollectorId<C> {
 }
 unsafe impl<C: RawCollectorImpl> ::zerogc::CollectorId for CollectorId<C> {
     type System = CollectorRef<C>;
-    type RawVecRepr = C::RawVecRepr;
+    type RawVecRepr<'gc> = C::RawVecRepr<'gc>;
 
     #[inline]
-    fn from_gc_ptr<'a, 'gc, T>(gc: &'a Gc<'gc, T, Self>) -> &'a Self where T: GcSafe + ?Sized + 'gc, 'gc: 'a {
+    fn from_gc_ptr<'a, 'gc, T>(gc: &'a Gc<'gc, T, Self>) -> &'a Self where T: GcSafe<'gc, Self> + ?Sized + 'gc, 'gc: 'a {
         C::id_for_gc(gc)
     }
 
     #[inline]
-    fn resolve_array_len<'gc, T>(gc: GcArray<'gc, T, Self>) -> usize where T: GcSafe + 'gc {
+    fn resolve_array_len<'gc, T>(gc: GcArray<'gc, T, Self>) -> usize where T: GcSafe<'gc, Self> + 'gc {
         C::resolve_array_len(gc)
     }
 
     #[inline]
-    fn resolve_array_id<'a, 'gc, T>(gc: &'a GcArray<'gc, T, Self>) -> &'a Self where T: GcSafe + 'gc, 'gc: 'a {
+    fn resolve_array_id<'a, 'gc, T>(gc: &'a GcArray<'gc, T, Self>) -> &'a Self where T: GcSafe<'gc, Self> + 'gc, 'gc: 'a {
         C::id_for_array(gc)
     }
 
@@ -306,7 +306,7 @@ unsafe impl<C: RawCollectorImpl> ::zerogc::CollectorId for CollectorId<C> {
         owner: &Gc<'gc, O, Self>,
         value: &Gc<'gc, V, Self>,
         field_offset: usize
-    ) where O: GcSafe + ?Sized + 'gc, V: GcSafe + ?Sized + 'gc {
+    ) where O: GcSafe<'gc, Self> + ?Sized + 'gc, V: GcSafe<'gc, Self> + ?Sized + 'gc {
         C::gc_write_barrier(owner, value, field_offset)
     }
 
@@ -320,6 +320,7 @@ unsafe impl<C: RawCollectorImpl> ::zerogc::CollectorId for CollectorId<C> {
         &*(self as *const CollectorId<C> as *const CollectorRef<C>)
     }
 }
+unsafe impl<'gc, OtherId: zerogc::CollectorId, C: RawCollectorImpl> GcSafe<'gc, OtherId> for CollectorId<C> {}
 unsafe impl<C: RawCollectorImpl> Trace for CollectorId<C> {
     const NEEDS_TRACE: bool = false;
     const NEEDS_DROP: bool = false;
@@ -329,11 +330,12 @@ unsafe impl<C: RawCollectorImpl> Trace for CollectorId<C> {
     }
 
     #[inline]
-    unsafe fn visit_inside_gc<'gc, V, Id>(gc: &mut Gc<'gc, Self, Id>, visitor: &mut V) -> Result<(), V::Err> where V: GcVisitor, Id: zerogc::CollectorId, Self: GcSafe + 'gc {
+    unsafe fn visit_inside_gc<'gc, V, Id>(gc: &mut Gc<'gc, Self, Id>, visitor: &mut V) -> Result<(), V::Err> where V: GcVisitor, Id: zerogc::CollectorId, Self: GcSafe<'gc, Id> {
         // Fine to stuff inside a pointer. We're a regular 'Sized' type
         visitor.visit_gc(gc)
     }
 }
+unsafe impl<C: RawCollectorImpl> TrustedDrop for CollectorId<C> {}
 unsafe impl<C: RawCollectorImpl> TraceImmutable for CollectorId<C> {
     #[inline(always)]
     fn visit_immutable<V: GcVisitor>(&self, _visitor: &mut V) -> Result<(), <V as GcVisitor>::Err> {
@@ -363,35 +365,35 @@ impl<C: RawCollectorImpl> WeakCollectorRef<C> {
 }
 
 pub unsafe trait RawSimpleAlloc: RawCollectorImpl {
-    unsafe fn alloc_uninit<'gc, T: GcSafe + 'gc>(context: &'gc CollectorContext<Self>) -> (CollectorId<Self>, *mut T);
+    unsafe fn alloc_uninit<'gc, T: GcSafe<'gc, CollectorId<Self>>>(context: &'gc CollectorContext<Self>) -> (CollectorId<Self>, *mut T);
     unsafe fn alloc_uninit_slice<'gc, T>(context: &'gc CollectorContext<Self>, len: usize) -> (CollectorId<Self>, *mut T)
-        where T: GcSafe + 'gc;
+        where T: GcSafe<'gc, CollectorId<Self>>;
     fn alloc_vec<'gc, T>(context: &'gc CollectorContext<Self>) -> GcVec<'gc, T, CollectorContext<Self>>
-        where T: GcSafe + 'gc;
+        where T: GcSafe<'gc, CollectorId<Self>>;
     fn alloc_vec_with_capacity<'gc, T>(context: &'gc CollectorContext<Self>, capacity: usize) -> GcVec<'gc, T, CollectorContext<Self>>
-        where T: GcSafe + 'gc;
+        where T: GcSafe<'gc, CollectorId<Self>>;
 }
 unsafe impl<C> GcSimpleAlloc for CollectorContext<C>
     where C: RawSimpleAlloc {
     #[inline]
     unsafe fn alloc_uninit<'gc, T>(&'gc self) -> (CollectorId<C>, *mut T)
-        where T: GcSafe + 'gc {
+        where T: GcSafe<'gc, CollectorId<C>> + 'gc {
         C::alloc_uninit(self)
     }
 
     #[inline]
     unsafe fn alloc_uninit_slice<'gc, T>(&'gc self, len: usize) -> (Self::Id, *mut T)
-        where T: GcSafe + 'gc {
+        where T: GcSafe<'gc, CollectorId<C>> + 'gc {
         C::alloc_uninit_slice(self, len)
     }
 
     #[inline]
-    fn alloc_vec<'gc, T>(&'gc self) -> GcVec<'gc, T, Self> where T: GcSafe + 'gc {
+    fn alloc_vec<'gc, T>(&'gc self) -> GcVec<'gc, T, Self> where T: GcSafe<'gc, CollectorId<C>> + 'gc {
         C::alloc_vec(self)
     }
 
     #[inline]
-    fn alloc_vec_with_capacity<'gc, T>(&'gc self, capacity: usize) -> GcVec<'gc, T, Self> where T: GcSafe + 'gc {
+    fn alloc_vec_with_capacity<'gc, T>(&'gc self, capacity: usize) -> GcVec<'gc, T, Self> where T: GcSafe<'gc, CollectorId<C>> + 'gc {
         C::alloc_vec_with_capacity(self, capacity)
     }
 }

libs/context/src/handle.rs

@@ -19,7 +19,7 @@ pub unsafe trait RawHandleImpl: RawCollectorImpl {
     /// Type information
     type TypeInfo: Sized;
 
-    fn type_info_of<T: GcSafe>() -> &'static Self::TypeInfo;
+    fn type_info_of<'gc, T: GcSafe<'gc, CollectorId<Self>>>() -> &'static Self::TypeInfo;
 
     fn handle_list(&self) -> &GcHandleList<Self>;
 }
@@ -397,12 +397,12 @@ impl<C: RawHandleImpl> GcRawHandle<C> {
         trace(value, type_info)
     }
 }
-pub struct GcHandle<T: GcSafe, C: RawHandleImpl> {
+pub struct GcHandle<T: GcSafe<'static, CollectorId<C>>, C: RawHandleImpl> {
     inner: NonNull<GcRawHandle<C>>,
     collector: WeakCollectorRef<C>,
     marker: PhantomData<*mut T>
 }
-impl<T: GcSafe, C: RawHandleImpl> GcHandle<T, C> {
+impl<T: GcSafe<'static, CollectorId<C>>, C: RawHandleImpl> GcHandle<T, C> {
     #[inline]
     pub(crate) unsafe fn new(
         inner: NonNull<GcRawHandle<C>>,
@@ -414,7 +414,7 @@ impl<T: GcSafe, C: RawHandleImpl> GcHandle<T, C> {
         }
     }
 }
-unsafe impl<T: GcSafe, C: RawHandleImpl> ::zerogc::GcHandle<T> for GcHandle<T, C> {
+unsafe impl<T: GcSafe<'static, CollectorId<C>>, C: RawHandleImpl> ::zerogc::GcHandle<T> for GcHandle<T, C> {
     type System = CollectorRef<C>;
     type Id = CollectorId<C>;
 
@@ -438,8 +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: Sized,
-          T::Branded: GcSafe, C: RawHandleImpl {
+    where T: GcSafe<'static, CollectorId<C>>, T: GcRebrand<'new_gc, CollectorId<C>>, T::Branded: Sized,
+          T::Branded: GcSafe<'new_gc, CollectorId<C>>,
+          C: RawHandleImpl {
     #[inline]
     fn bind_to(&self, context: &'new_gc CollectorContext<C>) -> Gc<'new_gc, T::Branded, CollectorId<C>> {
         /*
@@ -474,7 +475,7 @@ unsafe impl<'new_gc, T, C> GcBindHandle<'new_gc, T> for GcHandle<T, C>
     }
 
 }
-unsafe impl<T: GcSafe, C: RawHandleImpl> Trace for GcHandle<T, C> {
+unsafe impl<T: GcSafe<'static, CollectorId<C>>, C: RawHandleImpl> Trace for GcHandle<T, C> {
     /// See docs on reachability
     const NEEDS_TRACE: bool = false;
     const NEEDS_DROP: bool = true;
@@ -486,20 +487,20 @@ unsafe impl<T: GcSafe, C: RawHandleImpl> Trace for GcHandle<T, C> {
 
     #[inline]
     unsafe fn visit_inside_gc<'gc, V, Id>(gc: &mut Gc<'gc, Self, Id>, visitor: &mut V) -> Result<(), V::Err>
-        where V: GcVisitor, Id: zerogc::CollectorId, Self: GcSafe + 'gc {
+        where V: GcVisitor, Id: zerogc::CollectorId, Self: GcSafe<'gc, Id> {
         // Fine to stuff inside a pointer. We're a `Sized` type
         visitor.visit_gc(gc)
     }
 }
-unsafe impl<T: GcSafe, C: RawHandleImpl> TraceImmutable for GcHandle<T, C> {
+unsafe impl<T: GcSafe<'static, CollectorId<C>>, C: RawHandleImpl> TraceImmutable for GcHandle<T, C> {
     #[inline(always)]
     fn visit_immutable<V>(&self, _visitor: &mut V) -> Result<(), V::Err>
         where V: GcVisitor {
         Ok(())
     }
 }
-unsafe impl<T: GcSafe, C: RawHandleImpl> NullTrace for GcHandle<T, C> {}
-impl<T: GcSafe, C: RawHandleImpl> Clone for GcHandle<T, C> {
+unsafe impl<T: GcSafe<'static, CollectorId<C>>, C: RawHandleImpl> NullTrace for GcHandle<T, C> {}
+impl<T: GcSafe<'static, CollectorId<C>>, C: RawHandleImpl> Clone for GcHandle<T, C> {
     fn clone(&self) -> Self {
         // NOTE: Dead collector -> invalid handle
         let collector = self.collector
@@ -542,7 +543,7 @@ impl<T: GcSafe, C: RawHandleImpl> Clone for GcHandle<T, C> {
         }
     }
 }
-impl<T: GcSafe, C: RawHandleImpl> Drop for GcHandle<T, C> {
+impl<T: GcSafe<'static, CollectorId<C>>, C: RawHandleImpl> Drop for GcHandle<T, C> {
     fn drop(&mut self) {
         self.collector.try_ensure_valid(|id| {
             let collector = match id {
@@ -596,20 +597,20 @@ impl<T: GcSafe, C: RawHandleImpl> Drop for GcHandle<T, C> {
 /// This is the same reason that `Arc<T>: Send` requires `T: Sync`
 ///
 /// Requires that the collector is thread-safe.
-unsafe impl<T: GcSafe + Sync, C: RawHandleImpl + Sync> Send for GcHandle<T, C> {}
+unsafe impl<T: GcSafe<'static, CollectorId<C>> + Sync, C: RawHandleImpl + Sync> Send for GcHandle<T, C> {}
 
 /// If the underlying type is Sync,
 /// it's safe to share garbage collected references between threads.
 ///
 /// Requires that the collector is thread-safe.
-unsafe impl<T: GcSafe + Sync, C: RawHandleImpl + Sync> Sync for GcHandle<T, C> {}
+unsafe impl<T: GcSafe<'static, CollectorId<C>> + 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>
+unsafe impl<'gc, T, C> GcHandleSystem<'gc, T> for CollectorRef<C>
     where C: RawHandleImpl,
-          T: GcSafe + 'gc,
-          T: GcRebrand<'a, CollectorId<C>>,
-          T::Branded: GcSafe + Sized {
+          T: GcSafe<'gc, CollectorId<C>>,
+          T: GcRebrand<'static, CollectorId<C>>,
+          T::Branded: GcSafe<'static, CollectorId<C>> + Sized {
     type Handle = GcHandle<T::Branded, C>;
 
     #[inline]

libs/context/src/lib.rs

@@ -2,6 +2,7 @@
     negative_impls, // !Send is much cleaner than `PhantomData<Rc>`
     untagged_unions, // I want to avoid ManuallyDrop in unions
     const_fn_trait_bound, // So generics + const fn are unstable, huh?
+    generic_associated_types, // Finally!
 )]
 #![allow(
     clippy::missing_safety_doc, // Entirely internal code

libs/derive/Cargo.toml

@@ -21,3 +21,6 @@ quote = "1.0.8"
 proc-macro2 = "1"
 # Utilities for argument parsing
 proc-macro-kwargs = "0.1.1"
+# Misc
+indexmap = "1"
+itertools = "0.10.1"

libs/derive/src/lib.rs

@@ -441,11 +441,20 @@ pub fn unsafe_gc_impl(input: proc_macro::TokenStream) -> proc_macro::TokenStream
     let parsed = parse_macro_input!(input as macros::MacroInput);
     let res = parsed.expand_output()
         .unwrap_or_else(|e| e.to_compile_error());
+    let tp = match parsed.target_type {
+        Type::Path(ref p) => Some(&p.path.segments.last().unwrap().ident),
+        _ => None
+    };
     let span_loc = span_file_loc(Span::call_site());
+    let f = if let Some(tp) = tp {
+        format!("unsafe_gc_impl!(target={}, ...) @ {}", tp, span_loc)
+    } else {
+        format!("unsafe_gc_impl! @ {}", span_loc)
+    };
     debug_derive(
         "unsafe_gc_impl!",
-        &span_loc,
-        &format_args!("unsafe_gc_impl! @ {}", span_loc),
+        &tp.map_or_else(|| span_loc.to_string(), |tp| tp.to_string()),
+        &f,
         &res
     );
     res.into()