diff --git a/c2rust-ast-builder/src/builder.rs b/c2rust-ast-builder/src/builder.rs
index 07518e0f33..69aa730727 100644
--- a/c2rust-ast-builder/src/builder.rs
+++ b/c2rust-ast-builder/src/builder.rs
@@ -1228,6 +1228,20 @@ impl Builder {
         })
     }
 
+    pub fn tuple_struct_pat<Pa>(self, path: Pa, qself: Option<QSelf>, elems: Vec<Pat>) -> Pat
+    where
+        Pa: Make<Path>,
+    {
+        let path = path.make(&self);
+        Pat::TupleStruct(PatTupleStruct {
+            attrs: self.attrs,
+            qself,
+            path,
+            paren_token: token::Paren(self.span),
+            elems: punct(elems),
+        })
+    }
+
     // Types
 
     pub fn barefn_ty(self, decl: BareFnTyParts) -> Box<Type> {
diff --git a/c2rust-refactor/src/macros.rs b/c2rust-refactor/src/macros.rs
index a286197d36..689db7a60e 100644
--- a/c2rust-refactor/src/macros.rs
+++ b/c2rust-refactor/src/macros.rs
@@ -13,7 +13,14 @@ macro_rules! match_or_else {
     ([$e:expr] $($arm_pat:pat => $arm_body:expr),*; $or_else:expr) => {
         match $e {
             $( $arm_pat => $arm_body, )*
-            ref x @ _ => $or_else(x),
+            _ => $or_else,
+        }
+    };
+
+    ([$e:expr] $($arm_pat:pat => $arm_body:expr),*; $or_else_var:ident => $or_else:expr) => {
+        match $e {
+            $( $arm_pat => $arm_body, )*
+            ref $or_else_var @ _ => $or_else,
         }
     };
 }
@@ -22,11 +29,11 @@ macro_rules! match_or_else {
 macro_rules! expect {
     ([$e:expr] $arm_pat:pat => $arm_body:expr) => {
         $crate::match_or_else!([$e] $arm_pat => $arm_body;
-            |x| panic!("expected {}, got {:?}", stringify!($arm_pat), x))
+            x => panic!("expected {}, got {:?}", stringify!($arm_pat), x))
     };
     ([$e:expr] $($arm_pat:pat => $arm_body:expr),*) => {
         $crate::match_or_else!([$e] $($arm_pat => $arm_body),*;
-            |x| panic!("expected one of: {}, got {:?}", stringify!($($arm_pat),*), x))
+            x => panic!("expected one of: {}, got {:?}", stringify!($($arm_pat),*), x))
     };
 }
 
@@ -35,6 +42,28 @@ macro_rules! unpack {
     ([$e:expr] $enum_:ident :: $variant:ident ( $($arg:ident),* )) => {
         let ($($arg,)*) = $crate::expect!([$e] $enum_::$variant($($arg),*) => ($($arg,)*));
     };
+
+    (
+        [$e:expr]
+        $enum_:ident :: $variant:ident ( $($arg:ident),* );
+        $or_else:expr
+    ) => {
+        let ($($arg,)*) = $crate::match_or_else!(
+            [$e] $enum_::$variant($($arg),*) => ($($arg,)*);
+            $or_else
+        );
+    };
+
+    (
+        [$e:expr]
+        $enum_:ident :: $variant:ident ( $($arg:ident),* );
+        $or_else_var:ident => $or_else:expr
+    ) => {
+        let ($($arg,)*) = $crate::match_or_else!(
+            [$e] $enum_::$variant($($arg),*) => ($($arg,)*);
+            $or_else_var => $or_else
+        );
+    };
 }
 
 #[macro_export]
diff --git a/c2rust-refactor/src/path_edit.rs b/c2rust-refactor/src/path_edit.rs
index b503055288..0e7e15edd7 100644
--- a/c2rust-refactor/src/path_edit.rs
+++ b/c2rust-refactor/src/path_edit.rs
@@ -124,7 +124,11 @@ where
                     _ => {}
                 }
 
-                unpack!([&mut t.kind] TyKind::Path(qself, path));
+                if !matches!(t.kind, TyKind::Path(..)) {
+                    panic!("{qpath:?}");
+                }
+
+                unpack!([&mut t.kind] TyKind::Path(qself, path); return);
                 let (new_qself, new_path) =
                     self.handle_qpath(id, qself.clone(), path.clone(), qpath);
                 *qself = new_qself;
