transpile: Translate enums into newtype structs

Rua · Rua · commit 0b1c4430e184 · 2026-02-25T17:24:44.000+01:00
diff --git a/c2rust-transpile/src/translator/enums.rs b/c2rust-transpile/src/translator/enums.rs
@@ -23,10 +23,18 @@ impl<'c> Translation<'c> {
             .borrow()
             .resolve_decl_name(enum_id)
             .expect("Enums should already be renamed");
-        let ty = self.convert_type(integral_type.ctype)?;
-        Ok(ConvertedDecl::Item(
-            mk().span(span).pub_().type_item(enum_name, ty),
-        ))
+
+        let field = mk()
+            .pub_()
+            .enum_field(self.convert_type(integral_type.ctype)?);
+        let item = mk()
+            .span(span)
+            .call_attr("derive", vec!["Clone", "Copy"])
+            .call_attr("repr", vec!["transparent"])
+            .pub_()
+            .struct_item(enum_name, vec![field], true);
+
+        Ok(ConvertedDecl::Item(item))
     }
 
     pub fn convert_enum_constant(
@@ -46,47 +54,51 @@ impl<'c> Translation<'c> {
             .borrow()
             .resolve_decl_name(enum_id)
             .expect("Enums should already be renamed");
-        self.add_import(enum_id, &enum_name);
 
         let ty = mk().ident_ty(enum_name);
         let val = match value {
             ConstIntExpr::I(value) => signed_int_expr(value),
             ConstIntExpr::U(value) => mk().lit_expr(mk().int_unsuffixed_lit(value as u128)),
         };
+        let init = self.enum_constructor_expr(enum_id, val);
 
         Ok(ConvertedDecl::Item(
-            mk().span(span).pub_().const_item(name, ty, val),
+            mk().span(span).pub_().const_item(name, ty, init),
         ))
     }
 
-    pub fn convert_enum_zero_initializer(&self, type_id: CTypeId) -> WithStmts<Box<Expr>> {
-        WithStmts::new_val(self.enum_for_i64(type_id, 0))
+    pub fn convert_enum_zero_initializer(&self, enum_id: CEnumId) -> WithStmts<Box<Expr>> {
+        WithStmts::new_val(self.enum_for_i64(enum_id, 0))
     }
 
     /// Translate a cast where the source type, but not the target type, is an `enum` type.
     pub fn convert_cast_from_enum(
         &self,
         target_cty: CTypeId,
-        val: Box<Expr>,
+        mut val: Box<Expr>,
     ) -> TranslationResult<Box<Expr>> {
         // Convert it to the expected integral type.
+        val = self.integer_from_enum(val);
+
         let ty = self.convert_type(target_cty)?;
-        Ok(mk().cast_expr(val, ty))
+        val = mk().cast_expr(val, ty);
+
+        Ok(val)
+    }
+
+    /// Gets the inner integral value of an enum value.
+    pub fn integer_from_enum(&self, val: Box<Expr>) -> Box<Expr> {
+        mk().anon_field_expr(val, 0)
     }
 
-    /// Translate a cast where the target type is an `enum` type.
-    ///
-    /// When translating variable references to `EnumConstant`s, we always insert casts to the
-    /// expected type. In C, `EnumConstant`s have some integral type, _not_ the enum type. However,
-    /// if we then immediately have a cast to convert this variable back into an enum type, we would
-    /// like to produce Rust with _no_ casts. This function handles this simplification.
+    /// Translates a cast where the target type is an `enum` type.
     pub fn convert_cast_to_enum(
         &self,
         ctx: ExprContext,
-        enum_type_id: CTypeId,
         enum_id: CEnumId,
         expr: Option<CExprId>,
-        val: Box<Expr>,
+        source_cty: CQualTypeId,
+        mut val: Box<Expr>,
     ) -> TranslationResult<Box<Expr>> {
         if let Some(expr) = expr {
             match self.ast_context[expr].kind {
@@ -109,53 +121,57 @@ impl<'c> Translation<'c> {
                 }
 
                 CExprKind::Literal(_, CLiteral::Integer(i, _)) => {
-                    return Ok(self.enum_for_i64(enum_type_id, i as i64));
+                    return Ok(self.enum_for_i64(enum_id, i as i64));
                 }
 
                 CExprKind::Unary(_, c_ast::UnOp::Negate, subexpr_id, _) => {
                     if let &CExprKind::Literal(_, CLiteral::Integer(i, _)) =
                         &self.ast_context[subexpr_id].kind
                     {
-                        return Ok(self.enum_for_i64(enum_type_id, -(i as i64)));
+                        return Ok(self.enum_for_i64(enum_id, -(i as i64)));
                     }
                 }
 
                 _ => {}
             }
         }
 
-        let target_ty = self.convert_type(enum_type_id)?;
-        Ok(mk().cast_expr(val, target_ty))
+        let integral_type = self.enum_integral_type(enum_id);
+        let mut needs_cast = true;
+
+        // C allows directly casting from enum to enum, but in Rust we need to use
+        // the inner integer value as an intermediate.
+        if let CTypeKind::Enum(source_enum_id) =
+            self.ast_context.resolve_type(source_cty.ctype).kind
+        {
+            val = self.integer_from_enum(val);
+            needs_cast = integral_type.ctype != self.enum_integral_type(source_enum_id).ctype;
+        }
+
+        if needs_cast {
+            let ty = self.convert_type(integral_type.ctype)?;
+            val = mk().cast_expr(val, ty);
+            val = self.enum_constructor_expr(enum_id, val);
+        }
+
+        Ok(val)
     }
 
     /// Given an integer value this attempts to either generate the corresponding enum
     /// variant directly, otherwise it converts a number to the enum type.
-    fn enum_for_i64(&self, enum_type_id: CTypeId, value: i64) -> Box<Expr> {
-        let enum_id = match self.ast_context.resolve_type(enum_type_id).kind {
-            CTypeKind::Enum(enum_id) => enum_id,
-            _ => panic!("{:?} does not point to an `enum` type", enum_type_id),
-        };
-
+    fn enum_for_i64(&self, enum_id: CEnumId, value: i64) -> Box<Expr> {
         if let Some(enum_constant_id) = self.enum_variant_for_i64(enum_id, value) {
             return self.enum_constant_expr(enum_constant_id);
         }
 
-        let underlying_type_id = match self.ast_context[enum_id].kind {
-            CDeclKind::Enum {
-                integral_type: Some(integral_type),
-                ..
-            } => integral_type,
-            _ => panic!("{:?} does not point to an `enum` declaration", enum_id),
-        };
-
+        let underlying_type_id = self.enum_integral_type(enum_id);
         let value = match self.ast_context.resolve_type(underlying_type_id.ctype).kind {
             CTypeKind::UInt => mk().lit_expr(mk().int_unsuffixed_lit((value as u32) as u128)),
             CTypeKind::ULong => mk().lit_expr(mk().int_unsuffixed_lit((value as u64) as u128)),
             _ => signed_int_expr(value),
         };
 
-        let target_ty = self.convert_type(enum_type_id).unwrap();
-        mk().cast_expr(value, target_ty)
+        self.enum_constructor_expr(enum_id, value)
     }
 
     /// Returns the id of the variant of `enum_id` whose value matches `value`, if any.
@@ -185,9 +201,29 @@ impl<'c> Translation<'c> {
         variants.contains(&enum_constant_id)
     }
 
+    fn enum_constructor_expr(&self, enum_id: CEnumId, value: Box<Expr>) -> Box<Expr> {
+        let enum_name = self
+            .type_converter
+            .borrow()
+            .resolve_decl_name(enum_id)
+            .unwrap();
+        self.add_import(enum_id, &enum_name);
+        mk().call_expr(mk().ident_expr(enum_name), vec![value])
+    }
+
     fn enum_constant_expr(&self, enum_constant_id: CEnumConstantId) -> Box<Expr> {
         let name = self.renamer.borrow().get(&enum_constant_id).unwrap();
         self.add_import(enum_constant_id, &name);
         mk().ident_expr(name)
     }
+
+    fn enum_integral_type(&self, enum_id: CEnumId) -> CQualTypeId {
+        match self.ast_context[enum_id].kind {
+            CDeclKind::Enum {
+                integral_type: Some(integral_type),
+                ..
+            } => integral_type,
+            _ => panic!("{:?} does not point to an `enum` declaration", enum_id),
+        }
+    }
 }
diff --git a/c2rust-transpile/src/translator/mod.rs b/c2rust-transpile/src/translator/mod.rs
@@ -4481,18 +4481,12 @@ impl<'c> Translation<'c> {
                     Ok(val.map(|val| mk().call_expr(fn_path, vec![val])))
                 } else if let CTypeKind::LongDouble = self.ast_context[source_cty.ctype].kind {
                     self.f128_cast_to(val, target_ty_kind)
-                } else if let &CTypeKind::Enum(enum_decl_id) = target_ty_kind {
+                } else if let &CTypeKind::Enum(enum_id) = target_ty_kind {
                     // Casts targeting `enum` types...
                     let expr =
                         expr.ok_or_else(|| format_err!("Casts to enums require a C ExprId"))?;
                     val.result_map(|val| {
-                        self.convert_cast_to_enum(
-                            ctx,
-                            target_cty.ctype,
-                            enum_decl_id,
-                            Some(expr),
-                            val,
-                        )
+                        self.convert_cast_to_enum(ctx, enum_id, Some(expr), source_cty, val)
                     })
                 } else if target_ty_kind.is_floating_type() && source_ty_kind.is_bool() {
                     val.and_then(|x| {
@@ -4794,7 +4788,7 @@ impl<'c> Translation<'c> {
             }
 
             // Transmute the number `0` into the enum type
-            CDeclKind::Enum { .. } => self.convert_enum_zero_initializer(type_id),
+            CDeclKind::Enum { .. } => self.convert_enum_zero_initializer(decl_id),
 
             _ => {
                 return Err(TranslationError::generic(
@@ -4915,7 +4909,7 @@ impl<'c> Translation<'c> {
             }
 
             let val = if ty.is_enum() {
-                mk().cast_expr(val, mk().path_ty(vec!["u64"]))
+                mk().anon_field_expr(val, 0)
             } else {
                 val
             };
diff --git a/c2rust-transpile/src/translator/operators.rs b/c2rust-transpile/src/translator/operators.rs
@@ -221,9 +221,12 @@ impl<'c> Translation<'c> {
         } else {
             let compute_lhs_resolved_ty = &self.ast_context.resolve_type(compute_lhs_type_id.ctype);
             let lhs_type = self.convert_type(compute_lhs_type_id.ctype)?;
+            let result_ty_kind = &self.ast_context.resolve_type(lhs_type_id.ctype).kind;
 
-            // We can't simply as-cast into a non primitive like f128
-            let lhs = if compute_lhs_resolved_ty.kind == CTypeKind::LongDouble {
+            let lhs = if let CTypeKind::Enum(..) = result_ty_kind {
+                self.convert_cast_from_enum(compute_lhs_type_id.ctype, read)?
+            } else if compute_lhs_resolved_ty.kind == CTypeKind::LongDouble {
+                // We can't simply as-cast into a non primitive like f128
                 self.use_crate(ExternCrate::F128);
 
                 let fn_path = mk().abs_path_expr(vec!["f128", "f128", "from"]);
@@ -245,11 +248,9 @@ impl<'c> Translation<'c> {
                 None,
             )?;
 
-            let result_ty_kind = &self.ast_context.resolve_type(lhs_type_id.ctype).kind;
-
             if let &CTypeKind::Enum(enum_id) = result_ty_kind {
                 val = val.result_map(|val| {
-                    self.convert_cast_to_enum(ctx, lhs_type_id.ctype, enum_id, None, val)
+                    self.convert_cast_to_enum(ctx, enum_id, None, compute_res_type_id, val)
                 })?;
             } else if compute_lhs_resolved_ty.kind == CTypeKind::LongDouble {
                 // We can't as-cast from a non primitive like f128 back to the result_type
@@ -488,9 +489,9 @@ impl<'c> Translation<'c> {
                                 if let &CTypeKind::Enum(enum_id) = result_ty_kind {
                                     val = val.result_map(|val| self.convert_cast_to_enum(
                                         ctx,
-                                        expr_type_id.ctype,
                                         enum_id,
                                         None,
+                                        result_type_id,
                                         val,
                                     ))?;
                                 } else {
diff --git a/c2rust-transpile/src/translator/pointers.rs b/c2rust-transpile/src/translator/pointers.rs
@@ -265,6 +265,10 @@ impl<'c> Translation<'c> {
         let lhs_node_type = lhs_node
             .get_type()
             .ok_or_else(|| format_err!("lhs node bad type"))?;
+        let rhs_node_type = rhs_node
+            .get_type()
+            .ok_or_else(|| format_err!("rhs node bad type"))?;
+
         if self
             .ast_context
             .resolve_type(lhs_node_type)
@@ -278,7 +282,12 @@ impl<'c> Translation<'c> {
         }
 
         let rhs = self.convert_expr(ctx.used(), rhs, None)?;
-        rhs.and_then(|rhs| {
+        rhs.and_then(|mut rhs| {
+            // C allows enums to index arrays directly without inserting a numeric cast.
+            if let CTypeKind::Enum(..) = self.ast_context.resolve_type(rhs_node_type).kind {
+                rhs = self.integer_from_enum(rhs);
+            }
+
             let simple_index_array = if ctx.needs_address() {
                 // We can't necessarily index into an array if we're using
                 // that element to compute an address.
diff --git a/c2rust-transpile/tests/snapshots/snapshots__transpile@exprs.c.snap b/c2rust-transpile/tests/snapshots/snapshots__transpile@exprs.c.snap
@@ -15,10 +15,12 @@ input_file: c2rust-transpile/tests/snapshots/exprs.c
 extern "C" {
     fn puts(str: *const ::core::ffi::c_char) -> ::core::ffi::c_int;
 }
-pub type C2RustUnnamed = ::core::ffi::c_uint;
-pub const C: C2RustUnnamed = 2;
-pub const B: C2RustUnnamed = 1;
-pub const A: C2RustUnnamed = 0;
+#[derive(Clone, Copy)]
+#[repr(transparent)]
+pub struct C2RustUnnamed(pub ::core::ffi::c_uint);
+pub const C: C2RustUnnamed = C2RustUnnamed(2);
+pub const B: C2RustUnnamed = C2RustUnnamed(1);
+pub const A: C2RustUnnamed = C2RustUnnamed(0);
 unsafe extern "C" fn side_effect() -> ::core::ffi::c_int {
     puts(b"the return of side effect\0" as *const u8 as *const ::core::ffi::c_char);
     return 10 as ::core::ffi::c_int;
@@ -54,5 +56,5 @@ pub unsafe extern "C" fn unary_with_side_effect() {
 }
 #[no_mangle]
 pub unsafe extern "C" fn compound_literal() {
-    let mut i: ::core::ffi::c_int = B as ::core::ffi::c_int;
+    let mut i: ::core::ffi::c_int = B.0 as ::core::ffi::c_int;
 }
diff --git a/c2rust-transpile/tests/snapshots/snapshots__transpile@macrocase.c.snap b/c2rust-transpile/tests/snapshots/snapshots__transpile@macrocase.c.snap
@@ -11,14 +11,16 @@ input_file: c2rust-transpile/tests/snapshots/macrocase.c
     unused_assignments,
     unused_mut
 )]
-pub type ZSTD_dParameter = ::core::ffi::c_uint;
-pub const ZSTD_d_experimentalParam1: ZSTD_dParameter = 1000;
-pub const ZSTD_d_windowLogMax: ZSTD_dParameter = 100;
+#[derive(Clone, Copy)]
+#[repr(transparent)]
+pub struct ZSTD_dParameter(pub ::core::ffi::c_uint);
+pub const ZSTD_d_experimentalParam1: ZSTD_dParameter = ZSTD_dParameter(1000);
+pub const ZSTD_d_windowLogMax: ZSTD_dParameter = ZSTD_dParameter(100);
 pub const ZSTD_d_format: ::core::ffi::c_uint = 1000 as ::core::ffi::c_uint;
 #[no_mangle]
 pub unsafe extern "C" fn ZSTD_dParam_getBounds(mut dParam: ZSTD_dParameter) -> ::core::ffi::c_int {
     let mut bounds: ::core::ffi::c_int = 0 as ::core::ffi::c_int;
-    match dParam as ::core::ffi::c_uint {
+    match dParam.0 as ::core::ffi::c_uint {
         100 => {
             bounds = 1 as ::core::ffi::c_int;
             return bounds;
diff --git a/c2rust-transpile/tests/snapshots/snapshots__transpile@records.c.snap b/c2rust-transpile/tests/snapshots/snapshots__transpile@records.c.snap
@@ -14,9 +14,11 @@ input_file: c2rust-transpile/tests/snapshots/records.c
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub struct AnonEnumInStruct {}
-pub type C2RustUnnamed = ::core::ffi::c_uint;
-pub const VALUE2: C2RustUnnamed = 1;
-pub const VALUE1: C2RustUnnamed = 0;
+#[derive(Clone, Copy)]
+#[repr(transparent)]
+pub struct C2RustUnnamed(pub ::core::ffi::c_uint);
+pub const VALUE2: C2RustUnnamed = C2RustUnnamed(1);
+pub const VALUE1: C2RustUnnamed = C2RustUnnamed(0);
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub struct AnonStructInStruct {
@@ -40,9 +42,11 @@ pub struct InsideStruct {
 pub union AnonEnumInUnion {
     pub a: ::core::ffi::c_int,
 }
-pub type C2RustUnnamed_1 = ::core::ffi::c_uint;
-pub const VALUE4: C2RustUnnamed_1 = 1;
-pub const VALUE3: C2RustUnnamed_1 = 0;
+#[derive(Clone, Copy)]
+#[repr(transparent)]
+pub struct C2RustUnnamed_1(pub ::core::ffi::c_uint);
+pub const VALUE4: C2RustUnnamed_1 = C2RustUnnamed_1(1);
+pub const VALUE3: C2RustUnnamed_1 = C2RustUnnamed_1(0);
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub union AnonStructInUnion {
@@ -66,7 +70,7 @@ pub struct InsideUnion {
 }
 #[no_mangle]
 pub unsafe extern "C" fn struct_declaration() {
-    let mut value: ::core::ffi::c_int = VALUE2 as ::core::ffi::c_int;
+    let mut value: ::core::ffi::c_int = VALUE2.0 as ::core::ffi::c_int;
     let mut a: AnonEnumInStruct = AnonEnumInStruct {};
     let mut b: AnonStructInStruct = AnonStructInStruct {
         c2rust_unnamed: C2RustUnnamed_0 { some_number: 0 },
@@ -77,7 +81,7 @@ pub unsafe extern "C" fn struct_declaration() {
 }
 #[no_mangle]
 pub unsafe extern "C" fn union_declaration() {
-    let mut value: ::core::ffi::c_int = VALUE4 as ::core::ffi::c_int;
+    let mut value: ::core::ffi::c_int = VALUE4.0 as ::core::ffi::c_int;
     let mut a: AnonEnumInUnion = AnonEnumInUnion { a: 0 };
     let mut b: AnonStructInUnion = AnonStructInUnion {
         c2rust_unnamed: C2RustUnnamed_2 { some_number: 0 },
diff --git a/tests/unit/enums/src/test_enums.rs b/tests/unit/enums/src/test_enums.rs
diff --git a/tests/unit/misc/src/test_uninitialized.rs b/tests/unit/misc/src/test_uninitialized.rs
