Make the GcErase trait an alias for GcRebrand

GcErase is now deprecated.

Simplifies things significantly.

Author: Techcable

libs/context/src/handle.rs

@@ -8,7 +8,7 @@ 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};
+use zerogc::{Trace, GcSafe, GcRebrand, GcVisitor, NullTrace, TraceImmutable, GcHandleSystem, GcBindHandle};
 use crate::{Gc, WeakCollectorRef, CollectorId, CollectorContext, CollectorRef, CollectionManager};
 use crate::collector::RawCollectorImpl;
 
@@ -608,9 +608,9 @@ unsafe impl<T: GcSafe + Sync, C: RawHandleImpl + Sync> Sync for GcHandle<T, C> {
 unsafe impl<'gc, 'a, T, C> GcHandleSystem<'gc, 'a, T> for CollectorRef<C>
     where C: RawHandleImpl,
           T: GcSafe + 'gc,
-          T: GcErase<'a, CollectorId<C>>,
-          T::Erased: GcSafe + Sized {
-    type Handle = GcHandle<T::Erased, C>;
+          T: GcRebrand<'a, CollectorId<C>>,
+          T::Branded: GcSafe + Sized {
+    type Handle = GcHandle<T::Branded, C>;
 
     #[inline]
     fn create_handle(gc: Gc<'gc, T, CollectorId<C>>) -> Self::Handle {

libs/derive/src/lib.rs

@@ -504,17 +504,11 @@ fn impl_derive_trace(input: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStre
     } else {
         impl_rebrand(input, info)?
     };
-    let erase_impl = if info.config.nop_trace {
-        impl_erase_nop(input, info)?
-    } else {
-        impl_erase(input, info)?
-    };
     let gc_safe_impl = impl_gc_safe(input, info)?;
     let extra_impls = impl_extras(input, info)?;
     Ok(quote! {
         #trace_impl
         #rebrand_impl
-        #erase_impl
         #gc_safe_impl
         #extra_impls
     })
@@ -665,172 +659,6 @@ fn impl_extras(target: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStream, E
     })
 }
 
-
-fn impl_erase_nop(target: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStream, Error> {
-    let zerogc_crate = zerogc_crate();
-    let name = &target.ident;
-    let mut generics: Generics = target.generics.clone();
-    for param in &mut generics.params {
-        match param {
-            GenericParam::Type(ref mut type_param) => {
-                // Require all params are NullTrace
-                type_param.bounds.push(parse_quote!(#zerogc_crate::NullTrace));
-            },
-            GenericParam::Lifetime(ref mut l) => {
-                if l.lifetime == info.config.gc_lifetime() {
-                    assert!(!info.config.ignored_lifetimes.contains(&l.lifetime));
-                    return Err(Error::new(
-                        l.lifetime.span(),
-                        "Unexpected GC lifetime: Expected #[zerogc(nop_trace)] during #[derive(GcErase)]"
-                    ))
-                } else if info.config.ignored_lifetimes.contains(&l.lifetime) {
-                    // Explicitly ignored is okay, as long as it outlives the `'min`
-                    l.bounds.push(parse_quote!('min));
-                } else {
-                    return Err(Error::new(
-                        l.span(),
-                        "Lifetime must be explicitly ignored"
-                    ))
-                }
-            },
-            GenericParam::Const(_) => {}
-        }
-    }
-    let mut impl_generics = generics.clone();
-    impl_generics.params.push(GenericParam::Lifetime(parse_quote!('min)));
-    let collector_id = match info.config.collector_id {
-        Some(ref id) => id.clone(),
-        None => {
-            impl_generics.params.push(GenericParam::Type(parse_quote!(Id: #zerogc_crate::CollectorId)));
-            parse_quote!(Id)
-        }
-    };
-    // Require that `Self: NullTrace`
-    impl_generics.make_where_clause().predicates.push(WherePredicate::Type(PredicateType {
-        lifetimes: None,
-        bounded_ty: parse_quote!(Self),
-        bounds: parse_quote!(#zerogc_crate::NullTrace),
-        colon_token: Default::default()
-    }));
-    let (_, ty_generics, _) = generics.split_for_impl();
-    let (impl_generics, _, where_clause) = impl_generics.split_for_impl();
-    Ok(quote! {
-        unsafe impl #impl_generics #zerogc_crate::GcErase<'min, #collector_id>
-            for #name #ty_generics #where_clause {
-            // We can pass-through because we are NullTrace
-            type Erased = Self;
-        }
-    })
-}
-fn impl_erase(target: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStream, Error> {
-    let zerogc_crate = zerogc_crate();
-    let name = &target.ident;
-    let mut generics: Generics = target.generics.clone();
-    let mut rewritten_params = Vec::new();
-    let mut rewritten_restrictions = Vec::new();
-    let collector_id = match info.config.collector_id {
-        Some(ref id) => id.clone(),
-        None => parse_quote!(Id)
-    };
-    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;
-                if info.is_ignored_param(&*type_param) {
-                    let param_name = &type_param.ident;
-                    rewritten_params.push(parse_quote!(#param_name));
-                    continue
-                }
-                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) => {
-                            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);
-                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!('min);
-                    assert!(!info.config.ignored_lifetimes.contains(&l.lifetime));
-                } else {
-                    return Err(unsupported_lifetime_param(&l.lifetime))
-                }
-            },
-            GenericParam::Const(ref param) => {
-                let name = &param.ident;
-                rewritten_param = GenericArgument::Const(parse_quote!(#name));
-            }
-        }
-        rewritten_params.push(rewritten_param);
-    }
-    let mut field_types = Vec::new();
-    match target.data {
-        Data::Struct(ref s) => {
-            for f in &s.fields {
-                field_types.push(f.ty.clone());
-            }
-        },
-        Data::Enum(ref e) => {
-            for variant in &e.variants {
-                for f in &variant.fields {
-                    field_types.push(f.ty.clone());
-                }
-            }
-        },
-        Data::Union(_) => {
-            return Err(Error::new(target.ident.span(), "Unable to derive(GcErase) for unions"))
-        }
-    }
-    let mut impl_generics = generics.clone();
-    impl_generics.params.push(GenericParam::Lifetime(parse_quote!('min)));
-    if info.config.collector_id.is_none() {
-        impl_generics.params.push(GenericParam::Type(parse_quote!(Id: #zerogc_crate::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();
-    let assert_erase = field_types.iter().map(|field_type| {
-        let span = field_type.span();
-        quote_spanned!(span => <#field_type as #zerogc_crate::GcErase<'min, #collector_id>>::assert_erase();)
-    }).collect::<Vec<_>>();
-    Ok(quote! {
-        unsafe impl #impl_generics #zerogc_crate::GcErase<'min, #collector_id>
-            for #name #ty_generics #where_clause {
-            type Erased = #name::<#(#rewritten_params),*>;
-
-            fn assert_erase() {
-                #(#assert_erase)*
-            }
-        }
-    })
-}
-
-
 fn impl_rebrand_nop(target: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStream, Error> {
     let zerogc_crate = zerogc_crate();
     let name = &target.ident;
@@ -966,7 +794,7 @@ fn impl_rebrand(target: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStream,
             }
         },
         Data::Union(_) => {
-            return Err(Error::new(target.ident.span(), "Unable to derive(GcErase) for unions"))
+            return Err(Error::new(target.ident.span(), "Unable to derive(GcRebrand) for unions"))
         }
     }
     let mut impl_generics = generics.clone();

libs/derive/src/macros.rs

@@ -54,9 +54,6 @@ pub struct MacroInput {
     /// The associated type implemented as `GcRebrand::Branded`
     #[kwarg(optional)]
     branded_type: Option<Type>,
-    /// The associated type implemented as `GcErase::Erased`
-    #[kwarg(optional)]
-    erased_type: Option<Type>,
     /// A (constant) expression determining whether the array needs to be traced
     #[kwarg(rename = "NEEDS_TRACE")]
     needs_trace: Expr,
@@ -164,15 +161,13 @@ impl MacroInput {
         } else {
             quote!()
         };
-        let rebrand_impl = self.expand_brand_impl(true)?;
-        let erase_impl = self.expand_brand_impl(false)?;
+        let rebrand_impl = self.expand_rebrand_impl()?;
         Ok(quote! {
             #trace_impl
             #trace_immutable_impl
             #null_trace_impl
             #gcsafe_impl
             #rebrand_impl
-            #erase_impl
         })
     }
     fn expand_trace_impl(&self, mutable: bool) -> Result<Option<TokenStream>, Error> {
@@ -263,9 +258,9 @@ impl MacroInput {
             unsafe impl #impl_generics #zerogc_crate::GcSafe for #target_type #where_clause {}
         })
     }
-    fn expand_brand_impl(&self, rebrand: bool /* true => rebrand, false => erase */) -> Result<Option<TokenStream>, Error> {
+    fn expand_rebrand_impl(&self) -> Result<Option<TokenStream>, Error> {
         let zerogc_crate = zerogc_crate();
-        let requirements = if rebrand { self.bounds.rebrand.clone() } else { self.bounds.erase.clone() };
+        let requirements = self.bounds.rebrand.as_ref();
         let target_type = &self.target_type;
         let mut generics = self.basic_generics();
         let id_type: Type = match self.collector_id {
@@ -290,11 +285,7 @@ impl MacroInput {
                 return Ok(None); // They are requesting we dont implement it at all
             },
             None => {
-                (true, if rebrand {
-                    vec![parse_quote!(#zerogc_crate::GcRebrand<'new_gc, #id_type>)]
-                } else {
-                    vec![parse_quote!(#zerogc_crate::GcErase<'min, #id_type>)]
-                })
+                (true, vec![parse_quote!(#zerogc_crate::GcRebrand<'new_gc, #id_type>)])
             }
         };
         // generate default bounds
@@ -311,15 +302,9 @@ impl MacroInput {
                 generics.make_where_clause()
                     .predicates.push(WherePredicate::Type(PredicateType {
                     lifetimes: None,
-                    bounded_ty: if rebrand {
-                        self.branded_type.clone().unwrap_or_else(|| {
-                            parse_quote!(<#type_name as #zerogc_crate::GcRebrand<'new_gc, Id>>::Branded)
-                        })
-                    } else {
-                        self.erased_type.clone().unwrap_or_else(|| {
-                            parse_quote!(<#type_name as #zerogc_crate::GcErase<'min, Id>>::Erased)
-                        })
-                    },
+                    bounded_ty: self.branded_type.clone().unwrap_or_else(|| {
+                        parse_quote!(<#type_name as #zerogc_crate::GcRebrand<'new_gc, Id>>::Branded)
+                    }),
                     colon_token: Default::default(),
                     bounds: bounds.clone(),
                 }));
@@ -346,25 +331,13 @@ impl MacroInput {
                 if let GenericParam::Type(ref tp) = param {
                     let param_name = &tp.ident;
                     generics.make_where_clause().predicates
-                        .push(if rebrand {
-                            parse_quote!(<#param_name as #zerogc_crate::GcRebrand<'new_gc, Id>>::Branded: Sized)
-                        } else {
-                            parse_quote!(<#param_name as #zerogc_crate::GcErase<'min, Id>>::Erased: Sized)
-                        })
+                        .push(parse_quote!(<#param_name as #zerogc_crate::GcRebrand<'new_gc, Id>>::Branded: Sized))
                 }
             }
         }
-        if rebrand {
-            generics.params.push(parse_quote!('new_gc));
-        } else {
-            generics.params.push(parse_quote!('min));
-        }
+        generics.params.push(parse_quote!('new_gc));
         let (impl_generics, _, where_clause) = generics.split_for_impl();
-        let target_trait = if rebrand {
-            quote!(#zerogc_crate::GcRebrand<'new_gc, #id_type>)
-        } else {
-            quote!(#zerogc_crate::GcErase<'min, #id_type>)
-        };
+        let target_trait = quote!(#zerogc_crate::GcRebrand<'new_gc, #id_type>);
         fn rewrite_brand_trait(
             target: &Type, trait_name: &str, target_params: &HashSet<Ident>,
             target_trait: TokenStream, associated_type: Ident
@@ -390,30 +363,17 @@ impl MacroInput {
             GenericParam::Type(ref tp) => Some(tp.ident.clone()),
             _ => None
         }).collect::<HashSet<_>>();
-        let associated_type = if rebrand {
-            let branded = self.branded_type.clone().map_or_else(|| {
-                rewrite_brand_trait(
-                    &self.target_type, "GcRebrand",
-                    &target_params,
-                    parse_quote!(#zerogc_crate::GcRebrand<'new_gc, #id_type>),
-                    parse_quote!(Branded)
-                )
-            }, Ok)?;
-            quote!(type Branded = #branded;)
-        } else {
-            let erased = Ok(self.erased_type.clone()).transpose().unwrap_or_else(|| {
-                rewrite_brand_trait(
-                    &self.target_type, "GcErase",
-                    &target_params,
-                    parse_quote!(#zerogc_crate::GcErase<'min, #id_type>),
-                    parse_quote!(Erased)
-                )
-            })?;
-            quote!(type Erased = #erased;)
-        };
+        let branded = self.branded_type.clone().map_or_else(|| {
+            rewrite_brand_trait(
+                &self.target_type, "GcRebrand",
+                &target_params,
+                parse_quote!(#zerogc_crate::GcRebrand<'new_gc, #id_type>),
+                parse_quote!(Branded)
+            )
+        }, Ok)?;
         Ok(Some(quote! {
             unsafe impl #impl_generics #target_trait for #target_type #where_clause {
-                #associated_type
+                type Branded = #branded;
             }
         }))
     }
@@ -497,9 +457,6 @@ pub struct CustomBounds {
     /// The requirements to implement `GcRebrand`
     #[kwarg(optional, rename = "GcRebrand")]
     rebrand: Option<TraitRequirements>,
-    /// The requirements to implement `GcErase`
-    #[kwarg(optional, rename = "GcErase")]
-    erase: Option<TraitRequirements>,
     #[kwarg(optional)]
     visit_inside_gc: Option<Syn<WhereClause>>
 }

src/cell.rs

@@ -17,7 +17,7 @@ use core::cell::Cell;
 
 use zerogc_derive::unsafe_gc_impl;
 
-use crate::{Trace, NullTrace, GcDirectBarrier, CollectorId, GcErase, GcRebrand, GcSafe};
+use crate::{Trace, NullTrace, GcDirectBarrier, CollectorId, GcRebrand, GcSafe};
 
 /// A `Cell` pointing to a garbage collected object.
 ///
@@ -85,10 +85,8 @@ unsafe_gc_impl!(
         Trace => { where T: Trace + Copy },
         // NOTE: TraceImmutable requires a 'NullTrace' for interior mutability
         TraceImmutable => { where T: NullTrace + Copy },
-        GcErase => { where T: Trace + Copy + GcErase<'min, Id>, Id: CollectorId, T::Erased: Copy + Trace },
         GcRebrand => { where T: Trace + Copy + GcRebrand<'new_gc, Id>, Id: CollectorId,T::Branded: Copy + Trace }
     },
-    erased_type => GcCell<T::Erased>,
     branded_type => GcCell<T::Branded>,
     null_trace => { where T: GcSafe + Copy + NullTrace },
     trace_mut => |self, visitor| {