diff --git a/c2rust-transpile/src/c_ast/mod.rs b/c2rust-transpile/src/c_ast/mod.rs
index e6b7516991..2996b394d0 100644
--- a/c2rust-transpile/src/c_ast/mod.rs
+++ b/c2rust-transpile/src/c_ast/mod.rs
@@ -780,6 +780,14 @@ impl TypedAstContext {
             TypeOf(ty) => ty,
             Paren(ty) => ty,
             Auto(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)
diff --git a/c2rust-transpile/src/cfg/mod.rs b/c2rust-transpile/src/cfg/mod.rs
index 7d6a413a43..ded233be4c 100644
--- a/c2rust-transpile/src/cfg/mod.rs
+++ b/c2rust-transpile/src/cfg/mod.rs
@@ -34,7 +34,7 @@ use std::ops::Index;
 use std::rc::Rc;
 use std::{fmt, io};
 use syn::Lit;
-use syn::{spanned::Spanned, Arm, Expr, Pat, Stmt};
+use syn::{punctuated::Punctuated, spanned::Spanned, Arm, Expr, Pat, Stmt};
 
 use failure::format_err;
 use indexmap::indexset;
@@ -433,6 +433,7 @@ impl GenTerminator<StructureLabel<StmtOrDecl>> {
 pub struct SwitchCases {
     cases: Vec<(Pat, Label)>,
     default: Option<Label>,
+    override_type_id: Option<CQualTypeId>,
 }
 
 /// A Rust statement, or a C declaration, or a comment
@@ -1857,42 +1858,45 @@ impl CfgBuilder {
                 self.add_wip_block(wip, Jump(this_label.clone()));
 
                 // Case
-                let resolved = translator.ast_context.unwrap_cast_expr(case_expr);
-                let branch = match translator.ast_context.index(resolved).kind {
-                    CExprKind::Literal(..) | CExprKind::ConstantExpr(_, _, Some(_)) => {
-                        match translator
-                            .convert_expr(ctx.used(), resolved, None)?
-                            .to_pure_expr()
+
+                let switch_case = self.switch_expr_cases.last_mut().ok_or_else(|| {
+                    format_err!(
+                        "Cannot find the 'switch' wrapping this ({:?}) 'case' statement",
+                        stmt_id,
+                    )
+                })?;
+
+                let expr = translator
+                    .convert_expr(
+                        ctx.const_().pattern().used(),
+                        case_expr,
+                        switch_case.override_type_id,
+                    )
+                    .ok()
+                    .and_then(WithStmts::to_pure_expr);
+                let pat = expr.and_then(|expr| expr_to_pat(*expr)).unwrap_or_else(|| {
+                    let mut pat = match cie {
+                        ConstIntExpr::U(n) => mk().lit_pat(mk().int_unsuffixed_lit(n)),
+                        ConstIntExpr::I(n) => mk().lit_pat(mk().int_unsuffixed_lit(n)),
+                    };
+
+                    if let Some(override_ty) = switch_case.override_type_id {
+                        if let CTypeKind::Enum(enum_id) =
+                            translator.ast_context.resolve_type(override_ty.ctype).kind
                         {
-                            Some(expr) => match *expr {
-                                Expr::Lit(lit) => Some(mk().lit_pat(lit.lit)),
-                                Expr::Path(path) => Some(mk().path_pat(path.path, path.qself)),
-                                _ => None,
-                            },
-                            _ => None,
+                            let enum_name = translator
+                                .type_converter
+                                .borrow()
+                                .resolve_decl_name(enum_id)
+                                .unwrap();
+                            pat = mk().tuple_struct_pat(enum_name.as_str(), None, vec![pat]);
                         }
                     }
-                    _ => None,
-                };
 
-                let pat = match branch {
-                    Some(pat) => pat,
-                    None => match cie {
-                        ConstIntExpr::U(n) => mk().lit_pat(mk().int_unsuffixed_lit(n)),
-                        ConstIntExpr::I(n) => mk().lit_pat(mk().int_unsuffixed_lit(n)),
-                    },
-                };
+                    pat
+                });
 
-                self.switch_expr_cases
-                    .last_mut()
-                    .ok_or_else(|| {
-                        format_err!(
-                            "Cannot find the 'switch' wrapping this ({:?}) 'case' statement",
-                            stmt_id,
-                        )
-                    })?
-                    .cases
-                    .push((pat, this_label.clone()));
+                switch_case.cases.push((pat, this_label.clone()));
 
                 // Sub stmt
                 let sub_stmt_next = self.convert_stmt_help(
@@ -1938,8 +1942,30 @@ impl CfgBuilder {
                 let body_label = self.fresh_label();
 
                 // Convert the condition
+
+                let mut override_type_id = None;
+
+                // If the condition is an implicit cast from an enum to its integral type,
+                // override the type to that of the enum.
+                if let CExprKind::ImplicitCast(target_type_id, castee_id, ..) =
+                    translator.ast_context[scrutinee].kind
+                {
+                    let castee_kind = &translator.ast_context[castee_id].kind;
+                    let castee_type_id = castee_kind.get_qual_type().unwrap();
+                    let castee_type_kind = &translator
+                        .ast_context
+                        .resolve_type(castee_type_id.ctype)
+                        .kind;
+
+                    if let &CTypeKind::Enum(enum_id) = castee_type_kind {
+                        if target_type_id == translator.enum_integral_type(enum_id) {
+                            override_type_id = Some(castee_type_id);
+                        }
+                    }
+                }
+
                 let (stmts, val) = translator
-                    .convert_expr(ctx.used(), scrutinee, None)?
+                    .convert_expr(ctx.used(), scrutinee, override_type_id)?
                     .discard_unsafe();
                 wip.extend(stmts);
 
@@ -1951,7 +1977,10 @@ impl CfgBuilder {
                 let saw_unmatched_case = self.last_per_stmt_mut().saw_unmatched_case;
                 let saw_unmatched_default = self.last_per_stmt_mut().saw_unmatched_default;
                 self.break_labels.push(next_label.clone());
-                self.switch_expr_cases.push(SwitchCases::default());
+                self.switch_expr_cases.push(SwitchCases {
+                    override_type_id,
+                    ..Default::default()
+                });
 
                 let body_stuff = self.convert_stmt_help(
                     translator,
@@ -2317,3 +2346,173 @@ impl Cfg<Label, StmtOrDecl> {
         Ok(())
     }
 }
+
+fn expr_to_pat(expr: Expr) -> Option<Pat> {
+    use syn::{
+        ExprArray, ExprCall, ExprLit, ExprParen, ExprPath, ExprReference, ExprStruct, ExprTuple,
+        ExprUnary, FieldPat, FieldValue, LitInt, PatLit, PatParen, PatPath, PatReference, PatSlice,
+        PatStruct, PatTuple, PatTupleStruct, UnOp,
+    };
+
+    match expr {
+        Expr::Array(ExprArray {
+            attrs,
+            bracket_token,
+            elems,
+        }) => {
+            let elems = punctuated_expr_to_pat(elems)?;
+
+            Some(Pat::Slice(PatSlice {
+                attrs,
+                bracket_token,
+                elems,
+            }))
+        }
+
+        Expr::Call(ExprCall {
+            attrs,
+            func,
+            paren_token,
+            args,
+        }) => {
+            let (qself, path) = match *func {
+                Expr::Path(ExprPath { qself, path, .. }) => (qself, path),
+                _ => return None,
+            };
+            let elems = punctuated_expr_to_pat(args)?;
+
+            Some(Pat::TupleStruct(PatTupleStruct {
+                attrs,
+                qself,
+                path,
+                paren_token,
+                elems,
+            }))
+        }
+
+        Expr::Lit(ExprLit { attrs, lit }) => Some(Pat::Lit(PatLit { attrs, lit })),
+
+        Expr::Paren(ExprParen {
+            attrs,
+            paren_token,
+            expr,
+        }) => {
+            let pat = Box::new(expr_to_pat(*expr)?);
+            Some(Pat::Paren(PatParen {
+                attrs,
+                paren_token,
+                pat,
+            }))
+        }
+
+        Expr::Path(ExprPath { attrs, qself, path }) => {
+            Some(Pat::Path(PatPath { attrs, qself, path }))
+        }
+
+        Expr::Range(range) => Some(Pat::Range(range)),
+
+        Expr::Reference(ExprReference {
+            attrs,
+            and_token,
+            mutability,
+            expr,
+        }) => {
+            let pat = Box::new(expr_to_pat(*expr)?);
+
+            Some(Pat::Reference(PatReference {
+                attrs,
+                and_token,
+                mutability,
+                pat,
+            }))
+        }
+
+        Expr::Struct(ExprStruct {
+            attrs,
+            qself,
+            path,
+            brace_token,
+            fields,
+            dot2_token: None,
+            rest: None,
+        }) => {
+            let fields = fields
+                .into_iter()
+                .map(|field| {
+                    let FieldValue {
+                        attrs,
+                        member,
+                        colon_token,
+                        expr,
+                    } = field;
+                    let pat = Box::new(expr_to_pat(expr)?);
+
+                    Some(FieldPat {
+                        attrs,
+                        member,
+                        colon_token,
+                        pat,
+                    })
+                })
+                .collect::<Option<_>>()?;
+
+            Some(Pat::Struct(PatStruct {
+                attrs,
+                qself,
+                path,
+                brace_token,
+                fields,
+                rest: None,
+            }))
+        }
+
+        Expr::Tuple(ExprTuple {
+            attrs,
+            paren_token,
+            elems,
+        }) => {
+            let elems = punctuated_expr_to_pat(elems)?;
+
+            Some(Pat::Tuple(PatTuple {
+                attrs,
+                paren_token,
+                elems,
+            }))
+        }
+
+        // There is no equivalent `PatUnary`, but the negative sign can be folded into the literal.
+        Expr::Unary(ExprUnary {
+            attrs,
+            op: UnOp::Neg(_),
+            expr,
+        }) => {
+            let Expr::Lit(ExprLit {
+                attrs: _,
+                lit: Lit::Int(lit_int),
+            }) = *expr else {
+                return None
+            };
+
+            let repr = format!("-{}{}", lit_int.base10_digits(), lit_int.suffix());
+            let lit = Lit::Int(LitInt::new(&repr, lit_int.span()));
+            Some(Pat::Lit(PatLit { attrs, lit }))
+        }
+
+        _ => None,
+    }
+}
+
+fn punctuated_expr_to_pat(
+    elems: Punctuated<Expr, syn::Token![,]>,
+) -> Option<Punctuated<Pat, syn::Token![,]>> {
+    use syn::punctuated::Pair;
+
+    elems
+        .into_pairs()
+        .map(|pair| {
+            let (expr, token) = pair.into_tuple();
+            let pat = expr_to_pat(expr)?;
+            Some(Pair::new(pat, token))
+        })
+        .collect()
+}
diff --git a/c2rust-transpile/src/lib.rs b/c2rust-transpile/src/lib.rs
index 20fdc8cfea..a1db5911cc 100644
--- a/c2rust-transpile/src/lib.rs
+++ b/c2rust-transpile/src/lib.rs
@@ -37,7 +37,7 @@ use c2rust_ast_exporter as ast_exporter;
 
 use crate::build_files::{emit_build_files, get_build_dir, CrateConfig};
 use crate::compile_cmds::get_compile_commands;
-pub use crate::translator::ReplaceMode;
+pub use crate::translator::{EnumMode, ReplaceMode};
 use std::prelude::v1::Vec;
 
 type PragmaVec = Vec<(&'static str, Vec<&'static str>)>;
@@ -108,6 +108,7 @@ pub struct TranspilerConfig {
     pub log_level: log::LevelFilter,
     pub edition: RustEdition,
     pub deny_unsafe_op_in_unsafe_fn: bool,
+    pub enum_mode: EnumMode,
 
     /// Run `c2rust-postprocess` after transpiling and potentially refactoring.
     pub postprocess: bool,
diff --git a/c2rust-transpile/src/translator/enums.rs b/c2rust-transpile/src/translator/enums.rs
index d1a9c0b8c9..300fbe5ca3 100644
--- a/c2rust-transpile/src/translator/enums.rs
+++ b/c2rust-transpile/src/translator/enums.rs
@@ -2,13 +2,13 @@ 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, ExprContext, Translation},
+    translator::{
+        signed_int_expr, ConvertedDecl, EnumMode, ExprContext, Translation, TranslationError,
+    },
     with_stmts::WithStmts,
-    CDeclKind, CEnumConstantId, CEnumId, CExprId, CExprKind, CLiteral, CQualTypeId, CTypeId,
-    CTypeKind, ConstIntExpr,
+    CDeclKind, CEnumConstantId, CEnumId, CQualTypeId, CTypeId, CTypeKind, ConstIntExpr,
 };
 
 impl<'c> Translation<'c> {
@@ -23,10 +23,24 @@ 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 integral_type_rs = self.convert_type(integral_type.ctype)?;
+        let item = match self.tcfg.enum_mode {
+            EnumMode::NewType => {
+                let field = mk().pub_().enum_field(integral_type_rs);
+                mk().span(span)
+                    .call_attr("derive", vec!["Clone", "Copy", "PartialEq", "Eq"])
+                    .call_attr("repr", vec!["transparent"])
+                    .pub_()
+                    .struct_item(enum_name, vec![field], true)
+            }
+
+            EnumMode::Consts => mk()
+                .span(span)
+                .pub_()
+                .type_item(enum_name, integral_type_rs),
+        };
+
+        Ok(ConvertedDecl::Item(item))
     }
 
     pub fn convert_enum_constant(
@@ -46,94 +60,153 @@ 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))
+    }
+
+    /// Translates a `DeclRef` for an `EnumConstant`.
+    pub fn convert_enum_constant_decl_ref(
+        &self,
+        ctx: ExprContext,
+        enum_constant_id: CEnumConstantId,
+        target_type_id: CQualTypeId,
+    ) -> TranslationResult<WithStmts<Box<Expr>>> {
+        let mut val = WithStmts::new_val(self.enum_constant_expr(enum_constant_id));
+
+        if !self.enum_constant_matches_type(target_type_id.ctype, enum_constant_id) {
+            // Add a cast to the expected integral type.
+            let enum_id = self.ast_context.parents[&enum_constant_id];
+            val = val.and_then_try(|val| {
+                self.convert_cast_from_enum(ctx, enum_id, target_type_id, val)
+            })?;
+        }
+
+        Ok(val)
     }
 
     /// 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>,
-    ) -> TranslationResult<Box<Expr>> {
-        // Convert it to the expected integral type.
-        let ty = self.convert_type(target_cty)?;
-        Ok(mk().cast_expr(val, ty))
+        ctx: ExprContext,
+        enum_id: CEnumId,
+        target_cty: CQualTypeId,
+        mut val: Box<Expr>,
+    ) -> TranslationResult<WithStmts<Box<Expr>>> {
+        match self.tcfg.enum_mode {
+            // First extract the enum's inner type...
+            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 => {}
+        }
+
+        // Cast from the enum's integral type to the expected integral type.
+        let source_cty = self.enum_integral_type(enum_id);
+        self.convert_cast(
+            ctx,
+            source_cty,
+            target_cty,
+            WithStmts::new_val(val),
+            None,
+            None,
+            None,
+        )
+    }
+
+    /// Gets the inner integral value of an enum value.
+    pub fn integer_from_enum(&self, val: Box<Expr>) -> Box<Expr> {
+        match self.tcfg.enum_mode {
+            EnumMode::NewType => mk().anon_field_expr(val, 0),
+            EnumMode::Consts => 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.
+    /// Translates a cast where the target type is an `enum` type.
     pub fn convert_cast_to_enum(
         &self,
         ctx: ExprContext,
-        enum_type_id: CTypeId,
+        mut source_cty: CQualTypeId,
         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));
+        mut val: Box<Expr>,
+    ) -> TranslationResult<WithStmts<Box<Expr>>> {
+        // We could be casting from enum to enum...
+        if let CTypeKind::Enum(source_enum_id) =
+            self.ast_context.resolve_type(source_cty.ctype).kind
+        {
+            // Casting to ourselves, the audacity!
+            if source_enum_id == enum_id {
+                return Ok(WithStmts::new_val(val));
+            }
+
+            match self.tcfg.enum_mode {
+                // Enum-to-enum casts need to be translated via the inner value as an intermediate.
+                EnumMode::NewType => {
+                    if ctx.is_pattern {
+                        return Err(TranslationError::generic(
+                            "cast from enum is not supported in patterns",
+                        ));
                     }
-                }
 
-                CExprKind::Literal(_, CLiteral::Integer(i, _)) => {
-                    return Ok(self.enum_for_i64(enum_type_id, i as i64));
+                    val = self.integer_from_enum(val);
                 }
+                EnumMode::Consts => {}
+            }
 
-                CExprKind::Unary(_, CUnOp::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)));
-                    }
+            source_cty = self.enum_integral_type(source_enum_id);
+        }
+
+        let enum_integral_type = self.enum_integral_type(enum_id);
+        let mut val = WithStmts::new_val(val);
+
+        match self.tcfg.enum_mode {
+            EnumMode::NewType => {
+                val =
+                    self.convert_cast(ctx, source_cty, enum_integral_type, val, None, None, None)?;
+                val = val.map(|val| self.enum_constructor_expr(enum_id, val));
+            }
+
+            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;
+
+                if source_type_kind != enum_integral_type_kind {
+                    val = val.map(|val| self.enum_constructor_expr(enum_id, val));
+                }
             }
         }
 
