Add ParseCallbacks::allow_item() and ParseCallbacks::block_item().

Like `allowlist_item` and `blocklist_item` options, add new methods to
`ParseCallbacks`, `ParseCallbacks::allow_item()` and
`ParseCallbacks::block_item()`, to be able to allow and block items from
being generated.

`allowlist_*` and `blocklist_*` options work with regexes and are
inserted in a RegexSet.

There are two issues with this approach:
1. In some cases we want to have more flexibility than just using
   regexes. If we want to have dynamic conditions to allow or block
   items, using regexes can be limited.
2. RegexSet scales linearly with the number of elements inserted. This
   means that if we have a huge number of items that we want to allow or
   block, regexes and RegexSet are not necessarily the most appropriate
   data structures.

Using new methods in `ParseCallbacks` solves these two issues.
We can manually decide the appropriate rules and data structure to match
the items.

`ParseCallbacks::allow_item()` and `ParseCallbacks::block_item()` are
always called after the `allowlist_*` and `blocklist_*` options, and
allow or do not block the items by default respectively.

Author: nicopauss

bindgen-tests/tests/expectations/tests/allow-item-callback.rs

@@ -0,0 +1,33 @@
+// bindgen-parse-callbacks: allow-item
+
+struct allowed_my_struct {
+    int a;
+};
+
+union allowed_my_union {
+    int a;
+    double b;
+};
+
+enum allowed_my_enum {
+    ALLOWED_MY_ENUM_A,
+    ALLOWED_MY_ENUM_B,
+};
+
+static const int allowed_my_const = 10;
+
+struct non_allowed_my_struct {
+    int a;
+};
+
+union non_allowed_my_union {
+    int a;
+    double b;
+};
+
+enum non_allowed_my_enum {
+    NON_ALLOWED_MY_ENUM_A,
+    NON_ALLOWED_MY_ENUM_B,
+};
+
+static const int non_allowed_my_const = 10;

bindgen-tests/tests/expectations/tests/block-item-callback.rs

@@ -0,0 +1,33 @@
+// bindgen-parse-callbacks: block-item
+
+struct blocked_my_struct {
+    int a;
+};
+
+union blocked_my_union {
+    int a;
+    double b;
+};
+
+enum blocked_my_enum {
+    BLOCKED_MY_ENUM_A,
+    BLOCKED_MY_ENUM_B,
+};
+
+static const int blocked_my_const = 10;
+
+struct non_blocked_my_struct {
+    int a;
+};
+
+union non_blocked_my_union {
+    int a;
+    double b;
+};
+
+enum non_blocked_my_enum {
+    NON_BLOCKED_MY_ENUM_A,
+    NON_BLOCKED_MY_ENUM_B,
+};
+
+static const int non_blocked_my_const = 10;

bindgen-tests/tests/headers/allow-item-callback.h

@@ -159,6 +159,24 @@ impl ParseCallbacks for OperatorRename {
     }
 }
 
