@scriptc/compiler 0.2.3 → 0.2.5

package/dist/frontend/lowering/lower-event-emitter.js

@@ -45,7 +45,7 @@
 import * as ts from "../ts7/adapter.js";
 import { dynFallbackType, newFnCtx } from "./lowerer.js";
 import { isJsSourceFile, locOf } from "../program.js";
-import { arrayOf, BOOL, canBoxFuncIntoDyn, canConvertToDyn, DYN, F64, isUnitType, STRING, typeEquals, typeKey, VOID } from "../../ir/ir.js";
+import { arrayOf, BOOL, canBoxFuncIntoDyn, canConvertToDyn, DYN, F64, isUnitType, STRING, typeEquals, typeKey, VOID, } from "../../ir/ir.js";
 import { STREAM_FORCED_EVENT_NAMES, streamForcedTuple, streamSidesOf } from "./lower-stream.js";
 import { boolLit, strLit, varRef } from "../../ir/build.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
@@ -58,14 +58,20 @@ export function emitterRooted(lowerer, info) {
     return false;
 }
 const REGISTER_MEMBERS = new Set([
-    "on", "addListener", "once", "prependListener", "prependOnceListener",
+    "on",
+    "addListener",
+    "once",
+    "prependListener",
+    "prependOnceListener",
 ]);
 const META_EVENTS = new Set(["newListener", "removeListener"]);
 function flexibleJsEvent(name, sig) {
     // A stream may be upcast to EventEmitter. Its runtime-emitted payloads
     // keep their fixed ABI even when the static receiver looks ordinary.
-    return !STREAM_FORCED_EVENT_NAMES.has(name) && sig?.jsEmit === true && sig.typedListener !== true &&
-        (sig.unmappedEmit === true || sig.conflict !== null);
+    return (!STREAM_FORCED_EVENT_NAMES.has(name) &&
+        sig?.jsEmit === true &&
+        sig.typedListener !== true &&
+        (sig.unmappedEmit === true || sig.conflict !== null));
 }
 function scannedEmitterInfo(lowerer, receiver) {
     if (!receiver)
@@ -78,7 +84,9 @@ function scannedEmitterInfo(lowerer, receiver) {
         const arms = lowerer.unions.get(receiver.unionId)?.arms ?? [];
         const objects = arms.filter((arm) => arm.kind === "object");
         const object = objects[0];
-        if (objects.length !== 1 || object?.kind !== "object" || !arms.every((arm) => arm.kind === "object" || isUnitType(arm)))
+        if (objects.length !== 1 ||
+            object?.kind !== "object" ||
+            !arms.every((arm) => arm.kind === "object" || isUnitType(arm)))
             return null;
         className = object.className;
     }
@@ -89,8 +97,8 @@ function scannedEmitterInfo(lowerer, receiver) {
     return emitterRooted(lowerer, info) ? info : null;
 }
 function computedPatternOverlapsReserved(pattern) {
-    return ["error", "newListener", "removeListener"].some((name) => patternMatchesName(pattern, name)) ||
-        [...STREAM_FORCED_EVENT_NAMES].some((name) => patternMatchesName(pattern, name));
+    return (["error", "newListener", "removeListener"].some((name) => patternMatchesName(pattern, name)) ||
+        [...STREAM_FORCED_EVENT_NAMES].some((name) => patternMatchesName(pattern, name)));
 }
 /** The program-wide event-signature table, built lazily on the first
  * emitter lowering (class shapes are collected before any body lowers, so
@@ -105,13 +113,37 @@ function emitterEvents(lowerer) {
     const sigOf = (name) => {
         let sig = table.get(name);
         if (!sig)
-            table.set(name, (sig = { tuple: [], fromEmit: false, conflict: null, dynListener: false, hasListener: false }));
+            table.set(name, (sig = {
+                tuple: [],
+                fromEmit: false,
+                conflict: null,
+                dynListener: false,
+                hasListener: false,
+            }));
         return sig;
     };
     // The two forced tuples (see the header comment).
-    table.set("error", { tuple: [{ kind: "object", className: "%Error" }], fromEmit: true, conflict: null, dynListener: false, hasListener: false });
-    table.set("newListener", { tuple: [STRING], fromEmit: true, conflict: null, dynListener: false, hasListener: false });
-    table.set("removeListener", { tuple: [STRING], fromEmit: true, conflict: null, dynListener: false, hasListener: false });
+    table.set("error", {
+        tuple: [{ kind: "object", className: "%Error" }],
+        fromEmit: true,
+        conflict: null,
+        dynListener: false,
+        hasListener: false,
+    });
+    table.set("newListener", {
+        tuple: [STRING],
+        fromEmit: true,
+        conflict: null,
+        dynListener: false,
+        hasListener: false,
+    });
+    table.set("removeListener", {
+        tuple: [STRING],
+        fromEmit: true,
+        conflict: null,
+        dynListener: false,
+        hasListener: false,
+    });
     const fmt = (t) => lowerer.fmt(t);
     const mergeEmit = (name, args, js) => {
         const sig = sigOf(name);
@@ -211,7 +243,8 @@ function emitterEvents(lowerer) {
                 return;
             if (!nameT.isStringLiteralType()) {
                 const pattern = computedEventPatternOf(lowerer, arg0);
-                if (pattern && streamSidesOf(lowerer, info) === null &&
+                if (pattern &&
+                    streamSidesOf(lowerer, info) === null &&
                     !computedPatternOverlapsReserved(pattern)) {
                     computedPatterns.push({ ...pattern, listener: !isEmit });
                 }
@@ -233,7 +266,8 @@ function emitterEvents(lowerer) {
                 else if (node.arguments[1]) {
                     const cbCt = lowerer.typeOf(node.arguments[1]);
                     const cbT = lowerer.mapTypeOf(cbCt) ?? dynFallbackType(lowerer, node.arguments[1], cbCt);
-                    if (cbT?.kind !== "dyn" && (cbT?.kind !== "func" || cbT.params.some((p) => p.kind !== "dyn"))) {
+                    if (cbT?.kind !== "dyn" &&
+                        (cbT?.kind !== "func" || cbT.params.some((p) => p.kind !== "dyn"))) {
                         sigOf(name).typedListener = true;
                     }
                     // Dyn-flavored listeners (a checked-dynamic value, or a func
@@ -241,7 +275,8 @@ function emitterEvents(lowerer) {
                     // adapter and constrain nothing: a dyn parameter accepts any
                     // tuple position, and positions past the tuple read the boxed
                     // undefined (exactly JS's extra-parameter semantics).
-                    if (cbT?.kind === "dyn" || (cbT?.kind === "func" && cbT.params.some((p) => p.kind === "dyn"))) {
+                    if (cbT?.kind === "dyn" ||
+                        (cbT?.kind === "func" && cbT.params.some((p) => p.kind === "dyn"))) {
                         const sig = sigOf(name);
                         sig.hasListener = true;
                         sig.dynListener = true;
@@ -266,8 +301,8 @@ function computedPatterns(lowerer) {
     return lowerer.emitterComputedPatterns;
 }
 function computedPatternsOverlap(left, right) {
-    return (left.prefix.startsWith(right.prefix) || right.prefix.startsWith(left.prefix)) &&
-        (left.suffix.endsWith(right.suffix) || right.suffix.endsWith(left.suffix));
+    return ((left.prefix.startsWith(right.prefix) || right.prefix.startsWith(left.prefix)) &&
+        (left.suffix.endsWith(right.suffix) || right.suffix.endsWith(left.suffix)));
 }
 /** The compile-time name for a literal-only operation, or a pointed fence
  * (string-literal TYPE, so const bindings and literal unions of one
@@ -292,7 +327,9 @@ function staticStringPrefixOf(lowerer, node, seen = new Set()) {
             return null;
         seen.add(symbol);
         const declaration = lowerer.checker.valueDeclarationOf(symbol);
-        if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer &&
+        if (declaration &&
+            ts.isVariableDeclaration(declaration) &&
+            declaration.initializer &&
             (ts.getCombinedNodeFlags(declaration) & ts.NodeFlags.Const) !== 0) {
             return staticStringPrefixOf(lowerer, declaration.initializer, seen);
         }
@@ -318,12 +355,15 @@ function staticStringSuffixOf(lowerer, node, seen = new Set()) {
             return null;
         seen.add(symbol);
         const declaration = lowerer.checker.valueDeclarationOf(symbol);
-        if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer &&
+        if (declaration &&
+            ts.isVariableDeclaration(declaration) &&
+            declaration.initializer &&
             (ts.getCombinedNodeFlags(declaration) & ts.NodeFlags.Const) !== 0)
             return staticStringSuffixOf(lowerer, declaration.initializer, seen);
         return null;
     }
-    if (ts.isBinaryExpression(expression) && expression.operatorToken.kind === ts.SyntaxKind.PlusToken) {
+    if (ts.isBinaryExpression(expression) &&
+        expression.operatorToken.kind === ts.SyntaxKind.PlusToken) {
         return staticStringSuffixOf(lowerer, expression.right, seen);
     }
     return null;
@@ -385,27 +425,61 @@ function lowerFlexListenerCall(lowerer, member, name, receiver, cbNode, register
             { localId: "r.0", name: "r", type: recvT },
             { localId: "n.0", name: "n", type: STRING },
             { localId: "cb.0", name: "cb", type: DYN },
-            ...(registering ? [
-                { localId: "o.0", name: "o", type: BOOL },
-                { localId: "p.0", name: "p", type: BOOL },
-            ] : []),
+            ...(registering
+                ? [
+                    { localId: "o.0", name: "o", type: BOOL },
+                    { localId: "p.0", name: "p", type: BOOL },
+                ]
+                : []),
         ];
-        const locals = params.map((p) => ({ id: p.localId, name: p.name, type: p.type, mutable: false }));
+        const locals = params.map((p) => ({
+            id: p.localId,
+            name: p.name,
+            type: p.type,
+            mutable: false,
+        }));
         const body = [
-            { kind: "exprStmt", expr: { kind: "libCall", fn: "emitter.checkListener", args: [varRef("cb.0", DYN, loc)], type: VOID, loc }, loc },
-            { kind: "return", value: {
-                    kind: "libCall", fn: registering ? "emitter.onFlex" : "emitter.offDyn",
-                    args: [varRef("r.0", recvT, loc), varRef("n.0", STRING, loc), varRef("cb.0", DYN, loc),
-                        ...(registering ? [varRef("o.0", BOOL, loc), varRef("p.0", BOOL, loc)] : [])],
-                    type: recvT, loc,
-                }, loc },
+            {
+                kind: "exprStmt",
+                expr: {
+                    kind: "libCall",
+                    fn: "emitter.checkListener",
+                    args: [varRef("cb.0", DYN, loc)],
+                    type: VOID,
+                    loc,
+                },
+                loc,
+            },
+            {
+                kind: "return",
+                value: {
+                    kind: "libCall",
+                    fn: registering ? "emitter.onFlex" : "emitter.offDyn",
+                    args: [
+                        varRef("r.0", recvT, loc),
+                        varRef("n.0", STRING, loc),
+                        varRef("cb.0", DYN, loc),
+                        ...(registering ? [varRef("o.0", BOOL, loc), varRef("p.0", BOOL, loc)] : []),
+                    ],
+                    type: recvT,
+                    loc,
+                },
+                loc,
+            },
         ];
         lowerer.liftedFns.push({ name: helper, params, returnType: recvT, locals, body, loc });
     }
     return {
-        kind: "call", callee: helper,
-        args: [receiver, name, boxed, ...(registering ? [boolLit(once, loc), boolLit(prepend, loc)] : [])],
-        type: recvT, loc,
+        kind: "call",
+        callee: helper,
+        args: [
+            receiver,
+            name,
+            boxed,
+            ...(registering ? [boolLit(once, loc), boolLit(prepend, loc)] : []),
+        ],
+        type: recvT,
+        loc,
     };
 }
 /** The event's unified tuple, with conflicts reported at this site. */
@@ -449,7 +523,10 @@ function dynListenerFlavor(lowerer, node) {
     // null): route it through the dyn path too — the registration helper's
     // checkListener throws Node's exact ERR_INVALID_ARG_TYPE TypeError
     // (the TS lane never reaches this: tsc rejects the argument first).
-    if (t && t.kind !== "jsval" && (isUnitType(t) || canConvertToDyn(t, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))) {
+    if (t &&
+        t.kind !== "jsval" &&
+        (isUnitType(t) ||
+            canConvertToDyn(t, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))) {
         return "dyn";
     }
     return null;
@@ -534,7 +611,13 @@ streamData) {
         lowerer.arrHofHelpers.set(key, helper);
         const check = {
             kind: "exprStmt",
-            expr: { kind: "libCall", fn: "emitter.checkListener", args: [varRef("cb.0", DYN, loc)], type: VOID, loc },
+            expr: {
+                kind: "libCall",
+                fn: "emitter.checkListener",
+                args: [varRef("cb.0", DYN, loc)],
+                type: VOID,
+                loc,
+            },
             loc,
         };
         const params = [
@@ -548,19 +631,36 @@ streamData) {
                 ]
                 : []),
         ];
-        const locals = params.map((p) => ({ id: p.localId, name: p.name, type: p.type, mutable: false }));
+        const locals = params.map((p) => ({
+            id: p.localId,
+            name: p.name,
+            type: p.type,
+            mutable: false,
+        }));
         let body;
         if (registering) {
             locals.push({ id: "a.0", name: "a", type: adapterT, mutable: false });
             body = [
                 check,
-                { kind: "varDecl", localId: "a.0", init: { kind: "dynCheck", value: varRef("cb.0", DYN, loc), type: adapterT, loc }, loc },
+                {
+                    kind: "varDecl",
+                    localId: "a.0",
+                    init: { kind: "dynCheck", value: varRef("cb.0", DYN, loc), type: adapterT, loc },
+                    loc,
+                },
                 {
                     kind: "return",
                     value: {
                         kind: "libCall",
                         fn: onFn,
-                        args: [varRef("r.0", recvT, loc), varRef("n.0", STRING, loc), varRef("cb.0", DYN, loc), varRef("a.0", adapterT, loc), varRef("o.0", BOOL, loc), varRef("p.0", BOOL, loc)],
+                        args: [
+                            varRef("r.0", recvT, loc),
+                            varRef("n.0", STRING, loc),
+                            varRef("cb.0", DYN, loc),
+                            varRef("a.0", adapterT, loc),
+                            varRef("o.0", BOOL, loc),
+                            varRef("p.0", BOOL, loc),
+                        ],
                         type: recvT,
                         loc,
                     },
@@ -662,7 +762,13 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
             const target = { kind: "object", className: info.def.name };
             const helper = lowerer.narrowedArmHelper(receiver.type.unionId, target, locOf(access.expression));
             if (helper !== null) {
-                return { kind: "call", callee: helper, args: [receiver], type: target, loc: locOf(access.expression) };
+                return {
+                    kind: "call",
+                    callee: helper,
+                    args: [receiver],
+                    type: target,
+                    loc: locOf(access.expression),
+                };
             }
         }
         return receiver;
@@ -678,7 +784,13 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
             lowerer.noLowering(`${kind} emit on a nullable or non-emitter receiver`, access.expression, "narrow the receiver to an EventEmitter instance before emitting");
         }
         const payload = args.slice(1).map((arg) => lowerer.lowerExprExpecting(arg, DYN));
-        return { kind: "libCall", fn: "emitter.emitFlex", args: [receiver, name, ...payload], type: BOOL, loc };
+        return {
+            kind: "libCall",
+            fn: "emitter.emitFlex",
+            args: [receiver, name, ...payload],
+            type: BOOL,
+            loc,
+        };
     };
     // The class VALUE, not an instance (`EventEmitter.setMaxListeners(n)` —
     // the receiver's checker type carries construct signatures; mapType
@@ -688,7 +800,8 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
     // are a DIFFERENT surface: setMaxListeners(n) writes the process-wide
     // defaultMaxListeners (validated at runtime — Node's ERR_OUT_OF_RANGE);
     // everything else fences by its static name.
-    if (superRecv === undefined && lowerer.checker.getConstructSignatures(lowerer.typeOf(access.expression)).length > 0) {
+    if (superRecv === undefined &&
+        lowerer.checker.getConstructSignatures(lowerer.typeOf(access.expression)).length > 0) {
         if (member === "setMaxListeners" && args.length === 1) {
             if (lowerer.mapTypeOf(lowerer.typeOf(args[0]))?.kind !== "f64") {
                 // Node's runtime ladder over the dyn value ("setMaxListeners" is
@@ -721,18 +834,24 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
                 const nT = lowerer.mapTypeOf(lowerer.typeOf(args[0]));
                 const tT = lowerer.mapTypeOf(lowerer.typeOf(args[1]));
                 const nPure = ts.isIdentifier(args[0]) || ts.isLiteralExpression(args[0]);
-                const targetNotEmitter = tT !== null && tT.kind !== "dyn" && tT.kind !== "jsval" &&
-                    !(tT.kind === "object");
+                const targetNotEmitter = tT !== null && tT.kind !== "dyn" && tT.kind !== "jsval" && !(tT.kind === "object");
                 if (nT?.kind === "f64" && nPure && targetNotEmitter) {
                     const raw = lowerer.lowerExpr(args[1]);
-                    if (raw.type.kind === "dyn" || raw.kind === "unitLit" || lowerer.dynConvertible(raw.type)) {
+                    if (raw.type.kind === "dyn" ||
+                        raw.kind === "unitLit" ||
+                        lowerer.dynConvertible(raw.type)) {
                         const got = raw.type.kind === "dyn" ? raw : { kind: "dynFrom", value: raw, type: DYN, loc };
                         return {
                             kind: "libCall",
                             fn: "error.argTypeThrow",
                             args: [
                                 { kind: "strLit", value: "eventTargets", type: STRING, loc },
-                                { kind: "strLit", value: "an instance of EventEmitter or EventTarget", type: STRING, loc },
+                                {
+                                    kind: "strLit",
+                                    value: "an instance of EventEmitter or EventTarget",
+                                    type: STRING,
+                                    loc,
+                                },
                                 got,
                             ],
                             type: VOID,
@@ -762,9 +881,11 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
             return lowerFlexListenerCall(lowerer, member, name, receiver, args[1], registering, member === "once" || member === "prependOnceListener", member === "prependListener" || member === "prependOnceListener", loc);
         }
         const name = eventNameOf(lowerer, member, args[0]);
-        if (!META_EVENTS.has(name) && name !== "error" &&
+        if (!META_EVENTS.has(name) &&
+            name !== "error" &&
             streamForcedTuple(lowerer, info, name) === null &&
-            (flexibleJsEvent(name, table.get(name)) || computedPatterns(lowerer).some((pattern) => patternMatchesName(pattern, name)))) {
+            (flexibleJsEvent(name, table.get(name)) ||
+                computedPatterns(lowerer).some((pattern) => patternMatchesName(pattern, name)))) {
             return lowerFlexListenerCall(lowerer, member, strLit(name, loc), lowerReceiver(), args[1], registering, member === "once" || member === "prependOnceListener", member === "prependListener" || member === "prependOnceListener", loc);
         }
         // The runtime fires the meta events INTERNALLY (scr_ee_emit_meta —
@@ -846,14 +967,21 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
         const nameType = lowerer.typeOf(args[0]);
         if (!nameType.isStringLiteralType()) {
             const pattern = computedEventPatternOf(lowerer, args[0]);
-            const mayBeObserved = pattern === null || computedPatternOverlapsReserved(pattern) || [...table].some(([candidate, sig]) => (candidate === "error" || sig.hasListener) && patternMatchesName(pattern, candidate)) || computedPatterns(lowerer).some((registered) => registered.listener && computedPatternsOverlap(pattern, registered));
+            const mayBeObserved = pattern === null ||
+                computedPatternOverlapsReserved(pattern) ||
+                [...table].some(([candidate, sig]) => (candidate === "error" || sig.hasListener) && patternMatchesName(pattern, candidate)) ||
+                computedPatterns(lowerer).some((registered) => registered.listener && computedPatternsOverlap(pattern, registered));
             if (!mayBeObserved) {
                 const receiver = lowerReceiver();
                 const dynamicName = lowerer.lowerExprExpecting(args[0], STRING);
                 const payload = args.slice(1).map((arg) => lowerer.lowerExpr(arg));
                 return {
                     kind: "seqExpr",
-                    stmts: [receiver, dynamicName, ...payload].map((expr) => ({ kind: "exprStmt", expr, loc: expr.loc })),
+                    stmts: [receiver, dynamicName, ...payload].map((expr) => ({
+                        kind: "exprStmt",
+                        expr,
+                        loc: expr.loc,
+                    })),
                     result: boolLit(false, loc),
                     type: BOOL,
                     loc,
@@ -864,9 +992,11 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
             return lowerFlexEmit(name);
         }
         const name = eventNameOf(lowerer, member, args[0]);
-        if (name !== "error" && !META_EVENTS.has(name) &&
+        if (name !== "error" &&
+            !META_EVENTS.has(name) &&
             streamForcedTuple(lowerer, info, name) === null &&
-            (flexibleJsEvent(name, table.get(name)) || computedPatterns(lowerer).some((pattern) => patternMatchesName(pattern, name))))
+            (flexibleJsEvent(name, table.get(name)) ||
+                computedPatterns(lowerer).some((pattern) => patternMatchesName(pattern, name))))
             return lowerFlexEmit(strLit(name, loc), flexibleJsEvent(name, table.get(name)) ? "variable-arity" : "computed-name");
         const receiver = lowerReceiver();
         if (name === "error") {
@@ -898,7 +1028,8 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
                 lowerer.noLowering(`emit('data') with ${args.length - 1} payload arguments`, call, "the event carries one chunk (a Buffer or string)");
             }
             const chunk = lowerer.lowerExpr(args[1]);
-            if (!(chunk.type.kind === "bytes" && chunk.type.elem === "u8") && chunk.type.kind !== "string") {
+            if (!(chunk.type.kind === "bytes" && chunk.type.elem === "u8") &&
+                chunk.type.kind !== "string") {
                 lowerer.noLowering(`emit('data') with a '${lowerer.fmt(chunk.type)}' chunk`, args[1], "chunks are Buffers or strings");
             }
             return {
@@ -951,7 +1082,13 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
             // its word; no tuple check is needed to count.
             const cb = lowerer.lowerExpr(args[1]);
             if (cb.type.kind === "dyn") {
-                return { kind: "libCall", fn: "emitter.countDyn", args: [receiver, name, cb], type: F64, loc };
+                return {
+                    kind: "libCall",
+                    fn: "emitter.countDyn",
+                    args: [receiver, name, cb],
+                    type: F64,
+                    loc,
+                };
             }
             if (cb.type.kind !== "func") {
                 lowerer.noLowering(`listenerCount with a non-function filter`, args[1]);
@@ -975,7 +1112,9 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
         }
         const name = eventNameOf(lowerer, member, args[0]);
         const sig = table.get(name);
-        if (sig?.dynListener || flexibleJsEvent(name, sig) || computedPatterns(lowerer).some((pattern) => pattern.listener && patternMatchesName(pattern, name))) {
+        if (sig?.dynListener ||
+            flexibleJsEvent(name, sig) ||
+            computedPatterns(lowerer).some((pattern) => pattern.listener && patternMatchesName(pattern, name))) {
             // A dyn-adapted registration means the runtime bucket can hold
             // originals of MIXED signatures — no one honest element type.
             lowerer.noLowering(`${member} of the event '${name}'`, call, "a listener of this event uses checked-dynamic dispatch, so the listener array has no one static element type — listenerCount(name) counts");
@@ -1007,7 +1146,13 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
             const raw = lowerer.lowerExpr(args[0]);
             if (raw.type.kind === "dyn" || raw.kind === "unitLit" || lowerer.dynConvertible(raw.type)) {
                 const n = raw.type.kind === "dyn" ? raw : { kind: "dynFrom", value: raw, type: DYN, loc };
-                return { kind: "libCall", fn: "emitter.setMaxChk", args: [receiver, n], type: receiver.type, loc };
+                return {
+                    kind: "libCall",
+                    fn: "emitter.setMaxChk",
+                    args: [receiver, n],
+                    type: receiver.type,
+                    loc,
+                };
             }
         }
         const n = lowerer.lowerExprExpecting(args[0], F64);
@@ -1045,13 +1190,17 @@ export function emitOverrideShapeReason(lowerer, member) {
         return "it must declare exactly (event, ...args)";
     const p0 = member.parameters[0];
     const p1 = member.parameters[1];
-    if (!ts.isIdentifier(p0.name) || p0.dotDotDotToken !== undefined ||
-        p0.questionToken !== undefined || p0.initializer !== undefined ||
+    if (!ts.isIdentifier(p0.name) ||
+        p0.dotDotDotToken !== undefined ||
+        p0.questionToken !== undefined ||
+        p0.initializer !== undefined ||
         (p0.modifiers?.length ?? 0) > 0) {
         return "the event parameter must be a plain identifier";
     }
-    if (!p1.dotDotDotToken || !ts.isIdentifier(p1.name) ||
-        p1.initializer !== undefined || (p1.modifiers?.length ?? 0) > 0) {
+    if (!p1.dotDotDotToken ||
+        !ts.isIdentifier(p1.name) ||
+        p1.initializer !== undefined ||
+        (p1.modifiers?.length ?? 0) > 0) {
         return "the second parameter must be a plain rest parameter (...args)";
     }
     try {
@@ -1061,7 +1210,8 @@ export function emitOverrideShapeReason(lowerer, member) {
         // `any`); the specialization binds it as the string it always is —
         // event names are compile-time literals program-wide.
         const p0T = lowerer.mapTypeOf(lowerer.typeOf(p0.name));
-        const jsUnannotated = p0.type === undefined && isJsSourceFile(member.getSourceFile()) &&
+        const jsUnannotated = p0.type === undefined &&
+            isJsSourceFile(member.getSourceFile()) &&
             (p0T === null || p0T.kind === "dyn" || p0T.kind === "jsval");
         if (p0T?.kind !== "string" && !jsUnannotated) {
             return "the event parameter must be typed 'string' (symbol event names have no lowering)";
@@ -1092,10 +1242,12 @@ export function emitOverrideShapeReason(lowerer, member) {
                 s = undefined;
             }
             if (s === restSym && !isEmitForwardSpread(lowerer, member, n, eventSym)) {
-                reason = "the rest parameter may only forward through super.emit(event, ...args) in the method's own body";
+                reason =
+                    "the rest parameter may only forward through super.emit(event, ...args) in the method's own body";
             }
             else if (s === eventSym && n !== p0.name && isWriteTarget(n)) {
-                reason = "the event parameter cannot be reassigned (the forward's event name must stay pinned)";
+                reason =
+                    "the event parameter cannot be reassigned (the forward's event name must stay pinned)";
             }
         }
         n.forEachChild(visit);
@@ -1133,10 +1285,15 @@ function isEmitForwardSpread(lowerer, method, id, eventSym) {
     for (let p = call.parent; p; p = p.parent) {
         if (p === method)
             return true;
-        if (ts.isArrowFunction(p) || ts.isFunctionExpression(p) || ts.isFunctionDeclaration(p) ||
-            ts.isMethodDeclaration(p) || ts.isConstructorDeclaration(p) ||
-            ts.isGetAccessor(p) || ts.isSetAccessor(p) ||
-            ts.isClassDeclaration(p) || ts.isClassExpression(p)) {
+        if (ts.isArrowFunction(p) ||
+            ts.isFunctionExpression(p) ||
+            ts.isFunctionDeclaration(p) ||
+            ts.isMethodDeclaration(p) ||
+            ts.isConstructorDeclaration(p) ||
+            ts.isGetAccessor(p) ||
+            ts.isSetAccessor(p) ||
+            ts.isClassDeclaration(p) ||
+            ts.isClassExpression(p)) {
             return false;
         }
     }
@@ -1151,17 +1308,21 @@ function isWriteTarget(id) {
         const p = n.parent;
         if (ts.isBinaryExpression(p)) {
             const k = p.operatorToken.kind;
-            return p.left === n && k >= ts.SyntaxKind.FirstAssignment && k <= ts.SyntaxKind.LastAssignment;
+            return (p.left === n && k >= ts.SyntaxKind.FirstAssignment && k <= ts.SyntaxKind.LastAssignment);
         }
         if (ts.isPostfixUnaryExpression(p) || ts.isPrefixUnaryExpression(p)) {
-            return ((p.operator === ts.SyntaxKind.PlusPlusToken || p.operator === ts.SyntaxKind.MinusMinusToken) &&
+            return ((p.operator === ts.SyntaxKind.PlusPlusToken ||
+                p.operator === ts.SyntaxKind.MinusMinusToken) &&
                 p.operand === n);
         }
         if (ts.isForOfStatement(p) || ts.isForInStatement(p))
             return p.initializer === n;
-        if (ts.isParenthesizedExpression(p) || ts.isArrayLiteralExpression(p) ||
-            ts.isSpreadElement(p) || ts.isSpreadAssignment(p) ||
-            ts.isShorthandPropertyAssignment(p) || ts.isObjectLiteralExpression(p) ||
+        if (ts.isParenthesizedExpression(p) ||
+            ts.isArrayLiteralExpression(p) ||
+            ts.isSpreadElement(p) ||
+            ts.isSpreadAssignment(p) ||
+            ts.isShorthandPropertyAssignment(p) ||
+            ts.isObjectLiteralExpression(p) ||
             (ts.isPropertyAssignment(p) && p.initializer === n)) {
             n = p;
             continue;
@@ -1223,7 +1384,10 @@ function ensureEmitSpec(lowerer, info, event, tuple) {
         return;
     lowerer.emitSpecDone.add(key);
     if (!info.methods.has(mName)) {
-        info.methods.set(mName, { params: tuple.map((t) => ({ type: t, mode: "required" })), ret: BOOL });
+        info.methods.set(mName, {
+            params: tuple.map((t) => ({ type: t, mode: "required" })),
+            ret: BOOL,
+        });
         if (info.def.methods)
             info.def.methods.push(mName);
         else
@@ -1263,7 +1427,14 @@ export function lowerEmitOverrideSpec(lowerer, req) {
         const prologue = [
             { kind: "varDecl", localId: eventLocal.id, init: strLit(event, loc), loc },
         ];
-        lowerer.emitSpecCtx = { info, event, tuple, eventSym: ov.eventSym, restSym: ov.restSym, tupleParams };
+        lowerer.emitSpecCtx = {
+            info,
+            event,
+            tuple,
+            eventSym: ov.eventSym,
+            restSym: ov.restSym,
+            tupleParams,
+        };
         const body = [...prologue, ...lowerer.lowerStmts(ov.decl.body.statements)];
         return {
             name: `%${className}.emit:${event}`,
@@ -1304,18 +1475,41 @@ export function emitSpecSuperForward(lowerer, call, access) {
     if (!thisLocal)
         return null;
     const thisRef = { kind: "varRef", localId: thisLocal.id, type: thisLocal.type, loc };
-    const payload = ctx.tupleParams.map((p) => ({ kind: "varRef", localId: p.id, type: p.type, loc }));
+    const payload = ctx.tupleParams.map((p) => ({
+        kind: "varRef",
+        localId: p.id,
+        type: p.type,
+        loc,
+    }));
     const anc = emitOverrideAtOrAbove(ctx.info.base);
     if (anc) {
         ensureEmitSpec(lowerer, anc, ctx.event, ctx.tuple);
         const callee = `%${anc.def.name}.emit:${ctx.event}`;
         lowerer.noteEdge(callee);
-        return { kind: "call", callee, args: [lowerer.upcastTo(thisRef, anc.def.name), ...payload], type: BOOL, loc };
+        return {
+            kind: "call",
+            callee,
+            args: [lowerer.upcastTo(thisRef, anc.def.name), ...payload],
+            type: BOOL,
+            loc,
+        };
     }
     if (ctx.event === "error") {
-        return { kind: "libCall", fn: "emitter.emitError", args: [thisRef, strLit(ctx.event, loc), payload[0]], type: BOOL, loc };
+        return {
+            kind: "libCall",
+            fn: "emitter.emitError",
+            args: [thisRef, strLit(ctx.event, loc), payload[0]],
+            type: BOOL,
+            loc,
+        };
     }
-    return { kind: "libCall", fn: "emitter.emit", args: [thisRef, strLit(ctx.event, loc), ...payload], type: BOOL, loc };
+    return {
+        kind: "libCall",
+        fn: "emitter.emit",
+        args: [thisRef, strLit(ctx.event, loc), ...payload],
+        type: BOOL,
+        loc,
+    };
 }
 /** `super.<member>(...)` over an emitter-rooted base — the emitter spoke
  * with the current method's `this` as the receiver and STATIC dispatch
@@ -1337,8 +1531,20 @@ export function lowerEmitterSuperCall(lowerer, call, access, cls) {
 function emitDispatchExpr(lowerer, info, name, tuple, receiver, payload, superOf, loc) {
     const method = `emit:${name}`;
     const runtime = (recv, args) => name === "error"
-        ? { kind: "libCall", fn: "emitter.emitError", args: [recv, strLit(name, loc), args[0]], type: BOOL, loc }
-        : { kind: "libCall", fn: "emitter.emit", args: [recv, strLit(name, loc), ...args], type: BOOL, loc };
+        ? {
+            kind: "libCall",
+            fn: "emitter.emitError",
+            args: [recv, strLit(name, loc), args[0]],
+            type: BOOL,
+            loc,
+        }
+        : {
+            kind: "libCall",
+            fn: "emitter.emit",
+            args: [recv, strLit(name, loc), ...args],
+            type: BOOL,
+            loc,
+        };
     if (superOf !== undefined) {
         // super.emit: the nearest override STRICTLY ABOVE the lexical class.
         const anc = emitOverrideAtOrAbove(superOf.base);
@@ -1347,7 +1553,13 @@ function emitDispatchExpr(lowerer, info, name, tuple, receiver, payload, superOf
         ensureEmitSpec(lowerer, anc, name, tuple);
         const callee = `%${anc.def.name}.${method}`;
         lowerer.noteEdge(callee);
-        return { kind: "call", callee, args: [lowerer.upcastTo(receiver, anc.def.name), ...payload], type: BOOL, loc };
+        return {
+            kind: "call",
+            callee,
+            args: [lowerer.upcastTo(receiver, anc.def.name), ...payload],
+            type: BOOL,
+            loc,
+        };
     }
     const above = emitOverrideAtOrAbove(info);
     const below = [];
@@ -1364,11 +1576,24 @@ function emitDispatchExpr(lowerer, info, name, tuple, receiver, payload, superOf
     if (above) {
         if (below.length > 0) {
             lowerer.noteVirtualEdge(info, method);
-            return { kind: "virtualCall", className: info.def.name, method, args: [receiver, ...payload], type: BOOL, loc };
+            return {
+                kind: "virtualCall",
+                className: info.def.name,
+                method,
+                args: [receiver, ...payload],
+                type: BOOL,
+                loc,
+            };
         }
         const callee = `%${above.def.name}.${method}`;
         lowerer.noteEdge(callee);
-        return { kind: "call", callee, args: [lowerer.upcastTo(receiver, above.def.name), ...payload], type: BOOL, loc };
+        return {
+            kind: "call",
+            callee,
+            args: [lowerer.upcastTo(receiver, above.def.name), ...payload],
+            type: BOOL,
+            loc,
+        };
     }
     // Overrides only strictly below: the interned dispatch helper.
     const recvT = receiver.type;
@@ -1381,7 +1606,12 @@ function emitDispatchExpr(lowerer, info, name, tuple, receiver, payload, superOf
             { localId: "r.0", name: "r", type: recvT },
             ...tuple.map((t, i) => ({ localId: `a${i}.0`, name: `a${i}`, type: t })),
         ];
-        const locals = params.map((p) => ({ id: p.localId, name: p.name, type: p.type, mutable: false }));
+        const locals = params.map((p) => ({
+            id: p.localId,
+            name: p.name,
+            type: p.type,
+            mutable: false,
+        }));
         const rRef = () => ({ kind: "varRef", localId: "r.0", type: recvT, loc });
         const argRefs = () => tuple.map((t, i) => ({ kind: "varRef", localId: `a${i}.0`, type: t, loc }));
         const body = [];
@@ -1393,7 +1623,14 @@ function emitDispatchExpr(lowerer, info, name, tuple, receiver, payload, superOf
             let target;
             if (oBelow.length > 0) {
                 lowerer.noteVirtualEdge(o, method);
-                target = { kind: "virtualCall", className: o.def.name, method, args: [down, ...argRefs()], type: BOOL, loc };
+                target = {
+                    kind: "virtualCall",
+                    className: o.def.name,
+                    method,
+                    args: [down, ...argRefs()],
+                    type: BOOL,
+                    loc,
+                };
             }
             else {
                 const callee = `%${o.def.name}.${method}`;