Add option to avoid wrapping function pointer fields or arguments

CHANGELOG.md

@@ -162,6 +162,9 @@
 # Unreleased
 
 ## Added
+ * Added the `--non-null-fn-ptr=<PATH>` flag and its equivalent builder
+   method to avoid wrapping function pointer arguments or fields in `Option` if
+   their path matches `<PATH>`.
 
 ## Changed
 

bindgen-cli/options.rs

@@ -355,6 +355,10 @@ struct BindgenCommand {
     /// inline` functions.
     #[arg(long, requires = "experimental", value_name = "SUFFIX")]
     wrap_static_fns_suffix: Option<String>,
+    /// Do not wrap function pointers in `Option` if they are used as fields/arguments whose path
+    /// matches <PATH>.
+    #[arg(long, value_name = "PATH")]
+    non_null_fn_ptr: Vec<String>,
     /// Enables experimental features.
     #[arg(long)]
     experimental: bool,
@@ -478,6 +482,7 @@ where
         wrap_static_fns,
         wrap_static_fns_path,
         wrap_static_fns_suffix,
+        non_null_fn_ptr,
         experimental: _,
         version,
         clang_args,
@@ -989,5 +994,9 @@ where
         builder = builder.wrap_static_fns_suffix(suffix);
     }
 
+    for path in non_null_fn_ptr {
+        builder = builder.non_null_fn_ptr(path);
+    }
+
     Ok((builder, output, verbose))
 }

bindgen-tests/tests/headers/non_null_fn_ptr.h

@@ -0,0 +1,27 @@
+// bindgen-flags: --non-null-fn-ptr=".*foo::.*" --no-default=".*foo"
+
+typedef struct foo {
+    int (*bar)();
+} foo;
+
+foo new_foo(int (*arg)());
+
+typedef struct baz {
+    int (*foo)();
+} baz;
+
+baz new_baz(int (*foo)());
+
+typedef union union_foo {
+    int (*fst)();
+    float (*snd)();
+} union_foo;
+
+union_foo new_union_foo(int (*arg)());
+
+typedef union union_baz {
+    int (*foo)();
+    float (*bar)();
+} union_baz;
+
+union_baz new_union_baz(int (*foo)());

bindgen/codegen/mod.rs

@@ -3784,11 +3784,8 @@ impl TryToRustTy for Type {
                 // they aren't NonZero), so don't *ever* use an or_opaque
                 // variant here.
                 let ty = fs.try_to_rust_ty(ctx, &())?;
-
                 let prefix = ctx.trait_prefix();
-                Ok(quote! {
-                    ::#prefix::option::Option<#ty>
-                })
+                Ok(quote!(::#prefix::option::Option<#ty>))
             }
             TypeKind::Array(item, len) | TypeKind::Vector(item, len) => {
                 let ty = item.try_to_rust_ty(ctx, &())?;

bindgen/codegen/postprocessing/merge_extern_blocks.rs

@@ -3,7 +3,12 @@ use syn::{
     Item, ItemForeignMod, ItemMod,
 };
 
-pub(super) fn merge_extern_blocks(item_mod: &mut ItemMod) {
+use crate::BindgenOptions;
+
+pub(super) fn merge_extern_blocks(
+    item_mod: &mut ItemMod,
+    _options: &BindgenOptions,
+) {
     Visitor.visit_item_mod_mut(item_mod)
 }
 

bindgen/codegen/postprocessing/mod.rs

@@ -5,14 +5,16 @@ use syn::{parse2, ItemMod};
 use crate::BindgenOptions;
 
 mod merge_extern_blocks;
+mod non_null_fn_ptr;
 mod sort_semantically;
 
 use merge_extern_blocks::merge_extern_blocks;
+use non_null_fn_ptr::non_null_fn_ptr;
 use sort_semantically::sort_semantically;
 
 struct PostProcessingPass {
     should_run: fn(&BindgenOptions) -> bool,
-    run: fn(&mut ItemMod),
+    run: fn(&mut ItemMod, &BindgenOptions),
 }
 
 // TODO: This can be a const fn when mutable references are allowed in const
@@ -21,13 +23,19 @@ macro_rules! pass {
     ($pass:ident) => {
         PostProcessingPass {
             should_run: |options| options.$pass,
-            run: |item_mod| $pass(item_mod),
+            run: |item_mod, options| $pass(item_mod, options),
         }
     };
 }
 
-const PASSES: &[PostProcessingPass] =
-    &[pass!(merge_extern_blocks), pass!(sort_semantically)];
+const PASSES: &[PostProcessingPass] = &[
+    pass!(merge_extern_blocks),
+    pass!(sort_semantically),
+    PostProcessingPass {
+        should_run: |options| !options.non_null_fn_ptr.is_empty(),
+        run: non_null_fn_ptr,
+    },
+];
 
 pub(crate) fn postprocessing(
     items: Vec<TokenStream>,
@@ -51,7 +59,7 @@ pub(crate) fn postprocessing(
 
     for pass in PASSES {
         if (pass.should_run)(options) {
-            (pass.run)(&mut item_mod);
+            (pass.run)(&mut item_mod, options);
         }
     }