T: GcSafe<'gc, T> should no longer imply T: 'gc (#32)

Clarify the lifetime and ownership for `Gc`.
A Gc pointer is logically equivalent to a pair of (*mut T, &'gc Id::System). It does *not* contain a &'gc T like you would expect.
This means that we can weaken the `T: 'gc` lifetime, which paves the way for temporary borrows that are shorter than the 'gc lifetime. In other words, it should eventually be possible to have &'a T even if 'a < 'gc

Also, we can safely make the lifetime covariant now :)

Merges #32 

I had tried to make GcRebrand take advantage of generic associated types, but that was an utter failure.

Author: Techcable

libs/context/src/collector.rs

@@ -85,7 +85,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<'gc, CollectorId<Self>> + ?Sized + 'gc, V: GcSafe<'gc, CollectorId<Self>> + ?Sized + 'gc;
+    ) where O: GcSafe<'gc, CollectorId<Self>> + ?Sized, V: GcSafe<'gc, CollectorId<Self>> + ?Sized;
     /// The logger associated with this collector
     fn logger(&self) -> &Logger;
 
@@ -302,21 +302,20 @@ unsafe impl<C: RawCollectorImpl> ::zerogc::CollectorId for CollectorId<C> {
     type System = CollectorRef<C>;
     type RawVecRepr<'gc> = C::RawVecRepr<'gc>;
     // TODO: What if clients want to customize this?
-    type ArrayRepr<'gc, T: 'gc> = zerogc::array::repr::ThinArrayRepr<'gc, T, Self>;
+    type ArrayRepr<'gc, T> = zerogc::array::repr::ThinArrayRepr<'gc, T, Self>;
 
     #[inline]
-    fn from_gc_ptr<'a, 'gc, T>(gc: &'a Gc<'gc, T, Self>) -> &'a Self where T: ?Sized + 'gc, 'gc: 'a {
+    fn from_gc_ptr<'a, 'gc, T>(gc: &'a Gc<'gc, T, Self>) -> &'a Self where T: ?Sized, 'gc: 'a {
         C::id_for_gc(gc)
     }
 
     #[inline]
-    fn resolve_array_id<'a, 'gc, T>(gc: &'a Self::ArrayRepr<'gc, T>) -> &'a Self where T: 'gc, 'gc: 'a {
+    fn resolve_array_id<'a, 'gc, T>(gc: &'a Self::ArrayRepr<'gc, T>) -> &'a Self where 'gc: 'a {
         C::id_for_array(gc)
     }
 
     #[inline]
-    fn resolve_array_len<'gc, T>(repr: &ThinArrayRepr<'gc, T, Self>) -> usize
-        where T: 'gc {
+    fn resolve_array_len<'gc, T>(repr: &ThinArrayRepr<'gc, T, Self>) -> usize {
         C::resolve_array_len(repr)
     }
 
@@ -325,7 +324,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<'gc, Self> + ?Sized + 'gc, V: GcSafe<'gc, Self> + ?Sized + 'gc {
+    ) where O: GcSafe<'gc, Self> + ?Sized, V: GcSafe<'gc, Self> + ?Sized {
         C::gc_write_barrier(owner, value, field_offset)
     }
 
@@ -341,7 +340,7 @@ unsafe impl<C: RawCollectorImpl> ::zerogc::CollectorId for CollectorId<C> {
 }
 unsafe impl<C: ~const ConstRawCollectorImpl> const zerogc::internals::ConstCollectorId for CollectorId<C> {
     #[inline]
-    fn resolve_array_len_const<'gc, T>(repr: &Self::ArrayRepr<'gc, T>) -> usize where T: 'gc {
+    fn resolve_array_len_const<'gc, T>(repr: &Self::ArrayRepr<'gc, T>) -> usize {
         C::resolve_array_len_const(repr)
     }
 }
@@ -390,8 +389,8 @@ impl<C: RawCollectorImpl> WeakCollectorRef<C> {
 }
 
 pub unsafe trait RawSimpleAlloc: RawCollectorImpl {
-    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)
+    unsafe fn alloc_uninit<'gc, T: GcSafe<'gc, CollectorId<Self>>>(context: &'gc CollectorContext<Self>) -> *mut T;
+    unsafe fn alloc_uninit_slice<'gc, T>(context: &'gc CollectorContext<Self>, len: usize) -> *mut T
         where T: GcSafe<'gc, CollectorId<Self>>;
     fn alloc_vec<'gc, T>(context: &'gc CollectorContext<Self>) -> GcVec<'gc, T, CollectorContext<Self>>
         where T: GcSafe<'gc, CollectorId<Self>>;
