Add callback to allow renaming result error enum

Author: jschwe

bindgen-tests/tests/expectations/tests/parsecb-result-error-enum-name.rs

@@ -0,0 +1,14 @@
+// bindgen-flags: --result-error-enum MyResult
+// bindgen-parse-callbacks: result-error-enum-rename
+
+enum MyResult {
+    MyResultOk = 0,
+    MyResultInvalid,
+    MyResultAnotherError,
+};
+
+typedef enum MyResult AnotherResult;
+
+enum MyResult some_function(void);
+
+AnotherResult another_function(void);

bindgen-tests/tests/headers/parsecb-result-error-enum-name.h

@@ -72,6 +72,22 @@ impl ParseCallbacks for EnumVariantRename {
     }
 }
 
+#[derive(Debug)]
+struct ResultErrorEnumRename;
+
+impl ParseCallbacks for ResultErrorEnumRename {
+    fn result_error_enum_name(
+        &self,
+        original_enum_name: &str,
+    ) -> Option<(String, String)> {
+        if let Some(base) = original_enum_name.strip_suffix("Result") {
+            Some((original_enum_name.to_string(), format!("{base}Error")))
+        } else {
+            None
+        }
+    }
+}
+
 #[derive(Debug)]
 struct BlocklistedTypeImplementsTrait;
 
@@ -149,6 +165,7 @@ impl ParseCallbacks for WrapAsVariadicFn {
 pub fn lookup(cb: &str) -> Box<dyn ParseCallbacks> {
     match cb {
         "enum-variant-rename" => Box::new(EnumVariantRename),
+        "result-error-enum-rename" => Box::new(ResultErrorEnumRename),
         "blocklisted-type-implements-trait" => {
             Box::new(BlocklistedTypeImplementsTrait)
         }

bindgen-tests/tests/parse_callbacks/mod.rs

@@ -79,6 +79,21 @@ pub trait ParseCallbacks: fmt::Debug {
         None
     }
 
+    /// Allows to renum the types for a result_error_enum.
+    ///
+    /// The original enum is translated to a `Result<(), NonZero<ErrorEnum>>` representation.
+    /// The first string allows renaming the type alias for the Result.
+    /// The second string allows renaming the `ErrorEnum`.
+    ///
+    /// By default, the Result typealias will be the original enum name, and the
+    /// error enum will have an `Error` suffix appended to the original name.
+    fn result_error_enum_name(
+        &self,
+        _original_enum_name: &str,
+    ) -> Option<(String, String)> {
+        None
+    }
+
     /// Allows to rename an enum variant, replacing `_original_variant_name`.
     fn enum_variant_name(
         &self,

bindgen/callbacks.rs

@@ -3316,6 +3316,7 @@ impl<'a> EnumBuilder<'a> {
     /// the representation, and which variation it should be generated as.
     fn new(
         name: &'a str,
+        ctx: &BindgenContext,
         mut attrs: Vec<proc_macro2::TokenStream>,
         repr: syn::Type,
         enum_variation: EnumVariation,
@@ -3329,8 +3330,12 @@ impl<'a> EnumBuilder<'a> {
                 is_global,
                 is_result_type: true,
             } => {
-                // Todo: This identifier perhaps could be determined by a ParseCallback.
-                let error_ident = format_ident!("{}Error", ident);
+                let (result_alias, error_name) = ctx
+                    .options()
+                    .last_callback(|c| c.result_error_enum_name(&name))
+                    .unwrap_or((name.to_string(), format!("{name}Error")));
+                let ident = Ident::new(&result_alias, Span::call_site());
+                let error_ident = Ident::new(&error_name, Span::call_site());
                 EnumBuilder::NewType {
                     canonical_name: name,
                     tokens: quote! {
@@ -3837,7 +3842,7 @@ impl CodeGenerator for Enum {
         let has_typedef = ctx.is_enum_typedef_combo(item.id());
 
         let mut builder =
-            EnumBuilder::new(&name, attrs, repr, variation, has_typedef);
+            EnumBuilder::new(&name, ctx, attrs, repr, variation, has_typedef);
 
         // A map where we keep a value -> variant relation.
         let mut seen_values = HashMap::<_, Ident>::default();