Fix whole-enum match scrutinee move-out and add regression coverage.

Infer match enum_type from the scrutinee for binding-only arms and add a cgen unit test for emit_match_scrutinee_whole_enum_moved_out.

Author: Cod-e-Codes

.cursor/skills/finding-ion-bugs/references/bug-hotspots.md

@@ -13,7 +13,7 @@ CLI errors use `TypeCheckError` Debug form (`UseAfterMove { ... }`). LSP reforma
 ## Codegen (`src/cgen/`)
 
 - Drop order and `ion_drop_*` for moved fields
-- **Match scrutinee move-out**: pattern payload bindings null `match_val_N.data.variant_*` fields when ownership transfers (`statement_match_payload_move_neutralizes_scrutinee`); whole-enum binding arms clear active variant payloads via `emit_match_scrutinee_whole_enum_moved_out`
+- **Match scrutinee move-out**: pattern payload bindings null `match_val_N.data.variant_*` fields when ownership transfers (`statement_match_payload_move_neutralizes_scrutinee`); whole-enum binding arms clear active variant payloads via `emit_match_scrutinee_whole_enum_moved_out` (`whole_enum_binding_neutralizes_scrutinee_payloads`). IR infers `enum_type` from the scrutinee when arms use binding/wildcard only (`infer_match_enum_name`).
 - **Return unwind**: all function exits use `emit_function_return` (`ret_val`, `scope_emit_return_unwind`, `goto epilogue`), including diverging `return` inside rvalue `match` arms (`rvalue_match_divergent_return_unwinds_owned`). Value-producing rvalue arms still assign and `break` from the `switch`.
 - `Box`, `Vec`, `String` layout vs `runtime/ion_runtime.h`
 - Single-file merge (`merge_modules`) vs `--mode multi` divergences

src/cgen/mod.rs

@@ -5455,6 +5455,53 @@ fn main() -> int {
         );
     }
 
+    #[test]
+    fn whole_enum_binding_neutralizes_scrutinee_payloads() {
+        let src = r#"enum ReadResult {
+    Ok(String);
+    Err(int);
+}
+
+fn read() -> ReadResult {
+    return ReadResult::Ok("hello ion\n");
+}
+
+fn main() -> int {
+    match read() {
+        r => {
+            return 80;
+        },
+    };
+}"#;
+        let tokens = crate::lexer::Lexer::new(src).tokenize().unwrap();
+        let program = crate::parser::Parser::new(tokens).parse().unwrap();
+        let ir = crate::ir::IRBuilder::build(&program);
+        let mut cg = Codegen::new();
+        let c = cg.generate(&ir, "test.ion");
+        let binding_arm = c
+            .split("default: // binding r")
+            .nth(1)
+            .and_then(|tail| tail.split("goto epilogue;").next())
+            .unwrap_or("");
+        assert!(
+            binding_arm.contains("ReadResult r = match_val_0;"),
+            "expected whole-enum binding copy in:\n{c}"
+        );
+        assert!(
+            binding_arm.contains("switch (match_val_0.tag)"),
+            "expected scrutinee tag switch for whole-enum move-out in:\n{c}"
+        );
+        assert!(
+            binding_arm.contains("case 0:")
+                && binding_arm.contains("match_val_0.data.variant_0.arg0 = NULL"),
+            "expected Ok string payload nulled in scrutinee switch in:\n{c}"
+        );
+        assert!(
+            !binding_arm.contains("ion_string_free(match_val_0"),
+            "expected no direct scrutinee string drop in:\n{c}"
+        );
+    }
+
     #[test]
     fn rvalue_match_divergent_return_unwinds_owned() {
         let src = r#"enum E {

src/ir/mod.rs

@@ -254,6 +254,36 @@ fn pattern_to_ir(pattern: &Pattern) -> IRPattern {
     }
 }
 
+fn enum_name_from_type(ty: &Type) -> Option<String> {
+    match ty {
+        // Parser stores user type names as Struct until tc; enums share the same name.
+        Type::Enum(name) | Type::Struct(name) => Some(name.clone()),
+        Type::Generic { name, .. } => Some(name.clone()),
+        _ => None,
+    }
+}
+
+fn infer_match_enum_name(expr: &Expr, ctx: &LoweringContext) -> Option<String> {
+    if let Expr::EnumLit(lit) = expr {
+        return Some(lit.enum_name.clone());
+    }
+    if let Some(ty) = ctx.resolve_expr_type(expr)
+        && let Some(name) = enum_name_from_type(&ty)
+    {
+        return Some(name);
+    }
+    if let Expr::Call(call) = expr
+        && let Some(ret) = ctx
+            .function_returns
+            .get(&call.callee)
+            .and_then(|r| r.clone())
+        && let Some(name) = enum_name_from_type(&ret)
+    {
+        return Some(name);
+    }
+    None
+}
+
 #[derive(Debug, Clone)]
 pub enum IRPattern {
     Variant {
@@ -893,6 +923,7 @@ fn build_expr_with_ctx(expr: &Expr, ctx: &LoweringContext) -> IREexpr {
                     Pattern::Variant { enum_name, .. } => Some(enum_name.clone()),
                     _ => None,
                 })
+                .or_else(|| infer_match_enum_name(&match_expr.expr, ctx))
                 .unwrap_or_else(|| "Unknown".to_string());
 
             IREexpr::Match {