Fix trait_object_trace! macro

Author: Techcable

libs/simple/examples/binary_trees_parallel.rs

@@ -9,7 +9,7 @@ use rayon::prelude::*;
 use slog::{Logger, Drain, o};
 
 #[derive(Trace)]
-#[zerogc(collector_id(SimpleCollectorId))]
+#[zerogc(collector_ids(SimpleCollectorId))]
 struct Tree<'gc> {
     #[zerogc(mutable(public))]
     children: GcCell<Option<(Gc<'gc, Tree<'gc>>, Gc<'gc, Tree<'gc>>)>>,

libs/simple/tests/arrays.rs

@@ -15,7 +15,7 @@ fn test_collector() -> SimpleCollector {
 }
 
 #[derive(Trace, Copy, Clone, Debug)]
-#[zerogc(copy, collector_id(SimpleCollectorId))]
+#[zerogc(copy, collector_ids(SimpleCollectorId))]
 struct Dummy<'gc> {
     val: usize,
     inner: Option<Gc<'gc, Dummy<'gc>>>

libs/simple/tests/trait_objects.rs

@@ -15,11 +15,16 @@ fn test_collector() -> SimpleCollector {
     )
 }
 
-trait Foo<'gc>: 'gc + DynTrace {
+trait Foo<'gc>: DynTrace<'gc, SimpleCollectorId> {
     fn method(&self) -> i32;
     fn validate(&self);
 }
-trait_object_trace!(impl<'gc,> Trace for dyn Foo<'gc>; Branded<'new_gc> => dyn Foo<'new_gc>, Erased<'min> => dyn Foo<'min>);
+trait_object_trace!(
+    impl<'gc,> Trace for dyn Foo<'gc>;
+    Branded<'new_gc> => dyn Foo<'new_gc>,
+    collector_id => SimpleCollectorId,
+    gc_lifetime => 'gc
+);
 
 fn foo<'gc, T: ?Sized + Trace + Foo<'gc>>(t: &T) -> i32 {
     assert_eq!(t.method(), 12);
@@ -29,7 +34,7 @@ fn bar<'gc>(gc: Gc<'gc, dyn Foo + 'gc>) -> i32 {
     foo(gc.value())
 }
 #[derive(Trace)]
-#[zerogc(collector_id(SimpleCollectorId), unsafe_skip_drop)]
+#[zerogc(collector_ids(SimpleCollectorId), unsafe_skip_drop)]
 struct Bar<'gc> {
     inner: Option<Gc<'gc, Bar<'gc>>>,
     val: Gc<'gc, i32>

src/lib.rs

@@ -986,7 +986,7 @@ pub unsafe trait TrustedDrop: Trace {}
 /// #[derive(Trace)]
 /// struct MixedGc<'gc, 'js> {
 ///     internal_ptr: Gc<'gc, i32, OtherGcId>,
-///     js_ptr: Gc<'gc, i32, JsGcId>
+///     js_ptr: Gc<'js, i32, JsGcId>
 /// }
 /// impl<'gc, 'js> MixedGc<'gc, 'js> {
 ///     fn verify(&self) {
@@ -1233,7 +1233,7 @@ pub unsafe trait TraceImmutable: Trace {
 /// The garbage collector will be able to use its runtime type information
 /// to find the appropriate implementation at runtime,
 /// even though its not known at compile tme.
-pub unsafe trait DynTrace<'gc, Id: CollectorId> {}
+pub unsafe trait DynTrace<'gc, Id: CollectorId>: 'gc {}
 unsafe impl<'gc, Id: CollectorId, T: ?Sized + Trace + GcSafe<'gc, Id>> DynTrace<'gc, Id> for T {}
 
 impl<'gc, T, U, Id> CoerceUnsized<Gc<'gc, U, Id>> for Gc<'gc, T, Id>

src/macros.rs

@@ -13,7 +13,7 @@
 /// }
 /// trait_object_trace!(
 ///     impl<'gc,> Trace for dyn Foo<'gc>;
-///     Branded<'new_gc> => dyn Foo<'new_gc> + 'new_gc,
+///     Branded<'new_gc> => (dyn Foo<'new_gc> + 'new_gc),
 ///     collector_id => OurSpecificId,
 ///     gc_lifetime => 'gc
 /// );
@@ -25,7 +25,7 @@
 ///     foo(gc.value())
 /// }
 /// #[derive(Trace)]
-/// # #[zerogc(collector_ids(DummyCollectorId))]
+/// # #[zerogc(collector_ids(EpsilonCollectorId))]
 /// struct Bar<'gc> {
 ///     val: Gc<'gc, i32>
 /// }
@@ -47,9 +47,9 @@ macro_rules! trait_object_trace {
         Branded<$branded_lt:lifetime> => $branded:ty,
         collector_id => $collector_id:path,
         gc_lifetime => $gc_lt:lifetime) => {
-        unsafe impl$(<$($lt,)* $($param:ident),*>)? $crate::TrustedDrop for dyn $target where Self: $crate::DynTrace<$gc_lt, $collector_id>, $($($where_clause)*)? {}
-        unsafe impl$(<$($lt,)* $($param:ident),*>)? $crate::GcSafe<$gc_lt, $collector_id> for dyn $target where Self: $crate::DynTrace<$gc_lt, $collector_id>, $($($where_clause)*)? {}
-        unsafe impl$(<$($lt,)* $($param:ident),*>)? $crate::Trace for dyn $target where Self: $crate::DynTrace::<$gc_lt, $collector_id>, $($($where_clause)*)? {
+        unsafe impl$(<$($lt,)* $($param:ident),*>)? $crate::TrustedDrop for (dyn $target + $gc_lt) where Self: $crate::DynTrace<$gc_lt, $collector_id>, $($($where_clause)*)? {}
+        unsafe impl$(<$($lt,)* $($param:ident),*>)? $crate::GcSafe<$gc_lt, $collector_id> for (dyn $target + $gc_lt) where Self: $crate::DynTrace<$gc_lt, $collector_id>, $($($where_clause)*)? {}
+        unsafe impl$(<$($lt,)* $($param:ident),*>)? $crate::Trace for (dyn $target + $gc_lt) where Self: $crate::DynTrace::<$gc_lt, $collector_id>, $($($where_clause)*)? {
             /*
              * Insufficient compile-time information to know whether we need to be traced.
              *
@@ -69,7 +69,7 @@ macro_rules! trait_object_trace {
                 visitor.visit_trait_object(gc)
             }
         }
-        unsafe impl<$branded_lt, $($($lt,)* $($param:ident,)*)?> $crate::GcRebrand<$branded_lt, $collector_id> for dyn $target where Self: $crate::DynTrace<$gc_lt, $collector_id>, T::Branded: $crate::DynTrace<$branded_lt, $collectorId>, $($($where_clause)*)? {
+        unsafe impl<$branded_lt, $($($lt,)* $($param:ident,)*)?> $crate::GcRebrand<$branded_lt, $collector_id> for dyn $target $(where $($where_clause)*)? {
             type Branded = $branded;
         }
     }

src/manually_traced/core.rs

@@ -360,7 +360,7 @@ mod test {
 
     }
     #[derive(Trace)]
-    #[zerogc(collector_ids(DummyCollectorId))]
+    #[zerogc(collector_ids(EpsilonCollectorId))]
     struct Rec<'gc> {
         inner: Gc<'gc, Rec<'gc>>,
         inner_tuple: (Gc<'gc, Rec<'gc>>, Gc<'gc, Option<i32>>),