@scriptc/compiler 0.2.9 → 0.3.0

package/dist/ir/unshare.js

@@ -0,0 +1,60 @@
+import { reparseExpr, reparseStmt } from "./serialize.js";
+import { everyExprChild, everyStmtChild, mapExprChildren, mapStmtChildren } from "./traverse.js";
+/** Give every occurrence of an executable node its own object.
+ *
+ * Lowering helpers may place one node at several sites (a binding's varRef
+ * read in a loop condition and in its body, a shared `break`). Analyses key
+ * their facts by node identity (integer ranges, int32 write proofs, borrow
+ * and lifetime facts), so a shared node carries one fact for all of its
+ * sites: integer ranges keep the join, which loses what one site proves. A
+ * serialized module gives every occurrence its own node; this makes the
+ * in-memory module equivalent, so analyses and emission behave the same on
+ * a module lowered in memory and on one read back from its artifact.
+ * Functions without a repeated node are kept as they are; the input is
+ * never mutated. */
+export function unshareNodes(mod) {
+    const seen = new Set();
+    const repeated = new Set();
+    const affected = new Set();
+    let current = null;
+    // A repeated node marks the function holding the later occurrence. Its
+    // subtree is walked again, so every node under it is repeated as well.
+    const visit = (node) => {
+        if (!seen.has(node))
+            seen.add(node);
+        else {
+            repeated.add(node);
+            affected.add(current);
+        }
+    };
+    const findExpr = (node) => {
+        visit(node);
+        return everyExprChild(node, findExpr, findStmt);
+    };
+    const findStmt = (node) => {
+        visit(node);
+        return everyStmtChild(node, findExpr, findStmt);
+    };
+    for (const fn of mod.functions) {
+        current = fn;
+        for (const node of fn.body)
+            findStmt(node);
+    }
+    if (affected.size === 0)
+        return mod;
+    // Rebuilding a function copies every node that has children; a repeated
+    // childless node reads back as a fresh object at each of its sites there.
+    const expr = (node) => {
+        const copy = mapExprChildren(node, expr, stmt);
+        return copy !== node || !repeated.has(node) ? copy : reparseExpr(node);
+    };
+    const stmt = (node) => {
+        const copy = mapStmtChildren(node, expr, stmt);
+        return copy !== node || !repeated.has(node) ? copy : reparseStmt(node);
+    };
+    return {
+        ...mod,
+        functions: mod.functions.map((fn) => affected.has(fn) ? { ...fn, body: fn.body.map(stmt) } : fn),
+    };
+}
+//# sourceMappingURL=unshare.js.map

package/dist/ir/unshare.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unshare.js","sourceRoot":"","sources":["../../src/ir/unshare.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAEjG;;;;;;;;;;;oBAWoB;AACpB,MAAM,UAAU,YAAY,CAAC,GAAa;IACxC,MAAM,IAAI,GAAG,IAAI,GAAG,EAAmB,CAAC;IACxC,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAmB,CAAC;IAC5C,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAc,CAAC;IACvC,IAAI,OAAO,GAAsB,IAAI,CAAC;IACtC,uEAAuE;IACvE,uEAAuE;IACvE,MAAM,KAAK,GAAG,CAAC,IAAqB,EAAQ,EAAE;QAC5C,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;aAC/B,CAAC;YACJ,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YACnB,QAAQ,CAAC,GAAG,CAAC,OAAQ,CAAC,CAAC;QACzB,CAAC;IACH,CAAC,CAAC;IACF,MAAM,QAAQ,GAAG,CAAC,IAAY,EAAW,EAAE;QACzC,KAAK,CAAC,IAAI,CAAC,CAAC;QACZ,OAAO,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;IAClD,CAAC,CAAC;IACF,MAAM,QAAQ,GAAG,CAAC,IAAY,EAAW,EAAE;QACzC,KAAK,CAAC,IAAI,CAAC,CAAC;QACZ,OAAO,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;IAClD,CAAC,CAAC;IACF,KAAK,MAAM,EAAE,IAAI,GAAG,CAAC,SAAS,EAAE,CAAC;QAC/B,OAAO,GAAG,EAAE,CAAC;QACb,KAAK,MAAM,IAAI,IAAI,EAAE,CAAC,IAAI;YAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC7C,CAAC;IACD,IAAI,QAAQ,CAAC,IAAI,KAAK,CAAC;QAAE,OAAO,GAAG,CAAC;IACpC,wEAAwE;IACxE,0EAA0E;IAC1E,MAAM,IAAI,GAAG,CAAC,IAAY,EAAU,EAAE;QACpC,MAAM,IAAI,GAAG,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;QAC/C,OAAO,IAAI,KAAK,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IACzE,CAAC,CAAC;IACF,MAAM,IAAI,GAAG,CAAC,IAAY,EAAU,EAAE;QACpC,MAAM,IAAI,GAAG,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;QAC/C,OAAO,IAAI,KAAK,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IACzE,CAAC,CAAC;IACF,OAAO;QACL,GAAG,GAAG;QACN,SAAS,EAAE,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAClC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAC3D;KACF,CAAC;AACJ,CAAC"}

