Rename Trace::visit to Trace::trace

Less likely to conflict with a user-defined trait method.

Also rename the 'visit' option to 'trace_template' (in unsafe_gc_impl!).

This is something I've wanted to do for a while.

Author: Techcable

libs/context/src/collector.rs

@@ -350,20 +350,20 @@ unsafe impl<C: RawCollectorImpl> Trace for CollectorId<C> {
     const NEEDS_TRACE: bool = false;
     const NEEDS_DROP: bool = false;
     #[inline(always)]
-    fn visit<V: GcVisitor>(&mut self, _visitor: &mut V) -> Result<(), V::Err> {
+    fn trace<V: GcVisitor>(&mut self, _visitor: &mut V) -> Result<(), V::Err> {
         Ok(())
     }
 
     #[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, Id> {
+    unsafe fn trace_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)
+        visitor.trace_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> {
+    fn trace_immutable<V: GcVisitor>(&self, _visitor: &mut V) -> Result<(), <V as GcVisitor>::Err> {
         Ok(())
     }
 }

libs/context/src/handle.rs

@@ -477,21 +477,21 @@ unsafe impl<T: GcSafe<'static, CollectorId<C>>, C: RawHandleImpl> Trace for GcHa
     const NEEDS_TRACE: bool = false;
     const NEEDS_DROP: bool = true;
     #[inline(always)]
-    fn visit<V>(&mut self, _visitor: &mut V) -> Result<(), V::Err>
+    fn trace<V>(&mut self, _visitor: &mut V) -> Result<(), V::Err>
         where V: zerogc::GcVisitor {
         Ok(())
     }
 
     #[inline]
-    unsafe fn visit_inside_gc<'gc, V, Id>(gc: &mut Gc<'gc, Self, Id>, visitor: &mut V) -> Result<(), V::Err>
+    unsafe fn trace_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 `Sized` type
-        visitor.visit_gc(gc)
+        visitor.trace_gc(gc)
     }
 }
 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>
+    fn trace_immutable<V>(&self, _visitor: &mut V) -> Result<(), V::Err>
         where V: GcVisitor {
         Ok(())
     }

libs/derive/src/derive.rs

@@ -207,9 +207,9 @@ impl TraceField {
             parse_quote!(zerogc::Trace)
         };
         let method_name: Ident = if immutable {
-            parse_quote!(visit_immutable)
+            parse_quote!(trace_immutable)
         } else {
-            parse_quote!(visit)
+            parse_quote!(trace)
         };
         quote_spanned!(self.ty.span() => <#ty as #trait_name>::#method_name(#access, gc_visitor)?)
     }
@@ -284,7 +284,7 @@ struct SerdeTypeOpts {
     /// It is automatically inferred if you have any `Gc`, `GcArray`
     /// or `GcString` fields (ignoring fully qualified paths).
     #[darling(default)]
-    require_simple_alloc: bool,
+    require_simple_alloc: Option<bool>,
 }
 
 #[derive(Debug, Clone, Default, FromMeta)]
