Use void in parameterless functions (#2633)

* Use void for parameterless function arguments

* Update tests

* Update CHANGELOG.md

CHANGELOG.md

@@ -179,6 +179,8 @@
 
 ## Added
 ## Changed
+- The `--wrap-static-fns` feature was updated so function types that has no
+  argument use `void` as its sole argument.
 ## Removed
 ## Fixed
 ## Security

bindgen-tests/tests/expectations/tests/generated/wrap_static_fns.c

@@ -11,6 +11,7 @@ int takes_alias__extern(func f) { return takes_alias(f); }
 int takes_qualified__extern(const int *const *arg) { return takes_qualified(arg); }
 enum foo takes_enum__extern(const enum foo f) { return takes_enum(f); }
 void nevermore__extern(void) { nevermore(); }
+int takes_fn_with_no_args__extern(int (f) (void)) { return takes_fn_with_no_args(f); }
 void no_extra_argument__extern(__builtin_va_list va) { no_extra_argument(va); }
 int many_va_list__extern(int i, __builtin_va_list va1, __builtin_va_list va2) { return many_va_list(i, va1, va2); }
 int wrap_as_variadic_fn1__extern(int i, ...) {

bindgen-tests/tests/headers/wrap-static-fns.h

@@ -52,6 +52,10 @@ static inline void nevermore() {
     while (1) { }
 }
 
+static inline int takes_fn_with_no_args(int(f)(void)) {
+    return f();
+}
+
 static inline int variadic(int x, ...) {
     return x;
 }

bindgen/codegen/serialize.rs

@@ -322,21 +322,26 @@ impl<'a> CSerialize<'a> for Type {
                 }
                 write!(writer, ")")?;
 
-                write!(writer, " (")?;
-                serialize_sep(
-                    ", ",
-                    signature.argument_types().iter(),
-                    ctx,
-                    writer,
-                    |(name, type_id), ctx, buf| {
-                        let mut stack = vec![];
-                        if let Some(name) = name {
-                            stack.push(name.clone());
-                        }
-                        type_id.serialize(ctx, (), &mut stack, buf)
-                    },
-                )?;
-                write!(writer, ")")?
+                let args = signature.argument_types();
+                if args.is_empty() {
+                    write!(writer, " (void)")?;
+                } else {
+                    write!(writer, " (")?;
+                    serialize_sep(
+                        ", ",
+                        args.iter(),
+                        ctx,
+                        writer,
+                        |(name, type_id), ctx, buf| {
+                            let mut stack = vec![];
+                            if let Some(name) = name {
+                                stack.push(name.clone());
+                            }
+                            type_id.serialize(ctx, (), &mut stack, buf)
+                        },
+                    )?;
+                    write!(writer, ")")?
+                }
             }
             TypeKind::ResolvedTypeRef(type_id) => {
                 if self.is_const() {