@ball-lang/compiler 1.19.0 → 1.19.2

package/dist/compiler.d.ts

@@ -61,6 +61,28 @@ export declare class BallCompiler {
      * rather than silently emitting invalid or wrong-behaving TS.
      */
     private activeGotoLabels;
+    /**
+     * Stack of enclosing *goto-switch* lowerings (see `emitGotoSwitchStmt`). A
+     * Ball `switch` with labelled cases (`case 0: continue one; one: case 1: …`)
+     * is Dart's goto-via-switch: `continue <caseLabel>` transfers control to that
+     * case's body with NO subject re-check. TS has no labelled switch cases, so
+     * such a switch lowers to a `<loopLabel>: while (…) switch (<stateVar>) { … }`
+     * state machine; a `continue <caseLabel>` inside a case body becomes
+     * `<stateVar> = <armIndex>; continue <loopLabel>;`. `labelToIndex` maps each
+     * case label to its arm index, `depth` records `loopNest` at the case-body
+     * level (so an unlabeled `break`/`continue` inside a *nested* loop is left
+     * verbatim for that loop rather than hijacked into the switch's own loop).
+     */
+    private switchLabelStack;
+    /**
+     * Count of enclosing break/continue-capturing scopes (loops + switches)
+     * currently open during body emission. Consulted only when a
+     * `switchLabelStack` entry is active, to tell a case-body-level break from a
+     * nested-loop break (see `switchLabelStack`).
+     */
+    private loopNest;
+    /** Monotonic id for uniquely naming goto-switch loop labels / state vars. */
+    private switchUid;
     constructor(program: Program);
     /** Compile to TS source. */
     compile(options?: CompileOptions): string;
@@ -119,6 +141,58 @@ export declare class BallCompiler {
     private emitStatement;
     private isControlFlow;
     private emitControlFlowStatement;
+    /**
+     * Parse a switch's `cases[]` into if/else-chain arms, merging empty-body
+     * fall-through cases (`case 'a': case 'b': body`) into the following arm via
+     * `||`. Also records `label → arm index` for labelled cases so a
+     * goto-via-switch (`emitGotoSwitchStmt`) can jump between arms; a label on an
+     * empty fall-through case maps to the arm that absorbs it (jumping there and
+     * immediately falling through are equivalent). Conditions reference the
+     * subject as `__sw`, so callers must bind `const __sw = <subject>`.
+     */
+    private parseSwitchCases;
+    /**
+     * Lower a goto-via-switch (a Ball `switch` with labelled cases) to a
+     * state-machine loop. TS has no labelled switch cases, so
+     *
+     *   switch (s) { case 0: …; continue one; one: case 1: …; break; default: … }
+     *
+     * becomes
+     *
+     *   { const __sw = s; let __swst = -1;
+     *     if (__sw === 0) __swst = 0; else if (__sw === 1) __swst = 1;
+     *     if (__swst === -1) __swst = <default arm>;
+     *     __swl: while (__swst >= 0) { switch (__swst) {
+     *       case 0: { …; __swst = 1; continue __swl; }   // continue one → arm 1
+     *       case 1: { …; break __swl; }
+     *       case <default>: { …; break __swl; }
+     *     } break __swl; } }
+     *
+     * Phase 1 picks the entry arm by matching the subject (default only if
+     * nothing matched); phase 2 runs from that arm, where a `continue <label>`
+     * inside a body re-enters the loop at the labelled arm with NO subject
+     * re-check (see the `break`/`continue` cases in `emitControlFlowStatement`).
+     * A body that falls off its arm exits via the trailing `break __swl`.
+     *
+     * Known limitation: pattern bindings are recomputed from `__sw` on each arm
+     * (so a goto INTO a case with different bindings would rebind from the
+     * subject rather than leave them unbound as the reference engine does) — not
+     * reachable from valid Dart, where a `continue` target can't use a preceding
+     * case's binders.
+     */
+    private emitGotoSwitchStmt;
+    /** A switch arm's pattern bindings (`case int n`, `case {'k': var v}`, …),
+     *  read off the subject alias `__sw`. Shared by the if/else-chain and
+     *  goto-switch lowerings. */
+    private switchArmBindings;
+    /**
+     * A switch arm's match condition over `__sw`, folding a `when` guard in. The
+     * guard runs inside an IIFE bound to the pattern variables, gated by the
+     * match condition via `&&` (so it only runs once the pattern matched and the
+     * temps are valid); its binders are passed positionally, the guard expression
+     * itself untouched. Shared by the if/else-chain and goto-switch lowerings.
+     */
+    private buildSwitchArmCond;
     private emitIfStmt;
     private emitForStmt;
     private emitForInStmt;

package/dist/compiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compiler.d.ts","sourceRoot":"","sources":["../src/compiler.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"compiler.d.ts","sourceRoot":"","sources":["../src/compiler.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAMV,MAAM,EACN,OAAO,EAIR,MAAM,YAAY,CAAC;AAGpB,MAAM,WAAW,cAAc;IAC7B,2EAA2E;IAC3E,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,sEAAsE;IACtE,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAQD,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;IAElC,+CAA+C;IAC/C,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,KAAK,CAAK;IAElB,4EAA4E;IAC5E,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAqB;IAE/C,sEAAsE;IACtE,OAAO,CAAC,YAAY,CAA0B;IAE9C,mEAAmE;IACnE,OAAO,CAAC,kBAAkB,CAA0B;IAEpD,mEAAmE;IACnE,OAAO,CAAC,mBAAmB,CAA0B;IAErD,0EAA0E;IAC1E,OAAO,CAAC,uBAAuB,CAA0B;IAEzD;0EACsE;IACtE,OAAO,CAAC,uBAAuB,CAA0B;IAEzD;;;;OAIG;IACH,OAAO,CAAC,uBAAuB,CAA0B;IAEzD,8EAA8E;IAC9E,OAAO,CAAC,gBAAgB,CAAqB;IAE7C,8EAA8E;IAC9E,OAAO,CAAC,sBAAsB,CAA0B;IAExD,yEAAyE;IACzE,OAAO,CAAC,gBAAgB,CAA0B;IAElD,4DAA4D;IAC5D,OAAO,CAAC,aAAa,CAA0C;IAE/D;;;OAGG;IACH,OAAO,CAAC,iBAAiB,CAA0B;IAEnD;;;;;OAKG;IACH,OAAO,CAAC,WAAW,CAA6B;IAEhD;;;;;;;;;;OAUG;IACH,OAAO,CAAC,gBAAgB,CAAgB;IAExC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,gBAAgB,CAKhB;IAER;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAAK;IAErB,6EAA6E;IAC7E,OAAO,CAAC,SAAS,CAAK;gBAEV,OAAO,EAAE,OAAO;IAI5B,4BAA4B;IAC5B,OAAO,CAAC,OAAO,GAAE,cAAmB,GAAG,MAAM;IAkrE7C,OAAO,CAAC,gBAAgB;IAgDxB;;;;OAIG;IACH,OAAO,CAAC,QAAQ;IAUhB,wEAAwE;IACxE,OAAO,CAAC,iBAAiB;IAoBzB;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;IAmBrB,OAAO,CAAC,SAAS;IA8NjB,OAAO,CAAC,SAAS;IAqGjB;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IA0BtB;;;;OAIG;IACH,OAAO,CAAC,cAAc;IA4FtB,OAAO,CAAC,WAAW;IA0BnB,OAAO,CAAC,WAAW;IAiBnB,OAAO,CAAC,WAAW;IAoBnB,OAAO,CAAC,WAAW;IAcnB,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,iBAAiB;IAmBzB,OAAO,CAAC,yBAAyB;IAoBjC,OAAO,CAAC,SAAS;IA6BjB;;;OAGG;IACH,OAAO,CAAC,cAAc;IAStB;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IAiB9B,OAAO,CAAC,aAAa;IAsErB,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,wBAAwB;IA8IhC;;;;;;;;OAQG;IACH,OAAO,CAAC,gBAAgB;IAuGxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,OAAO,CAAC,kBAAkB;IA8D1B;;iCAE6B;IAC7B,OAAO,CAAC,iBAAiB;IAOzB;;;;;;OAMG;IACH,OAAO,CAAC,kBAAkB;IAc1B,OAAO,CAAC,UAAU;IAiBlB,OAAO,CAAC,WAAW;IAmDnB,OAAO,CAAC,aAAa;IAarB,OAAO,CAAC,aAAa;IAYrB;;;;;;;;;OASG;IACH,OAAO,CAAC,aAAa;IAkBrB,sEAAsE;IACtE,OAAO,CAAC,YAAY;IAcpB,OAAO,CAAC,eAAe;IAYvB,OAAO,CAAC,WAAW;IAyGnB,OAAO,CAAC,cAAc;IAyBtB;;;;OAIG;IACH,OAAO,CAAC,0BAA0B;IAsBlC;;;;;;;;OAQG;IACH,OAAO,CAAC,UAAU;IAWlB,OAAO,CAAC,mBAAmB;IA6B3B;;;;OAIG;IACH,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,IAAI;IAuDZ,OAAO,CAAC,cAAc;IAqCtB,OAAO,CAAC,0BAA0B;IAWlC,2DAA2D;IAC3D,OAAO,CAAC,mBAAmB;IAU3B,0DAA0D;IAC1D,OAAO,CAAC,kBAAkB;IAU1B;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB;IAmB1B,2EAA2E;IAC3E,OAAO,CAAC,YAAY;IAUpB;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IAkF7B;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;IAsBrB,OAAO,CAAC,kBAAkB;IA6C1B,OAAO,CAAC,sBAAsB;IAqI9B,OAAO,CAAC,yBAAyB;IAqBjC,OAAO,CAAC,sBAAsB;IAI9B,OAAO,CAAC,sBAAsB;IAe9B,OAAO,CAAC,aAAa;IA6BrB,OAAO,CAAC,WAAW;IAmGnB,OAAO,CAAC,cAAc;IAq8BtB,OAAO,CAAC,iBAAiB;IAoJzB,OAAO,CAAC,mBAAmB;IAU3B,OAAO,CAAC,gBAAgB;IAOxB,OAAO,CAAC,WAAW;IA2CnB,OAAO,CAAC,YAAY;IAUpB,OAAO,CAAC,iBAAiB;IA0FzB;;;;;;OAMG;IACH,OAAO,CAAC,gBAAgB;IAqBxB,OAAO,CAAC,iBAAiB;IAiCzB,OAAO,CAAC,iBAAiB;IAUzB,OAAO,CAAC,YAAY;CAgDrB;AAo6BD,+CAA+C;AAC/C,wBAAgB,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,CAE1E;AAMD,MAAM,WAAW,oBAAoB;IACnC,2EAA2E;IAC3E,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,sEAAsE;IACtE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,MAAM,CA+HpF"}

package/dist/compiler.js

@@ -70,6 +70,28 @@ export class BallCompiler {
      * rather than silently emitting invalid or wrong-behaving TS.
      */
     activeGotoLabels = [];
+    /**
+     * Stack of enclosing *goto-switch* lowerings (see `emitGotoSwitchStmt`). A
+     * Ball `switch` with labelled cases (`case 0: continue one; one: case 1: …`)
+     * is Dart's goto-via-switch: `continue <caseLabel>` transfers control to that
+     * case's body with NO subject re-check. TS has no labelled switch cases, so
+     * such a switch lowers to a `<loopLabel>: while (…) switch (<stateVar>) { … }`
+     * state machine; a `continue <caseLabel>` inside a case body becomes
+     * `<stateVar> = <armIndex>; continue <loopLabel>;`. `labelToIndex` maps each
+     * case label to its arm index, `depth` records `loopNest` at the case-body
+     * level (so an unlabeled `break`/`continue` inside a *nested* loop is left
+     * verbatim for that loop rather than hijacked into the switch's own loop).
+     */
+    switchLabelStack = [];
+    /**
+     * Count of enclosing break/continue-capturing scopes (loops + switches)
+     * currently open during body emission. Consulted only when a
+     * `switchLabelStack` entry is active, to tell a case-body-level break from a
+     * nested-loop break (see `switchLabelStack`).
+     */
+    loopNest = 0;
+    /** Monotonic id for uniquely naming goto-switch loop labels / state vars. */
+    switchUid = 0;
     constructor(program) {
         this.program = program;
     }
@@ -2752,12 +2774,43 @@ function __isUnknownFnError(e: any): boolean {
             }
             case "break": {
                 const label = stringField(call, "label");
-                this.writeln(label ? `break ${label};` : "break;");
+                if (label) {
+                    // A labelled break targets an enclosing labelled loop, never a
+                    // switch case — emit verbatim.
+                    this.writeln(`break ${label};`);
+                }
+                else {
+                    // An unlabeled break directly inside a goto-switch case body exits
+                    // the switch (its lowered state-machine loop). Inside a *nested* loop
+                    // it belongs to that loop, so leave it verbatim (see switchLabelStack).
+                    const ctx = this.switchLabelStack[this.switchLabelStack.length - 1];
+                    this.writeln(ctx && this.loopNest === ctx.depth ? `break ${ctx.loopLabel};` : "break;");
+                }
                 break;
             }
             case "continue": {
                 const label = stringField(call, "label");
-                this.writeln(label ? `continue ${label};` : "continue;");
+                if (label) {
+                    // `continue <caseLabel>` naming a labelled case of an enclosing
+                    // goto-switch is a goto: jump to that case's arm with no subject
+                    // re-check (innermost matching switch wins). Any other label targets
+                    // an enclosing labelled loop and is emitted verbatim.
+                    let handled = false;
+                    for (let i = this.switchLabelStack.length - 1; i >= 0; i--) {
+                        const ctx = this.switchLabelStack[i];
+                        const idx = ctx.labelToIndex.get(label);
+                        if (idx !== undefined) {
+                            this.writeln(`${ctx.stateVar} = ${idx}; continue ${ctx.loopLabel};`);
+                            handled = true;
+                            break;
+                        }
+                    }
+                    if (!handled)
+                        this.writeln(`continue ${label};`);
+                }
+                else {
+                    this.writeln("continue;");
+                }
                 break;
             }
             case "labeled": {
@@ -2803,122 +2856,26 @@ function __isUnknownFnError(e: any): boolean {
                     break;
                 }
                 const subjectStr = this.expr(subjectExpr);
+                const caseExprs = casesField.literal?.listValue?.elements ?? [];
+                const parsed = this.parseSwitchCases(caseExprs);
+                // A switch whose cases carry labels (`case 0: continue one; one: case
+                // 1: …`) is Dart's goto-via-switch — lower it to a state machine so
+                // `continue <caseLabel>` can jump between arms. Plain switches keep the
+                // if/else-chain (zero change for the non-labelled common case).
+                if (parsed.labelToArmIndex.size > 0) {
+                    this.emitGotoSwitchStmt(subjectStr, parsed);
+                    break;
+                }
+                const { parsedCases, defaultBody } = parsed;
+                let first = true;
                 // Wrap in do-while(false) so case `break;` exits the switch,
                 // not an enclosing for loop (switch is compiled as if/else chain).
                 this.writeln(`do { const __sw = ${subjectStr};`);
                 this.depth++;
-                const caseExprs = casesField.literal?.listValue?.elements ?? [];
-                let defaultBody;
-                let first = true;
-                // Parse all cases, detecting fall-through (empty body = merge
-                // with next case via ||).
-                const parsedCases = [];
-                const pendingConds = [];
-                let lastPatText;
-                for (const ce of caseExprs) {
-                    if (!ce.messageCreation)
-                        continue;
-                    let pattern;
-                    let body;
-                    let isDefaultFlag = false;
-                    let patternExprField;
-                    let guardField;
-                    for (const fd of ce.messageCreation.fields ?? []) {
-                        if (fd.name === "pattern")
-                            pattern = fd.value;
-                        if (fd.name === "body")
-                            body = fd.value;
-                        if (fd.name === "is_default" && fd.value?.literal?.boolValue === true)
-                            isDefaultFlag = true;
-                        if (fd.name === "pattern_expr")
-                            patternExprField = fd.value;
-                        if (fd.name === "guard")
-                            guardField = fd.value;
-                    }
-                    // Check for is_default flag
-                    if (isDefaultFlag) {
-                        defaultBody = body;
-                        continue;
-                    }
-                    // Handle structured pattern_expr (only for known pattern kinds)
-                    if (patternExprField) {
-                        const result = compileStructuredPattern(patternExprField, "__sw", (e) => this.expr(e));
-                        if (result) {
-                            const cond = result.condition;
-                            // A catch-all with no guard ends the chain; with a guard the
-                            // branch stays refutable (a false guard falls through).
-                            if (cond === "true" && !guardField) {
-                                defaultBody = body;
-                                break;
-                            }
-                            const isEmpty = body && body.block &&
-                                (body.block.statements ?? []).length === 0 &&
-                                body.block.result === undefined;
-                            if (!guardField && (!body || isEmpty)) {
-                                pendingConds.push(cond);
-                                continue;
-                            }
-                            pendingConds.push(cond);
-                            parsedCases.push({ conds: [...pendingConds], body, structuredBindings: result.bindings, guard: guardField });
-                            pendingConds.length = 0;
-                            continue;
-                        }
-                        // Unknown pattern kind -- fall through to text-based pattern handling
-                    }
-                    if (!pattern) {
-                        defaultBody = body;
-                        continue;
-                    }
-                    const patText = patternLiteralText(pattern);
-                    const cond = patText !== undefined
-                        ? patternToTsCondition(patText, "__sw")
-                        : `((__sw) === ${this.expr(pattern)})`;
-                    if (cond === "true" && !guardField) {
-                        defaultBody = body;
-                        break;
-                    }
-                    // Empty body = fall-through: accumulate conditions.
-                    const isEmpty = body && body.block &&
-                        (body.block.statements ?? []).length === 0 &&
-                        body.block.result === undefined;
-                    if (!guardField && (!body || isEmpty)) {
-                        pendingConds.push(cond);
-                        lastPatText = patText;
-                        continue;
-                    }
-                    pendingConds.push(cond);
-                    parsedCases.push({ conds: [...pendingConds], body, patText: patText ?? lastPatText, guard: guardField });
-                    pendingConds.length = 0;
-                    lastPatText = undefined;
-                }
+                this.loopNest++;
                 for (const pc of parsedCases) {
-                    // Gather this case's pattern bindings.
-                    const caseBindings = [];
-                    if (pc.structuredBindings)
-                        caseBindings.push(...pc.structuredBindings);
-                    if (pc.patText)
-                        caseBindings.push(...patternBindings(pc.patText, "__sw"));
-                    // When a `when` guard is present the bindings must be visible to the
-                    // guard, which is part of the `if` condition. Hoist them to temps
-                    // BEFORE the `if` (so the guard can read them) and reference the temps
-                    // inside. Without this, an entered `if` block swallows the arm and
-                    // later cases never get tested when the guard is false.
-                    let combinedCond = pc.conds.join(" || ");
-                    if (pc.guard) {
-                        // Evaluate the guard inside an IIFE bound to the pattern variables,
-                        // gated by the match condition via `&&` (so the IIFE only runs when
-                        // the pattern matched and the temps are valid). The guard's binders
-                        // are passed positionally; the guard expression itself is untouched.
-                        const matchCond = `(${pc.conds.join(" || ")})`;
-                        if (caseBindings.length > 0) {
-                            const params = caseBindings.map(b => b.varName).join(", ");
-                            const args = caseBindings.map(b => b.expr).join(", ");
-                            combinedCond = `${matchCond} && ((${params}) => (${this.expr(pc.guard)}))(${args})`;
-                        }
-                        else {
-                            combinedCond = `${matchCond} && (${this.expr(pc.guard)})`;
-                        }
-                    }
+                    const caseBindings = this.switchArmBindings(pc);
+                    const combinedCond = this.buildSwitchArmCond(pc, caseBindings);
                     const kw = first ? "if" : "else if";
                     this.writeln(`${kw} (${combinedCond}) {`);
                     this.depth++;
@@ -2942,12 +2899,254 @@ function __isUnknownFnError(e: any): boolean {
                         this.writeln("}");
                     }
                 }
+                this.loopNest--;
                 this.depth--;
                 this.writeln("} while (false);");
                 break;
             }
         }
     }
+    /**
+     * Parse a switch's `cases[]` into if/else-chain arms, merging empty-body
+     * fall-through cases (`case 'a': case 'b': body`) into the following arm via
+     * `||`. Also records `label → arm index` for labelled cases so a
+     * goto-via-switch (`emitGotoSwitchStmt`) can jump between arms; a label on an
+     * empty fall-through case maps to the arm that absorbs it (jumping there and
+     * immediately falling through are equivalent). Conditions reference the
+     * subject as `__sw`, so callers must bind `const __sw = <subject>`.
+     */
+    parseSwitchCases(caseExprs) {
+        const parsedCases = [];
+        const labelToArmIndex = new Map();
+        let defaultBody;
+        // Labels waiting to be bound to the arm that absorbs them (labels on empty
+        // fall-through cases, and the label of a non-empty case, both attach when
+        // that case's arm is pushed). Labels pending when `default` is reached bind
+        // to the default arm.
+        const pendingConds = [];
+        const pendingLabels = [];
+        const defaultLabels = [];
+        let lastPatText;
+        // Push the current arm, binding any labels accumulated for it.
+        const pushArm = (arm) => {
+            const armIndex = parsedCases.length;
+            for (const l of pendingLabels)
+                labelToArmIndex.set(l, armIndex);
+            pendingLabels.length = 0;
+            parsedCases.push(arm);
+        };
+        // Record the default arm's body and drain any labels accumulated up to it
+        // (a `continue <label>` naming a labelled case that falls into `default`
+        // jumps to the default arm).
+        const markDefault = (b) => {
+            defaultBody = b;
+            defaultLabels.push(...pendingLabels);
+            pendingLabels.length = 0;
+        };
+        for (const ce of caseExprs) {
+            if (!ce.messageCreation)
+                continue;
+            let pattern;
+            let body;
+            let isDefaultFlag = false;
+            let patternExprField;
+            let guardField;
+            let caseLabel;
+            for (const fd of ce.messageCreation.fields ?? []) {
+                if (fd.name === "pattern")
+                    pattern = fd.value;
+                if (fd.name === "body")
+                    body = fd.value;
+                if (fd.name === "is_default" && fd.value?.literal?.boolValue === true)
+                    isDefaultFlag = true;
+                if (fd.name === "pattern_expr")
+                    patternExprField = fd.value;
+                if (fd.name === "guard")
+                    guardField = fd.value;
+                if (fd.name === "label") {
+                    const l = fd.value?.literal?.stringValue;
+                    if (l)
+                        caseLabel = l;
+                }
+            }
+            if (caseLabel)
+                pendingLabels.push(caseLabel);
+            // Check for is_default flag
+            if (isDefaultFlag) {
+                markDefault(body);
+                continue;
+            }
+            // Handle structured pattern_expr (only for known pattern kinds)
+            if (patternExprField) {
+                const result = compileStructuredPattern(patternExprField, "__sw", (e) => this.expr(e));
+                if (result) {
+                    const cond = result.condition;
+                    // A catch-all with no guard ends the chain; with a guard the
+                    // branch stays refutable (a false guard falls through).
+                    if (cond === "true" && !guardField) {
+                        markDefault(body);
+                        break;
+                    }
+                    const isEmpty = body && body.block &&
+                        (body.block.statements ?? []).length === 0 &&
+                        body.block.result === undefined;
+                    if (!guardField && (!body || isEmpty)) {
+                        pendingConds.push(cond);
+                        continue;
+                    }
+                    pendingConds.push(cond);
+                    pushArm({ conds: [...pendingConds], body, structuredBindings: result.bindings, guard: guardField });
+                    pendingConds.length = 0;
+                    continue;
+                }
+                // Unknown pattern kind -- fall through to text-based pattern handling
+            }
+            if (!pattern) {
+                markDefault(body);
+                continue;
+            }
+            const patText = patternLiteralText(pattern);
+            const cond = patText !== undefined
+                ? patternToTsCondition(patText, "__sw")
+                : `((__sw) === ${this.expr(pattern)})`;
+            if (cond === "true" && !guardField) {
+                markDefault(body);
+                break;
+            }
+            // Empty body = fall-through: accumulate conditions.
+            const isEmpty = body && body.block &&
+                (body.block.statements ?? []).length === 0 &&
+                body.block.result === undefined;
+            if (!guardField && (!body || isEmpty)) {
+                pendingConds.push(cond);
+                lastPatText = patText;
+                continue;
+            }
+            pendingConds.push(cond);
+            pushArm({ conds: [...pendingConds], body, patText: patText ?? lastPatText, guard: guardField });
+            pendingConds.length = 0;
+            lastPatText = undefined;
+        }
+        const defaultArmIndex = defaultBody !== undefined ? parsedCases.length : -1;
+        if (defaultArmIndex >= 0) {
+            for (const l of defaultLabels)
+                labelToArmIndex.set(l, defaultArmIndex);
+        }
+        return { parsedCases, defaultBody, labelToArmIndex, defaultArmIndex };
+    }
+    /**
+     * Lower a goto-via-switch (a Ball `switch` with labelled cases) to a
+     * state-machine loop. TS has no labelled switch cases, so
+     *
+     *   switch (s) { case 0: …; continue one; one: case 1: …; break; default: … }
+     *
+     * becomes
+     *
+     *   { const __sw = s; let __swst = -1;
+     *     if (__sw === 0) __swst = 0; else if (__sw === 1) __swst = 1;
+     *     if (__swst === -1) __swst = <default arm>;
+     *     __swl: while (__swst >= 0) { switch (__swst) {
+     *       case 0: { …; __swst = 1; continue __swl; }   // continue one → arm 1
+     *       case 1: { …; break __swl; }
+     *       case <default>: { …; break __swl; }
+     *     } break __swl; } }
+     *
+     * Phase 1 picks the entry arm by matching the subject (default only if
+     * nothing matched); phase 2 runs from that arm, where a `continue <label>`
+     * inside a body re-enters the loop at the labelled arm with NO subject
+     * re-check (see the `break`/`continue` cases in `emitControlFlowStatement`).
+     * A body that falls off its arm exits via the trailing `break __swl`.
+     *
+     * Known limitation: pattern bindings are recomputed from `__sw` on each arm
+     * (so a goto INTO a case with different bindings would rebind from the
+     * subject rather than leave them unbound as the reference engine does) — not
+     * reachable from valid Dart, where a `continue` target can't use a preceding
+     * case's binders.
+     */
+    emitGotoSwitchStmt(subjectStr, parsed) {
+        const { parsedCases, defaultBody, labelToArmIndex, defaultArmIndex } = parsed;
+        const uid = this.switchUid++;
+        const loopLabel = `__swl${uid}`;
+        const stateVar = `__swst${uid}`;
+        this.writeln("{");
+        this.depth++;
+        this.writeln(`const __sw = ${subjectStr};`);
+        this.writeln(`let ${stateVar} = -1;`);
+        // Phase 1 — entry arm selection (non-default arms, in order).
+        let first = true;
+        for (let i = 0; i < parsedCases.length; i++) {
+            const pc = parsedCases[i];
+            const combinedCond = this.buildSwitchArmCond(pc, this.switchArmBindings(pc));
+            this.writeln(`${first ? "if" : "else if"} (${combinedCond}) { ${stateVar} = ${i}; }`);
+            first = false;
+        }
+        if (defaultArmIndex >= 0) {
+            this.writeln(`if (${stateVar} === -1) ${stateVar} = ${defaultArmIndex};`);
+        }
+        // Phase 2 — run from the entry arm, honoring goto/break.
+        this.writeln(`${loopLabel}: while (${stateVar} >= 0) {`);
+        this.depth++;
+        this.writeln(`switch (${stateVar}) {`);
+        this.depth++;
+        this.switchLabelStack.push({ loopLabel, stateVar, labelToIndex: labelToArmIndex, depth: this.loopNest + 1 });
+        this.loopNest++;
+        const emitArm = (idx, body, bindings) => {
+            this.writeln(`case ${idx}: {`);
+            this.depth++;
+            for (const b of bindings)
+                this.writeln(`const ${b.varName} = ${b.expr};`);
+            if (body)
+                this.emitStatementOrExpression(body, false);
+            // A body that falls off its arm (or an inner `break` that exited a nested
+            // loop) ends the switch — arms never fall through to the next.
+            this.writeln(`break ${loopLabel};`);
+            this.depth--;
+            this.writeln("}");
+        };
+        for (let i = 0; i < parsedCases.length; i++) {
+            emitArm(i, parsedCases[i].body, this.switchArmBindings(parsedCases[i]));
+        }
+        if (defaultArmIndex >= 0)
+            emitArm(defaultArmIndex, defaultBody, []);
+        this.loopNest--;
+        this.switchLabelStack.pop();
+        this.depth--;
+        this.writeln("}");
+        this.writeln(`break ${loopLabel};`);
+        this.depth--;
+        this.writeln("}");
+        this.depth--;
+        this.writeln("}");
+    }
+    /** A switch arm's pattern bindings (`case int n`, `case {'k': var v}`, …),
+     *  read off the subject alias `__sw`. Shared by the if/else-chain and
+     *  goto-switch lowerings. */
+    switchArmBindings(pc) {
+        const b = [];
+        if (pc.structuredBindings)
+            b.push(...pc.structuredBindings);
+        if (pc.patText)
+            b.push(...patternBindings(pc.patText, "__sw"));
+        return b;
+    }
+    /**
+     * A switch arm's match condition over `__sw`, folding a `when` guard in. The
+     * guard runs inside an IIFE bound to the pattern variables, gated by the
+     * match condition via `&&` (so it only runs once the pattern matched and the
+     * temps are valid); its binders are passed positionally, the guard expression
+     * itself untouched. Shared by the if/else-chain and goto-switch lowerings.
+     */
+    buildSwitchArmCond(pc, caseBindings) {
+        if (!pc.guard)
+            return pc.conds.join(" || ");
+        const matchCond = `(${pc.conds.join(" || ")})`;
+        if (caseBindings.length > 0) {
+            const params = caseBindings.map(b => b.varName).join(", ");
+            const args = caseBindings.map(b => b.expr).join(", ");
+            return `${matchCond} && ((${params}) => (${this.expr(pc.guard)}))(${args})`;
+        }
+        return `${matchCond} && (${this.expr(pc.guard)})`;
+    }
     emitIfStmt(call) {
         const cond = field(call, "condition");
         const then_ = field(call, "then");
@@ -3014,8 +3213,10 @@ function __isUnknownFnError(e: any): boolean {
         const updateStr = update ? this.expr(unwrapLambda(update)) : "";
         this.writeln(`for (${initStr}; ${condStr}; ${updateStr}) {`);
         this.depth++;
+        this.loopNest++;
         if (body)
             this.emitStatementOrExpression(unwrapLambda(body), false);
+        this.loopNest--;
         this.depth--;
         this.writeln(`}`);
     }
@@ -3025,8 +3226,10 @@ function __isUnknownFnError(e: any): boolean {
         const body = field(call, "body");
         this.writeln(`for (const ${variable} of ${this.expr(iterable)}) {`);
         this.depth++;
+        this.loopNest++;
         if (body)
             this.emitStatementOrExpression(unwrapLambda(body), false);
+        this.loopNest--;
         this.depth--;
         this.writeln(`}`);
     }
@@ -3035,8 +3238,10 @@ function __isUnknownFnError(e: any): boolean {
         const body = field(call, "body");
         this.writeln(`while (${this.expr(unwrapLambda(cond))}) {`);
         this.depth++;
+        this.loopNest++;
         if (body)
             this.emitStatementOrExpression(unwrapLambda(body), false);
+        this.loopNest--;
         this.depth--;
         this.writeln(`}`);
     }
@@ -3059,7 +3264,9 @@ function __isUnknownFnError(e: any): boolean {
         this.activeGotoLabels.push(name);
         this.writeln(`${name}: while (true) {`);
         this.depth++;
+        this.loopNest++;
         this.emitStatementOrExpression(body, false);
+        this.loopNest--;
         this.writeln(`break ${name};`);
         this.depth--;
         this.writeln(`}`);
@@ -3083,8 +3290,10 @@ function __isUnknownFnError(e: any): boolean {
         const body = field(call, "body");
         this.writeln(`do {`);
         this.depth++;
+        this.loopNest++;
         if (body)
             this.emitStatementOrExpression(unwrapLambda(body), false);
+        this.loopNest--;
         this.depth--;
         this.writeln(`} while (${this.expr(unwrapLambda(cond))});`);
     }