package/dist/ir/unshare.test.js

@@ -0,0 +1,115 @@
+import { expect, test } from "vitest";
+import { emitLlvmModule } from "../backend/llvm/emitter.js";
+import { analyzeIntegerRanges } from "./integer-ranges.js";
+import { F64, VOID } from "./ir.js";
+import { deserializeModule, serializeModule } from "./serialize.js";
+import { everyStmtList } from "./traverse.js";
+import { unshareNodes } from "./unshare.js";
+import { validateModule } from "./validate.js";
+const loc = { file: "unshare.ts", start: 0, end: 1 };
+const num = (value) => ({
+    kind: "numLit",
+    value,
+    type: F64,
+    loc,
+});
+const add = (left, right) => ({
+    kind: "bin",
+    op: "+",
+    left,
+    right,
+    type: F64,
+    loc,
+});
+/** One varRef object read at two sites: `x` is unknown at the first and
+ * exactly 5 at the second, as lowering helpers that reuse a read produce;
+ * and one `p + 2` expression stored at two sites. */
+function sharedRead() {
+    const read = { kind: "varRef", localId: "x", type: F64, loc };
+    const twice = add({ kind: "varRef", localId: "p", type: F64, loc }, num(2));
+    const body = [
+        {
+            kind: "varDecl",
+            localId: "x",
+            init: { kind: "varRef", localId: "p", type: F64, loc },
+            loc,
+        },
+        { kind: "varDecl", localId: "a", init: add(read, num(1)), loc },
+        { kind: "assign", localId: "x", value: num(5), loc },
+        { kind: "varDecl", localId: "b", init: add(read, num(1)), loc },
+        // A repeated node with children: its leaves repeat with it.
+        { kind: "varDecl", localId: "c", init: twice, loc },
+        { kind: "assign", localId: "c", value: twice, loc },
+        {
+            kind: "return",
+            value: add({ kind: "varRef", localId: "a", type: F64, loc }, {
+                kind: "varRef",
+                localId: "b",
+                type: F64,
+                loc,
+            }),
+            loc,
+        },
+    ];
+    const mod = {
+        irVersion: 16,
+        sourceFile: loc.file,
+        entry: "main",
+        functions: [
+            { name: "main", loc, params: [], locals: [], returnType: VOID, body: [] },
+            {
+                name: "f",
+                loc,
+                params: [{ name: "p", localId: "p", type: F64 }],
+                locals: ["p", "x", "a", "b", "c"].map((id) => ({
+                    id,
+                    name: id,
+                    type: F64,
+                    mutable: true,
+                })),
+                returnType: F64,
+                body,
+            },
+        ],
+    };
+    return { mod, read };
+}
+function nodes(mod) {
+    const out = [];
+    const visit = (node) => (out.push(node), true);
+    for (const fn of mod.functions)
+        everyStmtList(fn.body, { expr: visit, stmt: visit });
+    return out;
+}
+test("every occurrence gets its own node without mutating the input", () => {
+    const { mod, read } = sharedRead();
+    const before = serializeModule(mod);
+    const tree = unshareNodes(mod);
+    expect(serializeModule(mod)).toBe(before);
+    expect(serializeModule(tree)).toBe(before);
+    const all = nodes(tree);
+    expect(new Set(all).size).toBe(all.length);
+    expect(all).not.toContain(read);
+    // The entry function had no shared node and is kept as it is.
+    expect(tree.functions[0]).toBe(mod.functions[0]);
+    expect(unshareNodes(tree)).toBe(tree);
+});
+test("ranges are per occurrence once nodes are unshared", () => {
+    const { mod, read } = sharedRead();
+    // Keyed by identity, the shared read holds the join of both sites.
+    expect(analyzeIntegerRanges(mod.functions[1]).get(read)).toBeNull();
+    const fn = unshareNodes(mod).functions[1];
+    const reads = nodes({ ...mod, functions: [fn] }).filter((node) => node.kind === "varRef" && node.localId === "x");
+    const ranges = analyzeIntegerRanges(fn);
+    expect(reads.map((node) => ranges.get(node) ?? null)).toEqual([
+        null,
+        { min: 5, max: 5 },
+    ]);
+});
+test("emission matches the module read back from its serialized form", () => {
+    const { mod } = sharedRead();
+    expect(validateModule(mod)).toEqual([]);
+    const restored = deserializeModule(serializeModule(mod, true));
+    expect(emitLlvmModule(mod)).toBe(emitLlvmModule(restored));
+});
+//# sourceMappingURL=unshare.test.js.map

