transpile: Allow EnumConstant DeclRefs and casts to enums in patterns

Author: Rua

c2rust-transpile/src/translator/enums.rs

@@ -4,7 +4,9 @@ use syn::Expr;
 
 use crate::{
     diagnostics::TranslationResult,
-    translator::{signed_int_expr, ConvertedDecl, EnumMode, ExprContext, Translation},
+    translator::{
+        signed_int_expr, ConvertedDecl, EnumMode, ExprContext, Translation, TranslationError,
+    },
     with_stmts::WithStmts,
     CDeclKind, CEnumConstantId, CEnumId, CQualTypeId, CTypeId, CTypeKind, ConstIntExpr,
 };
@@ -105,7 +107,15 @@ impl<'c> Translation<'c> {
     ) -> TranslationResult<WithStmts<Box<Expr>>> {
         match self.tcfg.enum_mode {
             // First extract the enum's inner type...
-            EnumMode::NewType => val = self.integer_from_enum(val),
+            EnumMode::NewType => {
+                if ctx.is_pattern {
+                    return Err(TranslationError::generic(
+                        "cast from enum is not supported in patterns",
+                    ));
+                }
+
+                val = self.integer_from_enum(val);
+            }
             EnumMode::Consts => {}
         }
 
@@ -149,7 +159,15 @@ impl<'c> Translation<'c> {
 
             match self.tcfg.enum_mode {
                 // Enum-to-enum casts need to be translated via the inner value as an intermediate.
-                EnumMode::NewType => val = self.integer_from_enum(val),
+                EnumMode::NewType => {
+                    if ctx.is_pattern {
+                        return Err(TranslationError::generic(
+                            "cast from enum is not supported in patterns",
+                        ));
+                    }
+
+                    val = self.integer_from_enum(val);
+                }
                 EnumMode::Consts => {}
             }
 
@@ -167,6 +185,12 @@ impl<'c> Translation<'c> {
             }
 
             EnumMode::Consts => {
+                if ctx.is_pattern {
+                    return Err(TranslationError::generic(
+                        "cast to enum is not supported in patterns",
+                    ));
+                }
+
                 let source_type_kind = &self.ast_context.resolve_type(source_cty.ctype).kind;
                 let enum_integral_type_kind =
                     &self.ast_context.resolve_type(enum_integral_type.ctype).kind;

c2rust-transpile/src/translator/mod.rs

@@ -294,7 +294,7 @@ pub struct Translation<'c> {
     extern_crates: RefCell<CrateSet>,
 
     // Translation state and utilities
-    type_converter: RefCell<TypeConverter>,
+    pub type_converter: RefCell<TypeConverter>,
     renamer: RefCell<Renamer<CDeclId>>,
     zero_inits: RefCell<ZeroInits>,
     function_context: RefCell<FuncContext>,
@@ -2969,6 +2969,7 @@ impl<'c> Translation<'c> {
                 expr_kind,
                 CExprKind::Paren(..)
                     | CExprKind::ConstantExpr(..)
+                    | CExprKind::DeclRef(..)
                     | CExprKind::Literal(..)
                     | CExprKind::ImplicitCast(..)
                     | CExprKind::ExplicitCast(..)
@@ -3395,6 +3396,12 @@ impl<'c> Translation<'c> {
             );
         }
 
+        if ctx.is_pattern {
+            return Err(TranslationError::generic(
+                "non-EnumConstant DeclRefs are not supported in patterns",
+            ));
+        }
+
         let varname = decl.get_name().expect("expected variable name").to_owned();
         let rustname = self
             .renamer
@@ -3707,7 +3714,12 @@ impl<'c> Translation<'c> {
             return Ok(val);
         }
 
-        if ctx.is_pattern && !matches!(kind, CastKind::ToVoid | CastKind::ConstCast) {
+        if ctx.is_pattern
+            && !matches!(
+                kind,
+                CastKind::ToVoid | CastKind::ConstCast | CastKind::IntegralCast
+            )
+        {
             return Err(TranslationError::generic(
                 "cast kind is not supported in patterns",
             ));
@@ -3733,6 +3745,12 @@ impl<'c> Translation<'c> {
             | CastKind::BooleanToSignedIntegral => {
                 let target_ty = self.convert_type(target_cty.ctype)?;
 
+                if ctx.is_pattern && !target_ty_kind.is_enum() {
+                    return Err(TranslationError::generic(
+                        "integral casts to non-enums are not supported in patterns",
+                    ));
+                }
+
                 if let CTypeKind::LongDouble | CTypeKind::Float128 = target_ty_kind {
                     if let CTypeKind::LongDouble | CTypeKind::Float128 =
                         self.ast_context[source_cty.ctype].kind