custom derives after DeriveInfo

Author: hcldan

bindgen-cli/options.rs

@@ -204,6 +204,16 @@ where
             Arg::new("no-derive-copy")
                 .long("no-derive-copy")
                 .help("Avoid deriving Copy on any type."),
+            Arg::new("with-derive-custom")
+                .long("with-derive-custom")
+                .help(
+                    "Derive custom traits on any kind of type. \
+                     The derive value must be of the shape <regex>=<kind>=<derive> where <kind> can be one of: \
+                     Any, Struct, or Union.",
+                )
+                .value_name("trait")
+                .multiple_occurrences(true)
+                .number_of_values(1),
             Arg::new("no-derive-debug")
                 .long("no-derive-debug")
                 .help("Avoid deriving Debug on any type."),
@@ -1092,5 +1102,53 @@ where
         builder = builder.wrap_unsafe_ops(true);
     }
 
+    if let Some(custom_derives) = matches.values_of("with-derive-custom") {
+        #[derive(Debug)]
+        struct CustomDeriveCallback {
+            derive: String,
+            kind: String, 
+            regex: String,
+        }
+        impl bindgen::callbacks::ParseCallbacks for CustomDeriveCallback {
+            fn add_derives(&self, info: &bindgen::callbacks::DeriveInfo<'_>) -> Vec<String> {
+                match self.kind.to_lowercase().as_str() {
+                    "struct" => match info.kind {
+                        Some(bindgen::ir::comp::CompKind::Struct) => {}, // continue
+                        _ => return vec![], // bail
+                    }
+                    "union" => match info.kind {
+                        Some(bindgen::ir::comp::CompKind::Union) => {}, // continue
+                        _ => return vec![], // bail
+                    }
+                    "any" => {} // continue
+                    other => panic!("Invalid custom derive: Unexpected kind '{}'", other)
+                }
+                
+                let mut re = bindgen::RegexSet::new();
+                re.insert(self.regex.to_owned());
+                re.build(false);
+                
+                match re.matches(info.name) {
+                    true  => vec![self.derive.to_owned()],
+                    false => vec![],
+                }
+            }
+        }
+
+        for custom_derive in custom_derives {
+            let mut values = custom_derive.rsplitn(3, "=");
+            let derive = values.next().expect("Invalid custom derive: Expected 3 parts, found 0").to_owned();
+            let kind   = values.next().expect("Invalid custom derive: Expected 3 parts, found 1").to_owned();
+            let regex  = values.next().expect("Invalid custom derive: Expected 3 parts, found 2").to_owned();
+
+            builder = builder.parse_callbacks(Box::new(CustomDeriveCallback { derive, kind, regex: regex }));
+        }
+
+        
+
+        // let derives: Vec<String> = traits.into_iter().map(|t| t.to_string()).collect();
+        // builder = builder.parse_callbacks(Box::new(CustomTraitCallback { derives }));
+    }
+
     Ok((builder, output, verbose))
 }

bindgen/callbacks.rs

@@ -1,6 +1,7 @@
 //! A public API for more fine-grained customization of bindgen behavior.
 
 pub use crate::ir::analysis::DeriveTrait;
+use crate::ir::comp::CompKind;
 pub use crate::ir::derive::CanDerive as ImplementsTrait;
 pub use crate::ir::enum_ty::{EnumVariantCustomBehavior, EnumVariantValue};
 pub use crate::ir::int::IntKind;
@@ -120,10 +121,13 @@ pub trait ParseCallbacks: fmt::Debug {
 
 /// Relevant information about a type to which new derive attributes will be added using
 /// [`ParseCallbacks::add_derives`].
+#[derive(Debug)]
 #[non_exhaustive]
 pub struct DeriveInfo<'a> {
     /// The name of the type.
     pub name: &'a str,
+    /// The kind of the type
+    pub kind: Option<CompKind>,
 }
 
 /// An struct providing information about the item being passed to `ParseCallbacks::generated_name_override`.

bindgen/codegen/mod.rs

@@ -2105,6 +2105,7 @@ impl CodeGenerator for CompInfo {
         let custom_derives = ctx.options().all_callbacks(|cb| {
             cb.add_derives(&crate::callbacks::DeriveInfo {
                 name: &canonical_name,
+                kind: Some(self.kind()),
             })
         });
         // In most cases this will be a no-op, since custom_derives will be empty.
@@ -3121,7 +3122,10 @@ impl CodeGenerator for Enum {
             // The custom derives callback may return a list of derive attributes;
             // add them to the end of the list.
             let custom_derives = ctx.options().all_callbacks(|cb| {
-                cb.add_derives(&crate::callbacks::DeriveInfo { name: &name })
+                cb.add_derives(&crate::callbacks::DeriveInfo { 
+                    name: &name,
+                    kind: None,
+                })
             });
             // In most cases this will be a no-op, since custom_derives will be empty.
             derives.extend(custom_derives.iter().map(|s| s.as_str()));

bindgen/lib.rs

@@ -65,7 +65,7 @@ mod clang;
 mod codegen;
 mod deps;
 mod features;
-mod ir;
+pub mod ir;
 mod parse;
 mod regex_set;
 mod time;
@@ -91,7 +91,7 @@ use crate::ir::context::{BindgenContext, ItemId};
 pub use crate::ir::function::Abi;
 use crate::ir::item::Item;
 use crate::parse::ParseError;
-use crate::regex_set::RegexSet;
+pub use crate::regex_set::RegexSet;
 
 use std::borrow::Cow;
 use std::env;

bindgen/regex_set.rs

@@ -16,6 +16,11 @@ pub struct RegexSet {
 }
 
 impl RegexSet {
+    /// Create a new RegexSet
+    pub fn new() -> RegexSet {
+        RegexSet { ..Default::default() }
+    }
+
     /// Is this set empty?
     pub fn is_empty(&self) -> bool {
         self.items.is_empty()