Fix grouped match switch arms so scope drops run before break and guarded arms do not fall through.

Regenerate access_log and showcase C snapshots; note stale-binary pinning in adding-ion-features skill.

Author: Cod-e-Codes

.cursor/skills/adding-ion-features/SKILL.md

@@ -111,7 +111,7 @@ New builtins (channels, Vec, String, spawn) often need C runtime helpers. Keep h
 
 ## Debugging a failing stage
 
-**Stale binaries:** Rebuild `target/release/ion-compiler` (and `ion-build` when touching build code) after cgen or tc changes before `test_runner.sh` or regenerating `examples/*.c`. The harness defaults to `../target/release/ion-compiler`. Agent shells may set `CARGO_TARGET_DIR` outside the repo; override with `COMPILER=` or rebuild into `target/release/` and confirm the binary timestamp.
+**Stale binaries:** Rebuild `target/release/ion-compiler` (and `ion-build` when touching build code) after cgen or tc changes before `test_runner.sh` or regenerating `examples/*.c`. The harness defaults to `../target/release/ion-compiler`. Agent shells may set `CARGO_TARGET_DIR` outside the repo; pin it to the repo `target/` when verifying locally, or override with `COMPILER=` / `ION_BUILD=` and confirm the binary mtime.
 
 ```bash
 # See parser/tc errors

CHANGELOG.md

@@ -9,7 +9,7 @@
 - **LSP**: diagnostics, hover, completion, go-to-definition; multi-error reporting; symbol table mirroring; diagnostics cleared on close; hover fixes for `let` bindings and module-qualified calls. Contiguous `//` doc comments attached to declarations (including `pub` items) for hover.
 - **Tooling**: GitHub Actions CI (Linux and Windows), pinned toolchain (1.96.0), `test_expectations.tsv` manifest, `--version`, line-numbered errors, Cursor agent skills. Split `tc` and `cgen` into submodules. `ion-build` driver and `ion.toml` manifests (`single`/`multi`, `out_dir`, `cflags`, `ldflags`, `stdlib_paths`, `emit_in_source`); per-example manifests and `build_hello`/`build_bad_main` harness smoke tests. Shared `discover_import_config` and stdlib search paths for `ion-compiler`, `ion-build`, and LSP. Integration harness precompiles `runtime/ion_runtime.c` once per run (`RUNTIME_OBJ`). `writing-ion-code` agent skill; `creating-ion-skills` examples index lists all eight project skills. Documented checked-in `examples/*.c` codegen snapshots in README and integration-test skill; regenerated example C output. Fixed `researching-pl-literature` skill `paper-seeds` reference formatting.
 - **Docs**: README, CONTRIBUTING, ION_SPEC, and agent skills aligned on project layout, `ion-build` workflow, `emit_in_source`, stdlib import order, LSP features and limitations, `src/build/` checklists, portable Git Bash paths for `test_runner.sh`, and rebuilding release binaries before harness or example C regen (stale `target/release/ion-compiler` note).
