@scriptc/compiler 0.0.35 → 0.1.1

package/dist/backend/{emission/emit-stmts.js → c/stmts.js}

@@ -1,24 +1,26 @@
+import { InternalCompilerError } from "../../errors.js";
 import { mangleField, mangleGlobal, mangleLocal, mangleRawParam } from "../mangle.js";
-import { BOOL, CAUGHT, RUNTIME_ERROR_CLASSES, isRefCounted } from "../../ir/nodes.js";
-import { boxAccess, cDecl, cStringLiteral, elemAccess, vAdapters } from "./emit-types.js";
-import { OVERFLOW_MEMBER } from "./emit-shapes.js";
-import { emitBytesReceiver } from "./emit-exprs.js";
+import { BOOL, CAUGHT, RUNTIME_ERROR_CLASSES, isRefCounted } from "../../ir/ir.js";
+import { boxAccess, cDecl, cStringLiteral, elemAccess, vAdapters } from "./types.js";
+import { OVERFLOW_MEMBER } from "./shapes.js";
+import { emitBytesReceiver } from "./exprs.js";
 import { matchIntegerBytesForLoop } from "../../ir/integer-loops.js";
-export function emitFunction(E, fn) {
-    E.tempCounter = 0;
-    E.frames = [];
-    E.scopes = [];
-    E.jumpTargets = [];
-    E.tryStack = [];
-    E.finallyStack = [];
-    E.currentReturnType = fn.returnType;
-    E.currentGenerator = fn.generator ?? null;
-    E.labelCounter = 0;
-    E.currentLocals = new Map(fn.locals.map((l) => [l.id, l]));
-    E.captureIds = new Set((fn.captures ?? []).map((c) => c.localId));
-    E.integerLoopBindings.clear();
-    E.line(`${E.signature(fn)} {${E.srcComment(fn.loc)}`);
-    E.indent++;
+import { endsWithJump, matchStringSelfConcat } from "../../ir/analysis.js";
+export function emitFunction(emitter, fn) {
+    emitter.tempCounter = 0;
+    emitter.frames = [];
+    emitter.scopes = [];
+    emitter.jumpTargets = [];
+    emitter.tryStack = [];
+    emitter.finallyStack = [];
+    emitter.currentReturnType = fn.returnType;
+    emitter.currentGenerator = fn.generator ?? null;
+    emitter.labelCounter = 0;
+    emitter.currentLocals = new Map(fn.locals.map((l) => [l.id, l]));
+    emitter.captureIds = new Set((fn.captures ?? []).map((c) => c.localId));
+    emitter.integerLoopBindings.clear();
+    emitter.line(`${emitter.signature(fn)} {${emitter.srcComment(fn.loc)}`);
+    emitter.indent++;
     // The pending-return slot: a `return` crossing a finally computes its
     // value FIRST (before the finally runs — snapshotting it here is what
     // makes finally mutations of returned locals invisible, Node-exact),
@@ -26,54 +28,54 @@ export function emitFunction(E, fn) {
     // the slot. Declared only when some return actually crosses a finally.
     if (fn.returnType.kind !== "void" && returnCrossesFinally(fn.body)) {
         const init = isRefCounted(fn.returnType) ? "NULL" : "0";
-        E.line(`${cDecl(fn.returnType, "sc_pret")} = ${init}; /* pending return (through finally) */`);
+        emitter.line(`${cDecl(fn.returnType, "sc_pret")} = ${init}; /* pending return (through finally) */`);
     }
     // Captured bindings come in through the environment — borrowed for the
     // whole call (the closure owns them): bound here, never released here.
     (fn.captures ?? []).forEach((c, i) => {
-        E.line(`ScrBox *${mangleLocal(c.localId)} = sc_env->caps[${i}]; /* captured ${c.name} */`);
+        emitter.line(`ScrBox *${mangleLocal(c.localId)} = sc_env->caps[${i}]; /* captured ${c.name} */`);
     });
     const paramIds = new Set(fn.params.map((p) => p.localId));
     for (const local of fn.locals) {
-        if (paramIds.has(local.id) || E.captureIds.has(local.id))
+        if (paramIds.has(local.id) || emitter.captureIds.has(local.id))
             continue;
         if (local.boxed) {
-            E.line(`ScrBox *${mangleLocal(local.id)} = NULL; /* ${local.name} (boxed) */`);
+            emitter.line(`ScrBox *${mangleLocal(local.id)} = NULL; /* ${local.name} (boxed) */`);
         }
         else {
             const init = isRefCounted(local.type) ? " = NULL" : "";
-            E.line(`${cDecl(local.type, mangleLocal(local.id))}${init}; /* ${local.name} */`);
+            emitter.line(`${cDecl(local.type, mangleLocal(local.id))}${init}; /* ${local.name} */`);
         }
     }
     // Function scope owns refcounted params (callees own their params).
     // Boxed params: allocate the shared binding and move the raw value in.
     const fnScope = [];
     for (const p of fn.params) {
-        const local = E.currentLocals.get(p.localId);
+        const local = emitter.currentLocals.get(p.localId);
         if (local.boxed) {
             const box = mangleLocal(p.localId);
-            E.line(`ScrBox *${box} = ${E.boxNewC(p.type)}; /* ${p.name} (boxed param) */`);
-            E.line(`scr_box_set_${boxAccess(p.type)}(${box}, ${mangleRawParam(p.localId)});`);
+            emitter.line(`ScrBox *${box} = ${emitter.boxNewC(p.type)}; /* ${p.name} (boxed param) */`);
+            emitter.line(`scr_box_set_${boxAccess(p.type)}(${box}, ${mangleRawParam(p.localId)});`);
             fnScope.push({ name: box, type: p.type, boxed: true });
         }
         else if (isRefCounted(p.type)) {
             fnScope.push({ name: mangleLocal(p.localId), type: p.type });
         }
     }
-    E.scopes.push(fnScope);
-    E.emitStmts(fn.body);
+    emitter.scopes.push(fnScope);
+    emitter.emitStmts(fn.body);
     // Implicit exit of a void function: release function-scope refcounted
     // locals (unless the body already ended in an explicit return or a
     // throw, whose unwind released everything down to depth 0).
     const last = fn.body[fn.body.length - 1]?.kind;
     const endedWithReturn = last === "return" || last === "throw" || last === "rethrow" || last === "runtimeFence";
     if (fn.returnType.kind === "void" && !endedWithReturn) {
-        E.releaseFrame(E.scopes[0]);
+        emitter.releaseFrame(emitter.scopes[0]);
     }
-    E.scopes.pop();
-    E.indent--;
-    E.line(`}`);
-    E.line(``);
+    emitter.scopes.pop();
+    emitter.indent--;
+    emitter.line(`}`);
+    emitter.line(``);
 }
 /** The statement bodies nested directly under a statement — the shared
    * walk for returnCrossesFinally. */
@@ -120,29 +122,29 @@ function returnCrossesFinally(stmts) {
    * end). `setup` runs after the scope opens, before the statements — the
    * catch-binding hook: it may emit prelude lines and register entries the
    * scope owns (released on every exit, jumps and unwinds included). */
-export function emitBlock(E, stmts, setup) {
-    E.line(`{`);
-    E.indent++;
+export function emitBlock(emitter, stmts, setup) {
+    emitter.line(`{`);
+    emitter.indent++;
     const scope = [];
-    E.scopes.push(scope);
+    emitter.scopes.push(scope);
     setup?.(scope);
-    E.emitStmts(stmts);
-    const endedWithJump = E.endsWithJump(stmts);
-    E.scopes.pop();
+    emitter.emitStmts(stmts);
+    const endedWithJump = endsWithJump(stmts);
+    emitter.scopes.pop();
     if (!endedWithJump)
-        E.releaseFrame(scope);
-    E.indent--;
-    E.line(`}`);
+        emitter.releaseFrame(scope);
+    emitter.indent--;
+    emitter.line(`}`);
 }
-export function emitStmts(E, stmts) {
+export function emitStmts(emitter, stmts) {
     for (const s of stmts)
-        E.emitStmt(s);
+        emitter.emitStmt(s);
 }
-export function emitStmt(E, s) {
-    E.frames.push([]);
+export function emitStmt(emitter, s) {
+    emitter.frames.push([]);
     switch (s.kind) {
         case "varDecl": {
-            const local = E.currentLocals.get(s.localId);
+            const local = emitter.currentLocals.get(s.localId);
             const target = mangleLocal(s.localId);
             if (s.init === null) {
                 // Declared, uninitialized (`let x: number;`). tsc's TS2454 rejects
@@ -163,13 +165,13 @@ export function emitStmt(E, s) {
                     // bit pattern to spend on it.
                     const boxNew = local.tdz && boxAccess(local.type) !== "ref"
                         ? "scr_box_new(SCR_BOX_ARR)"
-                        : E.boxNewC(local.type);
-                    E.line(`${target} = ${boxNew};${E.srcComment(s.loc)} /* let ${local.name}; */`);
-                    E.scopes[E.scopes.length - 1].push({ name: target, type: local.type, boxed: true });
+                        : emitter.boxNewC(local.type);
+                    emitter.line(`${target} = ${boxNew};${emitter.srcComment(s.loc)} /* let ${local.name}; */`);
+                    emitter.scopes[emitter.scopes.length - 1].push({ name: target, type: local.type, boxed: true });
                 }
                 else if (isRefCounted(local.type)) {
-                    E.line(`${target} = NULL;${E.srcComment(s.loc)} /* let ${local.name}; */`);
-                    E.scopes[E.scopes.length - 1].push({ name: target, type: local.type });
+                    emitter.line(`${target} = NULL;${emitter.srcComment(s.loc)} /* let ${local.name}; */`);
+                    emitter.scopes[emitter.scopes.length - 1].push({ name: target, type: local.type });
                 }
                 // Scalars need nothing: the C local exists from the prologue and
                 // no read happens before an assign writes it.
@@ -178,203 +180,253 @@ export function emitStmt(E, s) {
             if (local.boxed) {
                 // Box FIRST, then evaluate the initializer: a named function
                 // expression's closure captures this box during init evaluation.
-                E.line(`${target} = ${E.boxNewC(local.type)};${E.srcComment(s.loc)}`);
-                E.scopes[E.scopes.length - 1].push({ name: target, type: local.type, boxed: true });
-                const v = E.emitExpr(s.init);
+                emitter.line(`${target} = ${emitter.boxNewC(local.type)};${emitter.srcComment(s.loc)}`);
+                emitter.scopes[emitter.scopes.length - 1].push({ name: target, type: local.type, boxed: true });
+                const v = emitter.emitExpr(s.init);
                 if (isRefCounted(v.type))
-                    E.moveTemp(v); // the box takes ownership
-                E.line(`scr_box_set_${boxAccess(local.type)}(${target}, ${v.name});`);
+                    emitter.moveTemp(v); // the box takes ownership
+                emitter.line(`scr_box_set_${boxAccess(local.type)}(${target}, ${v.name});`);
                 break;
             }
-            const v = E.emitExpr(s.init);
-            E.moveTemp(v);
-            E.line(`${target} = ${v.name};${E.srcComment(s.loc)}`);
+            const v = emitter.emitExpr(s.init);
+            emitter.moveTemp(v);
+            emitter.line(`${target} = ${v.name};${emitter.srcComment(s.loc)}`);
             if (isRefCounted(v.type)) {
-                E.scopes[E.scopes.length - 1].push({ name: target, type: v.type });
+                emitter.scopes[emitter.scopes.length - 1].push({ name: target, type: v.type });
             }
             break;
         }
         case "assign": {
-            const local = E.currentLocals.get(s.localId);
+            const local = emitter.currentLocals.get(s.localId);
+            const concat = s.value;
+            const suffix = matchStringSelfConcat(s.localId, concat);
+            if (suffix && concat.kind === "strConcat") {
+                // Snapshot the old left value before evaluating the suffix.  The
+                // snapshot is a normal frame-owned +1: the suffix may reassign the
+                // destination or throw, in which case unwinding must still release
+                // it while leaving the original binding intact.
+                const snapshot = emitter.emitExpr(concat.left);
+                const right = emitter.emitExpr(suffix);
+                const target = local ? mangleLocal(s.localId) : mangleGlobal(s.localId);
+                if (local?.boxed) {
+                    // set_ref unlinks then releases the binding's CURRENT value. It
+                    // may differ from snapshot when the suffix itself assigned target.
+                    emitter.line(`scr_box_set_ref(${target}, NULL);`);
+                }
+                else {
+                    const old = `sc_t${emitter.tempCounter++}`;
+                    emitter.line(`ScrStr *${old} = ${target};`);
+                    emitter.line(`${target} = NULL;`);
+                    emitter.releaseValue(old, snapshot.type);
+                }
+                const result = emitter.newTemp(s.value.type, `scr_str_concat(${snapshot.name}, ${right.name})`);
+                if (local?.boxed) {
+                    emitter.moveTemp(result); // the box takes the concat result's +1
+                    emitter.line(`scr_box_set_ref(${target}, ${result.name});${emitter.srcComment(s.loc)}`);
+                }
+                else {
+                    emitter.moveTemp(result); // binding takes the concat result's +1
+                    emitter.line(`${target} = ${result.name};${emitter.srcComment(s.loc)}`);
+                }
+                break;
+            }
             if (!local) {
                 // Module global: plain static storage, never boxed. Old-value
                 // release is NULL-tolerant (statics start NULL).
-                const g = E.globalsById.get(s.localId);
+                const g = emitter.globalsById.get(s.localId);
                 if (!g)
-                    throw new Error(`emitter bug: assign to unknown binding ${s.localId}`);
+                    throw new InternalCompilerError(`emitter bug: assign to unknown binding ${s.localId}`);
                 const target = mangleGlobal(g.id);
-                const v = E.emitExpr(s.value);
-                E.moveTemp(v);
+                const v = emitter.emitExpr(s.value);
+                emitter.moveTemp(v);
                 if (isRefCounted(v.type))
-                    E.releaseValue(target, v.type);
-                E.line(`${target} = ${v.name};${E.srcComment(s.loc)}`);
+                    emitter.releaseValue(target, v.type);
+                emitter.line(`${target} = ${v.name};${emitter.srcComment(s.loc)}`);
                 break;
             }
             const target = mangleLocal(s.localId);
-            const v = E.emitExpr(s.value);
+            const v = emitter.emitExpr(s.value);
             if (local.boxed) {
                 // A scalar TDZ box (forward-captured const): the initializing
                 // write mints the one-element array cell — set_ref moves it in
                 // (and the empty-slot sentinel ends here).
                 if (local.tdz && boxAccess(local.type) !== "ref") {
                     const acc = boxAccess(local.type);
-                    const cell = `sc_t${E.tempCounter++}`;
-                    E.line(`ScrArr *${cell} = ${E.arrNewC(local.type, 1)};${E.srcComment(s.loc)}`);
-                    E.line(`scr_arr_push_${acc}(${cell}, ${v.name});`);
-                    E.line(`scr_box_set_ref(${target}, ${cell});`);
+                    const cell = `sc_t${emitter.tempCounter++}`;
+                    emitter.line(`ScrArr *${cell} = ${emitter.arrNewC(local.type, 1)};${emitter.srcComment(s.loc)}`);
+                    emitter.line(`scr_arr_push_${acc}(${cell}, ${v.name});`);
+                    emitter.line(`scr_box_set_ref(${target}, ${cell});`);
                     break;
                 }
                 if (isRefCounted(v.type))
-                    E.moveTemp(v); // set_ref releases the old value
-                E.line(`scr_box_set_${boxAccess(local.type)}(${target}, ${v.name});${E.srcComment(s.loc)}`);
+                    emitter.moveTemp(v); // set_ref releases the old value
+                emitter.line(`scr_box_set_${boxAccess(local.type)}(${target}, ${v.name});${emitter.srcComment(s.loc)}`);
                 break;
             }
-            E.moveTemp(v);
+            emitter.moveTemp(v);
             if (isRefCounted(v.type))
-                E.releaseValue(target, v.type);
-            E.line(`${target} = ${v.name};${E.srcComment(s.loc)}`);
+                emitter.releaseValue(target, v.type);
+            emitter.line(`${target} = ${v.name};${emitter.srcComment(s.loc)}`);
             break;
         }
         case "exprStmt":
-            E.emitExpr(s.expr);
+            emitter.emitExpr(s.expr);
             break;
         case "if": {
-            const cond = E.emitCondition(s.cond);
-            E.line(`if (${cond}) `);
-            E.mergeBrace(() => E.emitBlock(s.then));
+            const cond = emitter.emitCondition(s.cond);
+            emitter.line(`if (${cond}) `);
+            emitter.mergeBrace(() => emitter.emitBlock(s.then));
             if (s.else_) {
-                E.line(`else `);
-                E.mergeBrace(() => E.emitBlock(s.else_));
+                emitter.line(`else `);
+                emitter.mergeBrace(() => emitter.emitBlock(s.else_));
             }
             break;
         }
         case "while": {
-            E.line(`for (;;) {${E.srcComment(s.loc)}`);
-            E.indent++;
-            const cond = E.emitCondition(s.cond);
-            E.line(`if (!(${cond})) break;`);
+            emitter.line(`for (;;) {${emitter.srcComment(s.loc)}`);
+            emitter.indent++;
+            const cond = emitter.emitCondition(s.cond);
+            emitter.line(`if (!(${cond})) break;`);
             // C continue re-evaluates the condition at the top: exactly right
             // for the unlabeled loop. A LABELED while allocates a continue
             // label placed at the END of the body (falling off it re-enters
             // the condition — the same point) so a labeled continue from a
             // NESTED loop can goto it, and a lazy end label for labeled break.
-            const loop = E.loopTarget(null, s.labels);
-            E.jumpTargets.push(loop);
-            E.emitBlock(s.body);
-            E.jumpTargets.pop();
+            const loop = emitter.loopTarget(null, s.labels);
+            emitter.jumpTargets.push(loop);
+            emitter.emitBlock(s.body);
+            emitter.jumpTargets.pop();
             if (loop.usedContinue && loop.continueLabel)
-                E.line(`${loop.continueLabel}:;`);
-            E.indent--;
-            E.line(`}`);
+                emitter.line(`${loop.continueLabel}:;`);
+            emitter.indent--;
+            emitter.line(`}`);
             if (loop.usedEnd)
-                E.line(`${loop.endLabel}:;`);
+                emitter.line(`${loop.endLabel}:;`);
             break;
         }
         case "doWhile": {
             // `for (;;) { body; cont: cond; if (!cond) break; }` — the body runs
             // before the first condition check (at least once), and `continue`
             // routes through the label so the condition still evaluates.
-            E.line(`for (;;) {${E.srcComment(s.loc)}`);
-            E.indent++;
-            const loop = E.loopTarget(`sc_cont_${E.labelCounter++}`, s.labels);
-            E.jumpTargets.push(loop);
-            E.emitBlock(s.body);
-            E.jumpTargets.pop();
+            emitter.line(`for (;;) {${emitter.srcComment(s.loc)}`);
+            emitter.indent++;
+            const loop = emitter.loopTarget(`sc_cont_${emitter.labelCounter++}`, s.labels);
+            emitter.jumpTargets.push(loop);
+            emitter.emitBlock(s.body);
+            emitter.jumpTargets.pop();
             if (loop.usedContinue)
-                E.line(`${loop.continueLabel}:;`);
-            const cond = E.emitCondition(s.cond);
-            E.line(`if (!(${cond})) break;`);
-            E.indent--;
-            E.line(`}`);
+                emitter.line(`${loop.continueLabel}:;`);
+            const cond = emitter.emitCondition(s.cond);
+            emitter.line(`if (!(${cond})) break;`);
+            emitter.indent--;
+            emitter.line(`}`);
             if (loop.usedEnd)
-                E.line(`${loop.endLabel}:;`);
+                emitter.line(`${loop.endLabel}:;`);
             break;
         }
         case "switch":
-            E.emitSwitch(s);
+            emitter.emitSwitch(s);
             break;
         case "for": {
             // Desugared in place; the init's scope wraps the whole loop, so
             // break/continue must NOT release it (scopeDepth captured after).
-            const integerLoop = matchIntegerBytesForLoop(s, E.currentLocals);
-            E.line(`{${E.srcComment(s.loc)}`);
-            E.indent++;
-            E.scopes.push([]);
+            const integerLoop = matchIntegerBytesForLoop(s, emitter.currentLocals);
+            emitter.line(`{${emitter.srcComment(s.loc)}`);
+            emitter.indent++;
+            emitter.scopes.push([]);
             let integerShadow = null;
             if (integerLoop) {
-                integerShadow = `sc_i${E.tempCounter++}`;
-                E.line(`uint64_t ${integerShadow} = 0; /* integer induction ${E.currentLocals.get(integerLoop.localId).name} */`);
-                E.integerLoopBindings.set(integerLoop.localId, integerShadow);
+                integerShadow = `sc_i${emitter.tempCounter++}`;
+                emitter.line(`uint64_t ${integerShadow} = 0; /* integer induction ${emitter.currentLocals.get(integerLoop.localId).name} */`);
+                emitter.integerLoopBindings.set(integerLoop.localId, integerShadow);
             }
             else if (s.init) {
-                E.emitStmt(s.init);
+                emitter.emitStmt(s.init);
             }
-            E.line(`for (;;) {`);
-            E.indent++;
+            emitter.line(`for (;;) {`);
+            emitter.indent++;
             if (integerLoop && integerShadow) {
-                const receiver = emitBytesReceiver(E, integerLoop.limitReceiver, []);
-                E.line(`if (!(${integerShadow} < ${receiver.name}->len)) break;`);
+                const receiver = emitBytesReceiver(emitter, integerLoop.limitReceiver, []);
+                emitter.line(`if (!(${integerShadow} < ${receiver.name}->len)) break;`);
             }
             else if (s.cond) {
-                const cond = E.emitCondition(s.cond);
-                E.line(`if (!(${cond})) break;`);
+                const cond = emitter.emitCondition(s.cond);
+                emitter.line(`if (!(${cond})) break;`);
             }
             // C continue would skip the update; route it through a label instead.
-            const loop = E.loopTarget(`sc_cont_${E.labelCounter++}`, s.labels);
-            E.jumpTargets.push(loop);
-            E.emitBlock(s.body);
-            E.jumpTargets.pop();
+            const loop = emitter.loopTarget(`sc_cont_${emitter.labelCounter++}`, s.labels);
+            emitter.jumpTargets.push(loop);
+            emitter.emitBlock(s.body);
+            emitter.jumpTargets.pop();
             if (loop.usedContinue)
-                E.line(`${loop.continueLabel}:;`);
+                emitter.line(`${loop.continueLabel}:;`);
             // JS `for (let i ...)`: each iteration gets a FRESH binding holding a
             // copy of the previous one, and the update mutates the fresh binding
             // — that's why closures made in iteration k keep seeing iteration
             // k's value. Only observable (and only emitted) when captured.
             if (s.init?.kind === "varDecl") {
-                const initLocal = E.currentLocals.get(s.init.localId);
+                const initLocal = emitter.currentLocals.get(s.init.localId);
                 if (initLocal?.boxed) {
                     const box = mangleLocal(initLocal.id);
-                    const fresh = `sc_t${E.tempCounter++}`;
+                    const fresh = `sc_t${emitter.tempCounter++}`;
                     const acc = boxAccess(initLocal.type);
-                    E.line(`ScrBox *${fresh} = ${E.boxNewC(initLocal.type)}; /* per-iteration ${initLocal.name} */`);
-                    E.line(`scr_box_set_${acc}(${fresh}, scr_box_get_${acc}(${box}));`);
-                    E.line(`scr_box_release(${box});`);
-                    E.line(`${box} = ${fresh};`);
+                    emitter.line(`ScrBox *${fresh} = ${emitter.boxNewC(initLocal.type)}; /* per-iteration ${initLocal.name} */`);
+                    emitter.line(`scr_box_set_${acc}(${fresh}, scr_box_get_${acc}(${box}));`);
+                    emitter.line(`scr_box_release(${box});`);
+                    emitter.line(`${box} = ${fresh};`);
                     // The wrapper scope's entry releases whatever `box` points to at
                     // loop exit — which is now the freshest binding. Nothing to fix.
                 }
             }
             if (integerLoop && integerShadow)
-                E.line(`${integerShadow}++;`);
+                emitter.line(`${integerShadow}++;`);
             else if (s.update)
-                E.emitStmt(s.update);
-            E.indent--;
-            E.line(`}`);
+                emitter.emitStmt(s.update);
+            emitter.indent--;
+            emitter.line(`}`);
             // A labeled break lands exactly where C break does: BEFORE the
             // init scope's release (the goto path must run the same releases
             // as the fall-through path).
             if (loop.usedEnd)
-                E.line(`${loop.endLabel}:;`);
-            E.releaseFrame(E.scopes.pop());
+                emitter.line(`${loop.endLabel}:;`);
+            emitter.releaseFrame(emitter.scopes.pop());
             if (integerLoop)
-                E.integerLoopBindings.delete(integerLoop.localId);
-            E.indent--;
-            E.line(`}`);
+                emitter.integerLoopBindings.delete(integerLoop.localId);
+            emitter.indent--;
+            emitter.line(`}`);
             break;
         }
         case "arraySet": {
             // Evaluation order matches JS: array, index, then value. Ownership
             // of a refcounted value moves into the array (the runtime releases
             // the replaced element itself).
-            const arr = E.emitExpr(s.arr);
-            const idx = E.emitExpr(s.index);
-            const v = E.emitExpr(s.value);
+            const arr = emitter.emitExpr(s.arr);
+            const idx = emitter.emitExpr(s.index);
+            const v = emitter.emitExpr(s.value);
             if (s.arr.type.kind !== "array")
-                throw new Error("emitter bug: arraySet on non-array");
+                throw new InternalCompilerError("emitter bug: arraySet on non-array");
             const acc = elemAccess(s.arr.type.elem);
             if (acc === "ref")
-                E.moveTemp(v);
-            E.line(`scr_arr_set_${acc}(${arr.name}, ${idx.name}, ${v.name});${E.srcComment(s.loc)}`);
+                emitter.moveTemp(v);
+            emitter.line(`scr_arr_set_${acc}(${arr.name}, ${idx.name}, ${v.name});${emitter.srcComment(s.loc)}`);
+            break;
+        }
+        case "arraySetLength": {
+            const arr = emitter.emitExpr(s.arr);
+            const length = emitter.emitExpr(s.length);
+            if (s.arr.type.kind !== "array")
+                throw new InternalCompilerError("emitter bug: arraySetLength on non-array");
+            emitter.line(`scr_arr_set_len(${arr.name}, ${length.name});${emitter.srcComment(s.loc)}`);
+            emitter.emitPendingCheck();
+            break;
+        }
+        case "arraySetUndefined":
+        case "arrayDelete": {
+            const arr = emitter.emitExpr(s.arr);
+            const idx = emitter.emitExpr(s.index);
+            if (s.arr.type.kind !== "array")
+                throw new InternalCompilerError(`emitter bug: ${s.kind} on non-array`);
+            emitter.line(`${s.kind === "arraySetUndefined" ? "scr_arr_set_undefined" : "scr_arr_delete"}(${arr.name}, ${idx.name});${emitter.srcComment(s.loc)}`);
             break;
         }
         case "bytesSet": {
@@ -383,13 +435,13 @@ export function emitStmt(E, s) {
             // JS-exactly), so no ownership moves. Any invalid index traps — no
             // append. The IR carries the element kind; do not rediscover it in
             // the generic runtime accessor on every loop iteration.
-            const arr = emitBytesReceiver(E, s.arr, [s.index, s.value]);
-            const integerIndex = E.integerLoopIndex(s.index);
-            const idx = integerIndex === null ? E.emitExpr(s.index).name : integerIndex;
-            const v = E.emitExpr(s.value);
+            const arr = emitBytesReceiver(emitter, s.arr, [s.index, s.value]);
+            const integerIndex = emitter.integerLoopIndex(s.index);
+            const idx = integerIndex === null ? emitter.emitExpr(s.index).name : integerIndex;
+            const v = emitter.emitExpr(s.value);
             if (s.arr.type.kind !== "bytes")
-                throw new Error("emitter bug: bytesSet on non-bytes");
-            E.line(`${E.bytesElementHelper("set", s.arr.type.elem, integerIndex !== null)}(${arr.name}, ${idx}, ${v.name});${E.srcComment(s.loc)}`);
+                throw new InternalCompilerError("emitter bug: bytesSet on non-bytes");
+            emitter.line(`${emitter.bytesElementHelper("set", s.arr.type.elem, integerIndex !== null)}(${arr.name}, ${idx}, ${v.name});${emitter.srcComment(s.loc)}`);
             break;
         }
         case "fieldSet":
@@ -401,31 +453,31 @@ export function emitStmt(E, s) {
             // cycle collection, which must never see a heap edge whose count
             // was already given up (scr_cycle.c). Classes and records share
             // the struct layout, so one emission.
-            const obj = E.emitExpr(s.obj);
-            const v = E.emitExpr(s.value);
+            const obj = emitter.emitExpr(s.obj);
+            const v = emitter.emitExpr(s.value);
             // Runtime error classes use ScrError's own member names.
             const member = s.kind === "fieldSet" && RUNTIME_ERROR_CLASSES.has(s.className)
                 ? s.field
                 : mangleField(s.field);
             const field = `${obj.name}->${member}`;
             if (isRefCounted(v.type)) {
-                E.moveTemp(v);
-                const old = `sc_t${E.tempCounter++}`;
-                E.line(`${cDecl(v.type, old)} = ${field};`);
-                E.line(`${field} = ${v.name};${E.srcComment(s.loc)}`);
-                E.releaseValue(old, v.type);
+                emitter.moveTemp(v);
+                const old = `sc_t${emitter.tempCounter++}`;
+                emitter.line(`${cDecl(v.type, old)} = ${field};`);
+                emitter.line(`${field} = ${v.name};${emitter.srcComment(s.loc)}`);
+                emitter.releaseValue(old, v.type);
             }
             else {
-                E.line(`${field} = ${v.name};${E.srcComment(s.loc)}`);
+                emitter.line(`${field} = ${v.name};${emitter.srcComment(s.loc)}`);
             }
             break;
         }
         case "recordKeyDelete": {
             // `delete obj[k]` on a pure index-signature shape: a Map delete on
             // the overflow (key and value released; absent keys no-op).
-            const obj = E.emitExpr(s.obj);
-            const key = E.emitExpr(s.key);
-            E.line(`scr_map_delete_str(${obj.name}->${OVERFLOW_MEMBER}, ${key.name});${E.srcComment(s.loc)}`);
+            const obj = emitter.emitExpr(s.obj);
+            const key = emitter.emitExpr(s.key);
+            emitter.line(`scr_map_delete_str(${obj.name}->${OVERFLOW_MEMBER}, ${key.name});${emitter.srcComment(s.loc)}`);
             break;
         }
         case "recordKeySet": {
@@ -434,25 +486,25 @@ export function emitStmt(E, s) {
             // overflow map). Evaluation order: obj, key, value. The helper OWNS
             // the value (+1 moves in). MAY THROW when a dyn value must validate
             // against a declared field's type — the pending check runs then.
-            const obj = E.emitExpr(s.obj);
-            const key = E.emitExpr(s.key);
-            const v = E.emitExpr(s.value);
+            const obj = emitter.emitExpr(s.obj);
+            const key = emitter.emitExpr(s.key);
+            const v = emitter.emitExpr(s.value);
             if (isRefCounted(v.type))
-                E.moveTemp(v);
+                emitter.moveTemp(v);
             // A LITERAL key naming no declared field is a plain overflow map
             // insert — no helper, no validation, no throw.
             if (s.overflowOnly) {
                 const acc = v.type.kind === "f64" ? "f64" : v.type.kind === "bool" ? "bool" : "ref";
-                E.line(`scr_map_set_str_${acc}(${obj.name}->${OVERFLOW_MEMBER}, ${key.name}, ${v.name});${E.srcComment(s.loc)}`);
+                emitter.line(`scr_map_set_str_${acc}(${obj.name}->${OVERFLOW_MEMBER}, ${key.name}, ${v.name});${emitter.srcComment(s.loc)}`);
                 break;
             }
-            const helper = E.recordKeySetHelper(s.shapeId);
-            E.line(`${helper}(${obj.name}, ${key.name}, ${v.name});${E.srcComment(s.loc)}`);
-            const shape = E.recordsById.get(s.shapeId);
+            const helper = emitter.recordKeySetHelper(s.shapeId);
+            emitter.line(`${helper}(${obj.name}, ${key.name}, ${v.name});${emitter.srcComment(s.loc)}`);
+            const shape = emitter.recordsById.get(s.shapeId);
             // MAY THROW: a dyn value validating against a declared field, or a
             // signature-free shape's key MISS (scr_record_key_miss).
             if (shape && (!shape.indexValue || (shape.indexValue.kind === "dyn" && shape.fields.length > 0))) {
-                E.emitPendingCheck();
+                emitter.emitPendingCheck();
             }
             break;
         }
@@ -463,72 +515,72 @@ export function emitStmt(E, s) {
             // when the whole loop ends (and by `return`'s frame sweep). A real
             // C for-loop makes plain `continue` correct: the update still runs.
             if (s.iterable.type.kind !== "array")
-                throw new Error("emitter bug: forOf over non-array");
+                throw new InternalCompilerError("emitter bug: forOf over non-array");
             const elem = s.iterable.type.elem;
-            const arr = E.emitExpr(s.iterable);
-            const idx = `sc_t${E.tempCounter++}`;
-            E.line(`for (double ${idx} = 0; ${idx} < scr_arr_len(${arr.name}); ${idx} += 1) {${E.srcComment(s.loc)}`);
-            E.indent++;
+            const arr = emitter.emitExpr(s.iterable);
+            const idx = `sc_t${emitter.tempCounter++}`;
+            emitter.line(`for (double ${idx} = 0; ${idx} < scr_arr_len(${arr.name}); ${idx} += 1) {${emitter.srcComment(s.loc)}`);
+            emitter.indent++;
             // A real C for-loop makes plain `continue` correct (the update
             // still runs); a LABELED forOf allocates a continue label placed at
             // the END of the iteration (after the per-iteration scope release —
             // the goto path released it itself) so nested loops can goto it.
-            const loop = E.loopTarget(null, s.labels);
-            E.jumpTargets.push(loop);
+            const loop = emitter.loopTarget(null, s.labels);
+            emitter.jumpTargets.push(loop);
             // The loop variable is a fresh const per iteration: its scope opens
             // here, holds the (for ref elements: owned +1) current element, and
             // releases it at the end of each iteration.
-            E.scopes.push([]);
+            emitter.scopes.push([]);
             const local = mangleLocal(s.localId);
-            const localInfo = E.currentLocals.get(s.localId);
+            const localInfo = emitter.currentLocals.get(s.localId);
             if (localInfo?.boxed) {
                 // Captured loop variable: a fresh box per iteration, matching the
                 // fresh const binding (closures made in iteration k keep seeing
                 // iteration k's element). The box takes ownership of a ref
                 // element's +1 and is released with the iteration's scope.
-                E.line(`${local} = ${E.boxNewC(elem)}; /* per-iteration ${localInfo.name} */`);
-                E.line(`scr_box_set_${boxAccess(elem)}(${local}, scr_arr_get_${elemAccess(elem)}(${arr.name}, ${idx}));`);
-                E.scopes[E.scopes.length - 1].push({ name: local, type: elem, boxed: true });
+                emitter.line(`${local} = ${emitter.boxNewC(elem)}; /* per-iteration ${localInfo.name} */`);
+                emitter.line(`scr_box_set_${boxAccess(elem)}(${local}, scr_arr_get_${elemAccess(elem)}(${arr.name}, ${idx}));`);
+                emitter.scopes[emitter.scopes.length - 1].push({ name: local, type: elem, boxed: true });
             }
             else {
-                E.line(`${local} = scr_arr_get_${elemAccess(elem)}(${arr.name}, ${idx});`);
+                emitter.line(`${local} = scr_arr_get_${elemAccess(elem)}(${arr.name}, ${idx});`);
                 if (isRefCounted(elem))
-                    E.scopes[E.scopes.length - 1].push({ name: local, type: elem });
+                    emitter.scopes[emitter.scopes.length - 1].push({ name: local, type: elem });
             }
-            E.emitStmts(s.body);
-            const endedWithJump = E.endsWithJump(s.body);
-            const scope = E.scopes.pop();
+            emitter.emitStmts(s.body);
+            const endedWithJump = endsWithJump(s.body);
+            const scope = emitter.scopes.pop();
             if (!endedWithJump)
-                E.releaseFrame(scope);
-            E.jumpTargets.pop();
+                emitter.releaseFrame(scope);
+            emitter.jumpTargets.pop();
             if (loop.usedContinue && loop.continueLabel)
-                E.line(`${loop.continueLabel}:;`);
-            E.indent--;
-            E.line(`}`);
+                emitter.line(`${loop.continueLabel}:;`);
+            emitter.indent--;
+            emitter.line(`}`);
             if (loop.usedEnd)
-                E.line(`${loop.endLabel}:;`);
+                emitter.line(`${loop.endLabel}:;`);
             break;
         }
         case "block": {
             if (s.labels === undefined) {
-                E.emitBlock(s.body);
+                emitter.emitBlock(s.body);
                 break;
             }
             // A labeled block: `break lbl` inside jumps to the end label
             // (releasing the block's scope itself); nothing else can target it.
             const target = {
                 kind: "block",
-                endLabel: `sc_end_${E.labelCounter++}`,
+                endLabel: `sc_end_${emitter.labelCounter++}`,
                 usedEnd: false,
                 labels: s.labels,
-                scopeDepth: E.scopes.length,
-                frameDepth: E.frames.length,
+                scopeDepth: emitter.scopes.length,
+                frameDepth: emitter.frames.length,
             };
-            E.jumpTargets.push(target);
-            E.emitBlock(s.body);
-            E.jumpTargets.pop();
+            emitter.jumpTargets.push(target);
+            emitter.emitBlock(s.body);
+            emitter.jumpTargets.pop();
             if (target.usedEnd)
-                E.line(`${target.endLabel}:;`);
+                emitter.line(`${target.endLabel}:;`);
             break;
         }
         case "break": {
@@ -542,16 +594,16 @@ export function emitStmt(E, s) {
             // loop's releases after the loop and a switch's after its end
             // label are still on this jump's path.
             let target;
-            for (let i = E.jumpTargets.length - 1; i >= 0; i--) {
-                const t = E.jumpTargets[i];
+            for (let i = emitter.jumpTargets.length - 1; i >= 0; i--) {
+                const t = emitter.jumpTargets[i];
                 if (s.label !== undefined ? t.labels?.includes(s.label) : t.kind !== "block") {
                     target = t;
                     break;
                 }
             }
             if (!target)
-                throw new Error("emitter bug: break target not found");
-            E.releaseForJump(target.frameDepth, target.scopeDepth);
+                throw new InternalCompilerError("emitter bug: break target not found");
+            emitter.releaseForJump(target.frameDepth, target.scopeDepth);
             if (target.kind !== "loop" || s.label !== undefined) {
                 // Switches are emitted as goto chains and blocks aren't C loops
                 // at all, so a C `break` cannot target either; and a LABELED
@@ -559,10 +611,10 @@ export function emitStmt(E, s) {
                 // All three jump to the target's end label (labeled loops always
                 // allocate one — loopTarget).
                 target.usedEnd = true;
-                E.line(`goto ${target.endLabel};${E.srcComment(s.loc)}`);
+                emitter.line(`goto ${target.endLabel};${emitter.srcComment(s.loc)}`);
             }
             else {
-                E.line(`break;${E.srcComment(s.loc)}`);
+                emitter.line(`break;${emitter.srcComment(s.loc)}`);
             }
             break;
         }
@@ -571,30 +623,30 @@ export function emitStmt(E, s) {
             // labeled blocks in between (their scopes are still released — the
             // jump exits them). Labeled: binds to the loop carrying the label.
             let loop;
-            for (let i = E.jumpTargets.length - 1; i >= 0; i--) {
-                const t = E.jumpTargets[i];
+            for (let i = emitter.jumpTargets.length - 1; i >= 0; i--) {
+                const t = emitter.jumpTargets[i];
                 if (t.kind === "loop" && (s.label === undefined || t.labels?.includes(s.label))) {
                     loop = t;
                     break;
                 }
             }
             if (!loop)
-                throw new Error("emitter bug: continue target not found");
-            E.releaseForJump(loop.frameDepth, loop.scopeDepth);
+                throw new InternalCompilerError("emitter bug: continue target not found");
+            emitter.releaseForJump(loop.frameDepth, loop.scopeDepth);
             if (loop.continueLabel) {
                 // Labeled loops always allocate one (a labeled continue may
                 // target an outer loop a C continue could never reach); for/
                 // do-while allocate one for their update/condition point.
                 loop.usedContinue = true;
-                E.line(`goto ${loop.continueLabel};${E.srcComment(s.loc)}`);
+                emitter.line(`goto ${loop.continueLabel};${emitter.srcComment(s.loc)}`);
             }
             else {
-                E.line(`continue;${E.srcComment(s.loc)}`);
+                emitter.line(`continue;${emitter.srcComment(s.loc)}`);
             }
             break;
         }
         case "return": {
-            const fin = E.finallyStack[E.finallyStack.length - 1];
+            const fin = emitter.finallyStack[emitter.finallyStack.length - 1];
             if (fin) {
                 // Crossing ≥1 finally: the value is computed and snapshotted
                 // FIRST (a finally mutating the returned local cannot change
@@ -602,26 +654,26 @@ export function emitStmt(E, s) {
                 // region releases and control runs that region's pending-return
                 // finally copy; its tail dispatches further out or returns.
                 if (s.value) {
-                    const v = E.emitExpr(s.value);
-                    E.moveTemp(v); // ownership parks in the slot until the dispatch returns it
-                    E.line(`sc_pret = ${v.name};${E.srcComment(s.loc)}`);
+                    const v = emitter.emitExpr(s.value);
+                    emitter.moveTemp(v); // ownership parks in the slot until the dispatch returns it
+                    emitter.line(`sc_pret = ${v.name};${emitter.srcComment(s.loc)}`);
                 }
                 fin.used = true;
-                E.releaseForJump(fin.frameDepth, fin.scopeDepth);
-                E.line(`goto ${fin.label};${s.value ? "" : E.srcComment(s.loc)}`);
+                emitter.releaseForJump(fin.frameDepth, fin.scopeDepth);
+                emitter.line(`goto ${fin.label};${s.value ? "" : emitter.srcComment(s.loc)}`);
                 break;
             }
             if (s.value) {
-                const v = E.emitExpr(s.value);
-                E.moveTemp(v);
+                const v = emitter.emitExpr(s.value);
+                emitter.moveTemp(v);
                 // Everything down to function depth releases; the moved result is
                 // exempt (already struck from its frame).
-                E.releaseForJump(0, 0);
-                E.line(`return ${v.name};${E.srcComment(s.loc)}`);
+                emitter.releaseForJump(0, 0);
+                emitter.line(`return ${v.name};${emitter.srcComment(s.loc)}`);
             }
             else {
-                E.releaseForJump(0, 0);
-                E.line(`return;${E.srcComment(s.loc)}`);
+                emitter.releaseForJump(0, 0);
+                emitter.line(`return;${emitter.srcComment(s.loc)}`);
             }
             break;
         }
@@ -629,34 +681,34 @@ export function emitStmt(E, s) {
             // Evaluate, move ownership into the runtime's exception cell, then
             // unwind unconditionally (the innermost try handler, or out of the
             // function) — the same release path as return/break/continue.
-            const v = E.emitExpr(s.value);
+            const v = emitter.emitExpr(s.value);
             const t = s.value.type;
             if (isRefCounted(t))
-                E.moveTemp(v); // the cell takes ownership
+                emitter.moveTemp(v); // the cell takes ownership
             if (t.kind === "date") {
-                throw new Error("emitter bug: Date throw reached backend");
+                throw new InternalCompilerError("emitter bug: Date throw reached backend");
             }
             else if (t.kind === "f64") {
-                E.line(`scr_throw_f64(${v.name});${E.srcComment(s.loc)}`);
+                emitter.line(`scr_throw_f64(${v.name});${emitter.srcComment(s.loc)}`);
             }
             else if (t.kind === "bool") {
-                E.line(`scr_throw_bool(${v.name});${E.srcComment(s.loc)}`);
+                emitter.line(`scr_throw_bool(${v.name});${emitter.srcComment(s.loc)}`);
             }
             else if (t.kind === "string") {
-                E.line(`scr_throw_str(${v.name});${E.srcComment(s.loc)}`);
+                emitter.line(`scr_throw_str(${v.name});${emitter.srcComment(s.loc)}`);
             }
-            else if (t.kind === "object" && E.classMeta.get(t.className)?.hierarchy) {
+            else if (t.kind === "object" && emitter.classMeta.get(t.className)?.hierarchy) {
                 // Hierarchy instances carry a vtable word: the OBJ kind keeps the
                 // dynamic class inspectable (catch-binding instanceof, and the
                 // uncaught printer's "name: message" for Error instances).
                 const rc = vAdapters(t);
-                E.line(`scr_throw_obj(${v.name}, &${rc.retain}, &${rc.release}, ${E.traceArgC(t)});${E.srcComment(s.loc)}`);
+                emitter.line(`scr_throw_obj(${v.name}, &${rc.retain}, &${rc.release}, ${emitter.traceArgC(t)});${emitter.srcComment(s.loc)}`);
             }
             else {
                 const rc = vAdapters(t);
-                E.line(`scr_throw_ref(${v.name}, &${rc.retain}, &${rc.release}, ${E.traceArgC(t)});${E.srcComment(s.loc)}`);
+                emitter.line(`scr_throw_ref(${v.name}, &${rc.retain}, &${rc.release}, ${emitter.traceArgC(t)});${emitter.srcComment(s.loc)}`);
             }
-            E.emitUnwind();
+            emitter.emitUnwind();
             break;
         }
         case "runtimeFence": {
@@ -664,29 +716,29 @@ export function emitStmt(E, s) {
             // the construct (message) with the SC code stamped on `code`,
             // then unwind exactly like `throw`.
             const bytes = Buffer.from(s.message, "utf8");
-            E.line(`scr_throw_error_msg_code(SCR_ERR_ERROR, ${cStringLiteral(bytes)}, ${bytes.length}, "${s.code}");${E.srcComment(s.loc)}`);
-            E.emitUnwind();
+            emitter.line(`scr_throw_error_msg_code(SCR_ERR_ERROR, ${cStringLiteral(bytes)}, ${bytes.length}, "${s.code}");${emitter.srcComment(s.loc)}`);
+            emitter.emitUnwind();
             break;
         }
         case "rethrow":
             // Re-raise the saved snapshot (payload retained — the binding local
             // releases with its scope) and unwind like `throw`.
-            E.line(`scr_rethrow(${mangleLocal(s.localId)});${E.srcComment(s.loc)}`);
-            E.emitUnwind();
+            emitter.line(`scr_rethrow(${mangleLocal(s.localId)});${emitter.srcComment(s.loc)}`);
+            emitter.emitUnwind();
             break;
         case "tryCatch":
-            E.emitTryCatch(s);
+            emitter.emitTryCatch(s);
             break;
         default: {
             const _exhaustive = s;
             void _exhaustive;
         }
     }
-    const frame = E.frames.pop();
+    const frame = emitter.frames.pop();
     // return/throw already released their frames on the jump path; emitting
     // the fall-through releases after them would be dead double-release code.
     if (s.kind !== "return" && s.kind !== "throw" && s.kind !== "rethrow" && s.kind !== "runtimeFence")
-        E.releaseFrame(frame);
+        emitter.releaseFrame(frame);
 }
 /** try/catch/finally via pending-flag unwinding. Entering a try emits NO
    * code: the try context is compile-time state (tryStack) that redirects
@@ -719,8 +771,8 @@ export function emitStmt(E, s) {
    * normal, exception, and pending-return are the only paths a finally
    * must model; jumps out of PLAIN try/catch need nothing here —
    * release-on-jump already walks the try scopes. */
-export function emitTryCatch(E, s) {
-    const id = E.labelCounter++;
+export function emitTryCatch(emitter, s) {
+    const id = emitter.labelCounter++;
     const hasCatch = s.catchBody !== null;
     const hasFinally = s.finallyBody !== null;
     const catchLabel = `sc_catch_${id}`;
@@ -732,8 +784,8 @@ export function emitTryCatch(E, s) {
     const handler = {
         label: hasCatch ? catchLabel : finExcLabel,
         used: false,
-        frameDepth: E.frames.length,
-        scopeDepth: E.scopes.length,
+        frameDepth: emitter.frames.length,
+        scopeDepth: emitter.scopes.length,
     };
     // The pending-return region: returns inside tryBody/catchBody snapshot
     // their value and jump here-ish (the pending-return finally copy below)
@@ -742,77 +794,77 @@ export function emitTryCatch(E, s) {
         ? {
             label: `sc_finret_${id}`,
             used: false,
-            frameDepth: E.frames.length,
-            scopeDepth: E.scopes.length,
+            frameDepth: emitter.frames.length,
+            scopeDepth: emitter.scopes.length,
         }
         : null;
-    E.line(`/* try */${E.srcComment(s.loc)}`);
+    emitter.line(`/* try */${emitter.srcComment(s.loc)}`);
     if (retEntry)
-        E.finallyStack.push(retEntry);
-    E.tryStack.push(handler);
-    E.emitBlock(s.tryBody);
-    E.tryStack.pop();
+        emitter.finallyStack.push(retEntry);
+    emitter.tryStack.push(handler);
+    emitter.emitBlock(s.tryBody);
+    emitter.tryStack.pop();
     // Exceptions raised in the CATCH body unwind to the exception-path
     // finally (pending stays set through it) when one exists.
     const excHandler = {
         label: finExcLabel,
         used: !hasCatch && handler.used,
-        frameDepth: E.frames.length,
-        scopeDepth: E.scopes.length,
+        frameDepth: emitter.frames.length,
+        scopeDepth: emitter.scopes.length,
     };
     if (hasCatch && handler.used) {
-        if (!E.endsWithJump(s.tryBody)) {
-            E.line(`goto ${afterTryLabel};`);
+        if (!endsWithJump(s.tryBody)) {
+            emitter.line(`goto ${afterTryLabel};`);
             afterTryLabelUsed = true;
         }
         if (hasFinally)
-            E.tryStack.push(excHandler);
+            emitter.tryStack.push(excHandler);
         // Generator bodies: a pending GENRET sentinel (.return(v) injected at
         // a yield) is a RETURN completion, not a throw — catch must not take
         // it. Re-unwind past this handler (finally still runs — the unwind
         // targets the exception-path finally or the enclosing context; the
         // runtime depths here equal the handler's, so no double release).
         const genretPrologue = () => {
-            if (E.currentGenerator === null)
+            if (emitter.currentGenerator === null)
                 return;
-            E.line(`if (scr_exc_genret_pending()) { /* .return(): not catchable */`);
-            E.indent++;
-            E.emitUnwind();
-            E.indent--;
-            E.line(`}`);
+            emitter.line(`if (scr_exc_genret_pending()) { /* .return(): not catchable */`);
+            emitter.indent++;
+            emitter.emitUnwind();
+            emitter.indent--;
+            emitter.line(`}`);
         };
         if (s.catchLocalId !== null) {
             // catch (e): the exception MOVES into the binding's snapshot box,
             // owned by the catch body's scope (released on every exit — normal
             // fall-through, jumps out, and unwinds from the body).
             const binding = mangleLocal(s.catchLocalId);
-            E.line(`${catchLabel}:; /* catch (${E.currentLocals.get(s.catchLocalId)?.name ?? "e"}) — takes the exception */`);
+            emitter.line(`${catchLabel}:; /* catch (${emitter.currentLocals.get(s.catchLocalId)?.name ?? "e"}) — takes the exception */`);
             genretPrologue();
-            E.emitBlock(s.catchBody, (scope) => {
-                E.line(`${binding} = scr_exc_take();`);
+            emitter.emitBlock(s.catchBody, (scope) => {
+                emitter.line(`${binding} = scr_exc_take();`);
                 scope.push({ name: binding, type: CAUGHT });
             });
         }
         else {
-            E.line(`${catchLabel}:; /* catch — takes the exception */`);
+            emitter.line(`${catchLabel}:; /* catch — takes the exception */`);
             genretPrologue();
-            E.line(`scr_exc_clear();`);
-            E.emitBlock(s.catchBody);
+            emitter.line(`scr_exc_clear();`);
+            emitter.emitBlock(s.catchBody);
         }
         if (hasFinally)
-            E.tryStack.pop();
+            emitter.tryStack.pop();
         // Normal completion of the catch falls through to afterTryLabel.
     }
     if (retEntry)
-        E.finallyStack.pop();
+        emitter.finallyStack.pop();
     if (hasFinally) {
         if (afterTryLabelUsed)
-            E.line(`${afterTryLabel}:;`);
-        E.line(`/* finally (normal path) */`);
-        E.emitBlock(s.finallyBody);
+            emitter.line(`${afterTryLabel}:;`);
+        emitter.line(`/* finally (normal path) */`);
+        emitter.emitBlock(s.finallyBody);
         const needEnd = excHandler.used || retEntry.used;
         if (needEnd)
-            E.line(`goto ${endLabel};`);
+            emitter.line(`goto ${endLabel};`);
         if (excHandler.used) {
             // The pending exception is STASHED across the finally body (a
             // ScrCaught snapshot, re-raised after) so the body runs with a
@@ -825,14 +877,14 @@ export function emitTryCatch(E, s) {
             // JS's replace semantics); normal completion re-raises the stash
             // and keeps propagating.
             const stash = `sc_fexc_${id}`;
-            E.line(`${finExcLabel}:; /* finally (exception path — stashed) */`);
-            E.line(`ScrCaught *${stash} = scr_exc_take();`);
-            E.scopes.push([{ name: stash, type: CAUGHT }]);
-            E.emitBlock(s.finallyBody);
-            E.scopes.pop(); // normal completion keeps the stash for the re-raise
-            E.line(`scr_rethrow(${stash});`);
-            E.line(`scr_caught_release(${stash});`);
-            E.emitUnwind();
+            emitter.line(`${finExcLabel}:; /* finally (exception path — stashed) */`);
+            emitter.line(`ScrCaught *${stash} = scr_exc_take();`);
+            emitter.scopes.push([{ name: stash, type: CAUGHT }]);
+            emitter.emitBlock(s.finallyBody);
+            emitter.scopes.pop(); // normal completion keeps the stash for the re-raise
+            emitter.line(`scr_rethrow(${stash});`);
+            emitter.line(`scr_caught_release(${stash});`);
+            emitter.emitUnwind();
         }
         if (retEntry.used) {
             // Pending-return path: a return in the try/catch body parked its
@@ -843,30 +895,30 @@ export function emitTryCatch(E, s) {
             // actual return. A THROW inside this copy replaces the pending
             // return (JS): the slot's owned value rides a synthetic scope
             // entry so the unwind releases it.
-            E.line(`${retEntry.label}:; /* finally (pending-return path) */`);
-            const retT = E.currentReturnType;
+            emitter.line(`${retEntry.label}:; /* finally (pending-return path) */`);
+            const retT = emitter.currentReturnType;
             const own = isRefCounted(retT);
             if (own)
-                E.scopes.push([{ name: "sc_pret", type: retT }]);
-            E.emitBlock(s.finallyBody);
+                emitter.scopes.push([{ name: "sc_pret", type: retT }]);
+            emitter.emitBlock(s.finallyBody);
             if (own)
-                E.scopes.pop();
-            const outer = E.finallyStack[E.finallyStack.length - 1];
+                emitter.scopes.pop();
+            const outer = emitter.finallyStack[emitter.finallyStack.length - 1];
             if (outer) {
                 outer.used = true;
-                E.releaseForJump(outer.frameDepth, outer.scopeDepth);
-                E.line(`goto ${outer.label};`);
+                emitter.releaseForJump(outer.frameDepth, outer.scopeDepth);
+                emitter.line(`goto ${outer.label};`);
             }
             else {
-                E.releaseForJump(0, 0);
-                E.line(retT.kind === "void" ? `return;` : `return sc_pret;`);
+                emitter.releaseForJump(0, 0);
+                emitter.line(retT.kind === "void" ? `return;` : `return sc_pret;`);
             }
         }
         if (needEnd)
-            E.line(`${endLabel}:;`);
+            emitter.line(`${endLabel}:;`);
     }
     else if (afterTryLabelUsed) {
-        E.line(`${endLabel}:;`);
+        emitter.line(`${endLabel}:;`);
     }
 }
 /** JS-exact switch as a goto chain — C `switch` cannot express lazily
@@ -887,27 +939,27 @@ export function emitTryCatch(E, s) {
    * it still holds the pointer a previous iteration's scope exit already
    * released. The declarations are therefore NULL-reset up front; the
    * scope-exit releases rely on the runtime's NULL-tolerant release calls. */
-export function emitSwitch(E, s) {
+export function emitSwitch(emitter, s) {
     if (s.disc.type.kind !== "f64" && s.disc.type.kind !== "string" && s.disc.type.kind !== "bool") {
-        throw new Error(`emitter bug: switch on ${s.disc.type.kind}`);
+        throw new InternalCompilerError(`emitter bug: switch on ${s.disc.type.kind}`);
     }
-    const id = E.labelCounter++;
+    const id = emitter.labelCounter++;
     const endLabel = `sc_swend_${id}`;
     const caseLabel = (i) => `sc_swcase_${id}_${i}`;
     // The disc temp lives in the whole statement's frame: for a string
     // discriminant it stays alive across every test and body, released when
     // the switch statement ends (break lands before that release; return
     // sweeps frames itself).
-    const disc = E.emitExpr(s.disc);
+    const disc = emitter.emitExpr(s.disc);
     // NULL-reset refcounted/boxed locals declared at the top level of case
     // bodies (nested blocks manage their own scopes on normal control flow).
     for (const c of s.cases) {
         for (const stmt of c.body) {
             if (stmt.kind !== "varDecl")
                 continue;
-            const local = E.currentLocals.get(stmt.localId);
+            const local = emitter.currentLocals.get(stmt.localId);
             if (local.boxed || isRefCounted(local.type)) {
-                E.line(`${mangleLocal(local.id)} = NULL; /* case-scoped ${local.name} */`);
+                emitter.line(`${mangleLocal(local.id)} = NULL; /* case-scoped ${local.name} */`);
             }
         }
     }
@@ -919,16 +971,16 @@ export function emitSwitch(E, s) {
             defaultIdx = i;
             return;
         }
-        E.frames.push([]);
-        const t = E.emitExpr(c.test);
+        emitter.frames.push([]);
+        const t = emitter.emitExpr(c.test);
         const cmp = c.test.type.kind === "string"
             ? `scr_str_eq(${disc.name}, ${t.name})`
             : `${disc.name} == ${t.name}`;
-        const hit = E.newTemp(BOOL, cmp);
-        E.releaseFrame(E.frames.pop());
-        E.line(`if (${hit.name}) goto ${caseLabel(i)};`);
+        const hit = emitter.newTemp(BOOL, cmp);
+        emitter.releaseFrame(emitter.frames.pop());
+        emitter.line(`if (${hit.name}) goto ${caseLabel(i)};`);
     });
-    E.line(`goto ${defaultIdx >= 0 ? caseLabel(defaultIdx) : endLabel};`);
+    emitter.line(`goto ${defaultIdx >= 0 ? caseLabel(defaultIdx) : endLabel};`);
     // Bodies in source order: entering one falls through the rest (JS-exact)
     // until a break jumps to the end label.
     const target = {
@@ -936,33 +988,33 @@ export function emitSwitch(E, s) {
         endLabel,
         usedEnd: defaultIdx < 0,
         ...(s.labels !== undefined && { labels: s.labels }),
-        scopeDepth: E.scopes.length,
-        frameDepth: E.frames.length,
+        scopeDepth: emitter.scopes.length,
+        frameDepth: emitter.frames.length,
     };
-    E.jumpTargets.push(target);
-    E.scopes.push([]);
+    emitter.jumpTargets.push(target);
+    emitter.scopes.push([]);
     s.cases.forEach((c, i) => {
-        E.line(`${caseLabel(i)}:;`);
-        E.indent++;
-        E.emitStmts(c.body);
-        E.indent--;
+        emitter.line(`${caseLabel(i)}:;`);
+        emitter.indent++;
+        emitter.emitStmts(c.body);
+        emitter.indent--;
     });
-    E.jumpTargets.pop();
-    const scope = E.scopes.pop();
+    emitter.jumpTargets.pop();
+    const scope = emitter.scopes.pop();
     // Natural fall-off of the last body releases the shared scope here; a
     // jump (break/return/continue/throw) already released it before jumping.
     const lastBody = s.cases[s.cases.length - 1]?.body;
-    if (!lastBody || !E.endsWithJump(lastBody))
-        E.releaseFrame(scope);
+    if (!lastBody || !endsWithJump(lastBody))
+        emitter.releaseFrame(scope);
     if (target.usedEnd)
-        E.line(`${endLabel}:;`);
+        emitter.line(`${endLabel}:;`);
 }
 /** Emits `if (cond) ` followed by a block on the same line for readability. */
-export function mergeBrace(E, emitBlockFn) {
-    const head = E.lines.pop();
-    const before = E.lines.length;
+export function mergeBrace(emitter, emitBlockFn) {
+    const head = emitter.lines.pop();
+    const before = emitter.lines.length;
     emitBlockFn();
-    E.lines[before] = head + E.lines[before].trimStart();
+    emitter.lines[before] = head + emitter.lines[before].trimStart();
 }
 /** Evaluates `expr` in its own statement frame inside an already-open
    * branch and moves the result into the C lvalue `target`: the chosen
@@ -970,20 +1022,20 @@ export function mergeBrace(E, emitBlockFn) {
    * releases inside the branch. The shared core of the lazily-branched
    * expressions (`logical`, `ternary`); the caller owns the surrounding
    * braces/indentation and registers `target` in ITS frame. */
-export function emitBranchInto(E, target, expr) {
-    E.frames.push([]);
-    const v = E.emitExpr(expr);
-    E.moveTemp(v);
-    E.line(`${target} = ${v.name};`);
-    E.releaseFrame(E.frames.pop());
+export function emitBranchInto(emitter, target, expr) {
+    emitter.frames.push([]);
+    const v = emitter.emitExpr(expr);
+    emitter.moveTemp(v);
+    emitter.line(`${target} = ${v.name};`);
+    emitter.releaseFrame(emitter.frames.pop());
 }
 /** Evaluates a condition; its string temps are released before the branch,
    * which is safe because the result is a scalar bool. */
-export function emitCondition(E, cond) {
-    const t = E.emitExpr(cond);
-    const frame = E.currentFrame();
-    E.releaseFrame(frame);
+export function emitCondition(emitter, cond) {
+    const t = emitter.emitExpr(cond);
+    const frame = emitter.currentFrame();
+    emitter.releaseFrame(frame);
     frame.length = 0;
     return t.name;
 }
-//# sourceMappingURL=emit-stmts.js.map
+//# sourceMappingURL=stmts.js.map