Auto merge of #1183 - fitzgen:repr-c-on-enums, r=emilio

repr(C) on enums

r? @pepyakin or @emilio

Author: bors-servo

csmith-fuzzing/predicate.py

@@ -45,6 +45,11 @@
     default=BINDGEN_ARGS,
     help="An argument string that `bindgen` should be invoked with. By default, all traits are derived. Note that the input header and output bindings file will automatically be provided by this script, and you should not manually specify them.")
 
+parser.add_argument(
+    "--save-temp-files",
+    action="store_true",
+    help="Do not delete temporary files.")
+
 parser.add_argument(
     "input",
     type=str,
@@ -144,11 +149,12 @@ def main():
         exit_code = 2
         print("Unexpected exception:", e)
 
-    for path in TEMP_FILES:
-        try:
-            os.remove(path)
-        except Exception as e:
-            print("Unexpected exception:", e)
+    if not args.save_temp_files:
+        for path in TEMP_FILES:
+            try:
+                os.remove(path)
+            except Exception as e:
+                print("Unexpected exception:", e)
 
     sys.exit(exit_code)
 

src/codegen/mod.rs

@@ -2148,7 +2148,10 @@ impl EnumVariation {
 
 /// A helper type to construct different enum variations.
 enum EnumBuilder<'a> {
-    Rust(quote::Tokens),
+    Rust {
+        tokens: quote::Tokens,
+        emitted_any_variants: bool,
+    },
     Bitfield {
         canonical_name: &'a str,
         tokens: quote::Tokens,
@@ -2188,7 +2191,10 @@ impl<'a> EnumBuilder<'a> {
                     pub enum #ident
                 };
                 tokens.append("{");
-                EnumBuilder::Rust(tokens)
+                EnumBuilder::Rust {
+                    tokens,
+                    emitted_any_variants: false,
+                }
             }
 
             EnumVariation::Consts => {
@@ -2229,12 +2235,15 @@ impl<'a> EnumBuilder<'a> {
         };
 
         match self {
-            EnumBuilder::Rust(tokens) => {
+            EnumBuilder::Rust { tokens, emitted_any_variants: _ } => {
                 let name = ctx.rust_ident(variant_name);
-                EnumBuilder::Rust(quote! {
-                    #tokens
-                    #name = #expr,
-                })
+                EnumBuilder::Rust {
+                    tokens: quote! {
+                        #tokens
+                        #name = #expr,
+                    },
+                    emitted_any_variants: true,
+                }
             }
 
             EnumBuilder::Bitfield { .. } => {
@@ -2295,9 +2304,12 @@ impl<'a> EnumBuilder<'a> {
         result: &mut CodegenResult<'b>,
     ) -> quote::Tokens {
         match self {
-            EnumBuilder::Rust(mut t) => {
-                t.append("}");
-                t
+            EnumBuilder::Rust { mut tokens, emitted_any_variants } => {
+                if !emitted_any_variants {
+                    tokens.append(quote! { __bindgen_cannot_repr_c_on_empty_enum = 0 });
+                }
+                tokens.append("}");
+                tokens
             }
             EnumBuilder::Bitfield {
                 canonical_name,
@@ -2432,15 +2444,12 @@ impl CodeGenerator for Enum {
 
         let mut attrs = vec![];
 
-        // FIXME: Rust forbids repr with empty enums. Remove this condition when
-        // this is allowed.
-        //
         // TODO(emilio): Delegate this to the builders?
         if variation.is_rust() {
-            if !self.variants().is_empty() {
-                attrs.push(attributes::repr(repr_name));
-            }
-        } else if variation.is_bitfield() {
+            attrs.push(attributes::repr(repr_name));
+        }
+
+        if variation.is_bitfield() || variation.is_rust() {
             attrs.push(attributes::repr("C"));
         }
 

tests/expectations/tests/anon_enum.rs

@@ -12,6 +12,7 @@ pub struct Test {
 }
 pub const Test_T_NONE: Test__bindgen_ty_1 = Test__bindgen_ty_1::T_NONE;
 #[repr(u32)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum Test__bindgen_ty_1 {
     T_NONE = 0,
@@ -40,6 +41,7 @@ fn bindgen_test_layout_Test() {
     );
 }
 #[repr(u32)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum Baz {
     Foo = 0,

tests/expectations/tests/anon_enum_trait.rs

@@ -19,6 +19,7 @@ pub const DataType_channels: DataType__bindgen_ty_1 = DataType__bindgen_ty_1::ge
 pub const DataType_fmt: DataType__bindgen_ty_1 = DataType__bindgen_ty_1::generic_type;
 pub const DataType_type_: DataType__bindgen_ty_1 = DataType__bindgen_ty_1::generic_type;
 #[repr(i32)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum DataType__bindgen_ty_1 {
     generic_type = 0,
@@ -31,6 +32,7 @@ pub struct Foo {
 pub const Foo_Bar: Foo__bindgen_ty_1 = Foo__bindgen_ty_1::Bar;
 pub const Foo_Baz: Foo__bindgen_ty_1 = Foo__bindgen_ty_1::Bar;
 #[repr(u32)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum Foo__bindgen_ty_1 {
     Bar = 0,

tests/expectations/tests/anon_enum_whitelist.rs

@@ -7,6 +7,7 @@
 pub const NODE_FLAG_FOO: _bindgen_ty_1 = _bindgen_ty_1::NODE_FLAG_FOO;
 pub const NODE_FLAG_BAR: _bindgen_ty_1 = _bindgen_ty_1::NODE_FLAG_BAR;
 #[repr(u32)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum _bindgen_ty_1 {
     NODE_FLAG_FOO = 0,

tests/expectations/tests/anon_union.rs

@@ -14,6 +14,7 @@ pub struct TErrorResult {
 pub const TErrorResult_UnionState_HasException: TErrorResult_UnionState =
     TErrorResult_UnionState::HasMessage;
 #[repr(i32)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum TErrorResult_UnionState {
     HasMessage = 0,

tests/expectations/tests/anon_union_1_0.rs

@@ -58,6 +58,7 @@ pub struct TErrorResult {
 pub const TErrorResult_UnionState_HasException: TErrorResult_UnionState =
     TErrorResult_UnionState::HasMessage;
 #[repr(i32)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum TErrorResult_UnionState {
     HasMessage = 0,

tests/expectations/tests/bitfield_align_2.rs

@@ -84,6 +84,7 @@ where
     }
 }
 #[repr(u32)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum MyEnum {
     ONE = 0,

tests/expectations/tests/class_with_inner_struct.rs

@@ -214,6 +214,7 @@ fn bindgen_test_layout_B() {
     );
 }
 #[repr(i32)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum StepSyntax {
     Keyword = 0,

tests/expectations/tests/class_with_inner_struct_1_0.rs

@@ -272,6 +272,7 @@ impl Clone for B {
     }
 }
 #[repr(i32)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum StepSyntax {
     Keyword = 0,

tests/expectations/tests/const_enum_unnamed.rs

@@ -7,6 +7,7 @@
 pub const FOO_BAR: _bindgen_ty_1 = _bindgen_ty_1::FOO_BAR;
 pub const FOO_BAZ: _bindgen_ty_1 = _bindgen_ty_1::FOO_BAZ;
 #[repr(u32)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum _bindgen_ty_1 {
     FOO_BAR = 0,
@@ -19,6 +20,7 @@ pub struct Foo {
 }
 pub const Foo_FOO_BAR: Foo__bindgen_ty_1 = Foo__bindgen_ty_1::FOO_BAR;
 #[repr(u32)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum Foo__bindgen_ty_1 {
     FOO_BAR = 10,

tests/expectations/tests/constify-enum.rs

@@ -9,6 +9,7 @@ pub const nsCSSPropertyID_eCSSProperty_COUNT_unexistingVariantValue: nsCSSProper
 pub const nsCSSPropertyID_eCSSProperty_COUNT: nsCSSPropertyID =
     nsCSSPropertyID::eCSSPropertyAlias_aa;
 #[repr(u32)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum nsCSSPropertyID {
     eCSSProperty_a = 0,

tests/expectations/tests/empty-enum.rs

@@ -0,0 +1,36 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
+
+
+pub type EmptyConstified = ::std::os::raw::c_uint;
+#[repr(u32)]
+#[repr(C)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub enum EmptyRustified {
+    __bindgen_cannot_repr_c_on_empty_enum = 0,
+}
+pub mod EmptyModule {
+    pub type Type = ::std::os::raw::c_uint;
+}
+#[repr(i8)]
+#[repr(C)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub enum EmptyClassRustified {
+    __bindgen_cannot_repr_c_on_empty_enum = 0,
+}
+pub type EmptyClassConstified = ::std::os::raw::c_char;
+pub mod EmptyClassModule {
+    pub type Type = ::std::os::raw::c_char;
+}
+#[repr(i8)]
+#[repr(C)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub enum ForwardClassRustified {
+    __bindgen_cannot_repr_c_on_empty_enum = 0,
+}
+pub type ForwardClassConstified = ::std::os::raw::c_char;
+pub mod ForwardClassModule {
+    pub type Type = ::std::os::raw::c_char;
+}

tests/expectations/tests/enum.rs

@@ -5,12 +5,14 @@
 
 
 #[repr(u32)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum Foo {
     Bar = 0,
     Qux = 1,
 }
 #[repr(i32)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum Neg {
     MinusOne = -1,

tests/expectations/tests/enum_alias.rs

@@ -5,6 +5,7 @@
 
 
 #[repr(u8)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum Bar {
     VAL = 0,

tests/expectations/tests/enum_and_vtable_mangling.rs

@@ -7,6 +7,7 @@
 pub const match_: _bindgen_ty_1 = _bindgen_ty_1::match_;
 pub const whatever_else: _bindgen_ty_1 = _bindgen_ty_1::whatever_else;
 #[repr(u32)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum _bindgen_ty_1 {
     match_ = 0,

tests/expectations/tests/enum_dupe.rs

@@ -6,6 +6,7 @@
 
 pub const Foo_Dupe: Foo = Foo::Bar;
 #[repr(u32)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum Foo {
     Bar = 1,

tests/expectations/tests/enum_explicit_type.rs

@@ -5,34 +5,40 @@
 
 
 #[repr(u8)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum Foo {
     Bar = 0,
     Qux = 1,
 }
 #[repr(i8)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum Neg {
     MinusOne = -1,
     One = 1,
 }
 #[repr(u16)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum Bigger {
     Much = 255,
     Larger = 256,
 }
 #[repr(i64)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum MuchLong {
     MuchLow = -4294967296,
 }
 #[repr(i64)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum MuchLongLong {
     I64_MIN = -9223372036854775808,
 }
 #[repr(u64)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum MuchULongLong {
     MuchHigh = 4294967296,

