refactor generate_varargs_trait

Author: pvdrz

src/codegen/mod.rs

@@ -4520,50 +4520,7 @@ pub(crate) fn codegen(
         }
 
         if let Some(max_len) = context.options().tuple_varargs_len {
-            let mut methods = Vec::with_capacity(result.variadic_methods.len());
-            let mut impls = (0..=max_len)
-                .map(|len| {
-                    (
-                        (0..len)
-                            .map(|len| quote::format_ident!("t{}", len))
-                            .collect::<Vec<_>>(),
-                        vec![],
-                    )
-                })
-                .collect::<Vec<_>>();
-            for (name, VariadicMethodInfo { args, ret, exprs }) in
-                result.variadic_methods.drain()
-            {
-                let call_name = quote::format_ident!("call_{}", name);
-                methods.push(quote! {
-                    unsafe fn #call_name(self, #(#args),*) #ret
-                });
-
-                for (fields, methods) in &mut impls {
-                    methods.push(quote! {
-                        unsafe fn #call_name(self, #(#args),*) #ret {
-                            let (#(#fields,)*) = self;
-                            #name(#(#exprs),*, #(#fields),*)
-                        }
-                    });
-                }
-            }
-            result.items.push(quote! {
-                pub trait VarArgs {
-                    #(#methods;)*
-                }
-            });
-
-            for (fields, methods) in impls {
-                let params = (0..fields.len())
-                    .map(|len| quote::format_ident!("T{}", len))
-                    .collect::<Vec<_>>();
-                result.items.push(quote! {
-                    impl<#(#params),*> VarArgs for (#(#params,)*) {
-                        #(#methods)*
-                    }
-                });
-            }
+            utils::generate_varargs_trait(max_len, &mut result);
         }
 
         postprocessing::postprocessing(result.items, context.options())
@@ -5105,4 +5062,78 @@ pub mod utils {
 
         true
     }
+
+    pub(super) fn generate_varargs_trait(
+        max_len: usize,
+        result: &mut super::CodegenResult,
+    ) {
+        // This will hold the identifiers to be used for the fields of the tuples `t0, ..., tn` as
+        // well as the identifiers of the type parameters for each field type of the tuples `T0, ..., TN`.
+        // FIXME (pvdrz): what if these identifiers are already in use?
+        let (fields, params): (Vec<_>, Vec<_>) = (0..max_len)
+            .map(|len| {
+                (
+                    quote::format_ident!("t{}", len),
+                    quote::format_ident!("T{}", len),
+                )
+            })
+            .unzip();
+
+        // This will hold the methods to be declared in the `VarArgs` trait as well as the
+        // bodies of the implementations of such methods for each tuple length.
+        let (trait_method_decls, trait_method_impl_fns): (Vec<_>, Vec<_>) =
+            result
+                .variadic_methods
+                .drain()
+                .map(|(name, info)| {
+                    let super::VariadicMethodInfo { args, ret, exprs } = info;
+
+                    // The name of the `VarArgs` trait method associated with this method.
+                    // FIXME (pvdrz): what these identifiers are already in use?
+                    let trait_method_name =
+                        quote::format_ident!("call_{}", name);
+
+                    // The declaration of the `VarArgs` trait method associated with this method.
+                    let trait_method_decl = quote! {
+                        unsafe fn #trait_method_name(self, #(#args),*) #ret
+                    };
+
+                    // The implementations of the `VarArgs` trait method associated with this
+                    // method for each tuple length.
+                    let trait_method_impls = (0..=fields.len())
+                        .map(|index| {
+                            let fields = &fields[..index];
+                            quote! {
+                                #trait_method_decl {
+                                    let (#(#fields,)*) = self;
+                                    #name(#(#exprs),*, #(#fields),*)
+                                }
+                            }
+                        })
+                        .collect::<Vec<_>>();
+
+                    (trait_method_decl, trait_method_impls)
+                })
+                .unzip();
+
+        // Push the trait with the method declarations.
+        result.items.push(quote! {
+            pub trait VarArgs {
+                #(#trait_method_decls;)*
+            }
+        });
+
+        for index in 0..=params.len() {
+            let params = &params[..index];
+            let methods =
+                trait_method_impl_fns.iter().map(|impls| &impls[index]);
+
+            // Push the implementation the trait for each tuple.
+            result.items.push(quote! {
+                impl<#(#params),*> VarArgs for (#(#params,)*) {
+                    #(#methods)*
+                }
+            });
+        }
+    }
 }