@@ -401,24 +400,24 @@ pub unsafe trait RawSimpleAlloc: RawCollectorImpl {
 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, CollectorId<C>> + 'gc {
+    unsafe fn alloc_uninit<'gc, T>(&'gc self) -> *mut T
+        where T: GcSafe<'gc, CollectorId<C>> {
         C::alloc_uninit(self)
     }
 
     #[inline]
-    unsafe fn alloc_uninit_slice<'gc, T>(&'gc self, len: usize) -> (Self::Id, *mut T)
-        where T: GcSafe<'gc, CollectorId<C>> + 'gc {
+    unsafe fn alloc_uninit_slice<'gc, T>(&'gc self, len: usize) -> *mut T
+        where T: GcSafe<'gc, CollectorId<C>> {
         C::alloc_uninit_slice(self, len)
     }
 
     #[inline]
-    fn alloc_vec<'gc, T>(&'gc self) -> GcVec<'gc, T, Self> where T: GcSafe<'gc, CollectorId<C>> + 'gc {
+    fn alloc_vec<'gc, T>(&'gc self) -> GcVec<'gc, T, Self> where T: GcSafe<'gc, CollectorId<C>> {
         C::alloc_vec(self)
     }
 
     #[inline]
-    fn alloc_vec_with_capacity<'gc, T>(&'gc self, capacity: usize) -> GcVec<'gc, T, Self> where T: GcSafe<'gc, CollectorId<C>> + 'gc {
+    fn alloc_vec_with_capacity<'gc, T>(&'gc self, capacity: usize) -> GcVec<'gc, T, Self> where T: GcSafe<'gc, CollectorId<C>> {
         C::alloc_vec_with_capacity(self, capacity)
     }
 }

libs/derive/src/derive.rs