-        let target_ty = self.convert_type(enum_type_id)?;
-        Ok(mk().cast_expr(val, target_ty))
+        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),
-        };
-
+    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);
         }
@@ -145,8 +218,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.
@@ -173,16 +245,34 @@ 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),
-        };
+    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);
 
-        variants.contains(&enum_constant_id)
+        match self.tcfg.enum_mode {
+            EnumMode::NewType => mk().call_expr(mk().ident_expr(enum_name), vec![value]),
+            EnumMode::Consts => mk().cast_expr(value, mk().ident_ty(enum_name)),
+        }
+    }
+
+    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,
+        };
+        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 {
+    pub fn enum_integral_type(&self, enum_id: CEnumId) -> CQualTypeId {
         match self.ast_context[enum_id].kind {
             CDeclKind::Enum {
                 integral_type: Some(integral_type),
diff --git a/c2rust-transpile/src/translator/literals.rs b/c2rust-transpile/src/translator/literals.rs
index e1bfeca9f3..ac934ede41 100644
--- a/c2rust-transpile/src/translator/literals.rs
+++ b/c2rust-transpile/src/translator/literals.rs
@@ -11,11 +11,24 @@ impl<'c> Translation<'c> {
     /// Generate an integer literal corresponding to the given type, value, and base.
     pub fn mk_int_lit(
         &self,
+        ctx: ExprContext,
         ty: CQualTypeId,
         val: u64,
         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)),
@@ -27,14 +40,19 @@ impl<'c> Translation<'c> {
             expr = neg_expr(expr);
         }
 
-        let target_ty = self.convert_type(ty.ctype)?;
-        Ok(mk().cast_expr(expr, target_ty))
+        if !ctx.is_pattern {
+            let target_ty = self.convert_type(ty.ctype)?;
+            expr = mk().cast_expr(expr, target_ty);
+        }
+
+        Ok(expr)
     }
 
     /// Return whether the literal can be directly translated as this type.
     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() =>
             {
@@ -56,13 +74,18 @@ impl<'c> Translation<'c> {
         lit: &CLiteral,
     ) -> TranslationResult<WithStmts<Box<Expr>>> {
         match *lit {
-            CLiteral::Integer(val, base) => {
-                Ok(WithStmts::new_val(self.mk_int_lit(ty, val, base, false)?))
-            }
+            CLiteral::Integer(val, base) => Ok(WithStmts::new_val(
+                self.mk_int_lit(ctx, ty, val, base, false)?,
+            )),
 
             CLiteral::Character(val) => {
                 let val = val as u32;
-                let expr = match char::from_u32(val) {
+                let mut expr = match char::from_u32(val).filter(|_| {
+                    // Always convert character literals as integers in patterns.
+                    // Character literals have problems with typing that need to be resolved. See
+                    // https://github.com/immunant/c2rust/issues/648
+                    !ctx.is_pattern
+                }) {
                     Some(c) => mk().lit_expr(c),
                     None => {
                         // Fallback for characters outside of the valid Unicode range
@@ -76,8 +99,12 @@ impl<'c> Translation<'c> {
                     }
                 };
 
-                let type_rs = self.convert_type(ty.ctype)?;
-                Ok(WithStmts::new_val(mk().cast_expr(expr, type_rs)))
+                if !ctx.is_pattern {
+                    let type_rs = self.convert_type(ty.ctype)?;
+                    expr = mk().cast_expr(expr, type_rs);
+                }
+
+                Ok(WithStmts::new_val(expr))
             }
 
             CLiteral::Floating(val, ref c_str) => {
@@ -111,6 +138,12 @@ impl<'c> Translation<'c> {
             }
 
             CLiteral::String(ref bytes, element_size) => {
+                if ctx.is_pattern {
+                    return Err(TranslationError::generic(
+                        "CLiteral::String is not supported in patterns",
+                    ));
+                }
+
                 let bytes_padded = self.string_literal_bytes(ty.ctype, bytes, element_size);
                 let len = bytes_padded.len();
                 let val = mk().lit_expr(bytes_padded);
diff --git a/c2rust-transpile/src/translator/macros.rs b/c2rust-transpile/src/translator/macros.rs
index 148e60a199..b8134d0fc9 100644
--- a/c2rust-transpile/src/translator/macros.rs
+++ b/c2rust-transpile/src/translator/macros.rs
@@ -178,7 +178,7 @@ impl<'c> Translation<'c> {
 
             // We haven't tried to expand it yet.
             None => {
-                self.convert_decl(ctx, *macro_id)?;
+                self.convert_decl(ctx.not_pattern(), *macro_id)?;
                 if let Some(Some(expansion)) = self.macro_expansions.borrow().get(macro_id) {
                     expansion.ty
                 } else {
@@ -194,7 +194,7 @@ impl<'c> Translation<'c> {
 
         self.add_import(*macro_id, &rust_name);
 
-        let val = WithStmts::new_val(mk().path_expr(vec![rust_name]));
+        let mut val = WithStmts::new_val(mk().path_expr(vec![rust_name]));
 
         let expr_kind = &self.ast_context[expr_id].kind;
         // TODO We'd like to get rid of this cast eventually (see #1321).
@@ -204,7 +204,7 @@ impl<'c> Translation<'c> {
         // so we need to cast it to the `override_ty` here.
         let expr_ty = override_ty.or_else(|| expr_kind.get_qual_type());
         if let Some(expr_ty) = expr_ty {
-            self.convert_cast(
+            let result = self.convert_cast(
                 ctx,
                 CQualTypeId::new(macro_ty),
                 expr_ty,
@@ -212,14 +212,18 @@ impl<'c> Translation<'c> {
                 None,
                 None,
                 None,
-            )
-            .map(Some)
-        } else {
-            Ok(Some(val))
+            );
+
+            match result {
+                Ok(new_val) => val = new_val,
+                Err(_) => return Ok(None),
+            }
         }
 
         // TODO: May need to handle volatile reads here.
         // See `DeclRef` below.
+
+        Ok(Some(val))
     }
 
     /// Convert the expansion of a function-like macro.
diff --git a/c2rust-transpile/src/translator/mod.rs b/c2rust-transpile/src/translator/mod.rs
index a86e745bdd..142a75f5da 100644
--- a/c2rust-transpile/src/translator/mod.rs
+++ b/c2rust-transpile/src/translator/mod.rs
@@ -127,6 +127,10 @@ pub struct ExprContext {
     /// translation.
     is_const: bool,
 
+    /// In a context where a pattern is expected, such as for `match` arms.
+    /// This restricts what kinds of expressions can be emitted.
+    is_pattern: bool,
+
     /// Evaluating a C global/static variable.
     /// This is usually in a const context, but doesn't have to be, for example with initializers
     /// that are executed by the `c2rust_run_static_initializers` function.
@@ -180,6 +184,18 @@ impl ExprContext {
             ..self
         }
     }
+    pub fn pattern(self) -> Self {
+        ExprContext {
+            is_pattern: true,
+            ..self
+        }
+    }
+    pub fn not_pattern(self) -> Self {
+        ExprContext {
+            is_pattern: false,
+            ..self
+        }
+    }
     pub fn not_static(self) -> Self {
         ExprContext {
             is_static: false,
@@ -278,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>,
@@ -688,8 +704,9 @@ pub fn translate(
     let mut t = Translation::new(ast_context, tcfg, main_file);
     let ctx = ExprContext {
         used: true,
-        is_static: false,
         is_const: false,
+        is_pattern: false,
+        is_static: false,
         decay_ref: DecayRef::Default,
         is_bitfield_write: false,
         needs_address: false,
@@ -2947,6 +2964,22 @@ impl<'c> Translation<'c> {
             }
         }
 
+        if ctx.is_pattern
+            && !matches!(
+                expr_kind,
+                CExprKind::Paren(..)
+                    | CExprKind::ConstantExpr(..)
+                    | CExprKind::DeclRef(..)
+                    | CExprKind::Literal(..)
+                    | CExprKind::ImplicitCast(..)
+                    | CExprKind::ExplicitCast(..)
+            )
+        {
+            return Err(TranslationError::generic(
+                "expr kind is not supported in patterns",
+            ));
+        }
+
         use CExprKind::*;
         match *expr_kind {
             DesignatedInitExpr(..) => {
@@ -2996,144 +3029,23 @@ impl<'c> Translation<'c> {
 
             ConstantExpr(ty, child, value) => {
                 if let Some(constant) = value {
-                    self.convert_constant(constant).map(WithStmts::new_val)
+                    if ctx.is_pattern {
+                        self.convert_expr(ctx, child, override_ty)
+                    } else {
+                        self.convert_constant(constant).map(WithStmts::new_val)
+                    }
                 } else {
                     self.convert_expr(ctx, child, Some(ty))
                 }
             }
 
-            DeclRef(qual_ty, decl_id, lrvalue) => {
-                let decl = &self
-                    .ast_context
-                    .get_decl(&decl_id)
-                    .ok_or_else(|| format_err!("Missing declref {:?}", decl_id))?
-                    .kind;
-                if ctx.expanding_macro.is_some() {
-                    // TODO Determining which declarations have been declared within the scope of the const macro expr
-                    // vs. which are out-of-scope of the const macro is non-trivial,
-                    // so for now, we don't allow const macros referencing any declarations.
-                    return Err(format_translation_err!(
-                        self.ast_context.display_loc(src_loc),
-                        "Cannot yet refer to declarations in a const expr",
-                    ));
-
-                    #[allow(unreachable_code)] // TODO temporary (see above).
-                    if let CDeclKind::Variable {
-                        has_static_duration: true,
-                        ..
-                    } = decl
-                    {
-                        return Err(format_translation_err!(
-                            self.ast_context.display_loc(src_loc),
-                            "Cannot refer to static duration variable in a const expression",
-                        ));
-                    }
-                }
-
-                let varname = decl.get_name().expect("expected variable name").to_owned();
-                let rustname = self
-                    .renamer
-                    .borrow_mut()
-                    .get(&decl_id)
-                    .ok_or_else(|| format_err!("name not declared: '{}'", varname))?;
-
-                // Import the referenced global decl into our submodule
-                if self.tcfg.reorganize_definitions {
-                    self.add_import(decl_id, &rustname);
-                    // match decl {
-                    //     CDeclKind::Variable { is_defn: false, .. } => {}
-                    //     _ => self.add_import(decl_id, &rustname),
-                    // }
-                }
-
-                let mut val = mk().path_expr(vec![rustname]);
-                let mut set_unsafe = false;
-
-                match decl {
-                    CDeclKind::EnumConstant { .. } => {
-                        // If the variable is actually an `EnumConstant`, we need to add a cast to
-                        // the expected integral type.
-                        val = self.convert_cast_from_enum(qual_ty.ctype, val)?;
-                    }
-
-                    CDeclKind::Function { parameters, .. } => {
-                        // If we are referring to a function and need its address, we
-                        // need to cast it to fn() to ensure that it has a real address.
-                        if ctx.needs_address() {
-                            let ty = self.convert_type(qual_ty.ctype)?;
-                            let actual_ty = self
-                                .type_converter
-                                .borrow_mut()
-                                .knr_function_type_with_parameters(
-                                    &self.ast_context,
-                                    qual_ty.ctype,
-                                    parameters,
-                                )?;
-                            if let Some(actual_ty) = actual_ty {
-                                if actual_ty != ty {
-                                    // If we're casting a concrete function to
-                                    // a K&R function pointer type, use transmute
-                                    self.import_type(qual_ty.ctype);
-
-                                    val = transmute_expr(actual_ty, ty, val);
-                                    set_unsafe = true;
-                                }
-                            } else {
-                                let decl_kind = &self.ast_context[decl_id].kind;
-                                let kind_with_declared_args =
-                                    self.ast_context.fn_decl_ty_with_declared_args(decl_kind);
-
-                                if let Some(ty) = self
-                                    .ast_context
-                                    .type_for_kind(&kind_with_declared_args)
-                                    .map(CQualTypeId::new)
-                                {
-                                    let ty = self.convert_type(ty.ctype)?;
-                                    val = mk().cast_expr(val, ty);
-                                } else {
-                                    val = mk().cast_expr(val, ty);
-                                }
-                            }
-                        }
-                    }
-
-                    CDeclKind::Variable {
-                        has_static_duration,
-                        has_thread_duration,
-                        ..
-                    } => {
-                        // Accessing a static variable is unsafe.
-                        // In the current nightly, this applies also to taking a raw pointer,
-                        // but this requirement was removed in later versions of the
-                        // `raw_ref_op` feature.
-                        if (*has_static_duration || *has_thread_duration)
-                            && (self.tcfg.edition < Edition2024 || !ctx.needs_address())
-                        {
-                            set_unsafe = true;
-                        }
-                    }
-
-                    _ => {}
-                }
-
-                if let CTypeKind::VariableArray(..) =
-                    self.ast_context.resolve_type(qual_ty.ctype).kind
-                {
-                    val = mk().method_call_expr(val, "as_mut_ptr", vec![]);
-                }
-
-                // if the context wants a different type, add a cast
-                if let Some(expected_ty) = override_ty {
-                    if lrvalue.is_rvalue() && expected_ty != qual_ty {
-                        val = mk().cast_expr(val, self.convert_type(expected_ty.ctype)?);
-                    }
-                }
-
-                Ok(WithStmts::new_val(val).merge_unsafe(set_unsafe))
-            }
+            DeclRef(qual_ty, decl_id, lrvalue) => self
+                .convert_decl_ref(ctx, qual_ty, decl_id, lrvalue, override_ty)
+                .map_err(|e| e.add_loc(self.ast_context.display_loc(src_loc))),
 
             OffsetOf(ty, ref kind) => match kind {
                 OffsetOfKind::Constant(val) => Ok(WithStmts::new_val(self.mk_int_lit(
+                    ctx,
                     override_ty.unwrap_or(ty),
                     *val,
                     IntBase::Dec,
@@ -3204,14 +3116,26 @@ impl<'c> Translation<'c> {
             ImplicitCast(ty, expr, kind, opt_field_id, _)
             | ExplicitCast(ty, expr, kind, opt_field_id, _) => {
                 let is_explicit = matches!(expr_kind, CExprKind::ExplicitCast(..));
-                // A reference must be decayed if a bitcast is required. Const casts in
-                // LLVM 8 are now NoOp casts, so we need to include it as well.
+                let target_ty = override_ty.unwrap_or(ty);
+
+                // In general, if we are casting the result of an expression, then the inner
+                // expression should be translated to whatever type it normally would.
+                // 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(ctx, expr, target_ty, is_explicit) {
+                    return self.convert_expr(ctx, expr, Some(target_ty));
+                }
+
                 match kind {
                     CastKind::IntegralToBoolean
                     | CastKind::FloatingToBoolean
                     | CastKind::PointerToBoolean => {
                         return self.convert_condition(ctx, true, expr);
                     }
+
+                    // A reference must be decayed if a bitcast is required. Const casts in
+                    // LLVM 8 are now NoOp casts, so we need to include it as well.
                     CastKind::BitCast | CastKind::PointerToIntegral | CastKind::NoOp => {
                         ctx.decay_ref = DecayRef::Yes
                     }
@@ -3223,30 +3147,6 @@ impl<'c> Translation<'c> {
                     _ => {}
                 }
 
-                let expr_kind = &self.ast_context[expr].kind;
-                let target_ty = override_ty.unwrap_or(ty);
-
-                // In general, if we are casting the result of an expression, then the inner
-                // expression should be translated to whatever type it normally would.
-                // But for literals, if we don't absolutely have to cast, we would rather the
-                // literal is translated according to the type we're expecting, and then we can
-                // skip the cast entirely.
-                if !is_explicit {
-                    let mut literal_expr_kind = expr_kind;
-                    let mut is_negated = false;
-
-                    if let &CExprKind::Unary(_, CUnOp::Negate, subexpr_id, _) = literal_expr_kind {
-                        literal_expr_kind = &self.ast_context[subexpr_id].kind;
-                        is_negated = true;
-                    }
-
-                    if let CExprKind::Literal(_, lit) = literal_expr_kind {
-                        if self.literal_matches_ty(lit, target_ty, is_negated) {
-                            return self.convert_expr(ctx, expr, Some(target_ty));
-                        }
-                    }
-                }
-
                 let mut val = self.convert_expr(ctx, expr, None)?;
 
                 if is_explicit {
@@ -3453,6 +3353,149 @@ impl<'c> Translation<'c> {
         }
     }
 
+    fn convert_decl_ref(
+        &self,
+        ctx: ExprContext,
+        qual_ty: CQualTypeId,
+        decl_id: CDeclId,
+        lrvalue: LRValue,
+        override_ty: Option<CQualTypeId>,
+    ) -> TranslationResult<WithStmts<Box<Expr>>> {
+        let decl = &self
+            .ast_context
+            .get_decl(&decl_id)
+            .ok_or_else(|| format_err!("Missing declref {:?}", decl_id))?
+            .kind;
+        if ctx.expanding_macro.is_some() {
+            // TODO Determining which declarations have been declared within the scope of the const macro expr
+            // vs. which are out-of-scope of the const macro is non-trivial,
+            // so for now, we don't allow const macros referencing any declarations.
+            return Err(format_translation_err!(
+                None,
+                "Cannot yet refer to declarations in a const expr",
+            ));
+
+            #[allow(unreachable_code)] // TODO temporary (see above).
+            if let CDeclKind::Variable {
+                has_static_duration: true,
+                ..
+            } = decl
+            {
+                return Err(format_translation_err!(
+                    None,
+                    "Cannot refer to static duration variable in a const expression",
+                ));
+            }
+        }
+
+        if let CDeclKind::EnumConstant { .. } = decl {
+            return self.convert_enum_constant_decl_ref(
+                ctx,
+                decl_id,
+                override_ty.unwrap_or(qual_ty),
+            );
+        }
+
+        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
+            .borrow_mut()
+            .get(&decl_id)
+            .ok_or_else(|| format_err!("name not declared: '{}'", varname))?;
+
+        // Import the referenced global decl into our submodule
+        if self.tcfg.reorganize_definitions {
+            self.add_import(decl_id, &rustname);
+            // match decl {
+            //     CDeclKind::Variable { is_defn: false, .. } => {}
+            //     _ => self.add_import(decl_id, &rustname),
+            // }
+        }
+
+        let mut val = mk().path_expr(vec![rustname]);
+        let mut set_unsafe = false;
+
+        match decl {
+            CDeclKind::Function { parameters, .. } => {
+                // If we are referring to a function and need its address, we
+                // need to cast it to fn() to ensure that it has a real address.
+                if ctx.needs_address() {
+                    let ty = self.convert_type(qual_ty.ctype)?;
+                    let actual_ty = self
+                        .type_converter
+                        .borrow_mut()
+                        .knr_function_type_with_parameters(
+                            &self.ast_context,
+                            qual_ty.ctype,
+                            parameters,
+                        )?;
+                    if let Some(actual_ty) = actual_ty {
+                        if actual_ty != ty {
+                            // If we're casting a concrete function to
+                            // a K&R function pointer type, use transmute
+                            self.import_type(qual_ty.ctype);
+
+                            val = transmute_expr(actual_ty, ty, val);
+                            set_unsafe = true;
+                        }
+                    } else {
+                        let decl_kind = &self.ast_context[decl_id].kind;
+                        let kind_with_declared_args =
+                            self.ast_context.fn_decl_ty_with_declared_args(decl_kind);
+
+                        if let Some(ty) = self
+                            .ast_context
+                            .type_for_kind(&kind_with_declared_args)
+                            .map(CQualTypeId::new)
+                        {
+                            let ty = self.convert_type(ty.ctype)?;
+                            val = mk().cast_expr(val, ty);
+                        } else {
+                            val = mk().cast_expr(val, ty);
+                        }
+                    }
+                }
+            }
+
+            CDeclKind::Variable {
+                has_static_duration,
+                has_thread_duration,
+                ..
+            } => {
+                // Accessing a static variable is unsafe.
+                // In the current nightly, this applies also to taking a raw pointer,
+                // but this requirement was removed in later versions of the
+                // `raw_ref_op` feature.
+                if (*has_static_duration || *has_thread_duration)
+                    && (self.tcfg.edition < Edition2024 || !ctx.needs_address())
+                {
+                    set_unsafe = true;
+                }
+            }
+
+            _ => {}
+        }
+
+        if let CTypeKind::VariableArray(..) = self.ast_context.resolve_type(qual_ty.ctype).kind {
+            val = mk().method_call_expr(val, "as_mut_ptr", vec![]);
+        }
+
+        // if the context wants a different type, add a cast
+        if let Some(expected_ty) = override_ty {
+            if lrvalue.is_rvalue() && expected_ty != qual_ty {
+                val = mk().cast_expr(val, self.convert_type(expected_ty.ctype)?);
+            }
+        }
+
+        Ok(WithStmts::new_val(val).merge_unsafe(set_unsafe))
+    }
+
     pub fn convert_constant(&self, constant: ConstIntExpr) -> TranslationResult<Box<Expr>> {
         let expr = match constant {
             ConstIntExpr::U(n) => mk().lit_expr(mk().int_unsuffixed_lit(n as u128)),
@@ -3581,6 +3624,68 @@ impl<'c> Translation<'c> {
         }
     }
 
+    fn can_propagate_cast(
+        &self,
+        ctx: ExprContext,
+        expr_id: CExprId,
+        target_type_id: CQualTypeId,
+        is_explicit: bool,
+    ) -> bool {
+        // Always preserve explicit casts.
+        if is_explicit {
+            return false;
+        }
+
+        let mut expr_kind = &self.ast_context[expr_id].kind;
+
+        // In patterns, skip over `ConstantExpr`s.
+        if ctx.is_pattern {
+            if let &CExprKind::ConstantExpr(_, expr_id, _) = expr_kind {
+                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) {
+                    return true;
+                }
+
+                let source_enum_id = self.ast_context.parents[&decl_id];
+                let source_integral_type_id = self.enum_integral_type(source_enum_id);
+                let target_type_resolved_id = self
+                    .ast_context
+                    .resolve_type_id_no_typedef(target_type_id.ctype);
+
+                // Likewise, if we are casting to the inner integral type of the enum, then
+                // translate the enum constant directly as that.
+                if target_type_resolved_id == source_integral_type_id.ctype {
+                    return true;
+                }
+            }
+        }
+
+        let mut literal_expr_kind = expr_kind;
+        let mut is_negated = false;
+
+        if let &CExprKind::Unary(_, CUnOp::Negate, subexpr_id, _) = literal_expr_kind {
+            literal_expr_kind = &self.ast_context[subexpr_id].kind;
+            is_negated = true;
+        }
+
+        if let CExprKind::Literal(_, lit) = literal_expr_kind {
+            // Does the inner literal fit in the type we're casting to?
+            if self.literal_matches_ty(lit, target_type_id, is_negated) {
+                return true;
+            }
+        }
+
+        false
+    }
+
     pub fn convert_cast(
         &self,
         ctx: ExprContext,
@@ -3609,22 +3714,29 @@ impl<'c> Translation<'c> {
             return Ok(val);
         }
 
+        if ctx.is_pattern
+            && !matches!(
+                kind,
+                CastKind::ToVoid | CastKind::ConstCast | CastKind::IntegralCast
+            )
+        {
+            return Err(TranslationError::generic(
+                "cast kind is not supported in patterns",
+            ));
+        }
+
         match kind {
             CastKind::BitCast | CastKind::NoOp => {
-                self.convert_pointer_to_pointer_cast(source_cty.ctype, target_cty.ctype, val)
+                self.convert_pointer_to_pointer_cast(source_cty, target_cty, val)
             }
 
             CastKind::IntegralToPointer => {
-                self.convert_integral_to_pointer_cast(ctx, source_cty.ctype, target_cty.ctype, val)
+                self.convert_integral_to_pointer_cast(ctx, source_cty, target_cty, val)
             }
 
-            CastKind::PointerToIntegral => self.convert_pointer_to_integral_cast(
-                ctx,
-                source_cty.ctype,
-                target_cty.ctype,
-                val,
-                expr,
-            ),
+            CastKind::PointerToIntegral => {
+                self.convert_pointer_to_integral_cast(ctx, source_cty, target_cty, val)
+            }
 
             CastKind::IntegralCast
             | CastKind::FloatingCast
@@ -3633,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
@@ -3658,17 +3776,16 @@ 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 {
-                    // Casts targeting `enum` types...
-                    val.try_map(|val| {
-                        self.convert_cast_to_enum(ctx, target_cty.ctype, enum_decl_id, expr, val)
-                    })
+                } 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, 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)
                     }))
-                } else if let &CTypeKind::Enum(..) = source_ty_kind {
-                    val.try_map(|val| self.convert_cast_from_enum(target_cty.ctype, val))
+                } else if let &CTypeKind::Enum(enum_id) = source_ty_kind {
+                    val.and_then_try(|val| {
+                        self.convert_cast_from_enum(ctx, enum_id, target_cty, val)
+                    })
                 } else {
                     Ok(val.map(|val| mk().cast_expr(val, target_ty)))
                 }
@@ -3933,8 +4050,7 @@ impl<'c> Translation<'c> {
                 field.map(|field| mk().struct_expr(vec![name], vec![field]))
             }
 
-            // 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(
@@ -4038,7 +4154,7 @@ impl<'c> Translation<'c> {
             }
 
             let val = if ty.is_enum() {
-                mk().cast_expr(val, mk().path_ty(vec!["u64"]))
+                self.integer_from_enum(val)
             } else {
                 val
             };
@@ -4360,3 +4476,9 @@ fn neg_expr(arg: Box<Expr>) -> Box<Expr> {
 fn wrapping_neg_expr(arg: Box<Expr>) -> Box<Expr> {
     mk().method_call_expr(arg, "wrapping_neg", vec![])
 }
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum EnumMode {
+    NewType,
+    Consts,
+}
diff --git a/c2rust-transpile/src/translator/operators.rs b/c2rust-transpile/src/translator/operators.rs
index a03f240ffe..30123ea63c 100644
--- a/c2rust-transpile/src/translator/operators.rs
+++ b/c2rust-transpile/src/translator/operators.rs
@@ -638,26 +638,35 @@ impl<'c> Translation<'c> {
             _ => mk().lit_expr(mk().int_unsuffixed_lit(1)),
         };
 
-        let one_type_id =
-            if let CTypeKind::Pointer(..) = self.ast_context.resolve_type(arg_type.ctype).kind {
-                CQualTypeId::new(
+        let mut rhs_type_id = arg_type;
+        let mut compute_lhs_type_id = arg_type;
+        let mut compute_res_type_id = ty;
+
+        match self.ast_context.resolve_type(arg_type.ctype).kind {
+            CTypeKind::Pointer(..) => {
+                rhs_type_id = CQualTypeId::new(
                     self.ast_context
                         .type_for_kind(&CTypeKind::Int)
                         .ok_or_else(|| format_err!("couldn't find type for CTypeKind::Int"))?,
-                )
-            } else {
-                arg_type
-            };
+                );
+            }
+            CTypeKind::Enum(enum_id) => {
+                rhs_type_id = self.enum_integral_type(enum_id);
+                compute_lhs_type_id = rhs_type_id;
+                compute_res_type_id = rhs_type_id;
+            }
+            _ => {}
+        };
 
         self.convert_assignment_operator_with_rhs(
             ctx.used(),
             op,
             ty,
             arg,
-            one_type_id,
+            rhs_type_id,
             WithStmts::new_val(one),
-            Some(arg_type),
-            Some(ty),
+            Some(compute_lhs_type_id),
+            Some(compute_res_type_id),
         )
     }
 
@@ -843,7 +852,7 @@ impl<'c> Translation<'c> {
             // If we are negating a literal, generate a negated literal directly.
             // This will create an expression like `-1 as ty` without parentheses,
             // rather than `-(1 as ty)`.
-            let val = self.mk_int_lit(expr_type_id, val, base, true)?;
+            let val = self.mk_int_lit(ctx, expr_type_id, val, base, true)?;
             Ok(WithStmts::new_val(val))
         } else {
             let val = self.convert_expr(ctx.used(), arg_id, Some(expr_type_id))?;
diff --git a/c2rust-transpile/src/translator/pointers.rs b/c2rust-transpile/src/translator/pointers.rs
index a15fef518c..bffb30efac 100644
--- a/c2rust-transpile/src/translator/pointers.rs
+++ b/c2rust-transpile/src/translator/pointers.rs
@@ -246,6 +246,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)
@@ -259,7 +263,12 @@ impl<'c> Translation<'c> {
         }
 
         let rhs = self.convert_expr(ctx.used(), rhs, None)?;
-        rhs.and_then_try(|rhs| {
+        rhs.and_then_try(|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.
@@ -426,35 +435,35 @@ impl<'c> Translation<'c> {
 
     pub fn convert_pointer_to_pointer_cast(
         &self,
-        source_cty: CTypeId,
-        target_cty: CTypeId,
+        source_cty: CQualTypeId,
+        target_cty: CQualTypeId,
         val: WithStmts<Box<Expr>>,
     ) -> TranslationResult<WithStmts<Box<Expr>>> {
-        if self.ast_context.is_function_pointer(target_cty)
-            || self.ast_context.is_function_pointer(source_cty)
+        if self.ast_context.is_function_pointer(target_cty.ctype)
+            || self.ast_context.is_function_pointer(source_cty.ctype)
         {
             let source_ty = self
                 .type_converter
                 .borrow_mut()
-                .convert(&self.ast_context, source_cty)?;
+                .convert(&self.ast_context, source_cty.ctype)?;
             let target_ty = self
                 .type_converter
                 .borrow_mut()
-                .convert(&self.ast_context, target_cty)?;
+                .convert(&self.ast_context, target_cty.ctype)?;
 
             if source_ty == target_ty {
                 return Ok(val);
             }
 
-            self.import_type(source_cty);
-            self.import_type(target_cty);
+            self.import_type(source_cty.ctype);
+            self.import_type(target_cty.ctype);
 
             Ok(val.and_then(|val| {
                 WithStmts::new_val(transmute_expr(source_ty, target_ty, val)).set_unsafe()
             }))
         } else {
             // Normal case
-            let target_ty = self.convert_type(target_cty)?;
+            let target_ty = self.convert_type(target_cty.ctype)?;
             Ok(val.map(|val| mk().cast_expr(val, target_ty)))
         }
     }
@@ -462,14 +471,14 @@ impl<'c> Translation<'c> {
     pub fn convert_integral_to_pointer_cast(
         &self,
         ctx: ExprContext,
-        source_cty: CTypeId,
-        target_cty: CTypeId,
+        source_cty: CQualTypeId,
+        target_cty: CQualTypeId,
         val: WithStmts<Box<Expr>>,
     ) -> TranslationResult<WithStmts<Box<Expr>>> {
-        let source_ty_kind = &self.ast_context.resolve_type(source_cty).kind;
-        let target_ty = self.convert_type(target_cty)?;
+        let source_ty_kind = &self.ast_context.resolve_type(source_cty.ctype).kind;
+        let target_ty = self.convert_type(target_cty.ctype)?;
 
-        if self.ast_context.is_function_pointer(target_cty) {
+        if self.ast_context.is_function_pointer(target_cty.ctype) {
             if ctx.is_const {
                 return Err(format_translation_err!(
                     None,
@@ -492,8 +501,8 @@ impl<'c> Translation<'c> {
                 val = mk().cast_expr(val, mk().abs_path_ty(vec!["libc", "size_t"]));
                 mk().cast_expr(val, target_ty)
             }))
-        } else if let &CTypeKind::Enum(..) = source_ty_kind {
-            val.try_map(|val| self.convert_cast_from_enum(target_cty, val))
+        } else if let &CTypeKind::Enum(enum_id) = source_ty_kind {
+            val.and_then_try(|val| self.convert_cast_from_enum(ctx, enum_id, target_cty, val))
         } else {
             Ok(val.map(|val| mk().cast_expr(val, target_ty)))
         }
@@ -502,10 +511,9 @@ impl<'c> Translation<'c> {
     pub fn convert_pointer_to_integral_cast(
         &self,
         ctx: ExprContext,
-        source_cty: CTypeId,
-        target_cty: CTypeId,
+        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!(
@@ -514,16 +522,16 @@ impl<'c> Translation<'c> {
             ));
         }
 
-        let target_ty = self.convert_type(target_cty)?;
-        let source_ty = self.convert_type(source_cty)?;
-        let target_ty_kind = &self.ast_context.resolve_type(target_cty).kind;
+        let target_ty = self.convert_type(target_cty.ctype)?;
+        let source_ty = self.convert_type(source_cty.ctype)?;
+        let target_ty_kind = &self.ast_context.resolve_type(target_cty.ctype).kind;
 
-        if self.ast_context.is_function_pointer(source_cty) {
+        if self.ast_context.is_function_pointer(source_cty.ctype) {
             Ok(val.and_then(|val| {
                 WithStmts::new_val(transmute_expr(source_ty, target_ty, val)).set_unsafe()
             }))
-        } else if let &CTypeKind::Enum(enum_decl_id) = target_ty_kind {
-            val.try_map(|val| self.convert_cast_to_enum(ctx, target_cty, enum_decl_id, expr, val))
+        } 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, val))
         } else {
             Ok(val.map(|val| mk().cast_expr(val, target_ty)))
         }
diff --git a/c2rust-transpile/tests/snapshots.rs b/c2rust-transpile/tests/snapshots.rs
index 4f10e330ea..dd06ae4908 100644
--- a/c2rust-transpile/tests/snapshots.rs
+++ b/c2rust-transpile/tests/snapshots.rs
@@ -11,8 +11,7 @@ use c2rust_rust_tools::RustEdition;
 use c2rust_rust_tools::RustEdition::Edition2021;
 use c2rust_rust_tools::RustEdition::Edition2024;
 use c2rust_transpile::renamer::RUST_KEYWORDS;
-use c2rust_transpile::ReplaceMode;
-use c2rust_transpile::TranspilerConfig;
+use c2rust_transpile::{EnumMode, ReplaceMode, TranspilerConfig};
 use itertools::Itertools;
 
 fn config(edition: RustEdition) -> TranspilerConfig {
@@ -68,6 +67,7 @@ fn config(edition: RustEdition) -> TranspilerConfig {
                 .unwrap()
                 .to_path_buf(),
         ),
+        enum_mode: EnumMode::NewType,
     }
 }
 
@@ -359,6 +359,11 @@ fn test_empty_init() {
     transpile("empty_init.c").run();
 }
 
+#[test]
+fn test_enums() {
+    transpile("enums.c").run();
+}
+
 #[test]
 fn test_exprs() {
     transpile("exprs.c").run();
diff --git a/c2rust-transpile/tests/snapshots/enums.c b/c2rust-transpile/tests/snapshots/enums.c
new file mode 100644
index 0000000000..ba83188062
--- /dev/null
+++ b/c2rust-transpile/tests/snapshots/enums.c
@@ -0,0 +1,90 @@
+typedef enum { Foo0, Foo1, Foo2, Foo3 } Foo;
+enum Bar { BarN1 = -1, Bar0, Bar1, Bar2, Bar3 };
+
+#define FOO1_MACRO Foo1
+#define BAR1_MACRO Bar1
+
+void test_enums(void) {
+    Foo foo = Foo0;
+    enum Bar bar = Bar0;
+    foo = Foo1;
+    bar = BarN1;
+
+    // Assign enum constant of wrong type
+    foo = Bar0;
+    bar = Foo0;
+
+    // Assign integer that matches a constant
+    foo = 1;
+    bar = 1;
+
+    // Assign integer that doesn't match any constant
+    foo = 3;
+    bar = 3;
+
+    // Arithmetic
+    foo -= 2;
+    bar -= 2;
+
+    Foo e = Foo1;
+
+    // Compare to same type
+    int enum_enum = e == foo;
+    int enum_constant = e == Foo0;
+
+    // Compare to wrong type
+    int wrong_enum_enum = e == bar;
+    int wrong_enum_constant = e == Bar0;
+
+    switch (foo) {
+        case Foo0:
+            break;
+
+        case FOO1_MACRO:
+            break;
+
+        // Integer with matching variant
+        case 2:
+            break;
+
+        // Wrong type
+        case Bar3:
+            break;
+
+        // No matching variant
+        case 42:
+            break;
+
+        // No matching variant, negative on unsigned enum
+        case -42:
+            break;
+    }
+
+    switch (bar) {
+        case Bar0:
+            break;
+
+        case BAR1_MACRO:
+            break;
+
+        // Integer with matching variant
+        case 2:
+            break;
+
+        // Wrong type
+        case Foo3:
+            break;
+
+        // Negative variant
+        case BarN1:
+            break;
+
+        // No matching variant
+        case 42:
+            break;
+
+        // No matching variant, negative on signed enum
+        case -42:
+            break;
+    }
+}
diff --git a/c2rust-transpile/tests/snapshots/snapshots__transpile@enums.c.2021.clang15.snap b/c2rust-transpile/tests/snapshots/snapshots__transpile@enums.c.2021.clang15.snap
new file mode 100644
index 0000000000..6ac3997f9a
--- /dev/null
+++ b/c2rust-transpile/tests/snapshots/snapshots__transpile@enums.c.2021.clang15.snap
@@ -0,0 +1,58 @@
+---
+source: c2rust-transpile/tests/snapshots.rs
+expression: cat tests/snapshots/enums.2021.clang15.rs
+---
+#![allow(
+    clippy::missing_safety_doc,
+    dead_code,
+    non_camel_case_types,
+    non_snake_case,
+    non_upper_case_globals,
+    unused_assignments,
+    unused_mut
+)]
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[repr(transparent)]
+pub struct Foo(pub ::core::ffi::c_uint);
+pub const Foo3: Foo = Foo(3);
+pub const Foo2: Foo = Foo(2);
+pub const Foo1: Foo = Foo(1);
+pub const Foo0: Foo = Foo(0);
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[repr(transparent)]
+pub struct Bar(pub ::core::ffi::c_int);
+pub const Bar3: Bar = Bar(3);
+pub const Bar2: Bar = Bar(2);
+pub const Bar1: Bar = Bar(1);
+pub const Bar0: Bar = Bar(0);
+pub const BarN1: Bar = Bar(-1);
+pub const FOO1_MACRO: ::core::ffi::c_uint = 1 as ::core::ffi::c_uint;
+pub const BAR1_MACRO: ::core::ffi::c_int = 1;
+#[no_mangle]
+pub unsafe extern "C" fn test_enums() {
+    let mut foo: Foo = Foo0;
+    let mut bar: Bar = Bar0;
+    foo = Foo1;
+    bar = BarN1;
+    foo = Foo(Bar0.0 as ::core::ffi::c_uint);
+    bar = Bar(Foo0.0 as ::core::ffi::c_int);
+    foo = Foo1;
+    bar = Bar1;
+    foo = Foo3;
+    bar = Bar3;
+    foo = Foo(foo.0.wrapping_sub(2 as ::core::ffi::c_uint));
+    bar = Bar(bar.0 - 2 as ::core::ffi::c_int);
+    let mut e: Foo = Foo1;
+    let mut enum_enum: ::core::ffi::c_int = (e.0 == foo.0) as ::core::ffi::c_int;
+    let mut enum_constant: ::core::ffi::c_int = (e.0 == Foo0.0) as ::core::ffi::c_int;
+    let mut wrong_enum_enum: ::core::ffi::c_int =
+        (e.0 == bar.0 as ::core::ffi::c_uint) as ::core::ffi::c_int;
+    let mut wrong_enum_constant: ::core::ffi::c_int =
+        (e.0 == Bar0.0 as ::core::ffi::c_uint) as ::core::ffi::c_int;
+    match foo {
+        Foo0 | Foo(FOO1_MACRO) | Foo2 | Foo(3) | Foo(42) | Foo(4294967254) | _ => {}
+    }
+    match bar {
+        Bar0 | Bar(BAR1_MACRO) | Bar2 | Bar(3) | BarN1 | Bar(42) | Bar(-42) | _ => {}
+    };
+}
diff --git a/c2rust-transpile/tests/snapshots/snapshots__transpile@enums.c.2024.clang15.snap b/c2rust-transpile/tests/snapshots/snapshots__transpile@enums.c.2024.clang15.snap
new file mode 100644
index 0000000000..d7e675b874
--- /dev/null
+++ b/c2rust-transpile/tests/snapshots/snapshots__transpile@enums.c.2024.clang15.snap
@@ -0,0 +1,59 @@
+---
+source: c2rust-transpile/tests/snapshots.rs
+expression: cat tests/snapshots/enums.2024.clang15.rs
+---
+#![allow(
+    clippy::missing_safety_doc,
+    dead_code,
+    non_camel_case_types,
+    non_snake_case,
+    non_upper_case_globals,
+    unsafe_op_in_unsafe_fn,
+    unused_assignments,
+    unused_mut
+)]
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[repr(transparent)]
+pub struct Foo(pub ::core::ffi::c_uint);
+pub const Foo3: Foo = Foo(3);
+pub const Foo2: Foo = Foo(2);
+pub const Foo1: Foo = Foo(1);
+pub const Foo0: Foo = Foo(0);
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[repr(transparent)]
+pub struct Bar(pub ::core::ffi::c_int);
+pub const Bar3: Bar = Bar(3);
+pub const Bar2: Bar = Bar(2);
+pub const Bar1: Bar = Bar(1);
+pub const Bar0: Bar = Bar(0);
+pub const BarN1: Bar = Bar(-1);
+pub const FOO1_MACRO: ::core::ffi::c_uint = 1 as ::core::ffi::c_uint;
+pub const BAR1_MACRO: ::core::ffi::c_int = 1;
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn test_enums() {
+    let mut foo: Foo = Foo0;
+    let mut bar: Bar = Bar0;
+    foo = Foo1;
+    bar = BarN1;
+    foo = Foo(Bar0.0 as ::core::ffi::c_uint);
+    bar = Bar(Foo0.0 as ::core::ffi::c_int);
+    foo = Foo1;
+    bar = Bar1;
+    foo = Foo3;
+    bar = Bar3;
+    foo = Foo(foo.0.wrapping_sub(2 as ::core::ffi::c_uint));
+    bar = Bar(bar.0 - 2 as ::core::ffi::c_int);
+    let mut e: Foo = Foo1;
+    let mut enum_enum: ::core::ffi::c_int = (e.0 == foo.0) as ::core::ffi::c_int;
+    let mut enum_constant: ::core::ffi::c_int = (e.0 == Foo0.0) as ::core::ffi::c_int;
+    let mut wrong_enum_enum: ::core::ffi::c_int =
+        (e.0 == bar.0 as ::core::ffi::c_uint) as ::core::ffi::c_int;
+    let mut wrong_enum_constant: ::core::ffi::c_int =
+        (e.0 == Bar0.0 as ::core::ffi::c_uint) as ::core::ffi::c_int;
+    match foo {
+        Foo0 | Foo(FOO1_MACRO) | Foo2 | Foo(3) | Foo(42) | Foo(4294967254) | _ => {}
+    }
+    match bar {
+        Bar0 | Bar(BAR1_MACRO) | Bar2 | Bar(3) | BarN1 | Bar(42) | Bar(-42) | _ => {}
+    };
+}
diff --git a/c2rust-transpile/tests/snapshots/snapshots__transpile@exprs.c.2021.clang15.snap b/c2rust-transpile/tests/snapshots/snapshots__transpile@exprs.c.2021.clang15.snap
index 56ee5f78bf..ecfafd2f01 100644
--- a/c2rust-transpile/tests/snapshots/snapshots__transpile@exprs.c.2021.clang15.snap
+++ b/c2rust-transpile/tests/snapshots/snapshots__transpile@exprs.c.2021.clang15.snap
@@ -15,13 +15,17 @@ expression: cat tests/snapshots/exprs.2021.clang15.rs
 extern "C" {
     fn puts(str: *const ::core::ffi::c_char) -> ::core::ffi::c_int;
 }
-pub type E = ::core::ffi::c_uint;
-pub const EA: E = 0;
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[repr(transparent)]
+pub struct E(pub ::core::ffi::c_uint);
+pub const EA: E = E(0);
 pub type int_t = ::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, PartialEq, Eq)]
+#[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;
@@ -60,7 +64,7 @@ pub unsafe extern "C" fn unsigned_compound_desugaring() {
     let mut i: ::core::ffi::c_int = 0 as ::core::ffi::c_int;
     let mut u: ::core::ffi::c_uint = 0 as ::core::ffi::c_uint;
     let mut e: E = EA;
-    e = (e as ::core::ffi::c_uint).wrapping_add(u) as E;
+    e = E(e.0.wrapping_add(u));
     i = (i as ::core::ffi::c_uint).wrapping_add(u) as ::core::ffi::c_int;
 }
 #[no_mangle]
@@ -72,7 +76,7 @@ pub unsafe extern "C" fn cast_literals() {
 }
 #[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.clang15.snap b/c2rust-transpile/tests/snapshots/snapshots__transpile@exprs.c.2024.clang15.snap
index 04e6019c9c..83da64a629 100644
--- a/c2rust-transpile/tests/snapshots/snapshots__transpile@exprs.c.2024.clang15.snap
+++ b/c2rust-transpile/tests/snapshots/snapshots__transpile@exprs.c.2024.clang15.snap
@@ -15,13 +15,17 @@ expression: cat tests/snapshots/exprs.2024.clang15.rs
 unsafe extern "C" {
     unsafe fn puts(str: *const ::core::ffi::c_char) -> ::core::ffi::c_int;
 }
-pub type E = ::core::ffi::c_uint;
-pub const EA: E = 0;
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[repr(transparent)]
+pub struct E(pub ::core::ffi::c_uint);
+pub const EA: E = E(0);
 pub type int_t = ::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, PartialEq, Eq)]
+#[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;
@@ -60,7 +64,7 @@ pub unsafe extern "C" fn unsigned_compound_desugaring() {
     let mut i: ::core::ffi::c_int = 0 as ::core::ffi::c_int;
     let mut u: ::core::ffi::c_uint = 0 as ::core::ffi::c_uint;
     let mut e: E = EA;
-    e = (e as ::core::ffi::c_uint).wrapping_add(u) as E;
+    e = E(e.0.wrapping_add(u));
     i = (i as ::core::ffi::c_uint).wrapping_add(u) as ::core::ffi::c_int;
 }
 #[unsafe(no_mangle)]
@@ -72,7 +76,7 @@ pub unsafe extern "C" fn cast_literals() {
 }
 #[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.clang15.snap b/c2rust-transpile/tests/snapshots/snapshots__transpile@macrocase.c.2021.clang15.snap
index 07857d1fdf..aa1bfbbe73 100644
--- a/c2rust-transpile/tests/snapshots/snapshots__transpile@macrocase.c.2021.clang15.snap
+++ b/c2rust-transpile/tests/snapshots/snapshots__transpile@macrocase.c.2021.clang15.snap
@@ -11,19 +11,21 @@ expression: cat tests/snapshots/macrocase.2021.clang15.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, PartialEq, Eq)]
+#[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 {
-        100 => {
+    match dParam {
+        ZSTD_d_windowLogMax => {
             bounds = 1 as ::core::ffi::c_int;
             return bounds;
         }
-        1000 => {
+        ZSTD_dParameter(ZSTD_d_format) => {
             bounds = 5 as ::core::ffi::c_int;
             return bounds;
         }
diff --git a/c2rust-transpile/tests/snapshots/snapshots__transpile@macrocase.c.2024.clang15.snap b/c2rust-transpile/tests/snapshots/snapshots__transpile@macrocase.c.2024.clang15.snap
index cdf1b52d30..4ad93d5a59 100644
--- a/c2rust-transpile/tests/snapshots/snapshots__transpile@macrocase.c.2024.clang15.snap
+++ b/c2rust-transpile/tests/snapshots/snapshots__transpile@macrocase.c.2024.clang15.snap
@@ -12,19 +12,21 @@ expression: cat tests/snapshots/macrocase.2024.clang15.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, PartialEq, Eq)]
+#[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 {
-        100 => {
+    match dParam {
+        ZSTD_d_windowLogMax => {
             bounds = 1 as ::core::ffi::c_int;
             return bounds;
         }
-        1000 => {
+        ZSTD_dParameter(ZSTD_d_format) => {
             bounds = 5 as ::core::ffi::c_int;
             return bounds;
         }
diff --git a/c2rust-transpile/tests/snapshots/snapshots__transpile@records.c.2021.clang15.snap b/c2rust-transpile/tests/snapshots/snapshots__transpile@records.c.2021.clang15.snap
index d24f14826f..694c5d1ab5 100644
--- a/c2rust-transpile/tests/snapshots/snapshots__transpile@records.c.2021.clang15.snap
+++ b/c2rust-transpile/tests/snapshots/snapshots__transpile@records.c.2021.clang15.snap
@@ -14,9 +14,11 @@ expression: cat tests/snapshots/records.2021.clang15.rs
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub struct AnonEnumInStruct {}
-pub type C2Rust_Unnamed = ::core::ffi::c_uint;
-pub const VALUE2: C2Rust_Unnamed = 1;
-pub const VALUE1: C2Rust_Unnamed = 0;
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[repr(transparent)]
+pub struct C2Rust_Unnamed(pub ::core::ffi::c_uint);
+pub const VALUE2: C2Rust_Unnamed = C2Rust_Unnamed(1);
+pub const VALUE1: C2Rust_Unnamed = C2Rust_Unnamed(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 C2Rust_Unnamed_1 = ::core::ffi::c_uint;
-pub const VALUE4: C2Rust_Unnamed_1 = 1;
-pub const VALUE3: C2Rust_Unnamed_1 = 0;
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[repr(transparent)]
+pub struct C2Rust_Unnamed_1(pub ::core::ffi::c_uint);
+pub const VALUE4: C2Rust_Unnamed_1 = C2Rust_Unnamed_1(1);
+pub const VALUE3: C2Rust_Unnamed_1 = C2Rust_Unnamed_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: C2Rust_Unnamed_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: C2Rust_Unnamed_2 { some_number: 0 },
diff --git a/c2rust-transpile/tests/snapshots/snapshots__transpile@records.c.2024.clang15.snap b/c2rust-transpile/tests/snapshots/snapshots__transpile@records.c.2024.clang15.snap
index 4ee9a80c6a..f7d4db7a8d 100644
--- a/c2rust-transpile/tests/snapshots/snapshots__transpile@records.c.2024.clang15.snap
+++ b/c2rust-transpile/tests/snapshots/snapshots__transpile@records.c.2024.clang15.snap
@@ -15,9 +15,11 @@ expression: cat tests/snapshots/records.2024.clang15.rs
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub struct AnonEnumInStruct {}
-pub type C2Rust_Unnamed = ::core::ffi::c_uint;
-pub const VALUE2: C2Rust_Unnamed = 1;
-pub const VALUE1: C2Rust_Unnamed = 0;
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[repr(transparent)]
+pub struct C2Rust_Unnamed(pub ::core::ffi::c_uint);
+pub const VALUE2: C2Rust_Unnamed = C2Rust_Unnamed(1);
+pub const VALUE1: C2Rust_Unnamed = C2Rust_Unnamed(0);
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub struct AnonStructInStruct {
@@ -41,9 +43,11 @@ pub struct InsideStruct {
 pub union AnonEnumInUnion {
     pub a: ::core::ffi::c_int,
 }
-pub type C2Rust_Unnamed_1 = ::core::ffi::c_uint;
-pub const VALUE4: C2Rust_Unnamed_1 = 1;
-pub const VALUE3: C2Rust_Unnamed_1 = 0;
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[repr(transparent)]
+pub struct C2Rust_Unnamed_1(pub ::core::ffi::c_uint);
+pub const VALUE4: C2Rust_Unnamed_1 = C2Rust_Unnamed_1(1);
+pub const VALUE3: C2Rust_Unnamed_1 = C2Rust_Unnamed_1(0);
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub union AnonStructInUnion {
@@ -67,7 +71,7 @@ pub struct InsideUnion {
 }
 #[unsafe(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: C2Rust_Unnamed_0 { some_number: 0 },
@@ -78,7 +82,7 @@ pub unsafe extern "C" fn struct_declaration() {
 }
 #[unsafe(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: C2Rust_Unnamed_2 { some_number: 0 },
diff --git a/c2rust-transpile/tests/snapshots/snapshots__transpile@scalar_init.c.2021.clang15.snap b/c2rust-transpile/tests/snapshots/snapshots__transpile@scalar_init.c.2021.clang15.snap
index 983068e241..17aff03fc0 100644
--- a/c2rust-transpile/tests/snapshots/snapshots__transpile@scalar_init.c.2021.clang15.snap
+++ b/c2rust-transpile/tests/snapshots/snapshots__transpile@scalar_init.c.2021.clang15.snap
@@ -12,8 +12,10 @@ expression: cat tests/snapshots/scalar_init.2021.clang15.rs
     unused_mut
 )]
 #![feature(raw_ref_op)]
-pub type E = ::core::ffi::c_uint;
-pub const A: E = 0;
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[repr(transparent)]
+pub struct E(pub ::core::ffi::c_uint);
+pub const A: E = E(0);
 pub const true_0: ::core::ffi::c_int = 1 as ::core::ffi::c_int;
 #[no_mangle]
 pub unsafe extern "C" fn scalar_init() {
diff --git a/c2rust-transpile/tests/snapshots/snapshots__transpile@scalar_init.c.2024.clang15.snap b/c2rust-transpile/tests/snapshots/snapshots__transpile@scalar_init.c.2024.clang15.snap
index be7f3a5d96..4d838fa28f 100644
--- a/c2rust-transpile/tests/snapshots/snapshots__transpile@scalar_init.c.2024.clang15.snap
+++ b/c2rust-transpile/tests/snapshots/snapshots__transpile@scalar_init.c.2024.clang15.snap
@@ -12,8 +12,10 @@ expression: cat tests/snapshots/scalar_init.2024.clang15.rs
     unused_assignments,
     unused_mut
 )]
-pub type E = ::core::ffi::c_uint;
-pub const A: E = 0;
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[repr(transparent)]
+pub struct E(pub ::core::ffi::c_uint);
+pub const A: E = E(0);
 pub const true_0: ::core::ffi::c_int = 1 as ::core::ffi::c_int;
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn scalar_init() {
diff --git a/c2rust/src/bin/c2rust-transpile.rs b/c2rust/src/bin/c2rust-transpile.rs
index 39f5ada8e7..34a272ac67 100644
--- a/c2rust/src/bin/c2rust-transpile.rs
+++ b/c2rust/src/bin/c2rust-transpile.rs
@@ -4,7 +4,7 @@ use regex::Regex;
 use std::{ffi::OsStr, fs, path::PathBuf};
 
 use c2rust_rust_tools::RustEdition;
-use c2rust_transpile::{Diagnostic, ReplaceMode, TranspilerConfig};
+use c2rust_transpile::{Diagnostic, EnumMode, ReplaceMode, TranspilerConfig};
 
 #[derive(Debug, Parser)]
 #[clap(
@@ -326,6 +326,7 @@ fn main() {
         log_level: args.log_level,
         edition: args.edition,
         deny_unsafe_op_in_unsafe_fn: args.deny_unsafe_op_in_unsafe_fn,
+        enum_mode: EnumMode::NewType,
     };
     // binaries imply emit-build-files
     if !tcfg.binaries.is_empty() {
diff --git a/tests/unit/enums/src/test_enums.rs b/tests/unit/enums/src/test_enums.rs
index 1e373fd354..c100fd91cc 100644
--- a/tests/unit/enums/src/test_enums.rs
+++ b/tests/unit/enums/src/test_enums.rs
@@ -35,8 +35,8 @@ const BUFFER_SIZE6: usize = 1;
 
 #[test]
 pub fn test_variants() {
-    assert_eq!(A as u32, 0);
-    assert_eq!(B as u32, 1);
+    assert_eq!(A.0 as u32, 0);
+    assert_eq!(B.0 as u32, 1);
 }
 
 #[test]
diff --git a/tests/unit/misc/src/test_uninitialized.rs b/tests/unit/misc/src/test_uninitialized.rs
index 87425c5b32..505aee8937 100644
--- a/tests/unit/misc/src/test_uninitialized.rs
+++ b/tests/unit/misc/src/test_uninitialized.rs
@@ -26,9 +26,9 @@ pub fn test_buffer() {
 
 #[test]
 pub fn test_types() {
-    assert_eq!(foo as u32, 1);
-    assert_eq!(bar as u32, 2);
-    assert_eq!(baz as u32, 3);
+    assert_eq!(foo.0 as u32, 1);
+    assert_eq!(bar.0 as u32, 2);
+    assert_eq!(baz.0 as u32, 3);
 
     // FIXME: union fields are private
     // let my_union = u { x: 32 };