@scriptc/compiler 0.3.1 → 0.3.3

package/dist/frontend/lowering/lower-event-emitter.d.ts

@@ -33,6 +33,12 @@ export interface ComputedEventPattern {
     suffix: string;
     listener: boolean;
 }
+/** The compile-time key of `events.errorMonitor`. Node keys it by a
+ * symbol, so no string event name may share it: literal names are keyed
+ * through literalEventKey, which never yields this key, and the runtime
+ * receives the emitter.errorMonitor key object (matched by identity)
+ * instead of any string. */
+export declare const ERROR_MONITOR_EVENT = "\0events.errorMonitor";
 /** `recv.<member>(...)` over an emitter-rooted receiver — the whole
  * EventEmitter method surface. Returns null only for members this spoke
  * does not own (the caller falls through to its own fences).

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

@@ -49,6 +49,7 @@ import { arrayOf, BOOL, canBoxFuncIntoDyn, canConvertToDyn, DYN, F64, isUnitType
 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";
+import { lowerAddAbortListener } from "./builtin-calls.js";
 /** True when the class descends from (or is) the runtime emitter. */
 export function emitterRooted(lowerer, info) {
     for (let c = info ?? null; c; c = c.base) {
@@ -122,14 +123,17 @@ function emitterEvents(lowerer) {
             }));
         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,