package/dist/ir/unshare.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unshare.test.js","sourceRoot":"","sources":["../../src/ir/unshare.test.ts"],"names":[],"mappings":"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"}

package/dist/ir/validate.js

@@ -4,7 +4,7 @@
  * an ICE that points at source is a gift to whoever debugs it.
  */
 import { validByteNumberToken } from "./byte-numbers.js";
-import { arrayOf, BYTES_ELEMENT_NAME, BOOL, BYTES_U8, bytesOf, canAdaptDynFuncTo, canDynCheckTo, canConvertToDyn, canExitIslandToType, canMarshalIntoIsland, canMarshalTypedFuncIntoIsland, DYN, DYN_HANDLE_KINDS, F64, ffiClassType, ffiSourceParamTypes, islandPromisePayloadTag, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isJsonSafeType, isJsonStringifySafeType, isRefCounted, isSortValuesElement, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, jsOpResultKind, JSVAL, REF_TRUTHY_KINDS, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, shapeHasAccessorSlots, STRING, typeEquals, typeKey, unionContainerArmsOk, VOID, } from "./ir.js";
+import { arrayOf, BYTES_ELEMENT_NAME, BOOL, BYTES_U8, bytesOf, canAdaptDynFuncTo, canDynCheckTo, canConvertToDyn, DYN, DYN_HANDLE_KINDS, F64, ffiClassType, ffiSourceParamTypes, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isJsonSafeType, isJsonStringifySafeType, isRefCounted, isSortValuesElement, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, REF_TRUTHY_KINDS, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, shapeHasAccessorSlots, STRING, typeEquals, typeKey, unionContainerArmsOk, VOID, } from "./ir.js";
 import { DYN_CLASS_PROPERTIES } from "./ir.js";
 import { unionWideningTags } from "./analysis.js";
 import { alwaysReturns } from "./control-flow.js";
