diff --git a/c2rust-ast-builder/src/builder.rs b/c2rust-ast-builder/src/builder.rs
index 526bbd45ad..2d77573eb7 100644
--- a/c2rust-ast-builder/src/builder.rs
+++ b/c2rust-ast-builder/src/builder.rs
@@ -1233,6 +1233,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-transpile/src/cfg/mod.rs b/c2rust-transpile/src/cfg/mod.rs
index 9ba204b198..1a93f9923c 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;
@@ -448,6 +448,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
@@ -1934,42 +1935,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_unwrap_parens(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(
@@ -2015,8 +2019,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);
 
@@ -2028,7 +2054,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,
@@ -2415,3 +2444,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/translator/enums.rs b/c2rust-transpile/src/translator/enums.rs
index 873fa4fb93..091ff5f8bc 100644
--- a/c2rust-transpile/src/translator/enums.rs
+++ b/c2rust-transpile/src/translator/enums.rs
@@ -4,9 +4,9 @@ use syn::Expr;
 
 use crate::{
     diagnostics::TranslationResult,
-    translator::{signed_int_expr, ConvertedDecl, ExprContext, Translation},
+    translator::{signed_int_expr, ConvertedDecl, ExprContext, Translation, TranslationError},
     with_stmts::WithStmts,
-    CDeclKind, CEnumConstantId, CEnumId, CExprId, CExprKind, CQualTypeId, CTypeKind, ConstIntExpr,
+    CDeclKind, CEnumConstantId, CEnumId, CQualTypeId, CTypeId, CTypeKind, ConstIntExpr,
 };
 
 impl<'c> Translation<'c> {
@@ -25,7 +25,7 @@ impl<'c> Translation<'c> {
         let field = mk().pub_().enum_field(integral_type_rs);
         let item = mk()
             .span(span)
-            .call_attr("derive", vec!["Clone", "Copy"])
+            .call_attr("derive", vec!["Clone", "Copy", "PartialEq", "Eq"])
             .call_attr("repr", vec!["transparent"])
             .pub_()
             .struct_item(enum_name, vec![field], true);
@@ -76,6 +76,10 @@ impl<'c> Translation<'c> {
     ) -> TranslationResult<WithStmts<Box<Expr>>> {
         let val = self.enum_constant_expr(enum_constant_id);
 
+        if self.enum_constant_matches_type(expr_type_id.ctype, enum_constant_id) {
+            return Ok(WithStmts::new_val(val));
+        }
+
         // Add a cast to the expected integral type.
         let enum_id = self.ast_context.parents[&enum_constant_id];
         self.convert_cast_from_enum(ctx, enum_id, expr_type_id, val)
@@ -89,6 +93,12 @@ impl<'c> Translation<'c> {
         target_cty: CQualTypeId,
         mut val: Box<Expr>,
     ) -> TranslationResult<WithStmts<Box<Expr>>> {
+        if ctx.is_pattern {
+            return Err(TranslationError::generic(
+                "cast from enum is not supported in patterns",
+            ));
+        }
+
         // First extract the enum's inner type...
         val = self.integer_from_enum(val);
 
@@ -108,32 +118,8 @@ impl<'c> Translation<'c> {
         ctx: ExprContext,
         mut source_cty: CQualTypeId,
         enum_id: CEnumId,
-        expr: Option<CExprId>,
         mut val: Box<Expr>,
     ) -> TranslationResult<WithStmts<Box<Expr>>> {
-        if let Some(expr) = expr {
-            match self.ast_context.index_unwrap_parens(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 {
-                        val = self.enum_constant_expr(enum_constant_id);
-                        return Ok(WithStmts::new_val(val));
-                    }
-                }
-
-                _ => {}
-            }
-        }
-
         // We could be casting from enum to enum...
         if let CTypeKind::Enum(source_enum_id) =
             self.ast_context.resolve_type(source_cty.ctype).kind
@@ -143,6 +129,12 @@ impl<'c> Translation<'c> {
                 return Ok(WithStmts::new_val(val));
             }
 
+            if ctx.is_pattern {
+                return Err(TranslationError::generic(
+                    "cast from enum is not supported in patterns",
+                ));
+            }
+
             // Enum-to-enum casts need to be translated via the inner value as an intermediate.
             val = self.integer_from_enum(val);
             source_cty = self.enum_integral_type(source_enum_id);
@@ -208,13 +200,16 @@ impl<'c> Translation<'c> {
         mk().call_expr(mk().ident_expr(enum_name), vec![value])
     }
 
-    fn is_variant_of_enum(&self, enum_id: CEnumId, enum_constant_id: CEnumConstantId) -> bool {
-        let variants = match self.ast_context[enum_id].kind {
-            CDeclKind::Enum { ref variants, .. } => variants,
-            _ => panic!("{:?} does not point to an `enum` declaration", enum_id),
+    pub(crate) fn enum_constant_matches_type(
+        &self,
+        type_id: CTypeId,
+        enum_constant_id: CEnumConstantId,
+    ) -> bool {
+        let CTypeKind::Enum(type_enum_id) = self.ast_context.resolve_type(type_id).kind else {
+            return false;
         };
-
-        variants.contains(&enum_constant_id)
+        let constant_enum_id = self.ast_context.parents[&enum_constant_id];
+        type_enum_id == constant_enum_id
     }
 
     pub(crate) fn enum_integral_type(&self, enum_id: CEnumId) -> CQualTypeId {
diff --git a/c2rust-transpile/src/translator/literals.rs b/c2rust-transpile/src/translator/literals.rs
index b20ed49c2c..9f3f984b94 100644
--- a/c2rust-transpile/src/translator/literals.rs
+++ b/c2rust-transpile/src/translator/literals.rs
@@ -11,6 +11,7 @@ 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,
@@ -36,7 +37,7 @@ impl<'c> Translation<'c> {
             expr = neg_expr(expr);
         }
 
-        Ok(if is_suffix {
+        Ok(if is_suffix || ctx.is_pattern {
             expr
         } else {
             mk().cast_expr(expr, target_ty)
@@ -68,13 +69,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
@@ -88,8 +94,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) => {
@@ -123,6 +133,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 99645b2fb7..17ee1487ac 100644
--- a/c2rust-transpile/src/translator/macros.rs
+++ b/c2rust-transpile/src/translator/macros.rs
@@ -188,7 +188,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 {
@@ -204,7 +204,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.index_unwrap_parens(expr_id).kind;
         // TODO We'd like to get rid of this cast eventually (see #1321).
@@ -214,14 +214,16 @@ 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.make_cast(ctx, CQualTypeId::new(macro_ty), expr_ty, val)
-                .map(Some)
-        } else {
-            Ok(Some(val))
+            match self.make_cast(ctx, CQualTypeId::new(macro_ty), expr_ty, val) {
+                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 e12be9f38d..b425ea496d 100644
--- a/c2rust-transpile/src/translator/mod.rs
+++ b/c2rust-transpile/src/translator/mod.rs
@@ -128,6 +128,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.
@@ -181,6 +185,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,
@@ -279,7 +295,7 @@ pub struct Translation<'c> {
     extern_crates: RefCell<CrateSet>,
 
     // Translation state and utilities
-    type_converter: RefCell<TypeConverter>,
+    pub(crate) type_converter: RefCell<TypeConverter>,
     renamer: Rc<RefCell<Renamer<CDeclId>>>,
     zero_inits: RefCell<ZeroInits>,
     function_context: RefCell<FuncContext>,
@@ -856,8 +872,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,
@@ -3207,6 +3224,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(..) => {
@@ -3272,7 +3305,11 @@ 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(override_ty.unwrap_or(ty)))
                 }
@@ -3284,6 +3321,7 @@ impl<'c> Translation<'c> {
 
             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,
@@ -3602,6 +3640,12 @@ impl<'c> Translation<'c> {
             );
         }
 
+        if ctx.is_pattern {
+            return Err(TranslationError::generic(
+                "non-EnumConstant DeclRefs are not supported in patterns",
+            ));
+        }
+
         let varname = decl.get_name().expect("expected variable name").to_owned();
         let rustname = self
             .renamer
@@ -3848,28 +3892,15 @@ impl<'c> Translation<'c> {
             return self.convert_condition(ctx, true, expr);
         }
 
-        let expr_kind = &self.ast_context.index_unwrap_parens(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.index_unwrap_parens(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));
-                }
-            }
+        // 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 {
@@ -3933,6 +3964,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.index_unwrap_parens(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.index_unwrap_parens(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.index_unwrap_parens(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 make_cast(
         &self,
         ctx: ExprContext,
@@ -3971,6 +4064,17 @@ 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, target_cty, val)
@@ -3981,7 +4085,7 @@ impl<'c> Translation<'c> {
             }
 
             CastKind::PointerToIntegral => {
-                self.convert_pointer_to_integral_cast(ctx, source_cty, target_cty, val, expr)
+                self.convert_pointer_to_integral_cast(ctx, source_cty, target_cty, val)
             }
 
             CastKind::IntegralCast
@@ -3991,6 +4095,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
@@ -4017,9 +4127,7 @@ impl<'c> Translation<'c> {
                 {
                     self.f128_cast_to(val, target_ty_kind)
                 } else if let &CTypeKind::Enum(enum_id) = target_ty_kind {
-                    val.and_then_try(|val| {
-                        self.convert_cast_to_enum(ctx, source_cty, enum_id, expr, val)
-                    })
+                    val.and_then_try(|val| self.convert_cast_to_enum(ctx, source_cty, enum_id, val))
                 } else if target_ty_kind.is_floating_type() && source_ty_kind.is_bool() {
                     Ok(val.map(|val| {
                         mk().cast_expr(mk().cast_expr(val, mk().path_ty(vec!["u8"])), target_ty)
diff --git a/c2rust-transpile/src/translator/operators.rs b/c2rust-transpile/src/translator/operators.rs
index 98c4c0fc45..1e8189a6f9 100644
--- a/c2rust-transpile/src/translator/operators.rs
+++ b/c2rust-transpile/src/translator/operators.rs
@@ -748,7 +748,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 af69a078aa..66fa70e490 100644
--- a/c2rust-transpile/src/translator/pointers.rs
+++ b/c2rust-transpile/src/translator/pointers.rs
@@ -611,7 +611,6 @@ impl<'c> Translation<'c> {
         source_cty: CQualTypeId,
         target_cty: CQualTypeId,
         val: WithStmts<Box<Expr>>,
-        expr: Option<CExprId>,
     ) -> TranslationResult<WithStmts<Box<Expr>>> {
         if ctx.is_const {
             return Err(format_translation_err!(
@@ -654,7 +653,6 @@ impl<'c> Translation<'c> {
                         ctx,
                         CQualTypeId::new(size_type_id),
                         enum_decl_id,
-                        expr,
                         val,
                     )
                 })
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
index 20e368b6e1..36af5f75e1 100644
--- a/c2rust-transpile/tests/snapshots/snapshots__transpile@enums.c.2021.clang15.snap
+++ b/c2rust-transpile/tests/snapshots/snapshots__transpile@enums.c.2021.clang15.snap
@@ -11,14 +11,14 @@ expression: cat tests/snapshots/enums.2021.clang15.rs
     unused_assignments,
     unused_mut
 )]
-#[derive(Clone, Copy)]
+#[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)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 #[repr(transparent)]
 pub struct Bar(pub ::core::ffi::c_int);
 pub const Bar3: Bar = Bar(3);
@@ -52,16 +52,15 @@ pub unsafe extern "C" fn test_enums() {
     foo = Foo(c2rust_fresh1.0 as ::core::ffi::c_uint);
     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 as ::core::ffi::c_uint) 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.0 {
-        0 | 1 | 2 | 3 | 42 | 4294967254 | _ => {}
+    match foo {
+        Foo0 | Foo(FOO1_MACRO) | Foo2 | Foo(3) | Foo(42) | Foo(4294967254) | _ => {}
     }
-    match bar.0 {
-        0 | BAR1_MACRO | 2 | 3 | -1 | 42 | -42 | _ => {}
+    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
index aa6c8dc7ef..e7139de0a9 100644
--- a/c2rust-transpile/tests/snapshots/snapshots__transpile@enums.c.2024.clang15.snap
+++ b/c2rust-transpile/tests/snapshots/snapshots__transpile@enums.c.2024.clang15.snap
@@ -12,14 +12,14 @@ expression: cat tests/snapshots/enums.2024.clang15.rs
     unused_assignments,
     unused_mut
 )]
-#[derive(Clone, Copy)]
+#[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)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 #[repr(transparent)]
 pub struct Bar(pub ::core::ffi::c_int);
 pub const Bar3: Bar = Bar(3);
@@ -53,16 +53,15 @@ pub unsafe extern "C" fn test_enums() {
     foo = Foo(c2rust_fresh1.0 as ::core::ffi::c_uint);
     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 as ::core::ffi::c_uint) 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.0 {
-        0 | 1 | 2 | 3 | 42 | 4294967254 | _ => {}
+    match foo {
+        Foo0 | Foo(FOO1_MACRO) | Foo2 | Foo(3) | Foo(42) | Foo(4294967254) | _ => {}
     }
-    match bar.0 {
-        0 | BAR1_MACRO | 2 | 3 | -1 | 42 | -42 | _ => {}
+    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 c537891706..edfdf4604a 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
@@ -17,12 +17,12 @@ extern "C" {
 }
 pub type ptrdiff_t = isize;
 pub type size_t = usize;
-#[derive(Clone, Copy)]
+#[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;
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 #[repr(transparent)]
 pub struct C2Rust_Unnamed(pub ::core::ffi::c_uint);
 pub const C: C2Rust_Unnamed = C2Rust_Unnamed(2);
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 1f8554c64c..6cf91f6e07 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
@@ -17,12 +17,12 @@ unsafe extern "C" {
 }
 pub type ptrdiff_t = isize;
 pub type size_t = usize;
-#[derive(Clone, Copy)]
+#[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;
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 #[repr(transparent)]
 pub struct C2Rust_Unnamed(pub ::core::ffi::c_uint);
 pub const C: C2Rust_Unnamed = C2Rust_Unnamed(2);
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 c41d837292..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,7 +11,7 @@ expression: cat tests/snapshots/macrocase.2021.clang15.rs
     unused_assignments,
     unused_mut
 )]
-#[derive(Clone, Copy)]
+#[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);
@@ -20,12 +20,12 @@ 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.0 {
-        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 e4cc4f1de0..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,7 +12,7 @@ expression: cat tests/snapshots/macrocase.2024.clang15.rs
     unused_assignments,
     unused_mut
 )]
-#[derive(Clone, Copy)]
+#[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);
@@ -21,12 +21,12 @@ 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.0 {
-        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@raw_keywords.c.2021.clang15.snap b/c2rust-transpile/tests/snapshots/snapshots__transpile@raw_keywords.c.2021.clang15.snap
index dc4e380e78..e4fd8f05df 100644
--- a/c2rust-transpile/tests/snapshots/snapshots__transpile@raw_keywords.c.2021.clang15.snap
+++ b/c2rust-transpile/tests/snapshots/snapshots__transpile@raw_keywords.c.2021.clang15.snap
@@ -12,7 +12,7 @@ expression: cat tests/snapshots/raw_keywords.2021.clang15.rs
     unused_mut
 )]
 pub type r#type = ::core::ffi::c_int;
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 #[repr(transparent)]
 pub struct r#as(pub ::core::ffi::c_uint);
 pub const r#await: r#as = r#as(1);
diff --git a/c2rust-transpile/tests/snapshots/snapshots__transpile@raw_keywords.c.2024.clang15.snap b/c2rust-transpile/tests/snapshots/snapshots__transpile@raw_keywords.c.2024.clang15.snap
index e73cb9436b..2b09114f40 100644
--- a/c2rust-transpile/tests/snapshots/snapshots__transpile@raw_keywords.c.2024.clang15.snap
+++ b/c2rust-transpile/tests/snapshots/snapshots__transpile@raw_keywords.c.2024.clang15.snap
@@ -13,7 +13,7 @@ expression: cat tests/snapshots/raw_keywords.2024.clang15.rs
     unused_mut
 )]
 pub type r#type = ::core::ffi::c_int;
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 #[repr(transparent)]
 pub struct r#as(pub ::core::ffi::c_uint);
 pub const r#await: r#as = r#as(1);
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 8cfbb62b5d..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,7 +14,7 @@ expression: cat tests/snapshots/records.2021.clang15.rs
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub struct AnonEnumInStruct {}
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 #[repr(transparent)]
 pub struct C2Rust_Unnamed(pub ::core::ffi::c_uint);
 pub const VALUE2: C2Rust_Unnamed = C2Rust_Unnamed(1);
@@ -42,7 +42,7 @@ pub struct InsideStruct {
 pub union AnonEnumInUnion {
     pub a: ::core::ffi::c_int,
 }
-#[derive(Clone, Copy)]
+#[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);
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 46cf4abce5..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,7 +15,7 @@ expression: cat tests/snapshots/records.2024.clang15.rs
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub struct AnonEnumInStruct {}
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 #[repr(transparent)]
 pub struct C2Rust_Unnamed(pub ::core::ffi::c_uint);
 pub const VALUE2: C2Rust_Unnamed = C2Rust_Unnamed(1);
@@ -43,7 +43,7 @@ pub struct InsideStruct {
 pub union AnonEnumInUnion {
     pub a: ::core::ffi::c_int,
 }
-#[derive(Clone, Copy)]
+#[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);
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 a8ac5f228d..70139ef5ba 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,7 +12,7 @@ expression: cat tests/snapshots/scalar_init.2021.clang15.rs
     unused_mut
 )]
 #![feature(raw_ref_op)]
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 #[repr(transparent)]
 pub struct E(pub ::core::ffi::c_uint);
 pub const A: E = E(0);
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 60ed10f771..56089d9b3f 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,7 +12,7 @@ expression: cat tests/snapshots/scalar_init.2024.clang15.rs
     unused_assignments,
     unused_mut
 )]
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 #[repr(transparent)]
 pub struct E(pub ::core::ffi::c_uint);
 pub const A: E = E(0);