feat: add custom attributes to fn items

Author: rich-ayr

bindgen/callbacks.rs

@@ -1,6 +1,7 @@
 //! A public API for more fine-grained customization of bindgen behavior.
 
 pub use crate::ir::analysis::DeriveTrait;
+pub use crate::ir::comp::MethodKind as AttributeMethodKind;
 pub use crate::ir::derive::CanDerive as ImplementsTrait;
 pub use crate::ir::enum_ty::{EnumVariantCustomBehavior, EnumVariantValue};
 pub use crate::ir::int::IntKind;
@@ -231,15 +232,30 @@ pub struct DeriveInfo<'a> {
     pub kind: TypeKind,
 }
 
-/// Relevant information about a type to which new attributes will be added using
+/// Relevant information about an item to which new attributes will be added using
 /// [`ParseCallbacks::add_attributes`].
 #[derive(Debug)]
 #[non_exhaustive]
 pub struct AttributeInfo<'a> {
-    /// The name of the type.
+    /// The name of the item.
     pub name: &'a str,
-    /// The kind of the type.
-    pub kind: TypeKind,
+    /// The kind of the item.
+    pub kind: AttributeItemKind,
+    /// The kind of a method item.
+    pub method_kind: Option<AttributeMethodKind>
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+/// The kind of the current item.
+pub enum AttributeItemKind {
+    /// The item is a Rust `struct`.
+    Struct,
+    /// The item is a Rust `enum`.
+    Enum,
+    /// The item is a Rust `union`.
+    Union,
+    /// The item is a Rust `fn`.
+    Function,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]

bindgen/codegen/mod.rs

@@ -21,8 +21,8 @@ use self::struct_layout::StructLayoutTracker;
 use super::BindgenOptions;
 
 use crate::callbacks::{
-    AttributeInfo, DeriveInfo, DiscoveredItem, DiscoveredItemId, FieldInfo,
-    TypeKind as DeriveTypeKind,
+    AttributeInfo, AttributeItemKind, DeriveInfo, DiscoveredItem,
+    DiscoveredItemId, FieldInfo, TypeKind as DeriveTypeKind,
 };
 use crate::codegen::error::Error;
 use crate::ir::analysis::{HasVtable, Sizedness};