@@ -55,7 +55,7 @@ export function validateModule(mod) {
     const moduleLoc = { file: mod.sourceFile, start: 0, end: 0 };
     if (mod.workers !== undefined && typeof mod.workers !== "boolean")
         errors.push({ message: "worker execution mode must be a boolean", loc: moduleLoc });
-    if (mod.workers && (mod.lib !== undefined || mod.embedded !== undefined))
+    if (mod.workers && mod.lib !== undefined)
         errors.push({
             message: "worker execution requires a native static executable",
             loc: moduleLoc,
@@ -545,9 +545,8 @@ export function validateModule(mod) {
             }
             else
                 fields.set(f.name, f.type);
-            // Unit kinds (undefinedT/nullT) exist only as union arms — a BARE
-            // unit field is as malformed as a void one. dyn and jsval slots
-            // are valid; both are refcounted values held by the record shape.
+            // Bare unit and void types have no record-field storage; unit values
+            // use their union representation.
             if (f.type.kind === "void" || isUnitType(f.type)) {
                 errors.push({
                     message: `record ${rec.id}: field "${f.name}" is ${f.type.kind}`,
@@ -688,7 +687,6 @@ export function validateModule(mod) {
             if (arm.kind === "void" ||
                 arm.kind === "union" ||
                 arm.kind === "dyn" ||
-                arm.kind === "jsval" ||
                 arm.kind === "date" ||
                 arm.kind === "generator") {
                 errors.push({ message: `union ${u.id}: arm ${i} is ${arm.kind}`, loc: noLoc });
@@ -1017,10 +1015,6 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             err(`${what}: expected ${want.kind}, got ${expr.type.kind}${detail}`, expr.loc);
         }
     };
-    /** Union arms a truthiness helper can answer: units (false), scalars and
-     * strings (per-value), ref kinds (always true), jsval (the engine
-     * answers). dyn/caught arms have no ToBoolean — the frontend fences them
-     * before emitting toBool/logical over the union. */
     const checkTruthyUnion = (unionId, loc) => {
         const def = unions.get(unionId);
         if (!def) {
@@ -1050,13 +1044,6 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
     };
     function checkNullishOperands(e) {
         expectType(e.right, e.type, "nullish right operand");
-        // The ISLAND form: `a ?? b` over an engine value — left, right,
-        // and result are all handles (the emitters' jsval nullish arm).
-        if (e.left.type.kind === "jsval") {
-            if (e.type.kind !== "jsval")
-                err("jsval nullish must answer jsval", e.loc);
-            return;
-        }
         // The CHECKED-DYNAMIC form: the runtime kind decides (the
         // emitters' scr_dyn_is_nullish arm) — left, right, and result
         // all live in the checked-dynamic tree.
@@ -1115,10 +1102,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 if (e.type.kind !== "f64" &&
                     e.type.kind !== "string" &&
                     e.type.kind !== "bool" &&
-                    e.type.kind !== "jsval" &&
                     e.type.kind !== "union" &&
                     e.type.kind !== "dyn") {
-                    err(`logical ${e.op} must be f64|string|bool|jsval|union|dyn, got ${e.type.kind}`, e.loc);
+                    err(`logical ${e.op} must be f64|string|bool|union|dyn, got ${e.type.kind}`, e.loc);
                 }
                 if (e.type.kind === "union")
                     checkTruthyUnion(e.type.unionId, e.loc);
@@ -1232,7 +1218,6 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             case "fieldAbsent":
                 return checkRecordExpr(e);
             case "dynFrom":
-            case "dynFromJsval":
             case "dynCall":
             case "dynInvoke":
             case "dynObjLit":
@@ -1266,11 +1251,6 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             case "newPromise":
             case "promiseWithResolvers":
                 return checkAsyncExpr(e);
-            case "jsMarshal":
-            case "jsOp":
-            case "jsExit":
-            case "jsBridgePromise":
-                return checkIslandExpr(e);
             default: {
                 const _exhaustive = e;
                 void _exhaustive;
@@ -1517,16 +1497,16 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
             case "dynDestrCheck": {
                 checkExpr(e.value);
-                if (e.value.type.kind !== "dyn" && e.value.type.kind !== "jsval")
-                    err("dynDestrCheck value must be dyn or jsval", e.loc);
+                if (e.value.type.kind !== "dyn")
+                    err("dynDestrCheck value must be dyn", e.loc);
                 if (e.type.kind !== e.value.type.kind)
                     err("dynDestrCheck must have its value's type", e.loc);
                 break;
             }
             case "dynIterN": {
                 checkExpr(e.value);
-                if (e.value.type.kind !== "dyn" && e.value.type.kind !== "jsval")
-                    err("dynIterN value must be dyn or jsval", e.loc);
+                if (e.value.type.kind !== "dyn")
+                    err("dynIterN value must be dyn", e.loc);
                 if (e.type.kind !== e.value.type.kind)
                     err("dynIterN must have its value's type", e.loc);
                 if (!Number.isInteger(e.count) || e.count < 0)
@@ -1611,24 +1591,6 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 break;
             case "optChain": {
                 checkExpr(e.receiver);
-                // An island-handle chain (`x?.y` on 'any'): the nullish test is a
-                // runtime ask of the engine value; the body is the plain island
-                // operation over the bound handle, and both body and result stay
-                // jsval (the unit path is the engine's undefined).
-                if (e.receiver.type.kind === "jsval") {
-                    if (activeChains.has(e.id))
-                        err(`optChain id "${e.id}" shadows an active chain`, e.loc);
-                    activeChains.set(e.id, JSVAL);
-                    checkExpr(e.body);
-                    activeChains.delete(e.id);
-                    if (e.body.type.kind !== "jsval") {
-                        err(`jsval optChain with ${e.body.type.kind} body`, e.loc);
-                    }
-                    if (e.type.kind !== "jsval") {
-                        err(`jsval optChain must be jsval, got ${e.type.kind}`, e.loc);
-                    }
-                    break;
-                }
                 // A dyn (dyn) chain (`rawName?.match(re)` on a JSON.parse result):
                 // the nullish test reads the node's kind tag; the body is the
                 // validated dynamic dispatch, its result converted back into the
@@ -2480,7 +2442,6 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 // declared params plus that one must match.
                 if (e.type.kind === "func") {
                     const wantRet = callSiteReturnType(target);
-                    // ISLAND-REST types (restAbi jsval) SPELL their trailing engine
                     // array param — the lifted signature matches directly, no
                     // hidden slot.
                     const hiddenRest = e.type.rest === true && e.type.restAbi === undefined;
@@ -3037,18 +2998,6 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 }
                 break;
             }
-            case "dynFromJsval": {
-                // The jsval→dyn crossing: exactly a jsval operand into a dyn
-                // result (the by-reference island wrap; scalars normalize at
-                // runtime).
-                checkExpr(e.value);
-                if (e.type.kind !== "dyn")
-                    err(`dynFromJsval must be dyn-typed, got ${e.type.kind}`, e.loc);
-                if (e.value.type.kind !== "jsval") {
-                    err(`dynFromJsval operand must be jsval, got ${e.value.type.kind}`, e.loc);
-                }
-                break;
-            }
             case "dynCall": {
                 checkExpr(e.callee);
                 if (e.calleeNameValue !== undefined) {
@@ -4548,14 +4497,6 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
         return false;
     }
     function checkLibSpecialCall(e) {
-        if (e.fn === "island.castFail") {
-            // The deferred boundary failure's typed dummy: a promise (the
-            // only cast shape the frontend defers).
-            if (e.type.kind !== "promise") {
-                err(`libCall island.castFail must return a promise type, got ${e.type.kind}`, e.loc);
-            }
-            return true;
-        }
         if (e.fn === "global.undefRead") {
             // Always throws — the result type is whatever the declared type
             // of the undefined global mapped to (never materialized).
@@ -5211,145 +5152,6 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
         }
     }
-    function checkIslandExpr(e) {
-        switch (e.kind) {
-            case "jsMarshal": {
-                checkExpr(e.value);
-                if (e.type.kind !== "jsval")
-                    err(`jsMarshal must be jsval, got ${e.type.kind}`, e.loc);
-                const src = e.value.type;
-                // The marshal direction admits qualifying closures (host-function
-                // wrapping) on top of the JSON-safe set; jsExit does not. Typed
-                // closures (per-param call-time conversion through the exit
-                // machinery) are the wider func shape.
-                // Typed arrays and URLs marshal IN (an engine typed-array copy /
-                // an engine URL built from the components) without ever joining
-                // the round-trip (JSON) set — the frontend's union lift narrows
-                // union arms before marshaling, so bare bytes/url operands are
-                // exactly what it produces.
-                if (src.kind !== "bytes" &&
-                    src.kind !== "url" &&
-                    src.kind !== "dyn" && // dyn values deep-copy in (data kinds; the runtime throws on boxes)
-                    // A STATIC promise crosses as a real engine thenable when its
-                    // fulfillment is in the reverse bridge's payload domain
-                    // (scr_jsval_from_promise — the async-callback return bridge).
-                    !(src.kind === "promise" && islandPromisePayloadTag(src.inner) !== null) &&
-                    !canMarshalIntoIsland(src, (id) => records.get(id), (id) => unions.get(id)) &&
-                    !canMarshalTypedFuncIntoIsland(src, (id) => records.get(id), (id) => unions.get(id))) {
-                    err(`jsMarshal of unmarshalable type ${src.kind}`, e.loc);
-                }
-                break;
-            }
-            case "jsOp": {
-                for (const a of e.args)
-                    checkExpr(a);
-                if (e.type.kind !== jsOpResultKind(e.op)) {
-                    err(`jsOp ${e.op} must be ${jsOpResultKind(e.op)}, got ${e.type.kind}`, e.loc);
-                }
-                const named = e.op === "getProp" ||
-                    e.op === "setProp" ||
-                    e.op === "callMethod" ||
-                    e.op === "optCallMethod" ||
-                    e.op === "globalGet" ||
-                    e.op === "callSpread"; // the spread expression's source spelling (V8's nullish text spells it)
-                if (named !== (e.name !== undefined)) {
-                    err(`jsOp ${e.op} ${named ? "requires" : "forbids"} a name`, e.loc);
-                }
-                const arity = {
-                    add: 2,
-                    sub: 2,
-                    mul: 2,
-                    div: 2,
-                    mod: 2,
-                    pow: 2,
-                    lt: 2,
-                    le: 2,
-                    gt: 2,
-                    ge: 2,
-                    eq: 2,
-                    neq: 2,
-                    instanceOf: 2,
-                    neg: 1,
-                    plus: 1,
-                    truthy: 1,
-                    not: 1,
-                    typeof: 1,
-                    toStr: 1,
-                    getProp: 1,
-                    setProp: 2,
-                    getIdx: 2,
-                    setIdx: 3,
-                    globalGet: 0,
-                    undefLit: 0,
-                    nullLit: 0,
-                    iterNew: 1,
-                    defineGetter: 3,
-                    objSpread: 2,
-                    callSpread: 3, // callee + pre array + spread source
-                    callMethod: null,
-                    optCallMethod: null,
-                    callFn: null,
-                    callFnThis: null,
-                    construct: null, // receiver/callee + any number of args
-                    objLit: null,
-                    arrLit: null,
-                    tplStrings: null, // variable length (objLit: key/value pairs; tplStrings: n cooked + n raw)
-                };
-                const want = arity[e.op];
-                if (want !== null && want !== undefined && e.args.length !== want) {
-                    err(`jsOp ${e.op} takes ${want} arg(s), got ${e.args.length}`, e.loc);
-                }
-                if (want === null &&
-                    e.op !== "objLit" &&
-                    e.op !== "arrLit" &&
-                    e.op !== "tplStrings" &&
-                    e.args.length < 1) {
-                    err(`jsOp ${e.op} needs a receiver/callee arg`, e.loc);
-                }
-                if (e.op === "callFnThis" && e.args.length < 2) {
-                    err("jsOp callFnThis needs a callee and receiver", e.loc);
-                }
-                if (e.op === "objLit" && e.args.length % 2 !== 0) {
-                    err("jsOp objLit takes key/value pairs", e.loc);
-                }
-                if (e.op === "tplStrings" && e.args.length % 2 !== 0) {
-                    err("jsOp tplStrings takes n cooked + n raw strings", e.loc);
-                }
-                for (const a of e.args) {
-                    if (a.type.kind !== "jsval")
-                        err(`jsOp ${e.op} arg must be jsval, got ${a.type.kind}`, e.loc);
-                }
-                break;
-            }
-            case "jsExit": {
-                checkExpr(e.value);
-                expectType(e.value, JSVAL, "jsExit operand");
-                if (!canExitIslandToType(e.type, (id) => records.get(id), (id) => unions.get(id))) {
-                    err(`jsExit to non-extractable type ${e.type.kind}`, e.loc);
-                }
-                break;
-            }
-            case "jsBridgePromise": {
-                checkExpr(e.value);
-                expectType(e.value, JSVAL, "jsBridgePromise operand");
-                // The settled engine value crosses as a HANDLE (or not at all) —
-                // plus the ONE converting payload: an `any[]`-declared
-                // fulfillment exits Array.isArray-gated by reference AT THE
-                // SETTLE (SCR_ISLP_JSVAL_ARR); every other typed use exits later.
-                if (e.type.kind !== "promise" ||
-                    (e.type.inner.kind !== "jsval" &&
-                        e.type.inner.kind !== "void" &&
-                        !(e.type.inner.kind === "array" && e.type.inner.elem.kind === "jsval"))) {
-                    err("jsBridgePromise must be a promise of jsval, void, or jsval-element array", e.loc);
-                }
-                break;
-            }
-            default: {
-                const _exhaustive = e;
-                void _exhaustive;
-            }
-        }
-    }
     // `continue` needs an enclosing loop; `break` an enclosing loop OR switch.
     let loopDepth = 0;
     let breakableDepth = 0;