First attempt a garbage collected arrays/vectors

This crashes even the most basic tests :(
Everything is broken.

I feel like I need to cleanup.

Author: Techcable

Cargo.toml

@@ -9,6 +9,7 @@ edition = "2018"
 readme = "README.md"
 
 [dependencies]
+scopeguard = "1.1"
 # Manually included tracing support for third party libraries
 # Providing support for these important libraries,
 # gives zerogc 'batteries included' support.

libs/context/src/collector.rs

@@ -12,6 +12,8 @@ use zerogc::{Gc, GcSafe, GcSystem, Trace, GcSimpleAlloc, NullTrace, TraceImmutab
 
 use crate::{CollectorContext};
 use crate::state::{CollectionManager, RawContext};
+use zerogc::vec::GcVec;
+use zerogc::vec::repr::GcVecRepr;
 
 /// A specific implementation of a collector
 pub unsafe trait RawCollectorImpl: 'static + Sized {
@@ -20,6 +22,8 @@ pub unsafe trait RawCollectorImpl: 'static + Sized {
     /// The simple collector implements this as
     /// a trait object pointer.
     type DynTracePtr: Copy + Debug + 'static;
+    /// The configuration
+    type Config: Sized + Default;
 
     /// A pointer to this collector
     ///
@@ -31,6 +35,8 @@ pub unsafe trait RawCollectorImpl: 'static + Sized {
 
     /// The context
     type RawContext: RawContext<Self>;
+    /// The raw representation of a vec
+    type RawVecRepr: GcVecRepr;
 
     /// True if this collector is a singleton
     ///
@@ -50,18 +56,18 @@ pub unsafe trait RawCollectorImpl: 'static + Sized {
     /// Initialize an instance of the collector
     ///
     /// Must panic if the collector is not a singleton
-    fn init(logger: Logger) -> NonNull<Self>;
+    fn init(config: Self::Config, logger: Logger) -> NonNull<Self>;
 
     /// The id of this collector
     #[inline]
     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>>,
+    unsafe fn gc_write_barrier<'gc, O, V>(
+        owner: &Gc<'gc, O, CollectorId<Self>>,
         value: &Gc<'gc, V, CollectorId<Self>>,
         field_offset: usize
-    ) where T: GcSafe + ?Sized + 'gc, V: GcSafe + ?Sized + 'gc;
+    ) where O: GcSafe + ?Sized + 'gc, V: GcSafe + ?Sized + 'gc;
     /// The logger associated with this collector
     fn logger(&self) -> &Logger;
 
@@ -90,7 +96,7 @@ pub unsafe trait SingletonCollector: RawCollectorImpl<Ptr=PhantomData<&'static S
     /// Initialize the global singleton
     ///
     /// Panics if already initialized
-    fn init_global(logger: Logger);
+    fn init_global(config: Self::Config, logger: Logger);
 }
 
 impl<C: RawCollectorImpl> PartialEq for CollectorId<C> {
@@ -278,6 +284,7 @@ impl<C: RawCollectorImpl> CollectorId<C> {
 }
 unsafe impl<C: RawCollectorImpl> ::zerogc::CollectorId for CollectorId<C> {
     type System = CollectorRef<C>;
+    type RawVecRepr = C::RawVecRepr;
 
     #[inline]
     fn from_gc_ptr<'a, 'gc, T>(gc: &'a Gc<'gc, T, Self>) -> &'a Self where T: GcSafe + ?Sized + 'gc, 'gc: 'a {
@@ -286,11 +293,11 @@ unsafe impl<C: RawCollectorImpl> ::zerogc::CollectorId for CollectorId<C> {
 
 
     #[inline(always)]
-    unsafe fn gc_write_barrier<'gc, T, V>(
-        owner: &Gc<'gc, T, Self>,
+    unsafe fn gc_write_barrier<'gc, O, V>(
+        owner: &Gc<'gc, O, Self>,
         value: &Gc<'gc, V, Self>,
         field_offset: usize
-    ) where T: GcSafe + ?Sized + 'gc, V: GcSafe + ?Sized + 'gc {
+    ) where O: GcSafe + ?Sized + 'gc, V: GcSafe + ?Sized + 'gc {
         C::gc_write_barrier(owner, value, field_offset)
     }
 
@@ -341,13 +348,33 @@ 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>>;
+    unsafe fn alloc_uninit_slice<'gc, T>(context: &'gc CollectorContext<Self>, len: usize) -> (CollectorId<Self>, *mut T)
+        where T: GcSafe + 'gc;
+    fn alloc_vec_with_capacity<'gc, T>(context: &'gc CollectorContext<Self>, capacity: usize) -> GcVec<'gc, T, CollectorContext<Self>> where T: GcSafe + 'gc;
 }
