Implement Trace/GcBrand for **all** tuple sizes

Before the macors weren't recursing properly, so we only
implemented it for 9-argument tuples ^_^
Add a test to verify that varius `core` types actually implement
`Trace` properly.

Unfortunately, the tests don't compile :(

Author: Techcable

src/manually_traced/core.rs

@@ -7,24 +7,29 @@
 use core::num::Wrapping;
 
 use crate::prelude::*;
-use crate::{GcDirectBarrier, CollectorId};
+use crate::GcDirectBarrier;
 
 use zerogc_derive::unsafe_gc_impl;
 
-macro_rules! __rec_trace_tuple {
-    ($($param:ident),*) => {
-        // Nothing remaining
+macro_rules! trace_tuple {
+    { $single_param:ident } => {
+        trace_tuple_impl!($single_param);
     };
-    ($first_param:ident, $($param:ident),+) => {
-        trace_tuple!($($param),*);
+    { $first_param:ident, $($param:ident),* } => {
+        trace_tuple! { $($param),* }
+        trace_tuple_impl!( $first_param, $($param),*);
     };
 }
-macro_rules! trace_tuple {
-    { $($param:ident),* } => {
-        __rec_trace_tuple!($($param),* );
+
+macro_rules! trace_tuple_impl {
+    {  $($param:ident),* } => {
         unsafe_gc_impl! {
             target => ( $($param,)* ),
             params => [$($param),*],
+            bounds => {
+                GcRebrand => { where $($param: GcRebrand<'new_gc, Id>),* },
+                GcErase => { where $($param: GcErase<'min, Id>),* },
+            }
             null_trace => { where $($param: NullTrace,)* i32: Sized },
             /*
              * HACK: Macros don't allow using `||` as separator,
@@ -276,4 +281,30 @@ unsafe_gc_impl! {
         // We can trace `Wrapping` by simply tracing its interior
         visitor.#visit_func(#b self.0)
     }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::dummy_impl::Gc;
+    use zerogc_derive::Trace;
+    use crate::prelude::*;
+    #[test]
+    fn test_null_trace() {
+        assert!(!<Option<i32> as Trace>::NEEDS_TRACE);
+        assert!(!<Option<(i32, char)> as Trace>::NEEDS_TRACE)
+    }
+    #[derive(Trace)]
+    struct Rec<'gc> {
+        inner: Gc<'gc, Rec<'gc>>,
+        inner_tuple: (Gc<'gc, Rec<'gc>>, Gc<'gc, Option<i32>>),
+        inner_opt: Option<Gc<'gc, Rec<'gc>>>,
+        inner_opt_tuple: Option<(Gc<'gc, Rec<'gc>>, Gc<'gc, char>)>,
+    }
+    #[test]
+    fn test_trace<'gc>() {
+        assert!(<Option<Gc<'gc, i32>> as Trace>::NEEDS_TRACE);
+        assert!(<Option<(Gc<'gc, i32>, char)> as Trace>::NEEDS_TRACE);
+        assert!(<Rec<'gc> as Trace>::NEEDS_TRACE);
+        assert!(<Gc<'gc, Rec<'gc>> as Trace>::NEEDS_TRACE);
+    }
 }

src/manually_traced/stdlib.rs

@@ -3,13 +3,12 @@
 //! Types that are in `libcore` and are `#![no_std]` should go in the core module,
 //! but anything that requires the rest of the stdlib (including collections and allocations),
 //! should go in this module.
-use crate::prelude::*;
-
 use std::collections::{HashMap, HashSet};
-use crate::CollectorId;
 
 use zerogc_derive::unsafe_gc_impl;
 
+use crate::prelude::*;
+
 
 unsafe_gc_impl! {
     target => HashMap<K, V>,