transpile: let convert_literal handle casting literal to enum

Author: Rua

c2rust-transpile/src/translator/enums.rs

@@ -2,13 +2,11 @@ use c2rust_ast_builder::mk;
 use proc_macro2::Span;
 use syn::Expr;
 
-use crate::c_ast::CUnOp;
 use crate::{
     diagnostics::TranslationResult,
     translator::{signed_int_expr, ConvertedDecl, EnumMode, ExprContext, Translation},
     with_stmts::WithStmts,
-    CDeclKind, CEnumConstantId, CEnumId, CExprId, CExprKind, CLiteral, CQualTypeId, CTypeId,
-    CTypeKind, ConstIntExpr,
+    CDeclKind, CEnumConstantId, CEnumId, CQualTypeId, CTypeId, CTypeKind, ConstIntExpr,
 };
 
 impl<'c> Translation<'c> {
@@ -141,29 +139,8 @@ impl<'c> Translation<'c> {
         ctx: ExprContext,
         mut source_cty: CQualTypeId,
         enum_id: CEnumId,
-        expr: Option<CExprId>,
         mut val: Box<Expr>,
     ) -> TranslationResult<WithStmts<Box<Expr>>> {
-        if let Some(expr) = expr {
-            match self.ast_context[expr].kind {
-                CExprKind::Literal(_, CLiteral::Integer(i, _)) => {
-                    val = self.enum_for_i64(enum_id, i as i64);
-                    return Ok(WithStmts::new_val(val));
-                }
-
-                CExprKind::Unary(_, CUnOp::Negate, subexpr_id, _) => {
-                    if let &CExprKind::Literal(_, CLiteral::Integer(i, _)) =
-                        &self.ast_context[subexpr_id].kind
-                    {
-                        val = self.enum_for_i64(enum_id, -(i as i64));
-                        return Ok(WithStmts::new_val(val));
-                    }
-                }
-
-                _ => {}
-            }
-        }
-
         // We could be casting from enum to enum...
         if let CTypeKind::Enum(source_enum_id) =
             self.ast_context.resolve_type(source_cty.ctype).kind
@@ -208,7 +185,7 @@ impl<'c> Translation<'c> {
 
     /// 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_id: CEnumId, value: i64) -> Box<Expr> {
+    pub 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);
         }

c2rust-transpile/src/translator/literals.rs

@@ -16,6 +16,18 @@ impl<'c> Translation<'c> {
         base: IntBase,
         negative: bool,
     ) -> TranslationResult<Box<Expr>> {
+        let type_resolved_id = self.ast_context.resolve_type_id(ty.ctype);
+
+        if let CTypeKind::Enum(enum_id) = self.ast_context[type_resolved_id].kind {
+            let mut val = val as i64;
+
+            if negative {
+                val = -val;
+            }
+
+            return Ok(self.enum_for_i64(enum_id, val));
+        }
+
         let lit = match base {
             IntBase::Dec => mk().int_unsuffixed_lit(val),
             IntBase::Hex => mk().float_unsuffixed_lit(&format!("0x{:x}", val)),
@@ -35,6 +47,7 @@ impl<'c> Translation<'c> {
     pub fn literal_matches_ty(&self, lit: &CLiteral, ty: CQualTypeId, is_negated: bool) -> bool {
         let ty_kind = &self.ast_context.resolve_type(ty.ctype).kind;
         match *lit {
+            CLiteral::Integer(_, _) if ty_kind.is_enum() => true,
             CLiteral::Integer(value, _) | CLiteral::Character(value)
                 if ty_kind.is_integral_type() && !ty_kind.is_bool() =>
             {

c2rust-transpile/src/translator/mod.rs

@@ -3660,7 +3660,7 @@ impl<'c> Translation<'c> {
             }
 
             CastKind::PointerToIntegral => {
-                self.convert_pointer_to_integral_cast(ctx, source_cty, target_cty, val, expr)
+                self.convert_pointer_to_integral_cast(ctx, source_cty, target_cty, val)
             }
 
             CastKind::IntegralCast
@@ -3696,9 +3696,7 @@ impl<'c> Translation<'c> {
                 {
                     self.f128_cast_to(val, target_ty_kind)
                 } else if let &CTypeKind::Enum(enum_id) = target_ty_kind {
-                    val.and_then_try(|val| {
-                        self.convert_cast_to_enum(ctx, source_cty, enum_id, expr, val)
-                    })
+                    val.and_then_try(|val| self.convert_cast_to_enum(ctx, source_cty, enum_id, 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

@@ -514,7 +514,6 @@ impl<'c> Translation<'c> {
         source_cty: CQualTypeId,
         target_cty: CQualTypeId,
         val: WithStmts<Box<Expr>>,
-        expr: Option<CExprId>,
     ) -> TranslationResult<WithStmts<Box<Expr>>> {
         if ctx.is_const {
             return Err(format_translation_err!(
@@ -532,7 +531,7 @@ impl<'c> Translation<'c> {
                 WithStmts::new_val(transmute_expr(source_ty, target_ty, val)).set_unsafe()
             }))
         } else if let &CTypeKind::Enum(enum_id) = target_ty_kind {
-            val.and_then_try(|val| self.convert_cast_to_enum(ctx, source_cty, enum_id, expr, val))
+            val.and_then_try(|val| self.convert_cast_to_enum(ctx, source_cty, enum_id, val))
         } else {
             Ok(val.map(|val| mk().cast_expr(val, target_ty)))
         }