@@ -502,7 +502,7 @@ impl TraceDeriveInput {
             return Err(Error::custom("The `zerogc/serde1` feature is disabled (please enable it)"));
         }
         let (gc_lifetime, generics) = self.generics_with_gc_lifetime(parse_quote!('gc));
-        let should_require_simple_alloc = self.all_fields().iter().any(|field| {
+        let default_should_require_simple_alloc = self.all_fields().iter().any(|field| {
             let is_gc_allocated = match field.ty {
                 Type::Path(ref p) if p.path.segments.len() == 1 => {
                     /*
@@ -522,7 +522,10 @@ impl TraceDeriveInput {
                 }
             }
             is_gc_allocated
-        }) || self.serde_opts.as_ref().map_or(false, |opts| opts.require_simple_alloc);
+        });
+        let should_require_simple_alloc = self.serde_opts.as_ref()
+            .and_then(|opts| opts.require_simple_alloc)
+            .unwrap_or(default_should_require_simple_alloc);
         let do_require_simple_alloc = |id: &dyn ToTokens| {
             quote!(<<#id as zerogc::CollectorId>::System as zerogc::GcSystem>::Context: zerogc::GcSimpleAlloc)
         };
@@ -859,9 +862,9 @@ impl TraceDeriveInput {
             parse_quote!(zerogc::Trace)
         };
         let method_name: Ident = if immutable {
-            parse_quote!(visit_immutable)
+            parse_quote!(trace_immutable)
         } else {
-            parse_quote!(visit)
+            parse_quote!(trace)
         };
         let mut generics = self.generics.original.clone();
         for regular in self.generics.regular_type_params() {
@@ -925,9 +928,9 @@ impl TraceDeriveInput {
                 ActualId: zerogc::CollectorId, Self: zerogc::GcSafe<'actual_gc, ActualId> + 'actual_gc);
             Some(quote! {
                 #[inline]
-                unsafe fn visit_inside_gc<'actual_gc, Visitor, ActualId>(gc: &mut zerogc::Gc<'actual_gc, Self, ActualId>, visitor: &mut Visitor) -> Result<(), Visitor::Err>
+                unsafe fn trace_inside_gc<'actual_gc, Visitor, ActualId>(gc: &mut zerogc::Gc<'actual_gc, Self, ActualId>, visitor: &mut Visitor) -> Result<(), Visitor::Err>
                 #where_clause {
-                    visitor.visit_gc(gc)
+                    visitor.trace_gc(gc)
                 }
             })
         } else { None };

libs/derive/src/macros.rs

@@ -138,16 +138,7 @@ pub struct MacroInput {
     /// This is necessary if the type is not `Sized`
     #[kwarg(optional)]
     visit_inside_gc: Option<VisitInsideGcClosure>,
-    /*
-     * The following three arguments are parsed
-     * into a 'VisitImpl' via the 'parse_visitor' function.
-     *
-     * TODO: Make the name for this option 'visit_template'
-     *
-     * I feel like that's a more accurate description
-     * of its function.....
-     */
-    #[kwarg(optional, rename = "visit")]
+    #[kwarg(optional, rename = "trace_template")]
     raw_visit_template: Option<VisitClosure>,
     #[kwarg(optional, rename = "trace_mut")]
     trace_mut_closure: Option<VisitClosure>,
@@ -263,7 +254,7 @@ impl MacroInput {
         let visit_impl = self.parse_visitor()?.expand_impl(mutable)?;
         let (impl_generics, _, where_clause) = generics.split_for_impl();
         let trait_name = if mutable { quote!(#zerogc_crate::Trace) } else { quote!(#zerogc_crate::TraceImmutable) };
-        let visit_method_name = if mutable { quote!(visit) } else { quote!(visit_immutable) };
+        let trace_method_name = if mutable { quote!(trace) } else { quote!(trace_immutable) };
         let needs_drop_const = if mutable {
             let expr = &self.needs_drop;
             Some(quote!(const NEEDS_DROP: bool = {
@@ -286,7 +277,7 @@ impl MacroInput {
         let visit_inside_gc = if mutable {
             let expr = match self.visit_inside_gc {
                 Some(ref expr) => expr.0.body.clone(),
-                None => quote!(visitor.visit_gc(gc))
+                None => quote!(visitor.trace_gc(gc))
             };
             let where_clause = if let Some(ref clause) = self.bounds.visit_inside_gc {
                 clause.clone()
@@ -295,7 +286,7 @@ impl MacroInput {
             };
             Some(quote! {
                 #[inline]
-                unsafe fn visit_inside_gc<'actual_gc, Visitor, ActualId>(gc: &mut #zerogc_crate::Gc<'actual_gc, Self, ActualId>, visitor: &mut Visitor) -> Result<(), Visitor::Err>
+                unsafe fn trace_inside_gc<'actual_gc, Visitor, ActualId>(gc: &mut #zerogc_crate::Gc<'actual_gc, Self, ActualId>, visitor: &mut Visitor) -> Result<(), Visitor::Err>
                     #where_clause {
                     #expr
                 }
@@ -313,7 +304,7 @@ impl MacroInput {
                 #needs_trace_const
                 #needs_drop_const
                 #[inline] // TODO: Should this be unconditional?
-                fn #visit_method_name<Visitor: #zerogc_crate::GcVisitor + ?Sized>(&#mutability self, visitor: &mut Visitor) -> Result<(), Visitor::Err> {
+                fn #trace_method_name<Visitor: #zerogc_crate::GcVisitor + ?Sized>(&#mutability self, visitor: &mut Visitor) -> Result<(), Visitor::Err> {
                     #visit_impl
                 }
                 #visit_inside_gc
@@ -791,7 +782,7 @@ pub enum VisitImpl {
     /// | #mutability    | `` (empty) | `mut`              |
     /// | #as_ref        | `as_ref`   | `as_mut`           |
     /// | #iter          | `iter`     | `iter_mut`         |
-    /// | #visit_func    | `visit`    | `visit_immutable`  |
+    /// | #trace_func    | `trace`    | `trace_immutable`  |
     /// | #b             | `&`        | `&mut`             |
     /// | ## (escape)    | `#`        | `#`                |
     ///
@@ -816,7 +807,7 @@ enum MagicVarType {
     Mutability,
     AsRef,
     Iter,
-    VisitFunc,
+    TraceFunc,
     B
 }
 impl MagicVarType {
@@ -826,7 +817,7 @@ impl MagicVarType {
             "mutability" => MagicVarType::Mutability,
             "as_ref" => MagicVarType::AsRef,
             "iter" => MagicVarType::Iter,
-            "visit_func" => MagicVarType::VisitFunc,
+            "trace_func" => MagicVarType::TraceFunc,
             "b" => MagicVarType::B,
             _ => return Err(
                 Error::new(ident.span(),
@@ -862,11 +853,11 @@ impl VisitImpl {
                                 quote!(iter)
                             }
                         }
-                        MagicVarType::VisitFunc => {
+                        MagicVarType::TraceFunc => {
                             if mutable {
-                                quote!(visit)
+                                quote!(trace)
                             } else {
-                                quote!(visit_immutable)
+                                quote!(trace_immutable)
                             }
                         }
                         MagicVarType::B => {

libs/simple/src/layout.rs

@@ -191,7 +191,7 @@ unsafe_gc_impl!(
     NEEDS_TRACE => true,
     NEEDS_DROP => true,
     null_trace => never,
-    visit => |self, visitor| {
+    trace_template => |self, visitor| {
         unreachable!()
     }
 );
@@ -330,7 +330,7 @@ unsafe_gc_impl!(
         unsafe {
             let start: *mut T = self.ptr() as *const T as *mut T;
             for i in 0..self.len() {
-                visitor.visit(&mut *start.add(i))?;
+                visitor.trace(&mut *start.add(i))?;
             }
         }
         Ok(())
@@ -340,7 +340,7 @@ unsafe_gc_impl!(
         unsafe {
             let start: *mut T = self.ptr() as *const T as *mut T;
             for i in 0..self.len() {
-                visitor.visit_immutable(&*start.add(i))?;
+                visitor.trace_immutable(&*start.add(i))?;
             }
         }
         Ok(())
@@ -503,7 +503,7 @@ impl<'gc, T: GcSafe<'gc, crate::CollectorId>> StaticVecType for T {
                         val as *mut T,
                         len
                     );
-                    let Ok(()) = <[T] as Trace>::visit(slice, visitor);
+                    let Ok(()) = <[T] as Trace>::trace(slice, visitor);
                 }
                 visit::<T> as unsafe fn(*mut c_void, &mut MarkVisitor)
             })
@@ -544,7 +544,7 @@ impl<'gc, T: GcSafe<'gc, crate::CollectorId>> StaticGcType for [T] {
                         val as *mut T,
                         len
                     );
-                    let Ok(()) = <[T] as Trace>::visit(slice, visitor);
+                    let Ok(()) = <[T] as Trace>::trace(slice, visitor);
                 }
                 visit::<T> as unsafe fn(*mut c_void, &mut MarkVisitor)
             })

libs/simple/src/lib.rs

@@ -218,7 +218,7 @@ pub unsafe trait DynTrace {
 }
 unsafe impl<T: Trace + ?Sized> DynTrace for T {
     fn trace(&mut self, visitor: &mut MarkVisitor) {
-        let Ok(()) = self.visit(visitor);
+        let Ok(()) = self.trace(visitor);
     }
 }
 
@@ -816,7 +816,7 @@ impl RawSimpleCollector {
                             as *const *mut SimpleVecRepr<()>
                             as *const Gc<SimpleVecRepr<DynamicObj>>);
                         // TODO: Assert not moving?
-                        let Ok(()) = visitor.visit_vec::<(), _>(&mut target_gc);
+                        let Ok(()) = visitor.trace_vec::<(), _>(&mut target_gc);
                     }
                 }
             }
@@ -944,7 +944,7 @@ unsafe impl GcVisitor for MarkVisitor<'_> {
     type Err = !;
 
     #[inline]
-    unsafe fn visit_gc<'gc, T, Id>(
+    unsafe fn trace_gc<'gc, T, Id>(
         &mut self, gc: &mut ::zerogc::Gc<'gc, T, Id>
     ) -> Result<(), Self::Err>
         where T: GcSafe<'gc, Id>, Id: ::zerogc::CollectorId {
@@ -972,7 +972,7 @@ unsafe impl GcVisitor for MarkVisitor<'_> {
         }
     }
 
-    unsafe fn visit_trait_object<'gc, T, Id>(&mut self, gc: &mut zerogc::Gc<'gc, T, Id>) -> Result<(), Self::Err>
+    unsafe fn trace_trait_object<'gc, T, Id>(&mut self, gc: &mut zerogc::Gc<'gc, T, Id>) -> Result<(), Self::Err>
         where T: ?Sized + GcSafe<'gc, Id> + Pointee<Metadata=DynMetadata<T>> + zerogc::DynTrace<'gc, Id>, Id: zerogc::CollectorId {
         if TypeId::of::<Id>() == TypeId::of::<crate::CollectorId>() {
             /*
@@ -996,14 +996,14 @@ unsafe impl GcVisitor for MarkVisitor<'_> {
     }
 
     #[inline]
-    unsafe fn visit_vec<'gc, T, Id>(&mut self, raw: &mut ::zerogc::Gc<'gc, Id::RawVecRepr<'gc>, Id>) -> Result<(), Self::Err>
+    unsafe fn trace_vec<'gc, T, Id>(&mut self, raw: &mut ::zerogc::Gc<'gc, Id::RawVecRepr<'gc>, Id>) -> Result<(), Self::Err>
         where T: GcSafe<'gc, Id>, Id: ::zerogc::CollectorId {
         // Just visit our innards as if they were a regular `Gc` reference
-        self.visit_gc(raw)
+        self.trace_gc(raw)
     }
 
     #[inline]
-    unsafe fn visit_array<'gc, T, Id>(&mut self, array: &mut ::zerogc::array::GcArray<'gc, T, Id>) -> Result<(), Self::Err>
+    unsafe fn trace_array<'gc, T, Id>(&mut self, array: &mut ::zerogc::array::GcArray<'gc, T, Id>) -> Result<(), Self::Err>
         where T: GcSafe<'gc, Id>, Id: ::zerogc::CollectorId {
         if TypeId::of::<Id>() == TypeId::of::<crate::CollectorId>() {
             /*
@@ -1052,7 +1052,7 @@ impl MarkVisitor<'_> {
     unsafe fn _visit_own_gc<'gc, T: Trace + ?Sized>(
         &mut self, gc: &mut Gc<'gc, T>
     ) {
-        self._visit_own_gc_with(gc, |val, visitor| <T as Trace>::visit(val, visitor))
+        self._visit_own_gc_with(gc, |val, visitor| <T as Trace>::trace(val, visitor))
     }
     /// Visit a GC type whose [::zerogc::CollectorId] matches our own,
     /// tracing it with the specified closure

src/array.rs

@@ -279,10 +279,10 @@ unsafe_gc_impl!(
     NEEDS_TRACE => true,
     NEEDS_DROP => false,
     trace_mut => |self, visitor| {
-        unsafe { visitor.visit_array(self) }
+        unsafe { visitor.trace_array(self) }
     },
     collector_id => Id,
     visit_inside_gc => |gc, visitor| {
-        visitor.visit_gc(gc)
+        visitor.trace_gc(gc)
     }
 );

src/cell.rs

@@ -99,7 +99,7 @@ unsafe_gc_impl!(
          * In other words is possible to safely trace a `GcCell`
          * with a garbage collected type, as long as it is never mutated.
          */
-        visitor.visit(self.get_mut())
+        visitor.trace(self.get_mut())
     },
     trace_immutable => |self, visitor| {
         /*
@@ -108,7 +108,7 @@ unsafe_gc_impl!(
          * We require `NullTrace` in order to `set` our internals.
          */
         let mut value = self.get();
-        visitor.visit(&mut value)?;
+        visitor.trace(&mut value)?;
         self.set(value);
         Ok(())
     }

src/epsilon.rs

@@ -392,17 +392,17 @@ unsafe impl Trace for EpsilonCollectorId {
     const NEEDS_DROP: bool = false;
 
     #[inline]
-    fn visit<V: GcVisitor>(&mut self, _visitor: &mut V) -> Result<(), <V as GcVisitor>::Err> {
+    fn trace<V: GcVisitor>(&mut self, _visitor: &mut V) -> Result<(), <V as GcVisitor>::Err> {
         Ok(())
     }
 
-    unsafe fn visit_inside_gc<'gc, V, Id>(gc: &mut crate::Gc<'gc, Self, Id>, visitor: &mut V) -> Result<(), V::Err> where V: GcVisitor, Id: CollectorId, Self: GcSafe<'gc, Id> + 'gc {
-        visitor.visit_gc(gc)
+    unsafe fn trace_inside_gc<'gc, V, Id>(gc: &mut crate::Gc<'gc, Self, Id>, visitor: &mut V) -> Result<(), V::Err> where V: GcVisitor, Id: CollectorId, Self: GcSafe<'gc, Id> + 'gc {
+        visitor.trace_gc(gc)
     }
 }
 unsafe impl TraceImmutable for EpsilonCollectorId {
     #[inline]
-    fn visit_immutable<V: GcVisitor>(&self, _visitor: &mut V) -> Result<(), V::Err> {
+    fn trace_immutable<V: GcVisitor>(&self, _visitor: &mut V) -> Result<(), V::Err> {
         Ok(())
     }
 }