-    });
+    // The forced tuples (see the header comment); errorMonitor listeners
+    // receive the 'error' payload.
+    for (const name of ["error", ERROR_MONITOR_EVENT]) {
+        table.set(name, {
+            tuple: [{ kind: "object", className: "%Error" }],
+            fromEmit: true,
+            conflict: null,
+            dynListener: false,
+            hasListener: false,
+        });
+    }
     table.set("newListener", {
         tuple: [STRING],
         fromEmit: true,
@@ -241,7 +245,12 @@ function emitterEvents(lowerer) {
             const info = scannedEmitterInfo(lowerer, recvT);
             if (!info)
                 return;
-            if (!nameT.isStringLiteralType()) {
+            const literal = isErrorMonitorRef(lowerer, arg0)
+                ? ERROR_MONITOR_EVENT
+                : nameT.isStringLiteralType()
+                    ? literalEventKey(nameT.value)
+                    : null;
+            if (literal === null) {
                 const pattern = computedEventPatternOf(lowerer, arg0);
                 if (pattern &&
                     streamSidesOf(lowerer, info) === null &&
@@ -250,8 +259,8 @@ function emitterEvents(lowerer) {
                 }
                 return;
             }
-            const name = nameT.value;
-            if (META_EVENTS.has(name) || name === "error")
+            const name = literal;
+            if (META_EVENTS.has(name) || name === "error" || name === ERROR_MONITOR_EVENT)
                 return; // forced tuples
             // Stream receivers' runtime-emitted events carry PER-BASE forced
             // tuples (lower-stream.ts) — their sites never join the program-
@@ -304,13 +313,78 @@ 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)));
 }
-/** The compile-time name for a literal-only operation, or a pointed fence
- * (string-literal TYPE, so const bindings and literal unions of one
- * member count — the staticHeaderKeyOf stance). */
-function eventNameOf(lowerer, member, arg) {
+/** The compile-time key of `events.errorMonitor`. Node keys it by a
+ * symbol, so no string event name may share it: literal names are keyed
+ * through literalEventKey, which never yields this key, and the runtime
+ * receives the emitter.errorMonitor key object (matched by identity)
+ * instead of any string. */
+export const ERROR_MONITOR_EVENT = "\u0000events.errorMonitor";
+/** A string event name's compile-time key: the name itself, with one more
+ * leading NUL when it already starts with one, so a key of one NUL and
+ * then a non-NUL (ERROR_MONITOR_EVENT) belongs to no string. */
+function literalEventKey(name) {
+    return name.startsWith("\u0000") ? `\u0000${name}` : name;
+}
+/** The string name of a key that is not ERROR_MONITOR_EVENT. */
+function eventKeyName(key) {
+    return key.startsWith("\u0000") ? key.slice(1) : key;
+}
+/** The runtime event-name argument for a compile-time key. */
+function eventNameExpr(key, loc) {
+    if (key === ERROR_MONITOR_EVENT) {
+        return { kind: "libCall", fn: "emitter.errorMonitor", args: [], type: STRING, loc };
+    }
+    return strLit(eventKeyName(key), loc);
+}
+/** `errorMonitor` / `EventEmitter.errorMonitor` / `events.errorMonitor`:
+ * the events module's unique symbol, by declaration provenance. */
+function isErrorMonitorRef(lowerer, arg) {
+    const isMonitorType = (t) => {
+        if (!(t.flags & ts.TypeFlags.UniqueESSymbol))
+            return false;
+        const symbol = t.getSymbol();
+        return symbol?.name === "errorMonitor" && lowerer.isStdlibSymbol(symbol);
+    };
+    // The unique symbol TYPE names its declaration through any alias.
+    if (isMonitorType(lowerer.typeOf(arg)))
+        return true;
+    // A const destructuring (`const { errorMonitor } = events`) widens the
+    // binding's type in JavaScript; its source property still names it.
+    if (!ts.isIdentifier(arg))
+        return false;
+    const symbol = lowerer.resolveValueSymbol(arg);
+    const declaration = symbol ? lowerer.checker.valueDeclarationOf(symbol) : undefined;
+    if (!declaration || !ts.isBindingElement(declaration))
+        return false;
+    const pattern = declaration.parent;
+    const variable = pattern?.parent;
+    if (!pattern ||
+        !variable ||
+        !ts.isObjectBindingPattern(pattern) ||
+        !ts.isVariableDeclaration(variable) ||
+        !variable.initializer ||
+        !(ts.getCombinedNodeFlags(variable) & ts.NodeFlags.Const))
+        return false;
+    const key = declaration.propertyName ?? declaration.name;
+    if (!ts.isIdentifier(key))
+        return false;
+    const property = lowerer.checker.getPropertyOfType(lowerer.typeOf(variable.initializer), key.text);
+    return property !== undefined && isMonitorType(lowerer.checker.getTypeOfSymbol(property));
+}
+/** A compile-time event key (literalEventKey): a string-literal TYPE
+ * (const bindings and literal unions of one member count — the
+ * staticHeaderKeyOf stance) or the errorMonitor symbol. */
+function literalEventName(lowerer, arg) {
+    if (isErrorMonitorRef(lowerer, arg))
+        return ERROR_MONITOR_EVENT;
     const t = lowerer.typeOf(arg);
-    if (t.isStringLiteralType())
-        return t.value;
+    return t.isStringLiteralType() ? literalEventKey(t.value) : null;
+}
+/** The compile-time key for a literal-only operation, or a pointed fence. */
+function eventNameOf(lowerer, member, arg) {
+    const name = literalEventName(lowerer, arg);
+    if (name !== null)
+        return name;
     lowerer.noLowering(`${member} with a non-literal event name`, arg, "this operation needs a compile-time string literal (symbol names have no lowering)");
 }
 function staticStringPrefixOf(lowerer, node, seen = new Set()) {
@@ -373,7 +447,12 @@ function computedEventPatternOf(lowerer, node) {
     const suffix = staticStringSuffixOf(lowerer, node) ?? "";
     return prefix || suffix ? { prefix, suffix, listener: false } : null;
 }
-function patternMatchesName(pattern, name) {
+/** Whether a computed name could equal the event keyed `key` (never the
+ * errorMonitor key: computed names are strings). */
+function patternMatchesName(pattern, key) {
+    if (key === ERROR_MONITOR_EVENT)
+        return false;
+    const name = eventKeyName(key);
     return name.startsWith(pattern.prefix) && name.endsWith(pattern.suffix);
 }
 /** A computed event can use the variable-arity dyn path only when its
@@ -689,8 +768,8 @@ streamData) {
         kind: "call",
         callee: helper,
         args: registering
-            ? [receiver, strLit(name, loc), cbDyn, boolLit(once, loc), boolLit(prepend, loc)]
-            : [receiver, strLit(name, loc), cbDyn],
+            ? [receiver, eventNameExpr(name, loc), cbDyn, boolLit(once, loc), boolLit(prepend, loc)]
+            : [receiver, eventNameExpr(name, loc), cbDyn],
         type: recvT,
         loc,
     };
@@ -801,6 +880,8 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
     // everything else fences by its static name.
     if (superRecv === undefined &&
         lowerer.checker.getConstructSignatures(lowerer.typeOf(access.expression)).length > 0) {
+        if (member === "addAbortListener")
+            return lowerAddAbortListener(lowerer, call, loc);
         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
@@ -873,7 +954,7 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
             lowerer.noLowering(`${member} with ${args.length} arguments`, call, "the supported form is (eventName, listener)");
         }
         const registering = REGISTER_MEMBERS.has(member);
-        if (!lowerer.typeOf(args[0]).isStringLiteralType()) {
+        if (literalEventName(lowerer, args[0]) === null) {
             computedEventPattern(lowerer, info, member, args[0]);
             const receiver = lowerReceiver();
             const name = lowerer.lowerExprExpecting(args[0], STRING);
@@ -885,7 +966,7 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
             streamForcedTuple(lowerer, info, name) === null &&
             (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);
+            return lowerFlexListenerCall(lowerer, member, eventNameExpr(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 —
         // Node calls this.emit, which would dispatch through an emit
@@ -927,7 +1008,7 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
                 return {
                     kind: "libCall",
                     fn: "emitter.off",
-                    args: [receiver, strLit(name, loc), cb],
+                    args: [receiver, eventNameExpr(name, loc), cb],
                     type: receiver.type,
                     loc,
                 };
@@ -935,7 +1016,7 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
             return {
                 kind: "libCall",
                 fn: "emitter.onData",
-                args: [receiver, strLit(name, loc), cb, boolLit(once, loc), boolLit(prepend, loc)],
+                args: [receiver, eventNameExpr(name, loc), cb, boolLit(once, loc), boolLit(prepend, loc)],
                 type: receiver.type,
                 loc,
             };
@@ -953,8 +1034,8 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
             kind: "libCall",
             fn: registering ? "emitter.on" : "emitter.off",
             args: registering
-                ? [receiver, strLit(name, loc), cb, boolLit(once, loc), boolLit(prepend, loc)]
-                : [receiver, strLit(name, loc), cb],
+                ? [receiver, eventNameExpr(name, loc), cb, boolLit(once, loc), boolLit(prepend, loc)]
+                : [receiver, eventNameExpr(name, loc), cb],
             type: receiver.type,
             loc,
         };
@@ -963,8 +1044,7 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
         if (args.length === 0) {
             lowerer.noLowering("emit without an event name", call);
         }
-        const nameType = lowerer.typeOf(args[0]);
-        if (!nameType.isStringLiteralType()) {
+        if (literalEventName(lowerer, args[0]) === null) {
             const pattern = computedEventPatternOf(lowerer, args[0]);
             const mayBeObserved = pattern === null ||
                 computedPatternOverlapsReserved(pattern) ||
@@ -996,7 +1076,7 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
             streamForcedTuple(lowerer, info, name) === null &&
             (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");
+            return lowerFlexEmit(eventNameExpr(name, loc), flexibleJsEvent(name, table.get(name)) ? "variable-arity" : "computed-name");
         const receiver = lowerReceiver();
         if (name === "error") {
             // The special event: exactly one %Error-rooted payload; no listener
@@ -1034,7 +1114,7 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
             return {
                 kind: "libCall",
                 fn: "emitter.emitData",
-                args: [receiver, strLit(name, loc), chunk],
+                args: [receiver, eventNameExpr(name, loc), chunk],
                 type: BOOL,
                 loc,
             };
@@ -1055,7 +1135,11 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
         }
         const all = args.length === 0;
         const receiver = lowerReceiver();
-        const name = all ? strLit("", loc) : lowerer.lowerExprExpecting(args[0], STRING);
+        const name = all
+            ? strLit("", loc)
+            : isErrorMonitorRef(lowerer, args[0])
+                ? eventNameExpr(ERROR_MONITOR_EVENT, loc)
+                : lowerer.lowerExprExpecting(args[0], STRING);
         if (name.type.kind !== "string") {
             lowerer.noLowering(`removeAllListeners with a '${lowerer.fmt(name.type)}' event name`, args[0] ?? call);
         }
@@ -1072,7 +1156,9 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
             lowerer.noLowering(`listenerCount with ${args.length} arguments`, call);
         }
         const receiver = lowerReceiver();
-        const name = lowerer.lowerExprExpecting(args[0], STRING);
+        const name = isErrorMonitorRef(lowerer, args[0])
+            ? eventNameExpr(ERROR_MONITOR_EVENT, loc)
+            : lowerer.lowerExprExpecting(args[0], STRING);
         if (name.type.kind !== "string") {
             lowerer.noLowering(`listenerCount with a '${lowerer.fmt(name.type)}' event name`, args[0]);
         }
@@ -1123,7 +1209,7 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
         return {
             kind: "libCall",
             fn: "emitter.listeners",
-            args: [receiver, strLit(name, loc)],
+            args: [receiver, eventNameExpr(name, loc)],
             type: arrayOf({ kind: "func", params: tuple, ret: { kind: "void" } }),
             loc,
         };
@@ -1424,7 +1510,7 @@ export function lowerEmitOverrideSpec(lowerer, req) {
         const eventDecl = ov.decl.parameters[0];
         const eventLocal = lowerer.declareLocal(eventDecl.name, ts.isIdentifier(eventDecl.name) ? eventDecl.name.text : "event", STRING, true);
         const prologue = [
-            { kind: "varDecl", localId: eventLocal.id, init: strLit(event, loc), loc },
+            { kind: "varDecl", localId: eventLocal.id, init: eventNameExpr(event, loc), loc },
         ];
         lowerer.emitSpecCtx = {
             info,
@@ -1497,7 +1583,7 @@ export function emitSpecSuperForward(lowerer, call, access) {
         return {
             kind: "libCall",
             fn: "emitter.emitError",
-            args: [thisRef, strLit(ctx.event, loc), payload[0]],
+            args: [thisRef, eventNameExpr(ctx.event, loc), payload[0]],
             type: BOOL,
             loc,
         };
@@ -1505,7 +1591,7 @@ export function emitSpecSuperForward(lowerer, call, access) {
     return {
         kind: "libCall",
         fn: "emitter.emit",
-        args: [thisRef, strLit(ctx.event, loc), ...payload],
+        args: [thisRef, eventNameExpr(ctx.event, loc), ...payload],
         type: BOOL,
         loc,
     };
@@ -1533,14 +1619,14 @@ function emitDispatchExpr(lowerer, info, name, tuple, receiver, payload, superOf
         ? {
             kind: "libCall",
             fn: "emitter.emitError",
-            args: [recv, strLit(name, loc), args[0]],
+            args: [recv, eventNameExpr(name, loc), args[0]],
             type: BOOL,
             loc,
         }
         : {
             kind: "libCall",
             fn: "emitter.emit",
-            args: [recv, strLit(name, loc), ...args],
+            args: [recv, eventNameExpr(name, loc), ...args],
             type: BOOL,
             loc,
         };