allow renaming rules for C enums, structs, and typedefs

```rust
// true to enable debug output as warnings
let mut ren = Renamer::new(true);

// rename a single item, e.g. a struct, enum, or a typedef
ren.rename_item("my_struct", "MyStruct");

// rename an enum and its values
rename_enum!(
    ren,
    "my_enum" => "MyEnum", // rename the enum itself
    remove: "^I_SAID_",    // optionally any number of "remove" regexes
    remove: "_ENUM$",
    case: Pascal,          // optionally set case convert, defaults to "PascalCase"
    "MV_IT" => "Value1",   // rename a specific value after pattern removal
    "MV_IT2" => "Value2",  // more specific value renames
);

let bindings = Builder::default()
    // in real code, use .header("path/to/header.h")
    .header_contents("test.h", r#"
struct my_struct {
    int a;
};
enum my_enum {
	I_SAID_YES_ENUM,
	I_SAID_NO_ENUM,
	I_SAID_MV_IT_ENUM,
	I_SAID_MV_IT2_ENUM,
};
"#)
    .rustified_enum(ren.get_regex_str())
    .parse_callbacks(Box::new(ren))
    .generate().unwrap();
}

///////////  generated code

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MyStruct {
  pub a: ::std::os::raw::c_int,
}

#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum MyEnum {
  Yes = 0,
  No = 1,
  Value1 = 2,
  Value2 = 3,
}
```

Author: nyurik

Cargo.lock

@@ -30,6 +30,7 @@ cexpr = "0.6"
 clang-sys = "1"
 clap = "4"
 clap_complete = "4"
+convert_case = "0.8.0"
 env_logger = "0.10.0"
 itertools = { version = ">=0.10,<0.14", default-features = false }
 libloading = "0.8"

Cargo.toml

@@ -32,6 +32,7 @@ cexpr.workspace = true
 clang-sys = { workspace = true, features = ["clang_11_0"] }
 clap = { workspace = true, features = ["derive"], optional = true }
 clap_complete = { workspace = true, optional = true }
+convert_case.workspace = true
 itertools = { workspace = true }
 log = { workspace = true, optional = true }
 prettyplease = { workspace = true, optional = true, features = ["verbatim"] }

bindgen/Cargo.toml

@@ -395,15 +395,15 @@ pub(crate) struct BindgenContext {
     /// Whether a bindgen float16 was generated
     generated_bindgen_float16: Cell<bool>,
 
-    /// The set of `ItemId`s that are allowlisted. This the very first thing
+    /// The set of [`ItemId`]s that are allowlisted. This the very first thing
     /// computed after parsing our IR, and before running any of our analyses.
     allowlisted: Option<ItemSet>,
 
-    /// Cache for calls to `ParseCallbacks::blocklisted_type_implements_trait`
+    /// Cache for calls to [`crate::callbacks::ParseCallbacks::blocklisted_type_implements_trait`]
     blocklisted_types_implement_traits:
         RefCell<HashMap<DeriveTrait, HashMap<ItemId, CanDerive>>>,
 
-    /// The set of `ItemId`s that are allowlisted for code generation _and_ that
+    /// The set of [`ItemId`]s that are allowlisted for code generation _and_ that
     /// we should generate accounting for the codegen options.
     ///
     /// It's computed right after computing the allowlisted items.

bindgen/ir/context.rs

@@ -46,6 +46,7 @@ mod features;
 mod ir;
 mod parse;
 mod regex_set;
+mod renamer;
 
 pub use codegen::{
     AliasVariation, EnumVariation, MacroTypeVariation, NonCopyUnionStyle,
@@ -55,6 +56,7 @@ pub use ir::annotations::FieldVisibilityKind;
 pub use ir::function::Abi;
 #[cfg(feature = "__cli")]
 pub use options::cli::builder_from_flags;
+pub use renamer::{Case, IdentRenamer, Regex, Renamer};
 
 use codegen::CodegenError;
 use features::RustFeatures;
@@ -1312,6 +1314,42 @@ impl callbacks::ParseCallbacks for CargoCallbacks {
     }
 }
 
+/// Macro to help define renaming rules for an enum and its values. See an example in the [`Renamer`] documentation.
+#[macro_export]
+macro_rules! rename_enum {
+    ( $cb:expr,
+      $c_name:literal => $rust_name:literal
+      $(, remove: $remove:literal)*
+      $(, case: $case:ident)?
+      $(, $itm:literal => $ren:literal)*
+      $(,)?
+    ) => {
+        $cb.rename_item($c_name, $rust_name);
+        #[allow(clippy::needless_update)]
+        $cb.rename_enum_val(
+            Some(concat!("enum ", $c_name)),
+            $crate::IdentRenamer {
+                remove: {
+                    let patterns: Vec<&str> = vec![$($remove),*];
+                    if patterns.is_empty() {
+                        None
+                    } else {
+                        Some(
+                            patterns
+                                .into_iter()
+                                .map(|v| $crate::Regex::new(v).expect("Unable to compile regex for remove parameter"))
+                                .collect()
+                        )
+                    }
+                },
+                $( case: Some($crate::Case::$case), )?
+                renames: vec![$( ($itm.into(), $ren.into()), )*].into_iter().collect(),
+                ..$crate::IdentRenamer::default_case($crate::Case::Pascal)
+            }
+        );
+    };
+}
+
 /// Test `command_line_flag` function.
 #[test]
 fn commandline_flag_unit_test_function() {