WIP: double-enum

Author: jschwe

bindgen/codegen/mod.rs

@@ -3575,7 +3575,7 @@ impl EnumBuilder {
         ctx: &BindgenContext,
         rust_ty: &syn::Type,
         // Optionally place the enum bindings in a module
-        module: Option<syn::Ident>,
+        module: Option<Ident>,
         enum_variants: &[EnumVariantInfo],
         result: &mut CodegenResult<'_>,
     ) -> proc_macro2::TokenStream {
@@ -3813,9 +3813,27 @@ impl CodeGenerator for Enum {
 
         let variation = self.computed_enum_variation(ctx, item);
         self.codegen_variation(ctx, result, item, None, variation);
-        // let module = ctx.rust_ident("rustified_enum");
-        // Todo: add an option for additional rustified enum
-        // self.codegen_variation(ctx, result, item, Some(module), EnumVariation::Rust {non_exhaustive: true});
+        // todo: expose options for:
+        // - non-exhaustive
+        // - disambiguation: module-name / rename enum ( callback ?)
+        // - Variant-Casing
+        // perhaps we just make the additional enum a callback?
+        if ctx
+            .options()
+            .safe_rust_enums
+            .matches(item.canonical_name(ctx))
+        {
+            let module = ctx.rust_ident("rustified_enum");
+            self.codegen_variation(
+                ctx,
+                result,
+                item,
+                Some(module),
+                EnumVariation::Rust {
+                    non_exhaustive: true,
+                },
+            );
+        }
     }
 }
 
@@ -3831,7 +3849,7 @@ impl Enum {
         ctx: &BindgenContext,
         result: &mut CodegenResult<'_>,
         item: &Item,
-        module: Option<syn::Ident>,
+        module: Option<Ident>,
         variation: EnumVariation,
     ) {
         debug!("<Enum as CodeGenerator>::codegen: item = {item:?}");

bindgen/options/mod.rs

@@ -438,6 +438,27 @@ options! {
         },
         as_args: "--newtype-enum",
     },
+     /// Generate an **additional** rustified `enum`s, which can be converted from the FFI-safe
+     /// representation.
+    safe_rust_enums: RegexSet {
+        methods: {
+            regex_option! {
+                /// Generate a rustified `enum` **in addition** to an FFI-safe representation
+                ///
+                /// Regular rustified enums are not FFI-safe, since unknown variants are
+                /// immediate undefined behavior. This option allows generating a secondary
+                /// rustified enum representation, with From implemementation to conveninetly
+                /// convert the FFI-safe representation to the rustified enum.
+                ///
+                /// The rustified enum is placed in a module.
+                pub fn safe_rust_enums<T: AsRef<str>>(mut self, arg: T) -> Builder {
+                    self.options.safe_rust_enums.insert(arg);
+                    self
+                }
+            }
+        },
+        as_args: "--safe-rust-enum",
+    },
    /// `enum`s marked as `Result<(), ErrorEnum>`.
     result_error_enums: RegexSet {
         methods: {