support variadic arguments through tuples

Author: pvdrz

src/codegen/mod.rs

@@ -238,6 +238,15 @@ struct CodegenResult<'a> {
     /// function name to the number of overloads we have already codegen'd for
     /// that name. This lets us give each overload a unique suffix.
     overload_counters: HashMap<String, u32>,
+
+    variadic_methods: HashMap<
+        Ident,
+        (
+            Vec<proc_macro2::TokenStream>,
+            proc_macro2::TokenStream,
+            Vec<proc_macro2::TokenStream>,
+        ),
+    >,
 }
 
 impl<'a> CodegenResult<'a> {
@@ -255,6 +264,7 @@ impl<'a> CodegenResult<'a> {
             functions_seen: Default::default(),
             vars_seen: Default::default(),
             overload_counters: Default::default(),
+            variadic_methods: Default::default(),
         }
     }
 
@@ -2445,12 +2455,6 @@ impl MethodCodegen for Method {
             return;
         }
 
-        // Do not generate variadic methods, since rust does not allow
-        // implementing them, and we don't do a good job at it anyway.
-        if signature.is_variadic() {
-            return;
-        }
-
         let count = {
             let count = method_names.entry(name.clone()).or_insert(0);
             *count += 1;
@@ -2468,13 +2472,10 @@ impl MethodCodegen for Method {
         let function_name = ctx.rust_ident(function_name);
         let mut args = utils::fnsig_arguments(ctx, signature);
         let mut ret = utils::fnsig_return_ty(ctx, signature);
+        let is_variadic = signature.is_variadic();
 
-        if !self.is_static() && !self.is_constructor() {
-            args[0] = if self.is_const() {
-                quote! { &self }
-            } else {
-                quote! { &mut self }
-            };
+        if is_variadic & ctx.options().tuple_varargs_len.is_none() {
+            return;
         }
 
         // If it's a constructor, we always return `Self`, and we inject the
@@ -2490,6 +2491,24 @@ impl MethodCodegen for Method {
         let mut exprs =
             helpers::ast_ty::arguments_from_signature(signature, ctx);
 
+        if is_variadic {
+            let (last_arg, args) = args.split_last_mut().unwrap();
+            // FIXME (pvdrz): what if this identifier is already being used?
+            *last_arg = quote!(var_args: impl VarArgs);
+            result.variadic_methods.insert(
+                function_name.clone(),
+                (args.to_owned(), ret.clone(), exprs.clone()),
+            );
+        }
+
+        if !self.is_static() && !self.is_constructor() {
+            args[0] = if self.is_const() {
+                quote! { &self }
+            } else {
+                quote! { &mut self }
+            };
+        }
+
         let mut stmts = vec![];
 
         // If it's a constructor, we need to insert an extra parameter with a
@@ -2523,8 +2542,15 @@ impl MethodCodegen for Method {
             };
         };
 
-        let call = quote! {
-            #function_name (#( #exprs ),* )
+        let call = if is_variadic {
+            let function_name = quote::format_ident!("call_{}", function_name);
+            quote! {
+                var_args.#function_name(#( #exprs ),* )
+            }
+        } else {
+            quote! {
+                #function_name (#( #exprs ),* )
+            }
         };
 
         stmts.push(call);
@@ -4404,6 +4430,51 @@ pub(crate) fn codegen(
             result.push(dynamic_items_tokens);
         }
 
+        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, (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)*
+                    }
+                });
+            }
+        }
+
         result.items
     })
 }

src/lib.rs

@@ -601,6 +601,10 @@ impl Builder {
             output_vector.push("--sort-semantically".into());
         }
 
+        if let Some(len) = self.options.tuple_varargs_len {
+            output_vector.push(format!("--tuple-varargs-len={}", len));
+        }
+
         // Add clang arguments
 
         output_vector.push("--".into());
@@ -1510,6 +1514,12 @@ impl Builder {
         self
     }
 
+    /// Sets the maximum tuple length that can be used to emulate variadic arguments,
+    pub fn tuple_varargs_len(mut self, len: usize) -> Self {
+        self.options.tuple_varargs_len = Some(len);
+        self
+    }
+
     /// Generate the Rust bindings using the options built up thus far.
     pub fn generate(mut self) -> Result<Bindings, BindgenError> {
         // Add any extra arguments from the environment to the clang command line.
@@ -2045,6 +2055,9 @@ struct BindgenOptions {
 
     /// Sort the code generation
     sort_semantically: bool,
+
+    /// The maximum tuple length that can be used to emulate variadic arguments.
+    tuple_varargs_len: Option<usize>,
 }
 
 /// TODO(emilio): This is sort of a lie (see the error message that results from
@@ -2201,6 +2214,7 @@ impl Default for BindgenOptions {
             force_explicit_padding: false,
             vtable_generation: false,
             sort_semantically: false,
+            tuple_varargs_len: Default::default(),
         }
     }
 }

src/options.rs

@@ -524,6 +524,7 @@ where
             Arg::new("sort-semantically")
                 .long("sort-semantically")
                 .help("Enables sorting of code generation in a predefined manner."),
+            Arg::new("tuple-varargs-len").long("tuple-varargs-len").takes_value(true).help("Enables using tuples to emulate variadic arguments up to a certain tuple length"),
             Arg::new("V")
                 .long("version")
                 .help("Prints the version, and exits"),
@@ -1019,5 +1020,19 @@ where
         builder = builder.sort_semantically(true);
     }
 
+    if let Some(len) = matches.value_of("tuple-varargs-len") {
+        let len = match len.parse() {
+            Ok(len) => len,
+            Err(err) => {
+                return Err(io::Error::new(
+                    io::ErrorKind::Other,
+                    format!("invalid length: {}", err),
+                ))
+            }
+        };
+
+        builder = builder.tuple_varargs_len(len)
+    }
+
     Ok((builder, output, verbose))
 }

tests/expectations/tests/variadic-method.rs

@@ -1,3 +1,4 @@
+// bindgen-flags: --tuple-varargs-len 5
 
 void foo(const char* fmt, ...);