tests/expectations/tests/enum_in_template_with_typedef.rs

@@ -13,6 +13,7 @@ pub type std_fbstring_core_category_type = u8;
 pub const std_fbstring_core_Category_Bar: std_fbstring_core_Category =
     std_fbstring_core_Category::Foo;
 #[repr(u8)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum std_fbstring_core_Category {
     Foo = 0,

tests/expectations/tests/enum_negative.rs

@@ -5,6 +5,7 @@
 
 
 #[repr(i32)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum Foo {
     Bar = -2,

tests/expectations/tests/enum_packed.rs

@@ -5,18 +5,21 @@
 
 
 #[repr(u8)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum Foo {
     Bar = 0,
     Qux = 1,
 }
 #[repr(i8)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum Neg {
     MinusOne = -1,
     One = 1,
 }
 #[repr(u16)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum Bigger {
     Much = 255,

tests/expectations/tests/forward-enum-decl.rs

@@ -5,6 +5,7 @@
 
 
 #[repr(i32)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum CSSPseudoClassType {
     empty = 0,

tests/expectations/tests/func_ptr_in_struct.rs

@@ -4,8 +4,12 @@
 #![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
 
 
+#[repr(i32)]
+#[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub enum baz {}
+pub enum baz {
+    __bindgen_cannot_repr_c_on_empty_enum = 0,
+}
 #[repr(C)]
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct Foo {

tests/expectations/tests/issue-372.rs

@@ -77,6 +77,7 @@ pub mod root {
         }
     }
     #[repr(u32)]
+    #[repr(C)]
     #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
     pub enum n {
         o = 0,