-- **Fixes**: match rvalue codegen, `Vec` struct drops, channel codegen, parser handling of `alias::call()`, scope-drop for moved-into-call bindings, HTTP server on Windows, integration harness on Windows. Cgen return-unwind: stop marking bindings dropped after inner-branch `return` (restores outer-path drops), dedupe `_`-prefixed unused silences, mark call arguments moved at emission to avoid double-free on unwind, and unify all function returns via `emit_function_return` (including diverging rvalue `match` arms). Cgen struct field move-out neutralizes owned fields after partial move, deferred to statement end when the move is a call argument; `Vec::push` passes address of struct lvalues; non-generic enums emit before structs; tuple IR uses resolved element types and `tuple_Vec_T` mangling with compound-zero `ret_val` for tuple returns (functions and fn literals). Integer indexing and `Vec<i32>` inference in the type checker. Match rvalue arms: reject diverging arms mixed with value arms; structural control-flow analysis for arm bodies (nested `if`/`else`, `loop` without `break`, `unsafe` blocks); reject mixed diverge and value-producing paths within one arm; cgen assigns through `if`/`else` value branches. `fmt::int_to_string` uses `String::push_byte` per digit instead of per-digit `push_str` branches; integration test asserts `0`, negatives, and `int::MIN`. `int::MIN`/`int::MAX` on integer primitives; `Vec::new()`/`with_capacity()` infer `T` from a `let` type annotation. Clippy fix in `portable_source_label`. `Vec::get`/`Vec::pop`: IR infers `Option<T>` from the vector argument; cgen dereferences `&mut Vec<T>` parameters, unpacks runtime `Option` via `ion_option_from_raw`, and uses a temp for struct-returning `Vec::push`/`Vec::set` call values.
+- **Fixes**: match rvalue codegen, `Vec` struct drops, channel codegen, parser handling of `alias::call()`, scope-drop for moved-into-call bindings, HTTP server on Windows, integration harness on Windows. Cgen return-unwind: stop marking bindings dropped after inner-branch `return` (restores outer-path drops), dedupe `_`-prefixed unused silences, mark call arguments moved at emission to avoid double-free on unwind, and unify all function returns via `emit_function_return` (including diverging rvalue `match` arms). Cgen struct field move-out neutralizes owned fields after partial move, deferred to statement end when the move is a call argument; `Vec::push` passes address of struct lvalues; non-generic enums emit before structs; tuple IR uses resolved element types and `tuple_Vec_T` mangling with compound-zero `ret_val` for tuple returns (functions and fn literals). Integer indexing and `Vec<i32>` inference in the type checker. Match rvalue arms: reject diverging arms mixed with value arms; structural control-flow analysis for arm bodies (nested `if`/`else`, `loop` without `break`, `unsafe` blocks); reject mixed diverge and value-producing paths within one arm; cgen assigns through `if`/`else` value branches. `fmt::int_to_string` uses `String::push_byte` per digit instead of per-digit `push_str` branches; integration test asserts `0`, negatives, and `int::MIN`. `int::MIN`/`int::MAX` on integer primitives; `Vec::new()`/`with_capacity()` infer `T` from a `let` type annotation. Clippy fix in `portable_source_label`. `Vec::get`/`Vec::pop`: IR infers `Option<T>` from the vector argument; cgen dereferences `&mut Vec<T>` parameters, unpacks runtime `Option` via `ion_option_from_raw`, and uses a temp for struct-returning `Vec::push`/`Vec::set` call values. Grouped `match` switch arms: scope drops before the case `break` (GCC `-Wimplicit-fallthrough` under `-Werror`); guarded arms in a shared variant case break inside the guard `if` so fallback arms do not run.
 - **Examples**: `text_summary` (fixture file), `data_lib` (multi-module), `channel_worker` (flat single-file). Per-example `*.toml` manifests for `ion-build`. `http_server` accepts one client then exits (verifiable demo).
 - **Multi-file fixes**: merge private struct types for cross-module type checking; per-module C symbol prefixes in multi-file codegen (`io_print_int`); walk-up `runtime/` discovery for nested build directories. Integration tests `test_multi_struct`, `test_multi_fmt_io`. Example policy: single-file examples commit `.c` snapshots; `data_lib` multi-file keeps `.ion` only.
 

examples/access_log.c

