Do not return when calling void functions

CHANGELOG.md

@@ -167,6 +167,8 @@
 ## Added
 
 ## Changed
+* Wrappers for static functions that return `void` no longer contain a `return`
+  statement and only call the static function instead.
 
 ## Removed
 

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

@@ -10,3 +10,4 @@ int takes_fn__extern(int (f) (int)) { return takes_fn(f); }
 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(); }

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

@@ -40,3 +40,7 @@ enum foo {
 static inline enum foo takes_enum(const enum foo f) {
     return f;
 }
+
+static inline void nevermore() {
+    while (1) { }
+}

bindgen/codegen/serialize.rs

@@ -102,14 +102,31 @@ impl<'a> CSerialize<'a> for Function {
 
         // The name used for the wrapper self.
         let wrap_name = format!("{}{}", name, ctx.wrap_static_fns_suffix());
+
         // The function's return type
-        let ret_ty = signature.return_type();
+        let ret_ty = {
+            let type_id = signature.return_type();
+            let item = ctx.resolve_item(type_id);
+            let ret_ty = item.expect_type();
+
+            // Write `ret_ty`.
+            ret_ty.serialize(ctx, item, stack, writer)?;
+
+            ret_ty
+        };
 
-        // Write `ret_ty wrap_name(args) { return name(arg_names)' }`
-        ret_ty.serialize(ctx, (), stack, writer)?;
+        // Write `wrap_name(args`.
         write!(writer, " {}(", wrap_name)?;
         serialize_args(&args, ctx, writer)?;
-        write!(writer, ") {{ return {}(", name)?;
+
+        // Write `) { name(` if the function returns void and `) { return name(` if it does not.
+        if ret_ty.is_void() {
+            write!(writer, ") {{ {}(", name)?;
+        } else {
+            write!(writer, ") {{ return {}(", name)?;
+        }
+
+        // Write `arg_names); }`.
         serialize_sep(", ", args.iter(), ctx, writer, |(name, _), _, buf| {
             write!(buf, "{}", name).map_err(From::from)
         })?;

bindgen/ir/ty.rs

@@ -124,6 +124,10 @@ impl Type {
         matches!(self.kind, TypeKind::Enum(..))
     }
 
+    /// Is this void?
+    pub(crate) fn is_void(&self) -> bool {
+        matches!(self.kind, TypeKind::Void)
+    }
     /// Is this either a builtin or named type?
     pub(crate) fn is_builtin_or_type_param(&self) -> bool {
         matches!(