@@ -1070,7 +1070,8 @@ impl CodeGenerator for Type {
                             ctx.options().all_callbacks(|cb| {
                                 cb.add_attributes(&AttributeInfo {
                                     name: &name,
-                                    kind: DeriveTypeKind::Struct,
+                                    kind: AttributeItemKind::Struct,
+                                    method_kind: None,
                                 })
                             });
                         attributes.extend(
@@ -2533,10 +2534,11 @@ impl CodeGenerator for CompInfo {
             cb.add_attributes(&AttributeInfo {
                 name: &canonical_name,
                 kind: if is_rust_union {
-                    DeriveTypeKind::Union
+                    AttributeItemKind::Union
                 } else {
-                    DeriveTypeKind::Struct
+                    AttributeItemKind::Struct
                 },
+                method_kind: None,
             })
         });
         attributes.extend(custom_attributes.iter().map(|s| s.parse().unwrap()));
@@ -3148,6 +3150,15 @@ impl Method {
 
         let mut attrs = vec![attributes::inline()];
 
+        let custom_attributes = ctx.options().all_callbacks(|cb| {
+            cb.add_attributes(&AttributeInfo {
+                name: &name,
+                kind: AttributeItemKind::Function,
+                method_kind: Some(self.kind()),
+            })
+        });
+        attrs.extend(custom_attributes.iter().map(|s| s.parse().unwrap()));
+
         if signature.must_use() {
             attrs.push(attributes::must_use());
         }
@@ -3728,7 +3739,8 @@ impl CodeGenerator for Enum {
             let custom_attributes = ctx.options().all_callbacks(|cb| {
                 cb.add_attributes(&AttributeInfo {
                     name: &name,
-                    kind: DeriveTypeKind::Enum,
+                    kind: AttributeItemKind::Enum,
+                    method_kind: None,
                 })
             });
             attrs.extend(custom_attributes.iter().map(|s| s.parse().unwrap()));

bindgen/ir/comp.rs

@@ -32,7 +32,7 @@ pub(crate) enum CompKind {
 
 /// The kind of C++ method.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub(crate) enum MethodKind {
+pub enum MethodKind {
     /// A constructor. We represent it as method for convenience, to avoid code
     /// duplication.
     Constructor,

bindgen/options/cli.rs

@@ -3,7 +3,7 @@
 use crate::{
     builder,
     callbacks::{
-        AttributeInfo, DeriveInfo, ItemInfo, ParseCallbacks, TypeKind,
+        AttributeInfo, AttributeItemKind, DeriveInfo, ItemInfo, ParseCallbacks, TypeKind,
     },
     features::{RustEdition, EARLIEST_STABLE_RUST},
     regex_set::RegexSet,
@@ -477,7 +477,7 @@ struct BindgenCommand {
     /// Derive custom traits on a `union`. The CUSTOM value must be of the shape REGEX=DERIVE where DERIVE is a coma-separated list of derive macros.
     #[arg(long, value_name = "CUSTOM", value_parser = parse_custom_derive)]
     with_derive_custom_union: Vec<(Vec<String>, String)>,
-    /// Add custom attributes on any kind of type. The CUSTOM value must be of the shape REGEX=ATTRIBUTE where ATTRIBUTE is a coma-separated list of attributes.
+    /// Add custom attributes on any item. The CUSTOM value must be of the shape REGEX=ATTRIBUTE where ATTRIBUTE is a coma-separated list of attributes.
     #[arg(long, value_name = "CUSTOM", value_parser = parse_custom_attribute)]
     with_attribute_custom: Vec<(Vec<String>, String)>,
     /// Add custom attributes on a `struct`. The CUSTOM value must be of the shape REGEX=ATTRIBUTE where ATTRIBUTE is a coma-separated list of attributes.
@@ -489,6 +489,9 @@ struct BindgenCommand {
     /// Add custom attributes on a `union`. The CUSTOM value must be of the shape REGEX=ATTRIBUTE where ATTRIBUTE is a coma-separated list of attributes.
     #[arg(long, value_name = "CUSTOM", value_parser = parse_custom_attribute)]
     with_attribute_custom_union: Vec<(Vec<String>, String)>,
+    /// Add custom attributes on an `fn`. The CUSTOM value must be of the shape REGEX=ATTRIBUTE where ATTRIBUTE is a coma-separated list of attributes.
+    #[arg(long, value_name = "CUSTOM", value_parser = parse_custom_attribute)]
+    with_attribute_custom_function: Vec<(Vec<String>, String)>,
     /// Generate wrappers for `static` and `static inline` functions.
     #[arg(long)]
     wrap_static_fns: bool,
@@ -645,6 +648,7 @@ where
         with_attribute_custom_struct,
         with_attribute_custom_enum,
         with_attribute_custom_union,
+        with_attribute_custom_function,
         wrap_static_fns,
         wrap_static_fns_path,
         wrap_static_fns_suffix,
@@ -745,7 +749,7 @@ where
     #[derive(Debug)]
     struct CustomAttributeCallback {
         attributes: Vec<String>,
-        kind: Option<TypeKind>,
+        kind: Option<AttributeItemKind>,
         regex_set: RegexSet,
     }
 
@@ -755,9 +759,10 @@ where
 
             let flag = match &self.kind {
                 None => "--with-attribute-custom",
-                Some(TypeKind::Struct) => "--with-attribute-custom-struct",
-                Some(TypeKind::Enum) => "--with-attribute-custom-enum",
-                Some(TypeKind::Union) => "--with-attribute-custom-union",
+                Some(AttributeItemKind::Struct) => "--with-attribute-custom-struct",
+                Some(AttributeItemKind::Enum) => "--with-attribute-custom-enum",
+                Some(AttributeItemKind::Union) => "--with-attribute-custom-union",
+                Some(AttributeItemKind::Function) => "--with-attribute-custom-function",
             };
 
             let attributes = self.attributes.join(",");
@@ -1010,19 +1015,24 @@ where
         (with_attribute_custom, None, "--with-attribute-custom"),
         (
             with_attribute_custom_struct,
-            Some(TypeKind::Struct),
+            Some(AttributeItemKind::Struct),
             "--with-attribute-custom-struct",
         ),
         (
             with_attribute_custom_enum,
-            Some(TypeKind::Enum),
+            Some(AttributeItemKind::Enum),
             "--with-attribute-custom-enum",
         ),
         (
             with_attribute_custom_union,
-            Some(TypeKind::Union),
+            Some(AttributeItemKind::Union),
             "--with-attribute-custom-union",
         ),
+        (
+            with_attribute_custom_function,
+            Some(AttributeItemKind::Function),
+            "--with-attribute-custom-function",
+        ),
     ] {
         #[cfg(feature = "experimental")]
         let name = emit_diagnostics.then_some(_name);