@@ -717,9 +717,6 @@ impl TraceDeriveInput {
                 let regular = &regular.ident;
                 generics.make_where_clause().predicates.push(parse_quote!(#regular: zerogc::NullTrace));
             }
-            for ignored in &self.generics.ignored_lifetimes {
-                generics.make_where_clause().predicates.push(parse_quote!(#ignored: 'new_gc))
-            }
             generics.make_where_clause().predicates.push(parse_quote!(Self: zerogc::GcSafe<'new_gc, Id>));
             if let Some(ref gc_lt) = self.gc_lifetime() {
                 return Err(Error::custom("A NullTrace type may not have a 'gc lifetime").with_span(gc_lt))
@@ -792,9 +789,6 @@ impl TraceDeriveInput {
             }).collect::<Vec<_>>();
             generics.make_where_clause().predicates.push(parse_quote!(#target: #(#rewritten_bounds)+*));
         }
-        for ignored in &self.generics.ignored_lifetimes {
-            generics.make_where_clause().predicates.push(parse_quote!(#ignored: 'new_gc));
-        }
         let target_type = &self.ident;
 
         let rewritten_path: Path = {
@@ -925,7 +919,7 @@ impl TraceDeriveInput {
         };
         let visit_inside_gc = if !immutable {
             let where_clause = quote!(where Visitor: zerogc::GcVisitor,
-                ActualId: zerogc::CollectorId, Self: zerogc::GcSafe<'actual_gc, ActualId> + 'actual_gc);
+                ActualId: zerogc::CollectorId, Self: zerogc::GcSafe<'actual_gc, ActualId>);
             Some(quote! {
                 #[inline]
                 unsafe fn trace_inside_gc<'actual_gc, Visitor, ActualId>(gc: &mut zerogc::Gc<'actual_gc, Self, ActualId>, visitor: &mut Visitor) -> Result<(), Visitor::Err>

libs/derive/src/lib.rs

@@ -45,19 +45,31 @@ pub(crate) fn sort_params(generics: &mut Generics) {
         Lifetime,
         Type,
         Const,
-        EndPunct
     }
     let mut pairs = std::mem::take(&mut generics.params).into_pairs()
         .collect::<Vec<_>>();
     use syn::punctuated::Pair;
     pairs.sort_by_key(|pair| {
-        match pair {
-            Pair::Punctuated(syn::GenericParam::Lifetime(_), _) => ParamOrder::Lifetime,
-            Pair::Punctuated(syn::GenericParam::Type(_), _) => ParamOrder::Type,
-            Pair::Punctuated(syn::GenericParam::Const(_), _) => ParamOrder::Const,
-            Pair::End(_) => ParamOrder::EndPunct,
+        match pair.value() {
+            syn::GenericParam::Lifetime(_) => ParamOrder::Lifetime,
+            syn::GenericParam::Type(_) => ParamOrder::Type,
+            syn::GenericParam::Const(_) => ParamOrder::Const,
         }
     });
+    /*
+     * NOTE: The `Pair::End` can only come at the end.
+     * Now that we've sorted, it's possible the old ending
+     * could be in the first position or some other position
+     * before the end.
+     *
+     * If that's the case, then add punctuation to the end.
+     */
+    if let Some(old_ending_index) = pairs.iter().position(|p| p.punct().is_none()) {
+        if old_ending_index != pairs.len() - 1 {
+            let value = pairs.remove(old_ending_index).into_value();
+            pairs.insert(old_ending_index, Pair::Punctuated(value, Default::default()));
+        }
+    }
     generics.params = pairs.into_iter().collect();
 }
 

libs/derive/src/macros.rs

@@ -282,7 +282,7 @@ impl MacroInput {
             let where_clause = if let Some(ref clause) = self.bounds.visit_inside_gc {
                 clause.clone()
             } else {
-                parse_quote!(where Visitor: #zerogc_crate::GcVisitor, ActualId: #zerogc_crate::CollectorId, Self: #zerogc_crate::GcSafe<'actual_gc, ActualId> + 'actual_gc)
+                parse_quote!(where Visitor: #zerogc_crate::GcVisitor, ActualId: #zerogc_crate::CollectorId, Self: #zerogc_crate::GcSafe<'actual_gc, ActualId>)
             };
             Some(quote! {
                 #[inline]

libs/simple/src/layout.rs

@@ -259,8 +259,8 @@ impl GcVecHeader {
 ///
 /// NOTE: Length and capacity are stored implicitly in the [GcVecHeader]
 #[repr(C)]
-pub struct SimpleVecRepr<'gc, T: GcSafe<'gc, crate::CollectorId>> {
-    marker: PhantomData<&'gc T>,
+pub struct SimpleVecRepr<'gc, T: GcSafe<'gc, crate::CollectorId> + Sized> {
+    marker: PhantomData<(*const [T], &'gc crate::CollectorId)>,
 }
 impl<'gc, T: GcSafe<'gc, crate::CollectorId>> SimpleVecRepr<'gc, T> {
     #[inline]

libs/simple/src/lib.rs

@@ -68,7 +68,7 @@ use zerogc_context::utils::{ThreadId, MemorySize};
 use crate::alloc::{SmallArenaList, SmallArena};
 use crate::layout::{StaticGcType, GcType, SimpleVecRepr, DynamicObj, StaticVecType, SimpleMarkData, SimpleMarkDataSnapshot, GcHeader, BigGcObject, HeaderLayout, GcArrayHeader, GcVecHeader, GcTypeLayout};
 
-use zerogc_context::collector::{RawSimpleAlloc, RawCollectorImpl};
+use zerogc_context::collector::{RawSimpleAlloc};
 use zerogc_context::handle::{GcHandleList, RawHandleImpl};
 use zerogc_context::{CollectionManager as AbstractCollectionManager, RawContext as AbstractRawContext, CollectorContext};
 use zerogc::vec::{GcRawVec};
@@ -152,23 +152,23 @@ static GLOBAL_COLLECTOR: AtomicPtr<RawSimpleCollector> = AtomicPtr::new(std::ptr
 
 unsafe impl RawSimpleAlloc for RawSimpleCollector {
     #[inline]
-    unsafe fn alloc_uninit<'gc, T>(context: &'gc SimpleCollectorContext) -> (CollectorId, *mut T) where T: GcSafe<'gc, crate::CollectorId> {
+    unsafe fn alloc_uninit<'gc, T>(context: &'gc SimpleCollectorContext) -> *mut T where T: GcSafe<'gc, crate::CollectorId> {
         let (_header, ptr) = context.collector().heap.allocator.alloc_layout(
             GcHeader::LAYOUT,
             Layout::new::<T>(),
             T::STATIC_TYPE
         );
-        (context.collector().id(), ptr as *mut T)
+        ptr as *mut T
     }
 
-    unsafe fn alloc_uninit_slice<'gc, T>(context: &'gc CollectorContext<Self>, len: usize) -> (CollectorId, *mut T) where T: GcSafe<'gc, crate::CollectorId> {
+    unsafe fn alloc_uninit_slice<'gc, T>(context: &'gc CollectorContext<Self>, len: usize) -> *mut T where T: GcSafe<'gc, crate::CollectorId> {
         let (header, ptr) = context.collector().heap.allocator.alloc_layout(
             GcArrayHeader::LAYOUT,
             Layout::array::<T>(len).unwrap(),
             <[T] as StaticGcType>::STATIC_TYPE
         );
         (*header).len = len;
-        (context.collector().id(), ptr.cast())
+        ptr.cast()
     }
 
     #[inline]

src/array.rs

@@ -112,13 +112,13 @@ impl<'gc, Id: CollectorId> Display for GcString<'gc, Id> {
 /// This is a `#[repr(transparent)]` wrapper around
 /// [GcArrayRepr].
 #[repr(transparent)]
-pub struct GcArray<'gc, T: 'gc, Id: CollectorId> {
+pub struct GcArray<'gc, T, Id: CollectorId> {
     repr: Id::ArrayRepr<'gc, T>
 }
 impl<'gc, T, Id: CollectorId> GcArray<'gc, T, Id> {
     /// Convert this array into a slice
     #[inline]
-    pub fn as_slice(&self) -> &'gc [T] {
+    pub fn as_slice<'a>(&self) -> &'a [T] where 'gc: 'a {
         self.repr.as_slice()
     }
     /// Load a raw pointer to the array's value
@@ -159,7 +159,7 @@ impl<'gc, T, Id: CollectorId> GcArray<'gc, T, Id> {
 /// Const access to [GcString]
 pub trait ConstArrayAccess<'gc, T> {
     /// The value of the array as a slice
-    fn as_slice_const(&self) -> &'gc [T];
+    fn as_slice_const<'a>(&self) -> &'a [T] where 'gc: 'a;
     /// Load a raw pointer to the array's value
     fn as_raw_ptr_const(&self) -> *mut T;
     /// The length of this array
@@ -168,7 +168,7 @@ pub trait ConstArrayAccess<'gc, T> {
 // Relax T: GcSafe bound
 impl<'gc, T, Id: ~const ConstCollectorId> const ConstArrayAccess<'gc, T> for GcArray<'gc, T, Id> {
     #[inline]
-    fn as_slice_const(&self) -> &'gc [T] {
+    fn as_slice_const<'a>(&self) -> &'a [T] where 'gc: 'a {
         /*
          * TODO: This is horrible, but currently nessicarry
          * to do this in a const-fn context.
@@ -178,7 +178,7 @@ impl<'gc, T, Id: ~const ConstCollectorId> const ConstArrayAccess<'gc, T> for GcA
                 unsafe {
                     core::mem::transmute_copy::<
                         Id::ArrayRepr<'gc, T>,
-                        &'gc [T]
+                        &'a [T]
                     >(&self.repr)
                 }
             },

src/array/repr.rs

@@ -54,7 +54,7 @@ pub unsafe trait GcArrayRepr<'gc, T>: Copy + sealed::Sealed {
     /// The combination of pointer + length must be valid. 
     unsafe fn from_raw_parts(ptr: NonNull<T>, len: usize) -> Self;
     /// Convert the value to a slice
-    fn as_slice(&self) -> &'gc [T];
+    fn as_slice<'a>(&self) -> &'a [T] where 'gc: 'a;
     /// Get a raw pointer to this array's elements.
     fn as_raw_ptr(&self) -> *mut T;
     /// Get the length of this value
@@ -67,7 +67,7 @@ pub unsafe trait GcArrayRepr<'gc, T>: Copy + sealed::Sealed {
 /// This type is guaranteed to be compatible with `&[T]`.
 /// Transmuting back and forth is safe.
 #[repr(transparent)]
-pub struct FatArrayRepr<'gc, T: 'gc, Id: CollectorId> {
+pub struct FatArrayRepr<'gc, T, Id: CollectorId> {
     slice: NonNull<[T]>,
     marker: PhantomData<Gc<'gc, [T], Id>>
 }
@@ -104,7 +104,7 @@ unsafe impl<'gc, T, Id: CollectorId> GcArrayRepr<'gc, T> for FatArrayRepr<'gc, T
     }
 
     #[inline]
-    fn as_slice(&self) -> &'gc [T] {
+    fn as_slice<'a>(&self) -> &'a [T] where 'gc: 'a {
         unsafe { &*self.slice.as_ptr() }
     }
 
@@ -127,7 +127,7 @@ unsafe impl<'gc, T, Id: CollectorId> GcArrayRepr<'gc, T> for FatArrayRepr<'gc, T
 /// and can be transmuted back and forth
 /// (assuming the appropriate invariants are met).
 #[repr(transparent)]
-pub struct ThinArrayRepr<'gc, T: 'gc, Id: CollectorId> {
+pub struct ThinArrayRepr<'gc, T, Id: CollectorId> {
     elements: NonNull<T>,
     marker: PhantomData<Gc<'gc, [T], Id>>    
 }
@@ -152,7 +152,7 @@ unsafe impl<'gc, T, Id: CollectorId> GcArrayRepr<'gc, T> for ThinArrayRepr<'gc,
         res
     }
     #[inline]
-    fn as_slice(&self) -> &'gc [T] {
+    fn as_slice<'a>(&self) -> &'a [T] where 'gc: 'a {
         unsafe { core::slice::from_raw_parts(
             self.elements.as_ptr(),
             self.len()
@@ -173,4 +173,4 @@ unsafe impl<'gc, T, Id: CollectorId> GcArrayRepr<'gc, T> for ThinArrayRepr<'gc,
 
 mod sealed {
     pub trait Sealed {}
-}
+}