fix(transform): #5868 — switch inside async/generator state machines miscompiled

Two defects, one shared fix:

1. yield/await inside a case body was silently lowered to 0: the
   linearizer had no Stmt::Switch arm, so the switch fell to the
   catch-all, was emitted unsplit inside one state, and codegen's
   fallback lowered the residual Expr::Yield to 0.0. async f(x){
   switch(x){ case 1: return await g() } } resolved to 0 without
   suspending; a generator yield inside a case vanished.

2. a loop-level continue inside a yield-free switch in a CPS'd loop
   survived as a raw Stmt::Continue the dispatch loop ignored, so the
   iteration's remainder ran anyway.

New desugar_switch_to_ifs (break_continue.rs): discriminant temp +
match-index + guarded-if chain preserving JS switch semantics
(single-eval discriminant, in-order first-match-wins tests, fallthrough,
default-in-the-middle, break — incl. from nested if/try — via done-flag
with remainder guarding). Wired into (a) a new yielding-switch arm in
linearize_body, (b) a splice in rewrite_break_continue_in_stmts for
continue-bearing yield-free switches (next_local_id threaded through),
and (c) the labeled arm maps 'break label' to plain break inside a
labeled switch's cases.

e2e: crates/perry/tests/issue_5868_switch_state_machine.rs (9 scenarios
byte-for-byte vs node --experimental-strip-types).
cargo test -p perry-transform: 45 passed.

Author: Ralph Küpper

crates/perry-transform/src/generator/break_continue.rs

@@ -17,9 +17,18 @@ const CONTINUE_SENTINEL: f64 = 1_000_002.0;
 /// into `[LocalSet(state_id, <sentinel>), Stmt::Continue]`. The trailing
 /// `Stmt::Continue` is the state-machine's dispatch-loop continue, which
 /// re-enters the while(true) and re-dispatches on the new state. Stops at
-/// nested loop / switch / closure boundaries — their own break/continue
-/// belong to those constructs, not to us.
-pub fn rewrite_break_continue_in_stmts(stmts: &mut Vec<Stmt>, state_id: LocalId) {
+/// nested loop / closure boundaries — their own break/continue belong to
+/// those constructs, not to us. A nested `switch` captures `break` but
+/// NEVER `continue`: a switch whose cases carry a loop-level `continue` is
+/// desugared into plain `if`s first (#5868 — previously the raw
+/// `Stmt::Continue` survived verbatim inside the switch in the state body
+/// and the dispatch lowering silently ignored it, so the rest of the loop
+/// iteration ran anyway).
+pub fn rewrite_break_continue_in_stmts(
+    stmts: &mut Vec<Stmt>,
+    state_id: LocalId,
+    next_local_id: &mut u32,
+) {
     let mut i = 0;
     while i < stmts.len() {
         let stmt = std::mem::replace(&mut stmts[i], Stmt::Continue);
@@ -40,45 +49,61 @@ pub fn rewrite_break_continue_in_stmts(stmts: &mut Vec<Stmt>, state_id: LocalId)
                 stmts.insert(i + 1, Stmt::Continue);
                 i += 2;
             }
+            Stmt::Switch {
+                discriminant,
+                cases,
+            } if switch_cases_have_loop_continue(&cases) => {
+                // Replace the switch (currently a placeholder after the
+                // mem::replace) with its if-chain desugar and reprocess from
+                // the same index: the desugared statements are plain `if`s,
+                // so this rewriter descends them and converts the loop-level
+                // `continue`s to sentinels; `break`s were already folded
+                // into the desugar's done-flag.
+                let desugared = desugar_switch_to_ifs(&discriminant, &cases, next_local_id);
+                stmts.splice(i..=i, desugared);
+            }
             mut other => {
-                rewrite_break_continue_in_stmt(&mut other, state_id);
+                rewrite_break_continue_in_stmt(&mut other, state_id, next_local_id);
                 stmts[i] = other;
                 i += 1;
             }
         }
     }
 }
 