+#[derive(Debug)]
+struct AllowItem;
+
+impl ParseCallbacks for AllowItem {
+    fn allow_item(&self, item: ItemInfo) -> bool {
+        item.name.starts_with("allowed_")
+    }
+}
+
+#[derive(Debug)]
+struct BlockItem;
+
+impl ParseCallbacks for BlockItem {
+    fn block_item(&self, item: ItemInfo) -> bool {
+        item.name.starts_with("blocked_")
+    }
+}
+
 pub fn lookup(cb: &str) -> Box<dyn ParseCallbacks> {
     match cb {
         "enum-variant-rename" => Box::new(EnumVariantRename),
@@ -168,6 +186,8 @@ pub fn lookup(cb: &str) -> Box<dyn ParseCallbacks> {
         "wrap-as-variadic-fn" => Box::new(WrapAsVariadicFn),
         "type-visibility" => Box::new(TypeVisibility),
         "operator-rename" => Box::new(OperatorRename),
+        "allow-item" => Box::new(AllowItem),
+        "block-item" => Box::new(BlockItem),
         call_back => {
             if let Some(prefix) =
                 call_back.strip_prefix("remove-function-prefix-")

bindgen-tests/tests/headers/block-item-callback.h

@@ -171,6 +171,24 @@ pub trait ParseCallbacks: fmt::Debug {
     /// This will get called everytime an item (currently struct, union, and alias) is found with some information about it
     fn new_item_found(&self, _id: DiscoveredItemId, _item: DiscoveredItem) {}
 
+    /// Generate bindings for the given item.
+    ///
+    /// This method is called after processing the `allowlist_*` options.
+    ///
+    /// The default implementation is to allow the given item.
+    fn allow_item(&self, _item: ItemInfo) -> bool {
+        true
+    }
+
+    /// Block bindings for the given item.
+    ///
+    /// This method is called after processing the `blocklist_*` options.
+    ///
+    /// The default implementation is to not block the given item.
+    fn block_item(&self, _item: ItemInfo) -> bool {
+        false
+    }
+
     // TODO add callback for ResolvedTypeRef
 }
 

bindgen-tests/tests/parse_callbacks/mod.rs

@@ -22,7 +22,7 @@ use super::BindgenOptions;
 
 use crate::callbacks::{
     AttributeInfo, DeriveInfo, DiscoveredItem, DiscoveredItemId, FieldInfo,
-    TypeKind as DeriveTypeKind,
+    ItemInfo, ItemKind as CallbackItemKind, TypeKind as DeriveTypeKind,
 };
 use crate::codegen::error::Error;
 use crate::ir::analysis::{HasVtable, Sizedness};
@@ -4942,7 +4942,14 @@ fn objc_method_codegen(
     // Item::process_before_codegen; however, ObjC methods are not currently
     // made into function items.
     let name = format!("{rust_class_name}::{prefix}{}", method.rust_name());
-    if ctx.options().blocklisted_items.matches(name) {
+    let item_info = ItemInfo {
+        name: &name,
+        kind: CallbackItemKind::Function,
+    };
+    if ctx.options().blocklisted_items.matches(&name) ||
+        ctx.options()
+            .for_any_callback(|cb| cb.block_item(item_info))
+    {
         return;
     }
 
@@ -5259,6 +5266,7 @@ pub(crate) mod utils {
     use super::helpers::BITFIELD_UNIT;
     use super::serialize::CSerialize;
     use super::{error, CodegenError, CodegenResult, ToRustTyOrOpaque};
+    use crate::callbacks::{ItemInfo, ItemKind as CallbackItemKind};
     use crate::ir::context::BindgenContext;
     use crate::ir::context::TypeId;
     use crate::ir::function::{Abi, ClangAbi, FunctionSig};
@@ -5389,8 +5397,14 @@ pub(crate) mod utils {
         ctx: &BindgenContext,
         result: &mut Vec<proc_macro2::TokenStream>,
     ) {
+        let item_info = ItemInfo {
+            name: BITFIELD_UNIT,
+            kind: CallbackItemKind::Type,
+        };
         if ctx.options().blocklisted_items.matches(BITFIELD_UNIT) ||
-            ctx.options().blocklisted_types.matches(BITFIELD_UNIT)
+            ctx.options().blocklisted_types.matches(BITFIELD_UNIT) ||
+            ctx.options()
+                .for_any_callback(|cb| cb.block_item(item_info))
         {
             return;
         }

bindgen/callbacks.rs

@@ -21,6 +21,7 @@ use super::traversal::{self, Edge, ItemTraversal};
 use super::ty::{FloatKind, Type, TypeKind};
 use crate::clang::{self, ABIKind, Cursor};
 use crate::codegen::CodegenError;
+use crate::ir::item::ItemCanonicalName;
 use crate::BindgenOptions;
 use crate::{Entry, HashMap, HashSet};
 
@@ -2519,6 +2520,14 @@ If you encounter an error missing from this list, please file an issue or a PR!"
                         }
                     }
                 })
+                .filter(|&(_, item)| {
+                    let item_info = crate::callbacks::ItemInfo {
+                        name: &item.canonical_name(self),
+                        kind: item.callback_item_kind(),
+                    };
+                    self.options()
+                        .for_all_callbacks(|cb| cb.allow_item(item_info))
+                })
                 .map(|(id, _)| id)
                 .collect::<Vec<_>>();
 

bindgen/codegen/mod.rs

@@ -653,6 +653,10 @@ impl Item {
 
         let path = self.path_for_allowlisting(ctx);
         let name = path[1..].join("::");
+        let item_info = ItemInfo {
+            name: &name,
+            kind: self.callback_item_kind(),
+        };
         ctx.options().blocklisted_items.matches(&name) ||
             match self.kind {
                 ItemKind::Type(..) => {
@@ -667,7 +671,9 @@ impl Item {
                 }
                 // TODO: Add namespace blocklisting?
                 ItemKind::Module(..) => false,
-            }
+            } ||
+            ctx.options()
+                .for_any_callback(|cb| cb.block_item(item_info))
     }
 
     /// Take out item `NameOptions`
@@ -818,6 +824,16 @@ impl Item {
         }
     }
 
+    // Get the callback item kind of this item.
+    pub(crate) fn callback_item_kind(&self) -> crate::callbacks::ItemKind {
+        match self.kind() {
+            ItemKind::Module(..) => crate::callbacks::ItemKind::Module,
+            ItemKind::Type(..) => crate::callbacks::ItemKind::Type,
+            ItemKind::Function(..) => crate::callbacks::ItemKind::Function,
+            ItemKind::Var(..) => crate::callbacks::ItemKind::Var,
+        }
+    }
+
     /// Get the canonical name without taking into account the replaces
     /// annotation.
     ///
@@ -925,14 +941,7 @@ impl Item {
         let name = if opt.user_mangled == UserMangled::Yes {
             let item_info = ItemInfo {
                 name: &name,
-                kind: match self.kind() {
-                    ItemKind::Module(..) => crate::callbacks::ItemKind::Module,
-                    ItemKind::Type(..) => crate::callbacks::ItemKind::Type,
-                    ItemKind::Function(..) => {
-                        crate::callbacks::ItemKind::Function
-                    }
-                    ItemKind::Var(..) => crate::callbacks::ItemKind::Var,
-                },
+                kind: self.callback_item_kind(),
             };
             ctx.options()
                 .last_callback(|callbacks| callbacks.item_name(item_info))

bindgen/ir/context.rs

@@ -591,6 +591,20 @@ impl BindgenOptions {
         self.parse_callbacks.iter().for_each(|cb| f(cb.as_ref()));
     }
 
+    fn for_all_callbacks(
+        &self,
+        f: impl Fn(&dyn callbacks::ParseCallbacks) -> bool,
+    ) -> bool {
+        self.parse_callbacks.iter().all(|cb| f(cb.as_ref()))
+    }
+
+    fn for_any_callback(
+        &self,
+        f: impl Fn(&dyn callbacks::ParseCallbacks) -> bool,
+    ) -> bool {
+        self.parse_callbacks.iter().any(|cb| f(cb.as_ref()))
+    }
+
     fn process_comment(&self, comment: &str) -> String {
         let comment = comment::preprocess(comment);
         self.last_callback(|cb| cb.process_comment(&comment))