-unsafe impl<'gc, T, C> GcSimpleAlloc<'gc, T> for CollectorContext<C>
-    where T: GcSafe + 'gc, C: RawSimpleAlloc {
+unsafe impl<C> GcSimpleAlloc for CollectorContext<C>
+    where C: RawSimpleAlloc {
     #[inline]
-    fn alloc(&'gc self, value: T) -> Gc<'gc, T, Self::Id> {
+    fn alloc<'gc, T>(&'gc self, value: T) -> Gc<'gc, T, Self::Id>
+        where T: GcSafe + 'gc {
         C::alloc(self, value)
     }
+
+    #[inline]
+    unsafe fn alloc_uninit_slice<'gc, T>(&'gc self, len: usize) -> (Self::Id, *mut T)
+        where T: GcSafe + 'gc {
+        C::alloc_uninit_slice(self, len)
+    }
+
+    #[inline]
+    fn alloc_vec<'gc, T>(&'gc self) -> GcVec<'gc, T, Self> where T: GcSafe + 'gc {
+        self.alloc_vec_with_capacity(0)
+    }
+
+    #[inline]
+    fn alloc_vec_with_capacity<'gc, T>(&'gc self, capacity: usize) -> GcVec<'gc, T, Self> where T: GcSafe + 'gc {
+        C::alloc_vec_with_capacity(self, capacity)
+    }
 }
 
 /// A reference to the collector.
