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 --rust-target 1.79
+// 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,20 @@ impl ParseCallbacks for EnumVariantRename {
     }
 }
 
+#[derive(Debug)]
+struct ResultErrorEnumRename;
+
+impl ParseCallbacks for ResultErrorEnumRename {
+    fn result_error_enum_name(
+        &self,
+        original_enum_name: &str,
+    ) -> Option<String> {
+        original_enum_name
+            .strip_suffix("Result")
+            .map(|base| format!("{base}Error"))
+    }
+}
+
 #[derive(Debug)]
 struct BlocklistedTypeImplementsTrait;
 
@@ -149,6 +163,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,60 @@ pub trait ParseCallbacks: fmt::Debug {
         None
     }
 
+    /// Allows to rename the error enum name for a result-error-enum
+    ///
+    /// When the original C-enum is translated to a `Result<(), NonZero<ErrorEnum>>` representation,
+    /// the original enum name is used as a type alias for the result.
+    /// The error enum hence must have a different name. By default, we simply append an `Error` to
+    /// the typename, but this callback allows overriding the name for the error enum.
+    /// Please note that the new enum name returned by this callback must be distinct from the
+    /// original enum name.
+    ///
+    /// ### Example
+    ///
+    /// Given a header file like this:
+    /// ```c
+    /// enum MyResult {
+    ///     MyResultOk = 0,
+    ///     MyResultInvalid,
+    ///     MyResultAnotherError,
+    /// };
+    /// ```
+    /// A user could the implement the following callback:
+    /// ```rust
+    /// # use bindgen::callbacks::ParseCallbacks;
+    /// #[derive(Debug)]
+    /// struct ResultErrorEnumRename;
+    ///
+    /// impl ParseCallbacks for ResultErrorEnumRename {
+    ///     fn result_error_enum_name(
+    ///         &self,
+    ///         original_enum_name: &str,
+    ///     ) -> Option<String> {
+    ///         original_enum_name
+    ///             .strip_suffix("Result")
+    ///             .map(|base| format!("{base}Error"))
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// The above callback would result in the following rust binding:
+    ///
+    /// ```no_run
+    /// # // Note: doctests break when running with MSRV.
+    /// pub type MyResult = Result<(), MyError>;
+    /// #[repr(transparent)]
+    /// #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+    /// pub struct MyError(pub core::num::NonZero<::std::os::raw::c_uint>);
+    /// // <Definition of MyError variants>
+    /// ```
+    fn result_error_enum_name(
+        &self,
+        _original_enum_name: &str,
+    ) -> Option<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 error_enum_name = ctx
+                    .options()
+                    .last_callback(|c| c.result_error_enum_name(&name))
+                    .unwrap_or(format!("{name}Error"));
+                let error_ident =
+                    Ident::new(&error_enum_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();