Infer T: 'new_gc bounds for ignored params

This fixes a bug I need for rust-static-reflect

Author: Techcable

libs/derive/src/derive.rs

@@ -626,15 +626,20 @@ impl TraceDeriveInput {
             &mut fold,
             initial_generics.unwrap_or_else(|| self.generics.original.clone()),
         );
-        for param in self.generics.regular_type_params() {
+        for param in &self.generics.type_params {
             let name = &param.ident;
-            generics.make_where_clause().predicates.push(parse_quote!(#name: zerogc::GcRebrand<#new_lt, #id>));
+            let target: Path = if !self.generics.is_ignored(name) {
+                generics.make_where_clause().predicates.push(parse_quote!(#name: zerogc::GcRebrand<#new_lt, #id>));
+                parse_quote!(#name::Branded)
+            } else {
+                Path::from(name.clone())
+            };
             let rewritten_bounds = param.bounds.iter().cloned().map(|bound| {
                 syn::fold::fold_type_param_bound(&mut ReplaceLt {
                     orig_lt, new_lt: &new_lt
                 }, bound)
             }).collect::<Vec<_>>();
-            generics.make_where_clause().predicates.push(parse_quote!(#name::Branded: #(#rewritten_bounds)+*));
+            generics.make_where_clause().predicates.push(parse_quote!(#target: #(#rewritten_bounds)+*));
         }
         for ignored in &self.generics.ignored_lifetimes {
             generics.make_where_clause().predicates.push(parse_quote!(#ignored: 'new_gc));

libs/derive/tests/basic.rs

@@ -6,9 +6,10 @@ use zerogc::{Gc, CollectorId, Trace, GcSafe, NullTrace, epsilon::{self, EpsilonC
 use zerogc_derive::{Trace, NullTrace};
 use zerogc::cell::GcCell;
 use std::marker::PhantomData;
+use std::fmt::Debug;
 
 #[derive(Trace)]
-#[zerogc(collector_ids(DummyCollectorId))]
+#[zerogc(collector_ids(EpsilonCollectorId))]
 pub struct SpecificCollector<'gc> {
     gc: Gc<'gc, i32, EpsilonCollectorId>,
     rec: Gc<'gc, SpecificCollector<'gc>, EpsilonCollectorId>,
@@ -92,7 +93,7 @@ struct NopTrace {
 }
 
 #[derive(Trace)]
-#[zerogc(unsafe_skip_drop, collector_ids(DummyCollectorId))]
+#[zerogc(unsafe_skip_drop, collector_ids(EpsilonCollectorId))]
 #[allow(unused)]
 struct UnsafeSkipped<'gc> {
     s: &'static str,
@@ -102,7 +103,7 @@ struct UnsafeSkipped<'gc> {
 }
 
 #[derive(Trace)]
-#[zerogc(ignore_lifetimes("'a"), immutable, collector_ids(DummyCollectorId))]
+#[zerogc(ignore_lifetimes("'a"), immutable, collector_ids(EpsilonCollectorId))]
 #[allow(unused)]
 struct LifetimeTrace<'a: 'gc, 'gc, T: GcSafe<'gc, EpsilonCollectorId> + 'a> {
     s: String,
@@ -113,6 +114,13 @@ struct LifetimeTrace<'a: 'gc, 'gc, T: GcSafe<'gc, EpsilonCollectorId> + 'a> {
     marker: PhantomData<&'gc ()>
 }
 
+#[derive(Trace)]
+#[zerogc(copy, collector_ids(Id), ignore_params(T))]
+struct IgnoredParam<'gc, T: Debug + 'gc, Id: CollectorId> {
+    gc: Gc<'gc, IgnoredParam<'gc, T, Id>, Id>,
+    param: PhantomData<fn() -> T>,
+}
+
 #[test]
 fn basic<'gc>() {
     let _b = Basic::<epsilon::EpsilonCollectorId> {

libs/derive/tests/deserialize.rs

@@ -5,7 +5,7 @@ use zerogc::prelude::*;
 use zerogc::epsilon::{EpsilonCollectorId};
 
 #[derive(Trace, GcDeserialize)]
-#[zerogc(collector_ids(DummyCollectorId))]
+#[zerogc(collector_ids(EpsilonCollectorId))]
 struct BasicDeserialize<'gc> {
     test: Gc<'gc, String, EpsilonCollectorId>
 }