@@ -371,26 +398,26 @@ unsafe impl<C: SyncCollector> Sync for CollectorRef<C> {}
 #[doc(hidden)]
 pub trait CollectorInit<C: RawCollectorImpl<Ptr=Self>>: CollectorPtr<C> {
     fn create() -> CollectorRef<C> {
-        Self::with_logger(Logger::root(
+        Self::with_logger(C::Config::default(), Logger::root(
             slog::Discard,
             o!()
         ))
     }
-    fn with_logger(logger: Logger) -> CollectorRef<C>;
+    fn with_logger(config: C::Config, logger: Logger) -> CollectorRef<C>;
 }
 
 impl<C: RawCollectorImpl<Ptr=NonNull<C>>> CollectorInit<C> for NonNull<C> {
-    fn with_logger(logger: Logger) -> CollectorRef<C> {
+    fn with_logger(config: C::Config, logger: Logger) -> CollectorRef<C> {
         assert!(!C::SINGLETON);
-        let raw_ptr = C::init(logger);
+        let raw_ptr = C::init(config, logger);
         CollectorRef { ptr: raw_ptr }
     }
 }
 impl<C> CollectorInit<C> for PhantomData<&'static C>
     where C: SingletonCollector {
-    fn with_logger(logger: Logger) -> CollectorRef<C> {
+    fn with_logger(config: C::Config, logger: Logger) -> CollectorRef<C> {
         assert!(C::SINGLETON);
-        C::init_global(logger); // TODO: Is this safe?
+        C::init_global(config, logger); // TODO: Is this safe?
         // NOTE: The raw pointer is implicit (now that we're leaked)
         CollectorRef { ptr: PhantomData }
     }
@@ -405,7 +432,11 @@ impl<C: RawCollectorImpl> CollectorRef<C> {
 
     #[inline]
     pub fn with_logger(logger: Logger) -> Self where C::Ptr: CollectorInit<C> {
-        <C::Ptr as CollectorInit<C>>::with_logger(logger)
+        Self::with_config(C::Config::default(), logger)
+    }
+
+    pub fn with_config(config: C::Config, logger: Logger) -> Self where C::Ptr: CollectorInit<C> {
+        <C::Ptr as CollectorInit<C>>::with_logger(config, logger)
     }
 
     #[inline]

libs/context/src/utils.rs

@@ -8,9 +8,14 @@ use core::cell::Cell;
 /// Get the offset of the specified field within a structure
 #[macro_export]
 macro_rules! field_offset {
-    ($target:ty, $($field:ident).+) => {
-        unsafe { (core::ptr::addr_of!((*(std::ptr::null_mut::<$target>()))$(.$field)*) as usize) }
-    };
+    ($target:ty, $($field:ident).+) => {{
+        const OFFSET: usize = {
+            let uninit = core::mem::MaybeUninit::<$target>::uninit();
+            unsafe { ((core::ptr::addr_of!((*uninit.as_ptr())$(.$field)*)) as *const u8)
+                .offset_from(uninit.as_ptr() as *const u8) as usize }
+        };
+        OFFSET
+    }};
 }
 
 #[cfg(feature = "sync")]

libs/derive/src/lib.rs

@@ -732,6 +732,12 @@ fn impl_erase(target: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStream, Er
     };
     for param in &mut generics.params {
         let rewritten_param: GenericArgument;
+        fn unsupported_lifetime_param(lt: &Lifetime) -> Error {
+            Error::new(
+                lt.span(),
+                "Unless Self: NullTrace, derive(GcErase) is currently unable to handle lifetimes"
+            )
+        }
         match param {
             GenericParam::Type(ref mut type_param) => {
                 let param_name = &type_param.ident;
@@ -740,7 +746,20 @@ fn impl_erase(target: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStream, Er
                     rewritten_params.push(parse_quote!(#param_name));
                     continue
                 }
-                let original_bounds = type_param.bounds.iter().cloned().collect::<Vec<_>>();
+                fn rewrite_bound(bound: &TypeParamBound, info: &GcTypeInfo) -> Result<TypeParamBound, Error> {
+                    match bound {
+                        TypeParamBound::Trait(ref t) => Ok(TypeParamBound::Trait(t.clone())),
+                        TypeParamBound::Lifetime(ref lt) if *lt == info.config.gc_lifetime() => {
+                            Ok(parse_quote!('new_gc))
+                        },
+                        TypeParamBound::Lifetime(ref lt) => {
+                            return Err(unsupported_lifetime_param(lt))
+                        }
+                    }
+                }
+                let original_bounds = type_param.bounds.iter()
+                    .map(|bound| rewrite_bound(bound, info))
+                    .collect::<Result<Vec<_>, _>>()?;
                 type_param.bounds.push(parse_quote!(#zerogc_crate::GcErase<'min, #collector_id>));
                 type_param.bounds.push(parse_quote!('min));
                 let rewritten_type: Type = parse_quote!(<#param_name as #zerogc_crate::GcErase<'min, #collector_id>>::Erased);
@@ -754,13 +773,10 @@ fn impl_erase(target: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStream, Er
             },
             GenericParam::Lifetime(ref l) => {
                 if l.lifetime == info.config.gc_lifetime() {
-                    rewritten_param = parse_quote!('static);
+                    rewritten_param = parse_quote!('min);
                     assert!(!info.config.ignored_lifetimes.contains(&l.lifetime));
                 } else {
-                    return Err(Error::new(
-                        l.span(),
-                        "Unless Self: NullTrace, derive(GcErase) is currently unable to handle lifetimes"
-                    ))
+                    return Err(unsupported_lifetime_param(&l.lifetime))
                 }
             },
             GenericParam::Const(ref param) => {
@@ -881,14 +897,33 @@ fn impl_rebrand(target: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStream,
     };
     for param in &mut generics.params {
         let rewritten_param: GenericArgument;
+        fn unsupported_lifetime_param(lt: &Lifetime) -> Error {
+            Error::new(
+                lt.span(),
+                "Unless Self: NullTrace, derive(GcRebrand) is currently unable to handle lifetimes"
+            )
+        }
         match param {
             GenericParam::Type(ref mut type_param) => {
                 let param_name = &type_param.ident;
                 if info.is_ignored_param(&*type_param) {
                     rewritten_params.push(parse_quote!(#param_name));
                     continue
                 }
-                let original_bounds = type_param.bounds.iter().cloned().collect::<Vec<_>>();
+                let original_bounds = type_param.bounds.iter()
+                    .map(|bound| rewrite_bound(bound, info))
+                    .collect::<Result<Vec<_>, Error>>()?;
+                fn rewrite_bound(bound: &TypeParamBound, info: &GcTypeInfo) -> Result<TypeParamBound, Error> {
+                    match bound {
+                        TypeParamBound::Trait(ref t) => Ok(TypeParamBound::Trait(t.clone())),
+                        TypeParamBound::Lifetime(ref lt) if *lt == info.config.gc_lifetime() => {
+                            Ok(parse_quote!('new_gc))
+                        },
+                        TypeParamBound::Lifetime(ref lt) => {
+                            return Err(unsupported_lifetime_param(lt))
+                        }
+                    }
+                }
                 type_param.bounds.push(parse_quote!(#zerogc_crate::GcRebrand<'new_gc, #collector_id>));
                 let rewritten_type: Type = parse_quote!(<#param_name as #zerogc_crate::GcRebrand<'new_gc, #collector_id>>::Branded);
                 rewritten_restrictions.push(WherePredicate::Type(PredicateType {
@@ -904,10 +939,7 @@ fn impl_rebrand(target: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStream,
                     rewritten_param = parse_quote!('new_gc);
                     assert!(!info.config.ignored_lifetimes.contains(&l.lifetime));
                 } else {
-                    return Err(Error::new(
-                        l.span(),
-                        "Unless Self: NullTrace, derive(GcRebrand) is currently unable to handle lifetimes"
-                    ))
+                    return Err(unsupported_lifetime_param(&l.lifetime));
                 }
             },
             GenericParam::Const(ref param) => {
@@ -962,7 +994,7 @@ fn impl_trace(target: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStream, Er
     let zerogc_crate = zerogc_crate();
     let name = &target.ident;
     let generics = add_trait_bounds_except(
-        &target.generics, parse_quote!(zerogc::Trace),
+        &target.generics, parse_quote!(#zerogc_crate::Trace),
         &info.config.ignore_params, None
     )?;
     let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();

libs/derive/src/macros.rs

@@ -172,6 +172,13 @@ impl MacroInput {
         }
         let target_type = &self.target_type;
         let mut generics = self.basic_generics();
+        let id_type: Type = match self.options.collector_id {
+            Some(ref tp) => tp.clone(),
+            None => {
+                generics.params.push(parse_quote!(Id: #zerogc_crate::CollectorId));
+                parse_quote!(Id)
+            }
+        };
         let default_bounds: Vec<TypeParamBound> = match requirements {
             Some(TraitRequirements::Where(ref explicit_requirements)) => {
                 generics.make_where_clause().predicates
@@ -185,9 +192,9 @@ impl MacroInput {
             Some(TraitRequirements::Never) => unreachable!(),
             None => {
                 if rebrand {
-                    vec![parse_quote!(#zerogc_crate::GcRebrand<'new_gc, Id>)]
+                    vec![parse_quote!(#zerogc_crate::GcRebrand<'new_gc, #id_type>)]
                 } else {
-                    vec![parse_quote!(#zerogc_crate::GcErase<'min, Id>)]
+                    vec![parse_quote!(#zerogc_crate::GcErase<'min, #id_type>)]
                 }
             }
         };
@@ -236,17 +243,16 @@ impl MacroInput {
          */
         generics.make_where_clause().predicates
             .extend(self.bounds.trace_where_clause(&self.params).predicates);
-        generics.params.push(parse_quote!(Id: #zerogc_crate::CollectorId));
         if rebrand {
             generics.params.push(parse_quote!('new_gc));
         } else {
             generics.params.push(parse_quote!('min));
         }
         let (impl_generics, _, where_clause) = generics.split_for_impl();
         let target_trait = if rebrand {
-            quote!(#zerogc_crate::GcRebrand<'new_gc, Id>)
+            quote!(#zerogc_crate::GcRebrand<'new_gc, #id_type>)
         } else {
-            quote!(#zerogc_crate::GcErase<'min, Id>)
+            quote!(#zerogc_crate::GcErase<'min, #id_type>)
         };
         fn rewrite_brand_trait(
             target: &Type, trait_name: &str, target_params: &HashSet<Ident>,
@@ -278,7 +284,7 @@ impl MacroInput {
                 rewrite_brand_trait(
                     &self.target_type, "GcRebrand",
                     &target_params,
-                    parse_quote!(#zerogc_crate::GcRebrand<'new_gc, Id>),
+                    parse_quote!(#zerogc_crate::GcRebrand<'new_gc, #id_type>),
                     parse_quote!(Branded)
                 )
             }, Ok)?;
@@ -288,7 +294,7 @@ impl MacroInput {
                 rewrite_brand_trait(
                     &self.target_type, "GcErase",
                     &target_params,
-                    parse_quote!(#zerogc_crate::GcErase<'min, Id>),
+                    parse_quote!(#zerogc_crate::GcErase<'min, #id_type>),
                     parse_quote!(Erased)
                 )
             })?;
@@ -378,6 +384,7 @@ impl Parse for MacroInput {
             "visit" [VisitClosure] opt => visit_closure;
             "trace_mut" [VisitClosure] opt => trace_mut_closure;
             "trace_immutable" [VisitClosure] opt => trace_immutable_closure;
+            "collector_id" [Type] opt => collector_id;
         });
         let bounds = res.bounds.unwrap_or_default();
         if let Some(TraitRequirements::Never) = bounds.trace  {
@@ -439,7 +446,8 @@ impl Parse for MacroInput {
                 branded_type: res.branded_type,
                 erased_type: res.erased_type,
                 needs_trace: res.needs_trace,
-                needs_drop: res.needs_drop
+                needs_drop: res.needs_drop,
+                collector_id: res.collector_id
             },
             visit: visit_impl
         })
@@ -598,6 +606,8 @@ pub struct StandardOptions {
     needs_trace: Expr,
     /// A (constant) expression determining whether the type should be dropped
     needs_drop: Expr,
+    /// The fixed id of the collector, or `None` if the type can work with any collector
+    collector_id: Option<Type>
 }
 
 /// The visit implementation.