@@ -172,7 +172,7 @@ int scan_logs(ion_sender_t ION_MAYBE_UNUSED code_tx, int ION_MAYBE_UNUSED expect
             case 1: { // ClientError
                 if ((code == 401)) {
                     auth_failures = (auth_failures + 1);
-                break;
+                    break;
                 }
                 break;
             }

examples/showcase.c

@@ -346,7 +346,7 @@ int pattern_matching_example(void) {
         case 0: { // Some
             int v = match_val_3.data.variant_0.arg0;
             if ((v == 42)) {
-            break;
+                break;
             }
             ret_val = 1;
             goto epilogue;

src/cgen/mod.rs

@@ -1431,6 +1431,29 @@ impl Codegen {
         }
     }
 
+    /// Drop owned bindings in the current scope frame without popping it.
+    /// Used when leaving a grouped `switch` arm early (guard match) before case-level cleanup.
+    fn scope_emit_top_frame_drops(&mut self) {
+        let Some(frame) = self.scope_stack.last().cloned() else {
+            return;
+        };
+        self.emit_frame_cleanup(&frame);
+        let to_drop: Vec<String> = frame
+            .bindings
+            .iter()
+            .filter(|b| !b.dropped && self.needs_drop(&b.ty))
+            .map(|b| b.name.clone())
+            .collect();
+        let Some(top) = self.scope_stack.last_mut() else {
+            return;
+        };
+        for name in to_drop {
+            if let Some(binding) = top.bindings.iter_mut().find(|b| b.name == name) {
+                binding.dropped = true;
+            }
+        }
+    }
+
     /// Assign `ret_val` (when needed), run scope unwind, and jump to the function epilogue.
     fn emit_function_return(&mut self, ret: &crate::ir::IRReturn) {
         self.write_indent();
@@ -3788,9 +3811,30 @@ impl Codegen {
                     );
                 }
                 for arm in group_arms {
-                    self.generate_match_arm_body(arm, match_result);
+                    if let Some(ref guard) = arm.guard {
+                        self.write_indent();
+                        self.write("if (");
+                        self.generate_expr(guard);
+                        self.writeln(") {");
+                        self.indent_level += 1;
+                        if let Some((result_var, result_type)) = match_result {
+                            self.emit_match_arm_result_stmts(&arm.body, result_var, result_type);
+                        } else {
+                            self.generate_block(&arm.body);
+                        }
+                        self.scope_emit_top_frame_drops();
+                        self.write_indent();
+                        self.writeln("break;");
+                        self.indent_level -= 1;
+                        self.write_indent();
+                        self.writeln("}");
+                    } else {
+                        self.generate_match_arm_body(arm, match_result, false);
+                    }
                 }
                 self.scope_emit_exit();
+                self.write_indent();
+                self.writeln("break;");
                 self.indent_level -= 1;
                 self.write_indent();
                 self.writeln("}");
@@ -3989,7 +4033,7 @@ impl Codegen {
                 self.write_indent();
                 self.writeln("default:");
                 self.indent_level += 1;
-                self.generate_match_arm_body(arm, match_result);
+                self.generate_match_arm_body(arm, match_result, true);
                 self.indent_level -= 1;
             }
             IRPattern::Binding { name } => {
@@ -4005,7 +4049,7 @@ impl Codegen {
                         type_params,
                     );
                 }
-                self.generate_match_arm_body(arm, match_result);
+                self.generate_match_arm_body(arm, match_result, true);
                 self.indent_level -= 1;
             }
             IRPattern::Variant { .. } => {
@@ -4014,7 +4058,12 @@ impl Codegen {
         }
     }
 
-    fn generate_match_arm_body(&mut self, arm: &IRMatchArm, match_result: Option<(&str, &Type)>) {
+    fn generate_match_arm_body(
+        &mut self,
+        arm: &IRMatchArm,
+        match_result: Option<(&str, &Type)>,
+        trailing_break: bool,
+    ) {
         if let Some(ref guard) = arm.guard {
             self.write_indent();
             self.write("if (");
@@ -4028,17 +4077,23 @@ impl Codegen {
             }
             self.indent_level -= 1;
             self.write_indent();
-            self.writeln("break;");
-            self.write_indent();
             self.writeln("}");
+            if trailing_break {
+                self.write_indent();
+                self.writeln("break;");
+            }
         } else if let Some((result_var, result_type)) = match_result {
             self.emit_match_arm_result_stmts(&arm.body, result_var, result_type);
-            self.write_indent();
-            self.writeln("break;");
+            if trailing_break {
+                self.write_indent();
+                self.writeln("break;");
+            }
         } else {
             self.generate_block(&arm.body);
-            self.write_indent();
-            self.writeln("break;");
+            if trailing_break {
+                self.write_indent();
+                self.writeln("break;");
+            }
         }
     }