transpile: Translate enums into newtype structs

Rua · Rua · commit 797e7a0dc954 · 2026-03-14T12:32:18.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 ty = mk().ident_ty(enum_name.clone());
         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)
     }
 
-    /// 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.
+    /// 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)
+    }
+
+    /// 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: CTypeId,
+        mut val: Box<Expr>,
     ) -> TranslationResult<Box<Expr>> {
         if let Some(expr) = expr {
             match self.ast_context[expr].kind {
@@ -110,33 +122,42 @@ 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).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);
+        }
+
+        Ok(self.enum_constructor_expr(enum_id, 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);
         }
@@ -148,8 +169,7 @@ impl<'c> Translation<'c> {
             _ => 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.
@@ -170,6 +190,16 @@ impl<'c> Translation<'c> {
             })
     }
 
+    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);
diff --git a/c2rust-transpile/src/translator/mod.rs b/c2rust-transpile/src/translator/mod.rs
@@ -4545,18 +4545,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.ctype, val)
                     })
                 } else if target_ty_kind.is_floating_type() && source_ty_kind.is_bool() {
                     val.and_then(|x| {
@@ -4837,7 +4831,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(
@@ -4958,7 +4952,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 resolve_lhs_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(..) = resolve_lhs_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 resolve_lhs_kind = &self.ast_context.resolve_type(lhs_type_id.ctype).kind;
-
             val = if let &CTypeKind::Enum(enum_id) = resolve_lhs_kind {
                 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_lhs_type_id.ctype, 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
@@ -487,9 +488,9 @@ impl<'c> Translation<'c> {
                                 val = if let &CTypeKind::Enum(enum_id) = expr_resolved_ty_kind {
                                     val.result_map(|val| self.convert_cast_to_enum(
                                         ctx,
-                                        expr_type_id.ctype,
                                         enum_id,
                                         None,
+                                        expr_type_id.ctype,
                                         val,
                                     ))?
                                 } else {
diff --git a/c2rust-transpile/src/translator/pointers.rs b/c2rust-transpile/src/translator/pointers.rs
@@ -261,6 +261,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)
@@ -274,7 +278,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.2021.snap b/c2rust-transpile/tests/snapshots/snapshots__transpile@exprs.c.2021.snap
@@ -14,10 +14,12 @@ expression: cat tests/snapshots/exprs.2021.rs
 extern "C" {
     fn puts(str: *const ::core::ffi::c_char) -> ::core::ffi::c_int;
 }
-pub type C2Rust_Unnamed = ::core::ffi::c_uint;
-pub const C: C2Rust_Unnamed = 2;
-pub const B: C2Rust_Unnamed = 1;
-pub const A: C2Rust_Unnamed = 0;
+#[derive(Clone, Copy)]
+#[repr(transparent)]
+pub struct C2Rust_Unnamed(pub ::core::ffi::c_uint);
+pub const C: C2Rust_Unnamed = C2Rust_Unnamed(2);
+pub const B: C2Rust_Unnamed = C2Rust_Unnamed(1);
+pub const A: C2Rust_Unnamed = C2Rust_Unnamed(0);
 unsafe extern "C" fn side_effect() -> ::core::ffi::c_int {
     puts(b"the return of side effect\0".as_ptr() as *const ::core::ffi::c_char);
     return 10 as ::core::ffi::c_int;
@@ -53,7 +55,7 @@ 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;
 }
 #[no_mangle]
 pub unsafe extern "C" fn statement_expr() {
diff --git a/c2rust-transpile/tests/snapshots/snapshots__transpile@exprs.c.2024.snap b/c2rust-transpile/tests/snapshots/snapshots__transpile@exprs.c.2024.snap
@@ -13,10 +13,12 @@ expression: cat tests/snapshots/exprs.2024.rs
 unsafe extern "C" {
     fn puts(str: *const ::core::ffi::c_char) -> ::core::ffi::c_int;
 }
-pub type C2Rust_Unnamed = ::core::ffi::c_uint;
-pub const C: C2Rust_Unnamed = 2;
-pub const B: C2Rust_Unnamed = 1;
-pub const A: C2Rust_Unnamed = 0;
+#[derive(Clone, Copy)]
+#[repr(transparent)]
+pub struct C2Rust_Unnamed(pub ::core::ffi::c_uint);
+pub const C: C2Rust_Unnamed = C2Rust_Unnamed(2);
+pub const B: C2Rust_Unnamed = C2Rust_Unnamed(1);
+pub const A: C2Rust_Unnamed = C2Rust_Unnamed(0);
 unsafe extern "C" fn side_effect() -> ::core::ffi::c_int {
     puts(b"the return of side effect\0".as_ptr() as *const ::core::ffi::c_char);
     return 10 as ::core::ffi::c_int;
@@ -52,7 +54,7 @@ pub unsafe extern "C" fn unary_with_side_effect() {
 }
 #[unsafe(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;
 }
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn statement_expr() {
diff --git a/c2rust-transpile/tests/snapshots/snapshots__transpile@macrocase.c.2021.snap b/c2rust-transpile/tests/snapshots/snapshots__transpile@macrocase.c.2021.snap
@@ -10,14 +10,16 @@ expression: cat tests/snapshots/macrocase.2021.rs
     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@macrocase.c.2024.snap b/c2rust-transpile/tests/snapshots/snapshots__transpile@macrocase.c.2024.snap
@@ -10,14 +10,16 @@ expression: cat tests/snapshots/macrocase.2024.rs
     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;
 #[unsafe(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.2021.snap b/c2rust-transpile/tests/snapshots/snapshots__transpile@records.c.2021.snap
diff --git a/c2rust-transpile/tests/snapshots/snapshots__transpile@records.c.2024.snap b/c2rust-transpile/tests/snapshots/snapshots__transpile@records.c.2024.snap
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