-pub fn rewrite_break_continue_in_stmt(stmt: &mut Stmt, state_id: LocalId) {
+pub fn rewrite_break_continue_in_stmt(stmt: &mut Stmt, state_id: LocalId, next_local_id: &mut u32) {
     match stmt {
         Stmt::If {
             then_branch,
             else_branch,
             ..
         } => {
-            rewrite_break_continue_in_stmts(then_branch, state_id);
+            rewrite_break_continue_in_stmts(then_branch, state_id, next_local_id);
             if let Some(eb) = else_branch.as_mut() {
-                rewrite_break_continue_in_stmts(eb, state_id);
+                rewrite_break_continue_in_stmts(eb, state_id, next_local_id);
             }
         }
         Stmt::Try {
             body,
             catch,
             finally,
         } => {
-            rewrite_break_continue_in_stmts(body, state_id);
+            rewrite_break_continue_in_stmts(body, state_id, next_local_id);
             if let Some(c) = catch.as_mut() {
-                rewrite_break_continue_in_stmts(&mut c.body, state_id);
+                rewrite_break_continue_in_stmts(&mut c.body, state_id, next_local_id);
             }
             if let Some(f) = finally.as_mut() {
-                rewrite_break_continue_in_stmts(f, state_id);
+                rewrite_break_continue_in_stmts(f, state_id, next_local_id);
             }
         }
-        // Inside nested loops / switch / labeled / closure expressions, the
-        // user's `break`/`continue` belongs to that construct and not to the
-        // outer loop the state machine is unrolling. Leave them as-is so the
-        // inner linearize_body (if it yields) / regular codegen (if it
-        // doesn't) handles them.
+        // Inside nested loops / closure expressions, the user's
+        // `break`/`continue` belongs to that construct and not to the outer
+        // loop the state machine is unrolling. Leave them as-is so the inner
+        // linearize_body (if it yields) / regular codegen (if it doesn't)
+        // handles them. A `switch` reaching here carries no loop-level
+        // `continue` (the stmts-level pass desugared those), and its
+        // `break`s bind to the switch itself. `Labeled` is left as-is
+        // (pre-existing single-sentinel limitation).
         Stmt::For { .. } | Stmt::While { .. } | Stmt::DoWhile { .. } => {}
         Stmt::Switch { .. } => {}
         Stmt::Labeled { .. } => {}
@@ -386,3 +411,277 @@ pub fn collect_vars_recursive(stmts: &[Stmt], vars: &mut Vec<(LocalId, String, T
         }
     }
 }
+
+// ---------------------------------------------------------------------------
+// #5868: switch desugaring for state-machine bodies
+// ---------------------------------------------------------------------------
+
+/// Does any case body carry a `continue` that binds to the ENCLOSING LOOP
+/// (i.e. at switch-case level, or nested only through `if`/`try`/inner
+/// `switch` — all constructs that do not capture `continue`)? Loops and
+/// labeled statements capture their own `continue`s, so descent stops there.
+fn switch_cases_have_loop_continue(cases: &[SwitchCase]) -> bool {
+    cases
+        .iter()
+        .any(|c| stmts_have_loop_level_continue(&c.body))
+}
+
+fn stmts_have_loop_level_continue(stmts: &[Stmt]) -> bool {
+    stmts.iter().any(|s| match s {
+        Stmt::Continue => true,
+        Stmt::If {
+            then_branch,
+            else_branch,
+            ..
+        } => {
+            stmts_have_loop_level_continue(then_branch)
+                || else_branch
+                    .as_ref()
+                    .is_some_and(|e| stmts_have_loop_level_continue(e))
+        }
+        Stmt::Try {
+            body,
+            catch,
+            finally,
+        } => {
+            stmts_have_loop_level_continue(body)
+                || catch
+                    .as_ref()
+                    .is_some_and(|c| stmts_have_loop_level_continue(&c.body))
+                || finally
+                    .as_ref()
+                    .is_some_and(|f| stmts_have_loop_level_continue(f))
+        }
+        Stmt::Switch { cases, .. } => switch_cases_have_loop_continue(cases),
+        _ => false,
+    })
+}
+
+/// Desugar a `switch` into an equivalent match-index + guarded-`if` chain
+/// (#5868). Used in two places:
+///
+///   1. `linearize_body`'s yielding-switch arm — a `yield`/`await` inside a
+///      case body previously fell through to the catch-all, was emitted
+///      unsplit inside one state, and codegen lowered the residual
+///      `Expr::Yield` to `0.0`.
+///   2. `rewrite_break_continue_in_stmts` — a loop-level `continue` inside
+///      a (yield-free) switch in a linearized loop body previously survived
+///      as a raw `Stmt::Continue` the dispatch loop ignored.
+///
+/// Shape (JS switch semantics preserved):
+///
+/// ```text
+///   __sw_d   = <discriminant>;            // evaluated exactly once
+///   __sw_idx = UNMATCHED;
+///   // case tests, evaluated only while still unmatched (first match wins;
+///   // spec order == source order of the non-default clauses):
+///   if (__sw_idx === UNMATCHED) { __sw_t = <test_i>; if (__sw_d === __sw_t) __sw_idx = i; }
+///   ...
+///   if (__sw_idx === UNMATCHED) __sw_idx = <default position, or past-end>;
+///   __sw_done = false;
+///   // bodies in POSITIONAL order — `__sw_idx <= i` gives fallthrough;
+///   // `break` becomes `__sw_done = true` plus remainder-guarding:
+///   if (!__sw_done && __sw_idx <= i) { <guarded body_i> }
+///   ...
+/// ```
+///
+/// `continue` / `return` / `throw` in case bodies pass through untouched —
+/// after the desugar they sit in plain `if`s, where the loop machinery (or
+/// function-level lowering) handles them normally. Fresh locals follow the
+/// DoWhile-flag pattern (plain `LocalSet` on an `alloc_local` id; generator
+/// local persistence carries them across suspend states).
+pub fn desugar_switch_to_ifs(
+    discriminant: &Expr,
+    cases: &[SwitchCase],
+    next_local_id: &mut u32,
+) -> Vec<Stmt> {
+    let n = cases.len();
+    let unmatched = (n + 1) as f64;
+    let default_pos = cases.iter().position(|c| c.test.is_none());
+    let start_when_unmatched = default_pos.unwrap_or(n) as f64;
+
+    let d_id = alloc_local(next_local_id);
+    let idx_id = alloc_local(next_local_id);
+    let done_id = alloc_local(next_local_id);
+
+    let idx_is_unmatched = || Expr::Compare {
+        op: CompareOp::Eq,
+        left: Box::new(Expr::LocalGet(idx_id)),
+        right: Box::new(Expr::Number(unmatched)),
+    };
+
+    let mut out = Vec::with_capacity(2 * n + 4);
+    out.push(Stmt::Expr(Expr::LocalSet(
+        d_id,
+        Box::new(discriminant.clone()),
+    )));
+    out.push(Stmt::Expr(Expr::LocalSet(
+        idx_id,
+        Box::new(Expr::Number(unmatched)),
+    )));
+
+    // Tests in source order over the non-default clauses — identical to the
+    // spec's pre-default-then-post-default order, since the default clause
+    // contributes no test. Each test evaluates only while unmatched, so
+    // side-effecting tests after the first match are (correctly) skipped.
+    for (i, case) in cases.iter().enumerate() {
+        let Some(test) = &case.test else { continue };
+        let t_id = alloc_local(next_local_id);
+        out.push(Stmt::If {
+            condition: idx_is_unmatched(),
+            then_branch: vec![
+                Stmt::Expr(Expr::LocalSet(t_id, Box::new(test.clone()))),
+                Stmt::If {
+                    condition: Expr::Compare {
+                        op: CompareOp::Eq,
+                        left: Box::new(Expr::LocalGet(d_id)),
+                        right: Box::new(Expr::LocalGet(t_id)),
+                    },
+                    then_branch: vec![Stmt::Expr(Expr::LocalSet(
+                        idx_id,
+                        Box::new(Expr::Number(i as f64)),
+                    ))],
+                    else_branch: None,
+                },
+            ],
+            else_branch: None,
+        });
+    }
+    out.push(Stmt::If {
+        condition: idx_is_unmatched(),
+        then_branch: vec![Stmt::Expr(Expr::LocalSet(
+            idx_id,
+            Box::new(Expr::Number(start_when_unmatched)),
+        ))],
+        else_branch: None,
+    });
+    out.push(Stmt::Expr(Expr::LocalSet(
+        done_id,
+        Box::new(Expr::Bool(false)),
+    )));
+
+    for (i, case) in cases.iter().enumerate() {
+        let mut guarded = Vec::new();
+        guard_switch_breaks(&case.body, done_id, &mut guarded);
+        out.push(Stmt::If {
+            condition: Expr::Logical {
+                op: LogicalOp::And,
+                left: Box::new(Expr::Unary {
+                    op: UnaryOp::Not,
+                    operand: Box::new(Expr::LocalGet(done_id)),
+                }),
+                right: Box::new(Expr::Compare {
+                    op: CompareOp::Le,
+                    left: Box::new(Expr::LocalGet(idx_id)),
+                    right: Box::new(Expr::Number(i as f64)),
+                }),
+            },
+            then_branch: guarded,
+            else_branch: None,
+        });
+    }
+    out
+}
+
+/// Copy a case body into `out`, rewriting every `break` that binds to the
+/// switch being desugared into `__sw_done = true`, and guarding every
+/// statement that follows a potentially-breaking statement behind
+/// `if (!__sw_done)`. Descends `if`/`try` (which don't capture `break`);
+/// stops at nested loops, switches, and labeled statements (whose `break`
+/// binds to themselves). Statements directly after a bare `break` are
+/// unreachable and dropped.
+fn guard_switch_breaks(stmts: &[Stmt], done_id: LocalId, out: &mut Vec<Stmt>) {
+    let mut i = 0;
+    while i < stmts.len() {
+        let s = &stmts[i];
+        if matches!(s, Stmt::Break) {
+            out.push(Stmt::Expr(Expr::LocalSet(
+                done_id,
+                Box::new(Expr::Bool(true)),
+            )));
+            return;
+        }
+        let may_break = stmt_may_break_switch(s);
+        out.push(rewrite_switch_breaks_in_stmt(s, done_id));
+        i += 1;
+        if may_break && i < stmts.len() {
+            let mut rest = Vec::new();
+            guard_switch_breaks(&stmts[i..], done_id, &mut rest);
+            out.push(Stmt::If {
+                condition: Expr::Unary {
+                    op: UnaryOp::Not,
+                    operand: Box::new(Expr::LocalGet(done_id)),
+                },
+                then_branch: rest,
+                else_branch: None,
+            });
+            return;
+        }
+    }
+}
+
+/// Can executing this statement hit a `break` that binds to the switch
+/// being desugared? Mirrors `guard_switch_breaks`'s descent scoping.
+fn stmt_may_break_switch(s: &Stmt) -> bool {
+    match s {
+        Stmt::Break => true,
+        Stmt::If {
+            then_branch,
+            else_branch,
+            ..
+        } => {
+            then_branch.iter().any(stmt_may_break_switch)
+                || else_branch
+                    .as_ref()
+                    .is_some_and(|e| e.iter().any(stmt_may_break_switch))
+        }
+        Stmt::Try {
+            body,
+            catch,
+            finally,
+        } => {
+            body.iter().any(stmt_may_break_switch)
+                || catch
+                    .as_ref()
+                    .is_some_and(|c| c.body.iter().any(stmt_may_break_switch))
+                || finally
+                    .as_ref()
+                    .is_some_and(|f| f.iter().any(stmt_may_break_switch))
+        }
+        _ => false,
+    }
+}
+
+/// Rebuild one statement with switch-binding `break`s rewritten (via
+/// `guard_switch_breaks`) inside its `if`/`try` sub-bodies.
+fn rewrite_switch_breaks_in_stmt(s: &Stmt, done_id: LocalId) -> Stmt {
+    let guarded = |body: &[Stmt]| {
+        let mut v = Vec::new();
+        guard_switch_breaks(body, done_id, &mut v);
+        v
+    };
+    match s {
+        Stmt::If {
+            condition,
+            then_branch,
+            else_branch,
+        } => Stmt::If {
+            condition: condition.clone(),
+            then_branch: guarded(then_branch),
+            else_branch: else_branch.as_ref().map(|e| guarded(e)),
+        },
+        Stmt::Try {
+            body,
+            catch,
+            finally,
+        } => Stmt::Try {
+            body: guarded(body),
+            catch: catch.as_ref().map(|c| CatchClause {
+                param: c.param.clone(),
+                body: guarded(&c.body),
+            }),
+            finally: finally.as_ref().map(|f| guarded(f)),
+        },
+        other => other.clone(),
+    }
+}

crates/perry-transform/src/generator/hoist_yields.rs

@@ -247,7 +247,7 @@ fn logical_rhs_contains_yield(expr: &Expr) -> bool {
     false
 }
 
-fn expr_contains_yield(expr: &Expr) -> bool {
+pub(super) fn expr_contains_yield(expr: &Expr) -> bool {
     if matches!(expr, Expr::Yield { .. }) {
         return true;
     }