Implement a DynTrace trait for object-safe tracing

This doesn't work well because it leaks the underlying visitor :(

Author: Techcable

libs/derive/tests/basic.rs

@@ -38,7 +38,6 @@ struct NopTrace {
     wow: Box<NopTrace>
 }
 
-
 #[test]
 fn basic() {
     let _b = Basic::<dummy::DummyCollectorId> {

libs/simple/src/lib.rs

@@ -94,15 +94,12 @@ unsafe impl RawSimpleAlloc for RawSimpleCollector {
     }
 }
 
-#[doc(hidden)] // NOTE: Needs be public for RawCollectorImpl
-pub unsafe trait DynTrace {
-    fn trace(&mut self, visitor: &mut MarkVisitor);
-}
-unsafe impl<T: Trace + ?Sized> DynTrace for T {
-    fn trace(&mut self, visitor: &mut MarkVisitor) {
-        let Ok(()) = self.visit(visitor);
-    }
-}
+/// A type alias for [::zerogc::DynTrace], which is an
+/// object-safe version of [::zerogc::Trace]
+///
+/// The `'static` lifetime is a lie and simply represents the
+/// fact the lifetime is unchecked.
+type DynTrace = dyn ::zerogc::DynTrace<MarkVisitor<'static>>;
 
 unsafe impl RawHandleImpl for RawSimpleCollector {
     type TypeInfo = GcType;
@@ -118,13 +115,13 @@ unsafe impl RawHandleImpl for RawSimpleCollector {
     }
 }
 
-/// A wrapper for [GcHandleList] that implements [DynTrace]
+/// A wrapper for [GcHandleList] that implements [::zerogc::DynTrace]
 #[repr(transparent)]
 struct GcHandleListWrapper(GcHandleList<RawSimpleCollector>);
-unsafe impl DynTrace for GcHandleListWrapper {
-    fn trace(&mut self, visitor: &mut MarkVisitor) {
+unsafe impl<'a> ::zerogc::DynTrace<MarkVisitor<'a>> for GcHandleListWrapper {
+    fn visit(&mut self, visitor: &mut MarkVisitor) -> Result<(), !> {
         unsafe {
-            let Ok(()) = self.0.trace::<_, !>(|raw_ptr, type_info| {
+            self.0.trace::<_, !>(|raw_ptr, type_info| {
                 let header = &mut *GcHeader::from_value_ptr(raw_ptr, type_info);
                 // Mark grey
                 header.update_raw_state(MarkState::Grey.
@@ -135,7 +132,7 @@ unsafe impl DynTrace for GcHandleListWrapper {
                 header.update_raw_state(MarkState::Black.
                     to_raw(visitor.inverted_mark));
                 Ok(())
-            });
+            })
         }
     }
 }
@@ -419,7 +416,7 @@ pub struct RawSimpleCollector {
 }
 
 unsafe impl ::zerogc_context::collector::RawCollectorImpl for RawSimpleCollector {
-    type GcDynPointer = NonNull<dyn DynTrace>;
+    type GcDynPointer = NonNull<DynTrace>;
 
     #[cfg(feature = "multiple-collectors")]
     type Ptr = NonNull<Self>;
@@ -440,9 +437,8 @@ unsafe impl ::zerogc_context::collector::RawCollectorImpl for RawSimpleCollector
         debug_assert!(!value.is_null());
         NonNull::new_unchecked(
             std::mem::transmute::<
-                *mut dyn DynTrace,
-                *mut (dyn DynTrace + 'static)
-            >(value as *mut dyn DynTrace)
+                _, *mut DynTrace
+            >(value as *mut dyn ::zerogc::DynTrace<MarkVisitor>)
         )
     }
 
@@ -553,7 +549,7 @@ impl RawSimpleCollector {
         &self, contexts: &[*mut RawContext<RawSimpleCollector>]
     ) {
         debug_assert!(self.manager.is_collecting());
-        let roots: Vec<*mut dyn DynTrace> = contexts.iter()
+        let roots: Vec<*mut DynTrace> = contexts.iter()
             .flat_map(|ctx| {
                 (**ctx).assume_valid_shadow_stack()
                     .reverse_iter().map(NonNull::as_ptr)
@@ -562,8 +558,8 @@ impl RawSimpleCollector {
                 // Cast to wrapper type
                 as *const GcHandleList<Self> as *const GcHandleListWrapper
                 // Make into virtual pointer
-                as *const dyn DynTrace
-                as *mut dyn DynTrace
+                as *const DynTrace
+                as *mut DynTrace
             ))
             .collect();
         let num_roots = roots.len();
@@ -590,7 +586,7 @@ impl RawSimpleCollector {
 }
 struct CollectionTask<'a> {
     expected_collector: CollectorId,
-    roots: Vec<*mut dyn DynTrace>,
+    roots: Vec<*mut DynTrace>,
     heap: &'a GcHeap,
     #[cfg_attr(feature = "implicit-grey-stack", allow(dead_code))]
     grey_stack: Vec<*mut GcHeader>
@@ -604,8 +600,16 @@ impl<'a> CollectionTask<'a> {
                 grey_stack: &mut self.grey_stack,
                 inverted_mark: self.heap.allocator.mark_inverted()
             };
-            // Dynamically dispatched
-            unsafe { (*root).trace(&mut visitor); }
+            unsafe {
+                // Dynamically dispatched
+                let Ok(()) = (*root).visit(
+                    // Ignore lifetime
+                    std::mem::transmute::<
+                        &mut  MarkVisitor,
+                        &mut MarkVisitor<'static>
+                    >(&mut visitor)
+                );
+            }
         }
         #[cfg(not(feature = "implicit-grey-stack"))] unsafe {
             let was_inverted_mark = self.heap.allocator.mark_inverted();
@@ -788,7 +792,8 @@ impl<T: GcSafe> StaticGcType for T {
         value_size: std::mem::size_of::<T>(),
         value_offset: Self::VALUE_OFFSET,
         trace_func: unsafe { transmute::<_, unsafe fn(*mut c_void, &mut MarkVisitor)>(
-            <T as DynTrace>::trace as fn(&mut T, &mut MarkVisitor),
+            <T as ::zerogc::DynTrace<MarkVisitor<'static>>>::visit
+                as fn(&mut T, &mut MarkVisitor<'static>) -> Result<(), !>,
         ) },
         drop_func: if <T as GcSafe>::NEEDS_DROP {
             unsafe { Some(transmute::<_, unsafe fn(*mut c_void)>(

src/lib.rs

@@ -783,6 +783,20 @@ pub unsafe trait GcBrand<'new_gc, Id: CollectorId>: Trace {
     type Branded: Trace + 'new_gc;
 }
 
+/// An object-safe version of the [Trace] trait
+pub unsafe trait DynTrace<V: GcVisitor> {
+    /// Visit this object
+    ///
+    /// See [Trace::visit] for more details
+    fn visit(&mut self, visitor: &mut V) -> Result<(), V::Err>;
+}
+unsafe impl<T: Trace, V: GcVisitor> DynTrace<V> for T {
+    #[inline]
+    fn visit(&mut self, visitor: &mut V) -> Result<(), <V as GcVisitor>::Err> {
+        <T as Trace>::visit(self, visitor)
+    }
+}
+
 /// Indicates that a type can be traced by a garbage collector.
 ///
 /// This doesn't necessarily mean that the type is safe to allocate in a garbage collector ([GcSafe]).