[BREAKING] Split GcBrand up into GcErase + GcRebrand

This helps clarify its two seperate purposes.
We stil require T: NullTrace for the `&'a T` implementation.
This seems like a requirement for the time beeing :(

Give warnings for the auto-derived implementations of GcRebrand and
GcErase indicating that we (currently) don't check the correctness
of the implementation on each of the fields.

I've changed the double-indirection and '&mut &mut T' behavior I
had setup back when we used a copying collector. This doesn't break anything
right now (because we use a non-moving collector).
However, I have to be really careful if we ever switch back!

This commit is so incompatible it will force us towards a 0.2.0-alpha release.

Author: Techcable

libs/context/src/handle.rs

@@ -5,7 +5,7 @@ use std::ptr::NonNull;
 use std::marker::PhantomData;
 use std::sync::atomic::{self, AtomicPtr, AtomicUsize, Ordering};
 
-use zerogc::{Trace, GcSafe, GcBrand, GcVisitor, NullTrace, TraceImmutable, GcHandleSystem, GcBindHandle};
+use zerogc::{Trace, GcSafe, GcErase, GcRebrand, GcVisitor, NullTrace, TraceImmutable, GcHandleSystem, GcBindHandle};
 use crate::{Gc, WeakCollectorRef, CollectorId, CollectorContext, CollectorRef, CollectionManager};
 use crate::collector::RawCollectorImpl;
 
@@ -434,7 +434,7 @@ 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: GcBrand<'new_gc, CollectorId<C>>,
+    where T: GcSafe, T: GcRebrand<'new_gc, CollectorId<C>>,
           T::Branded: GcSafe, C: RawHandleImpl {
     #[inline]
     fn bind_to(&self, context: &'new_gc CollectorContext<C>) -> Gc<'new_gc, T::Branded, CollectorId<C>> {
@@ -590,12 +590,12 @@ 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, T, C> GcHandleSystem<'gc, T> for CollectorRef<C>
+unsafe impl<'gc, 'a, T, C> GcHandleSystem<'gc, 'a, T> for CollectorRef<C>
     where C: RawHandleImpl,
           T: GcSafe + 'gc,
-          T: GcBrand<'static, CollectorId<C>>,
-          T::Branded: GcSafe {
-    type Handle = GcHandle<T::Branded, C>;
+          T: GcErase<'a, CollectorId<C>>,
+          T::Erased: GcSafe {
+    type Handle = GcHandle<T::Erased, C>;
 
     #[inline]
     fn create_handle(gc: Gc<'gc, T, CollectorId<C>>) -> Self::Handle {

libs/derive/src/lib.rs

@@ -1,3 +1,6 @@
+#![feature(
+    proc_macro_diagnostic, // NEEDED for warnings
+)]
 extern crate proc_macro;
 
 use quote::{quote, quote_spanned};
@@ -323,12 +326,14 @@ fn impl_derive_trace(input: &DeriveInput) -> Result<TokenStream, syn::Error> {
     } else {
         impl_trace(&input, &info)?
     };
-    let brand_impl = impl_brand(&input, &info)?;
+    let rebrand_impl = impl_rebrand(&input, &info)?;
+    let erase_impl = impl_erase(&input, &info)?;
     let gc_safe_impl = impl_gc_safe(&input, &info)?;
     let extra_impls = impl_extras(&input, &info)?;
     Ok(quote! {
         #trace_impl
-        #brand_impl
+        #rebrand_impl
+        #erase_impl
         #gc_safe_impl
         #extra_impls
     })
@@ -458,7 +463,7 @@ fn impl_extras(target: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStream, E
     })
 }
 
-fn impl_brand(target: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStream, Error> {
+fn impl_erase(target: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStream, Error> {
     let name = &target.ident;
     let mut generics: Generics = target.generics.clone();
     let mut rewritten_params = Vec::new();
@@ -468,9 +473,76 @@ fn impl_brand(target: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStream, Er
         match param {
             GenericParam::Type(ref mut type_param) => {
                 let original_bounds = type_param.bounds.iter().cloned().collect::<Vec<_>>();
-                type_param.bounds.push(parse_quote!(::zerogc::GcBrand<'new_gc, S>));
+                type_param.bounds.push(parse_quote!(::zerogc::GcErase<'max, S>));
+                type_param.bounds.push(parse_quote!('max));
                 let param_name = &type_param.ident;
-                let rewritten_type: Type = parse_quote!(<#param_name as ::zerogc::GcBrand<'new_gc, S>>::Branded);
+                let rewritten_type: Type = parse_quote!(<#param_name as ::zerogc::GcErase<'max, S>>::Erased);
+                rewritten_restrictions.push(WherePredicate::Type(PredicateType {
+                    lifetimes: None,
+                    bounded_ty: rewritten_type.clone(),
+                    colon_token: Default::default(),
+                    bounds: original_bounds.into_iter().collect()
+                }));
+                rewritten_param = GenericArgument::Type(rewritten_type);
+            },
+            GenericParam::Lifetime(ref l) => {
+                if l.lifetime == info.config.gc_lifetime() {
+                    rewritten_param = parse_quote!('static);
+                    assert!(!info.config.ignored_lifetimes.contains(&l.lifetime));
+                } else if info.config.ignored_lifetimes.contains(&l.lifetime) {
+                    let lt = l.lifetime.clone();
+                    rewritten_restrictions.push(WherePredicate::Lifetime(PredicateLifetime {
+                        lifetime: parse_quote!('max),
+                        colon_token: Default::default(),
+                        bounds: parse_quote!(#lt)
+                    }));
+                    rewritten_param = GenericArgument::Lifetime(lt);
+                } else {
+                    return Err(Error::new(
+                        l.span(),
+                        "Unable to handle lifetime"
+                    ));
+                }
+            },
+            GenericParam::Const(ref param) => {
+                let name = &param.ident;
+                rewritten_param = GenericArgument::Const(parse_quote!(#name));
+            }
+        }
+        rewritten_params.push(rewritten_param);
+    }
+    let mut impl_generics = generics.clone();
+    impl_generics.params.push(GenericParam::Lifetime(parse_quote!('max)));
+    impl_generics.params.push(GenericParam::Type(parse_quote!(S: ::zerogc::CollectorId)));
+    impl_generics.make_where_clause().predicates.extend(rewritten_restrictions);
+    let (_, ty_generics, _) = generics.split_for_impl();
+    let (impl_generics, _, where_clause) = impl_generics.split_for_impl();
+    ::proc_macro::Diagnostic::spanned(
+        ::proc_macro::Span::call_site(),
+        ::proc_macro::Level::Warning,
+        "derive(GcErase) doesn't currently verify the correctness of its fields"
+    ).emit();
+    Ok(quote! {
+        unsafe impl #impl_generics ::zerogc::GcErase<'max, S>
+            for #name #ty_generics #where_clause {
+            type Erased = #name::<#(#rewritten_params),*>;
+        }
+    })
+}
+
+fn impl_rebrand(target: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStream, Error> {
+    let name = &target.ident;
+    let mut generics: Generics = target.generics.clone();
+    let mut rewritten_params = Vec::new();
+    let mut rewritten_restrictions = Vec::new();
+    for param in &mut generics.params {
+        let rewritten_param: GenericArgument;
+        match param {
+            GenericParam::Type(ref mut type_param) => {
+                let original_bounds = type_param.bounds.iter().cloned().collect::<Vec<_>>();
+                type_param.bounds.push(parse_quote!(::zerogc::GcRebrand<'new_gc, S>));
+                let param_name = &type_param.ident;
+                let rewritten_type: Type = parse_quote!(<#param_name as ::zerogc::GcRebrand<'new_gc, S>>::Branded);
                 rewritten_restrictions.push(WherePredicate::Type(PredicateType {
                     lifetimes: None,
                     bounded_ty: rewritten_type.clone(),
@@ -505,8 +577,13 @@ fn impl_brand(target: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStream, Er
     impl_generics.make_where_clause().predicates.extend(rewritten_restrictions);
     let (_, ty_generics, _) = generics.split_for_impl();
     let (impl_generics, _, where_clause) = impl_generics.split_for_impl();
+    ::proc_macro::Diagnostic::spanned(
+        ::proc_macro::Span::call_site(),
+        ::proc_macro::Level::Warning,
+        "derive(GcRebrand) doesn't currently verify the correctness of its fields"
+    ).emit();
     Ok(quote! {
-        unsafe impl #impl_generics ::zerogc::GcBrand<'new_gc, S>
+        unsafe impl #impl_generics ::zerogc::GcRebrand<'new_gc, S>
             for #name #ty_generics #where_clause {
             type Branded = #name::<#(#rewritten_params),*>;
         }

libs/derive/tests/basic.rs

@@ -61,6 +61,7 @@ struct NopTrace {
     wow: Box<NopTrace>
 }
 
+#[cfg(disabled)] // TODO: Fixup
 #[derive(Trace)]
 #[zerogc(nop_trace, ignore_lifetimes("'a"), ignore_params(T))]
 #[allow(unused)]

src/lib.rs

@@ -86,7 +86,7 @@ macro_rules! safepoint_recurse {
          * We trust that GcContext::recurse_context
          * did not perform a collection after calling the closure.
          */
-        let result = unsafe { $context.rebrand_self(erased_result) };
+        let result = unsafe { $context.rebrand_self(**erased_result) };
         safepoint!($context, (root, result))
     }};
 }
@@ -117,7 +117,7 @@ macro_rules! __recurse_context {
              * NOTE: Guarenteed to live for the lifetime of the entire closure.
              * However, it could be relocated if 'sub_collector' is collected
              */
-            let $new_root = $sub_context.rebrand_self(erased_root);
+            let $new_root = $sub_context.rebrand_self(*erased_root);
             $closure
         })
     }};
@@ -208,11 +208,11 @@ pub unsafe trait GcSystem {
 /// This type-system hackery is needed because
 /// we need to place bounds on `T as GcBrand`
 // TODO: Remove when we get more powerful types
-pub unsafe trait GcHandleSystem<'gc, T: GcSafe + ?Sized + 'gc>: GcSystem
-    where T: GcBrand<'static, Self::Id>,
-          <T as GcBrand<'static, Self::Id>>::Branded: GcSafe {
+pub unsafe trait GcHandleSystem<'gc, 'a, T: GcSafe + ?Sized + 'gc>: GcSystem
+    where T: GcErase<'a, Self::Id>,
+          <T as GcErase<'a, Self::Id>>::Erased: GcSafe {
     /// The type of handles to this object.
-    type Handle: GcHandle<<T as GcBrand<'static, Self::Id>>::Branded, System=Self>;
+    type Handle: GcHandle<<T as GcErase<'a, Self::Id>>::Erased, System=Self>;
 
     /// Create a handle to the specified GC pointer,
     /// which can be used without a context
@@ -281,16 +281,16 @@ pub unsafe trait GcContext: Sized {
 
     #[inline(always)]
     #[doc(hidden)]
-    unsafe fn rebrand_static<T>(&self, value: T) -> T::Branded
-        where T: GcBrand<'static, Self::Id> {
+    unsafe fn rebrand_static<'a, T>(&self, value: T) -> T::Erased
+        where T: GcErase<'a, Self::Id> {
         let branded = mem::transmute_copy(&value);
         mem::forget(value);
         branded
     }
     #[inline(always)]
     #[doc(hidden)]
-    unsafe fn rebrand_self<'a, T>(&'a self, value: T) -> T::Branded
-        where T: GcBrand<'a, Self::Id> {
+    unsafe fn rebrand_self<'gc, T>(&'gc self, value: T) -> T::Branded
+        where T: GcRebrand<'gc, Self::Id> {
         let branded = mem::transmute_copy(&value);
         mem::forget(value);
         branded
@@ -414,6 +414,10 @@ pub struct Gc<'gc, T: GcSafe + ?Sized + 'gc, Id: CollectorId> {
     /// Used to uniquely identify the collector,
     /// to ensure we aren't modifying another collector's pointers
     collector_id: Id,
+    /*
+     * TODO: I think this lifetime variance is safe
+     * Better add some tests and an explination.
+     */
     marker: PhantomData<&'gc T>,
 }
 impl<'gc, T: GcSafe + ?Sized + 'gc, Id: CollectorId> Gc<'gc, T, Id> {
@@ -447,11 +451,11 @@ impl<'gc, T: GcSafe + ?Sized + 'gc, Id: CollectorId> Gc<'gc, T, Id> {
 
     /// Create a handle to this object, which can be used without a context
     #[inline]
-    pub fn create_handle(&self) -> <Id::System as GcHandleSystem<'gc, T>>::Handle
-        where Id::System: GcHandleSystem<'gc, T>,
-              T: GcBrand<'static, Id>,
-              <T as GcBrand<'static, Id>>::Branded: GcSafe {
-        <Id::System as GcHandleSystem<'gc, T>>::create_handle(*self)
+    pub fn create_handle<'a>(&self) -> <Id::System as GcHandleSystem<'gc, 'a, T>>::Handle
+        where Id::System: GcHandleSystem<'gc, 'a, T>,
+              T: GcErase<'a, Id> + 'a,
+              <T as GcErase<'a, Id>>::Erased: GcSafe + 'a {
+        <Id::System as GcHandleSystem<'gc, 'a, T>>::create_handle(*self)
     }
 
     /// Get a reference to the system
@@ -481,10 +485,17 @@ unsafe impl<'gc, T: GcSafe + 'gc, Id: CollectorId> GcSafe for Gc<'gc, T, Id> {
     const NEEDS_DROP: bool = true; // We are Copy
 }
 /// Rebrand
-unsafe impl<'gc, 'new_gc, T, Id> GcBrand<'new_gc, Id> for Gc<'gc, T, Id>
-    where T: GcSafe + GcBrand<'new_gc, Id>,
-          T::Branded: GcSafe, Id: CollectorId {
-    type Branded = Gc<'new_gc, <T as GcBrand<'new_gc, Id>>::Branded, Id>;
+unsafe impl<'gc, 'new_gc, T, Id> GcRebrand<'new_gc, Id> for Gc<'gc, T, Id>
+    where T: GcSafe + GcRebrand<'new_gc, Id>,
+          <T as GcRebrand<'new_gc, Id>>::Branded: GcSafe,
+          Id: CollectorId, {
+    type Branded = Gc<'new_gc, <T as GcRebrand<'new_gc, Id>>::Branded, Id>;
+}
+unsafe impl<'gc, 'a, T, Id> GcErase<'a, Id> for Gc<'gc, T, Id>
+    where T: GcSafe + GcErase<'a, Id>,
+          <T as GcErase<'a, Id>>::Erased: GcSafe,
+          Id: CollectorId, {
+    type Erased = Gc<'a, <T as GcErase<'a, Id>>::Erased, Id>;
 }
 unsafe impl<'gc, T: GcSafe + 'gc, Id: CollectorId> Trace for Gc<'gc, T, Id> {
     // We always need tracing....
@@ -626,8 +637,8 @@ pub unsafe trait GcHandle<T: GcSafe + ?Sized>: Clone + NullTrace {
 ///
 /// TODO: Remove when we get more powerful types
 pub unsafe trait GcBindHandle<'new_gc, T: GcSafe + ?Sized>: GcHandle<T>
-    where T: GcBrand<'new_gc, Self::Id>,
-          <T as GcBrand<'new_gc, Self::Id>>::Branded: GcSafe {
+    where T: GcRebrand<'new_gc, Self::Id>,
+          <T as GcRebrand<'new_gc, Self::Id>>::Branded: GcSafe {
     /// Associate this handle with the specified context,
     /// allowing its underlying object to be accessed
     /// as long as the context is valid.
@@ -638,7 +649,7 @@ pub unsafe trait GcBindHandle<'new_gc, T: GcSafe + ?Sized>: GcHandle<T>
     /// at the next safepoint.
     fn bind_to(&self, context: &'new_gc <Self::System as GcSystem>::Context) -> Gc<
         'new_gc,
-        <T as GcBrand<'new_gc, Self::Id>>::Branded,
+        <T as GcRebrand<'new_gc, Self::Id>>::Branded,
         Self::Id
     >;
 }
@@ -777,19 +788,34 @@ unsafe impl<T> GcSafe for AssumeNotTraced<T> {
 }
 unsafe_gc_brand!(AssumeNotTraced, T);
 
-/// Changes all references to garbage
-/// collected objects to match `'new_gc`.
+/// Changes all references to garbage collected
+/// objects to match a specific lifetime.
 ///
 /// This indicates that its safe to transmute to the new `Branded` type
 /// and all that will change is the lifetimes.
-pub unsafe trait GcBrand<'new_gc, Id: CollectorId>: Trace {
+// TODO: Can we support lifetimes that are smaller than 'new_gc
+pub unsafe trait GcRebrand<'new_gc, Id: CollectorId>: Trace {
     /// This type with all garbage collected lifetimes
     /// changed to `'new_gc`
     ///
     /// This must have the same in-memory repr as `Self`,
     /// so that it's safe to transmute.
     type Branded: Trace + 'new_gc;
 }
+/// Indicates that it's safe to erase all GC lifetimes
+/// and change them to 'static (logically an 'unsafe)
+///
+/// This trait is the opposite of [GcRebrand]
+///
+/// The lifetime '`a` is the minimum lifetime of all other non-gc references.
+pub unsafe trait GcErase<'a, Id: CollectorId>: Trace {
+    /// This type with all garbage collected lifetimes
+    /// changed to `'static` (or erased)
+    ///
+    /// This must have the same in-memory repr as `Self`,
+    /// so that it's safe to transmute.
+    type Erased: 'a;
+}
 
 /// Indicates that a type can be traced by a garbage collector.
 ///