Support repr(C) for rustified enums

CHANGELOG.md

@@ -227,6 +227,7 @@
 --------------------------------------------------------------------------------
 # Unreleased
 ## Added
+ * Add option in CLI to use rustified repr-C enums (--rustified-repr-c-enum, #3265).
 ## Changed
 ## Removed
 ## Fixed

bindgen-integration/build.rs

@@ -237,6 +237,7 @@ fn setup_macro_test() {
         .enable_cxx_namespaces()
         .default_enum_style(EnumVariation::Rust {
             non_exhaustive: false,
+            repr_c: false,
         })
         .raw_line("pub use self::root::*;")
         .raw_line("extern { fn my_prefixed_function_to_remove(i: i32); }")

bindgen-tests/tests/headers/enum-doc-rusty-repr-c.h

@@ -0,0 +1,3 @@
+// bindgen-flags: --rustified-repr-c-enum B
+
+#include "enum-doc.h"

bindgen/codegen/helpers.rs

@@ -52,6 +52,12 @@ pub(crate) mod attributes {
         }
     }
 
+    pub(crate) fn repr_c() -> TokenStream {
+        quote! {
+            #[repr(C)]
+        }
+    }
+
     pub(crate) fn doc(comment: &str) -> TokenStream {
         if comment.is_empty() {
             quote!()

bindgen/codegen/mod.rs

@@ -3168,6 +3168,8 @@ pub enum EnumVariation {
     Rust {
         /// Indicates whether the generated struct should be `#[non_exhaustive]`
         non_exhaustive: bool,
+        /// Indicates whether the generated struct should be `#[repr(C)]`
+        repr_c: bool,
     },
     /// The code for this enum will use a newtype
     NewType {
@@ -3199,11 +3201,14 @@ impl fmt::Display for EnumVariation {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let s = match self {
             Self::Rust {
-                non_exhaustive: false,
-            } => "rust",
-            Self::Rust {
-                non_exhaustive: true,
-            } => "rust_non_exhaustive",
+                non_exhaustive,
+                repr_c,
+            } => match (*non_exhaustive, *repr_c) {
+                (false, false) => "rust",
+                (false, true) => "rust_repr_c",
+                (true, false) => "rust_non_exhaustive",
+                (true, true) => "rust_non_exhaustive_repr_c",
+            },
             Self::NewType {
                 is_bitfield: true, ..
             } => "bitfield",
@@ -3232,9 +3237,19 @@ impl FromStr for EnumVariation {
         match s {
             "rust" => Ok(EnumVariation::Rust {
                 non_exhaustive: false,
+                repr_c: false,
+            }),
+            "rust_repr_c" => Ok(EnumVariation::Rust {
+                non_exhaustive: false,
+                repr_c: true,
             }),
             "rust_non_exhaustive" => Ok(EnumVariation::Rust {
                 non_exhaustive: true,
+                repr_c: false,
+            }),
+            "rust_non_exhaustive_repr_c" => Ok(EnumVariation::Rust {
+                non_exhaustive: true,
+                repr_c: true,
             }),
             "bitfield" => Ok(EnumVariation::NewType {
                 is_bitfield: true,
@@ -3281,6 +3296,7 @@ struct EnumBuilder {
 enum EnumBuilderKind {
     Rust {
         non_exhaustive: bool,
+        repr_c: bool,
     },
     NewType {
         is_bitfield: bool,
@@ -3326,9 +3342,13 @@ impl EnumBuilder {
                 is_anonymous: enum_is_anonymous,
             },
 
-            EnumVariation::Rust { non_exhaustive } => {
-                EnumBuilderKind::Rust { non_exhaustive }
-            }
+            EnumVariation::Rust {
+                non_exhaustive,
+                repr_c,
+            } => EnumBuilderKind::Rust {
+                non_exhaustive,
+                repr_c,
+            },
 
             EnumVariation::Consts => EnumBuilderKind::Consts {
                 needs_typedef: !has_typedef,
@@ -3539,14 +3559,23 @@ impl EnumBuilder {
 
         // 2. Generate the enum representation
         match self.kind {
-            EnumBuilderKind::Rust { non_exhaustive } => {
+            EnumBuilderKind::Rust {
+                non_exhaustive,
+                repr_c,
+            } => {
                 let non_exhaustive_opt =
                     non_exhaustive.then(attributes::non_exhaustive);
 
+                let repr = if repr_c {
+                    attributes::repr_c()
+                } else {
+                    quote! { #[repr(#enum_repr)] }
+                };
+
                 quote! {
                     // Note: repr is on top of attrs to keep the test expectations diff small.
                     // a future commit could move it further down.
-                    #[repr(#enum_repr)]
+                    #repr
                     #non_exhaustive_opt
                     #( #attrs )*
                     pub enum #enum_ident {

bindgen/ir/enum_ty.rs

@@ -216,6 +216,7 @@ impl Enum {
         ) {
             EnumVariation::Rust {
                 non_exhaustive: false,
+                repr_c: false,
             }
         } else if self.is_matching_enum(
             ctx,
@@ -224,6 +225,16 @@ impl Enum {
         ) {
             EnumVariation::Rust {
                 non_exhaustive: true,
+                repr_c: false,
+            }
+        } else if self.is_matching_enum(
+            ctx,
+            &ctx.options().rustified_repr_c_enums,
+            item,
+        ) {
+            EnumVariation::Rust {
+                non_exhaustive: false,
+                repr_c: true,
             }
         } else if self.is_matching_enum(
             ctx,

bindgen/lib.rs

@@ -468,7 +468,7 @@ impl Builder {
 
 impl BindgenOptions {
     fn build(&mut self) {
-        const REGEX_SETS_LEN: usize = 29;
+        const REGEX_SETS_LEN: usize = 30;
 
         let regex_sets: [_; REGEX_SETS_LEN] = [
             &mut self.blocklisted_types,
@@ -489,6 +489,7 @@ impl BindgenOptions {
             &mut self.newtype_global_enums,
             &mut self.rustified_enums,
             &mut self.rustified_non_exhaustive_enums,
+            &mut self.rustified_repr_c_enums,
             &mut self.type_alias,
             &mut self.new_type_alias,
             &mut self.new_type_alias_deref,
@@ -524,6 +525,7 @@ impl BindgenOptions {
                     "--newtype-global-enum",
                     "--rustified-enum",
                     "--rustified-enum-non-exhaustive",
+                    "--rustified-enum-repr-c",
                     "--constified-enum-module",
                     "--constified-enum",
                     "--type-alias",

bindgen/options/cli.rs

@@ -168,6 +168,9 @@ struct BindgenCommand {
     /// Mark any enum whose name matches REGEX as a non-exhaustive Rust enum.
     #[arg(long, value_name = "REGEX")]
     rustified_non_exhaustive_enum: Vec<String>,
+    /// Mark any enum whose name matches REGEX as a repr(C) Rust enum.
+    #[arg(long, value_name = "REGEX")]
+    rustified_repr_c_enum: Vec<String>,
     /// Mark any enum whose name matches REGEX as a series of constants.
     #[arg(long, value_name = "REGEX")]
     constified_enum: Vec<String>,
@@ -560,6 +563,7 @@ where
         newtype_global_enum,
         rustified_enum,
         rustified_non_exhaustive_enum,
+        rustified_repr_c_enum,
         constified_enum,
         constified_enum_module,
         default_macro_constant_type,
@@ -869,6 +873,7 @@ where
             newtype_global_enum,
             rustified_enum,
             rustified_non_exhaustive_enum,
+            rustified_repr_c_enum,
             constified_enum,
             constified_enum_module,
             default_macro_constant_type,

bindgen/options/mod.rs

@@ -447,7 +447,8 @@ options! {
             /// To set the style for individual `enum`s, use [`Builder::bitfield_enum`],
             /// [`Builder::newtype_enum`], [`Builder::newtype_global_enum`],
             /// [`Builder::rustified_enum`], [`Builder::rustified_non_exhaustive_enum`],
-            /// [`Builder::constified_enum_module`] or [`Builder::constified_enum`].
+            /// [`Builder::rustified_repr_c_enum`], [`Builder::constified_enum_module`],
+            /// or [`Builder::constified_enum`].
             pub fn default_enum_style(
                 mut self,
                 arg: EnumVariation,
@@ -549,6 +550,22 @@ options! {
         },
         as_args: "--rustified-non-exhaustive-enum",
     },
+    /// `enum`s marked as `repr(C)` Rust `enum`s.
+    rustified_repr_c_enums: RegexSet {
+        methods: {
+            regex_option! {
+                /// Mark the given `enum` as a `repr(C)` Rust `enum`.
+                ///
+                /// This is similar to the [`Builder::rustified_enum`] style, but the `enum` is
+                /// tagged with the `#[repr(C)]` attribute.
+                pub fn rustified_repr_c_enum<T: AsRef<str>>(mut self, arg: T) -> Builder {
+                    self.options.rustified_repr_c_enums.insert(arg);
+                    self
+                }
+            }
+        },
+        as_args: "--rustified-repr-c-enum",
+    },
     /// `enum`s marked as modules of constants.
     constified_enum_modules: RegexSet {
         methods: {