Use const generics for arrays.

Now Trace is implemented for arrays of arbitrary size :)

Modify unsafe_gc_impl! to support const-generic parameters.

Author: Techcable

libs/derive/src/lib.rs

@@ -37,6 +37,30 @@ pub(crate) fn zerogc_crate() -> TokenStream {
     quote!(::zerogc)
 }
 
+/// Sort the parameters so that lifetime parameters come before
+/// type parameters, and type parameters come before const paramaters
+pub(crate) fn sort_params(generics: &mut Generics) {
+    #[derive(Eq, PartialEq, Ord, PartialOrd, Copy, Clone, Debug)]
+    enum ParamOrder {
+        Lifetime,
+        Type,
+        Const,
+        EndPunct
+    }
+    let mut pairs = std::mem::take(&mut generics.params).into_pairs()
+        .collect::<Vec<_>>();
+    use syn::punctuated::Pair;
+    pairs.sort_by_key(|pair| {
+        match pair {
+            Pair::Punctuated(syn::GenericParam::Lifetime(_), _) => ParamOrder::Lifetime,
+            Pair::Punctuated(syn::GenericParam::Type(_), _) => ParamOrder::Type,
+            Pair::Punctuated(syn::GenericParam::Const(_), _) => ParamOrder::Const,
+            Pair::End(_) => ParamOrder::EndPunct,
+        }
+    });
+    generics.params = pairs.into_iter().collect();
+}
+
 pub(crate) fn emit_warning(msg: impl ToString, span: Span) {
     let mut d = proc_macro::Diagnostic::new(proc_macro::Level::Warning, msg.to_string());
     d.set_spans(span.unwrap());

libs/derive/src/macros.rs

@@ -320,6 +320,7 @@ impl MacroInput {
                     Some(clause) => clause.predicates,
                     None => return Ok(None)
                 });
+            crate::sort_params(&mut generics);
             let (impl_generics, _, where_clause) = generics.split_for_impl();
             Ok(Some(quote! {
                 unsafe impl #impl_generics #zerogc_crate::GcSafe<#gc_lt, #id_type> for #target_type #where_clause {}
@@ -344,6 +345,7 @@ impl MacroInput {
                     None => return Ok(None)
                 }
             );
+            crate::sort_params(&mut generics);
             let deserialize = match *strategy {
                 DeserializeStrategy::Delegate(_span) => {
                     // NOTE: quote_spanned messes up hygiene
@@ -518,6 +520,7 @@ impl MacroInput {
                 }
             }
             generics.params.push(parse_quote!('new_gc));
+            crate::sort_params(&mut generics);
             let (impl_generics, _, where_clause) = generics.split_for_impl();
             let target_trait = quote!(#zerogc_crate::GcRebrand<'new_gc, #id_type>);
             fn rewrite_brand_trait(

src/manually_traced/core.rs

@@ -199,29 +199,20 @@ unsafe_gc_impl! {
 
 trace_tuple! { A, B, C, D, E, F, G, H, I }
 
-macro_rules! trace_array {
-    ($size:tt) => {
-        unsafe_gc_impl! {
-            target => [T; $size],
-            params => [T],
-            null_trace => { where T: NullTrace },
-            bounds => {
-                GcRebrand => { where T: GcRebrand<'new_gc, Id>, T::Branded: Sized },
-            },
-            NEEDS_TRACE => T::NEEDS_TRACE,
-            NEEDS_DROP => T::NEEDS_DROP,
-            branded_type => [<T as GcRebrand<'new_gc, Id>>::Branded; $size],
-            collector_id => *,
-            trace_template => |self, visitor| {
-                visitor.#trace_func(#b*self as #b [T])
-            },
-        }
-    };
-    { $($size:tt),* } => ($(trace_array!($size);)*)
-}
-trace_array! {
-    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
-    24, 32, 48, 64, 100, 128, 256, 512, 1024, 2048, 4096
+unsafe_gc_impl! {
+    target => [T; SIZE],
+    params => [T, const SIZE: usize],
+    null_trace => { where T: NullTrace },
+    bounds => {
+        GcRebrand => { where T: GcRebrand<'new_gc, Id>, T::Branded: Sized },
+    },
+    NEEDS_TRACE => T::NEEDS_TRACE,
+    NEEDS_DROP => T::NEEDS_DROP,
+    branded_type => [<T as GcRebrand<'new_gc, Id>>::Branded; SIZE],
+    collector_id => *,
+    trace_template => |self, visitor| {
+        visitor.#trace_func(#b*self as #b [T])
+    },
 }
 
 /*