transpile: let can_propagate_cast handle casting EnumConstant to its own enum

Author: Rua

c2rust-transpile/src/c_ast/mod.rs

@@ -751,6 +751,14 @@ impl TypedAstContext {
             Decayed(ty) => ty,
             TypeOf(ty) => ty,
             Paren(ty) => ty,
+
+            // As an exception, resolve typedefs in `prenamed_decls`, because they do not
+            // get translated as type aliases in the final code.
+            Typedef(decl) if self.prenamed_decls.contains_key(&decl) => match self[decl].kind {
+                CDeclKind::Typedef { typ: ty, .. } => ty.ctype,
+                _ => panic!("Typedef decl did not point to a typedef"),
+            },
+
             _ => return typ,
         };
         self.resolve_type_id_no_typedef(ty)

c2rust-transpile/src/translator/enums.rs

@@ -5,7 +5,7 @@ use syn::Expr;
 use crate::c_ast::CUnOp;
 use crate::{
     diagnostics::TranslationResult,
-    translator::{signed_int_expr, ConvertedDecl, ExprContext, Translation},
+    translator::{signed_int_expr, ConvertedDecl, Translation},
     with_stmts::WithStmts,
     CDeclKind, CEnumConstantId, CEnumId, CExprId, CExprKind, CLiteral, CQualTypeId, CTypeId,
     CTypeKind, ConstIntExpr,
@@ -75,37 +75,14 @@ impl<'c> Translation<'c> {
     }
 
     /// 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.
     pub fn convert_cast_to_enum(
         &self,
-        ctx: ExprContext,
         enum_type_id: CTypeId,
-        enum_id: CEnumId,
         expr: Option<CExprId>,
         val: Box<Expr>,
     ) -> TranslationResult<Box<Expr>> {
         if let Some(expr) = expr {
             match self.ast_context[expr].kind {
-                // This is the case of finding a variable which is an `EnumConstant` of the same
-                // enum we are casting to. Here, we can just remove the extraneous cast instead of
-                // generating a new one.
-                CExprKind::DeclRef(_, enum_constant_id, _)
-                    if self.is_variant_of_enum(enum_id, enum_constant_id) =>
-                {
-                    // `enum`s shouldn't need portable `override_ty`s.
-                    let expr_is_macro = self.expr_is_expanded_macro(ctx, expr, None);
-
-                    // If this DeclRef expanded to a const macro, we actually need to insert a cast,
-                    // because the translation of a const macro skips implicit casts in its context.
-                    if !expr_is_macro {
-                        return Ok(self.enum_constant_expr(enum_constant_id));
-                    }
-                }
-
                 CExprKind::Literal(_, CLiteral::Integer(i, _)) => {
                     return Ok(self.enum_for_i64(enum_type_id, i as i64));
                 }
@@ -173,13 +150,17 @@ impl<'c> Translation<'c> {
         mk().ident_expr(name)
     }
 
-    fn is_variant_of_enum(&self, enum_id: CEnumId, enum_constant_id: CEnumConstantId) -> bool {
-        let variants = match self.ast_context[enum_id].kind {
-            CDeclKind::Enum { ref variants, .. } => variants,
-            _ => panic!("{:?} does not point to an `enum` declaration", enum_id),
+    pub fn enum_constant_matches_type(
+        &self,
+        type_id: CTypeId,
+        enum_constant_id: CEnumConstantId,
+    ) -> bool {
+        let type_enum_id = match self.ast_context.resolve_type_no_typedef(type_id).kind {
+            CTypeKind::Enum(enum_id) => enum_id,
+            _ => return false,
         };
-
-        variants.contains(&enum_constant_id)
+        let constant_enum_id = self.ast_context.parents[&enum_constant_id];
+        type_enum_id == constant_enum_id
     }
 
     fn enum_integral_type(&self, enum_id: CEnumId) -> CQualTypeId {

c2rust-transpile/src/translator/mod.rs

@@ -3104,7 +3104,13 @@ impl<'c> Translation<'c> {
                 // If the variable is actually an `EnumConstant`, we need to add a cast to the
                 // expected integral type.
                 if let &CDeclKind::EnumConstant { .. } = decl {
-                    val = self.convert_cast_from_enum(qual_ty.ctype, val)?;
+                    if !self
+                        .enum_constant_matches_type(override_ty.unwrap_or(qual_ty).ctype, decl_id)
+                    {
+                        val = self.convert_cast_from_enum(qual_ty.ctype, val)?;
+                    }
+
+                    return Ok(WithStmts::new_val(val));
                 }
 
                 // If we are referring to a function and need its address, we
@@ -3246,7 +3252,7 @@ impl<'c> Translation<'c> {
                 // But for some expression types, if we don't absolutely have to cast,
                 // we would rather the expression is translated according to the type we're
                 // expecting, and then we can skip the cast entirely.
-                if self.can_propagate_cast(expr, target_ty, is_explicit) {
+                if self.can_propagate_cast(ctx, expr, target_ty, is_explicit) {
                     return self.convert_expr(ctx, expr, Some(target_ty));
                 }
 
@@ -3517,6 +3523,7 @@ impl<'c> Translation<'c> {
 
     fn can_propagate_cast(
         &self,
+        ctx: ExprContext,
         expr_id: CExprId,
         target_type_id: CQualTypeId,
         is_explicit: bool,
@@ -3526,6 +3533,26 @@ impl<'c> Translation<'c> {
         }
 
         let expr_kind = &self.ast_context[expr_id].kind;
+
+        if let &CExprKind::DeclRef(_, decl_id, _) = expr_kind {
+            if let CDeclKind::EnumConstant { .. } = self.ast_context[decl_id].kind {
+                // 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
+                // the enum type, we would like to produce Rust with _no_ casts.
+                if self.enum_constant_matches_type(target_type_id.ctype, decl_id) {
+                    // `enum`s shouldn't need portable `override_ty`s.
+                    let expr_is_macro = self.expr_is_expanded_macro(ctx, expr_id, None);
+
+                    // If this DeclRef expanded to a const macro, we actually need to insert
+                    // a cast, because the translation of a const macro skips implicit casts
+                    // in its context.
+                    if !expr_is_macro {
+                        return true;
+                    }
+                }
+            }
+        }
+
         let mut literal_expr_kind = expr_kind;
         let mut is_negated = false;
 
@@ -3752,11 +3779,9 @@ impl<'c> Translation<'c> {
                     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(_) = target_ty_kind {
                     // Casts targeting `enum` types...
-                    val.result_map(|val| {
-                        self.convert_cast_to_enum(ctx, target_cty.ctype, enum_decl_id, expr, val)
-                    })
+                    val.result_map(|val| self.convert_cast_to_enum(target_cty.ctype, expr, val))
                 } else if target_ty_kind.is_floating_type() && source_ty_kind.is_bool() {
                     Ok(val.map(|val| {
                         mk().cast_expr(mk().cast_expr(val, mk().path_ty(vec!["u8"])), target_ty)

c2rust-transpile/src/translator/pointers.rs

@@ -533,10 +533,8 @@ impl<'c> Translation<'c> {
                     source_ty, target_ty, val,
                 )))
             })
-        } else if let &CTypeKind::Enum(enum_decl_id) = target_ty_kind {
-            val.result_map(|val| {
-                self.convert_cast_to_enum(ctx, target_cty, enum_decl_id, expr, val)
-            })
+        } else if let &CTypeKind::Enum(_) = target_ty_kind {
+            val.result_map(|val| self.convert_cast_to_enum(target_cty, expr, val))
         } else {
             Ok(val.map(|val| mk().cast_expr(val, target_ty)))
         }