Add option to avoid wrapping function pointer fields or arguments

Author: pvdrz

CHANGELOG.md

@@ -152,6 +152,8 @@
 # Unreleased
 
 ## Added
+ * Do not wrap function pointer fields or arguments in `Option` if the new
+   `--skip-fn-ptr-wrapping` option is enabled.
 
 ## Changed
  * Fixed name collisions when having a C `enum` and a `typedef` with the same

bindgen-cli/options.rs

@@ -565,6 +565,12 @@ where
             Arg::new("wrap-unsafe-ops")
                 .long("wrap-unsafe-ops")
                 .help("Wrap unsafe operations in unsafe blocks."),
+            Arg::new("skip-fn-ptr-wrapping")
+                .long("skip-fn-ptr-wrapping")
+                .help("Do not wrap function pointers in `Option` if they are used as fields/arguments matching <regex>.")
+                .value_name("regex")
+                .multiple_occurrences(true)
+                .number_of_values(1),
             Arg::new("V")
                 .long("version")
                 .help("Prints the version, and exits"),
@@ -1092,5 +1098,11 @@ where
         builder = builder.wrap_unsafe_ops(true);
     }
 
+    if let Some(must_use_type) = matches.values_of("skip-fn-ptr-wrapping") {
+        for regex in must_use_type {
+            builder = builder.skip_fn_ptr_wrapping(regex);
+        }
+    }
+
     Ok((builder, output, verbose))
 }

bindgen-tests/tests/expectations/tests/skip-fn-ptr-wrapping.rs

@@ -0,0 +1,27 @@
+// bindgen-flags: --skip-fn-ptr-wrapping=".*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-tests/tests/headers/skip-fn-ptr-wrapping.h

@@ -3746,11 +3746,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/mod.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/merge_extern_blocks.rs

@@ -5,14 +5,16 @@ use syn::{parse2, ItemMod};
 use crate::BindgenOptions;
 
 mod merge_extern_blocks;
+mod skip_fn_ptr_wrapping;
 mod sort_semantically;
 
 use merge_extern_blocks::merge_extern_blocks;
+use skip_fn_ptr_wrapping::skip_fn_ptr_wrapping;
 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.skip_fn_ptr_wrapping.is_empty(),
+        run: skip_fn_ptr_wrapping,
+    },
+];
 
 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);
         }
     }