@scriptc/compiler 0.4.7 → 0.4.8

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

@@ -70,11 +70,13 @@ export declare function lowerDynamicEmitterOn(lowerer: Lowerer, receiver: IrExpr
  * routes here): the receiver is the current method's `this`, and emit
  * NEVER dispatches through an override at-or-below the lexical class —
  * JS's static super dispatch (the nearest override STRICTLY ABOVE the
- * lexical class still answers, exactly like a prototype-chain walk). */
+ * lexical class still answers, exactly like a prototype-chain walk).
+ * `argsOverride` replaces the call's arguments (`method.call(thisArg,
+ * ...args)` passes the ones after thisArg). */
 export declare function lowerEmitterMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, info: ClassInfo, superRecv?: {
     thisRef: IrExpr;
     cls: ClassInfo;
-}): IrExpr | null;
+}, argsOverride?: readonly ts.Expression[]): IrExpr | null;
 export interface EmitOverrideRec {
     decl: ts.MethodDeclaration;
     eventSym: ts.Symbol;
@@ -105,6 +107,8 @@ export interface EmitSpecRequest {
  * when it conforms. Checked at class collection; the recorded override
  * then lowers per event with no further shape questions. */
 export declare function emitOverrideShapeReason(lowerer: Lowerer, member: ts.MethodDeclaration): string | null;
+/** The nearest class at-or-above `info` declaring an emit override. */
+export declare function emitOverrideAtOrAbove(info: ClassInfo | null | undefined): ClassInfo | null;
 /** One specialization body: the override method's statements lowered with
  * `event` bound to the name and hidden tuple parameters standing in for
  * the rest parameter (readable ONLY through the super-forward, which the

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

@@ -52,6 +52,8 @@ import * as ts from "../ts7/adapter.js";
 import { dynFallbackType, newFnCtx } from "./lowerer.js";
 import { isJsSourceFile, locOf } from "../program.js";
 import { bodyReadsArguments } from "../arguments-usage.js";
+import { nullishExprUnitOf, stripValueWrappers } from "./binding-analysis.js";
+import { isPureReference } from "./effect-free.js";
 import { functionUsesThis } from "./cjs-exports-object.js";
 import { isThisParameter } from "./call-signatures.js";
 import { arrayOf, BOOL, canBoxFuncIntoDyn, canConvertToDyn, canDynCheckTo, isDynTypedRefType, DYN, F64, isUnitType, STRING, typeEquals, typeKey, VOID, } from "../../ir/ir.js";
@@ -286,48 +288,48 @@ function emitterEvents(lowerer) {
             if ((ts.isIdentifier(callee) || ts.isPropertyAccessExpression(callee)) &&
                 (ts.isIdentifier(callee) ? callee : callee.name).text === "getEventListeners" &&
                 node.arguments.nodes.length === 2) {
-                const nameT = (() => {
-                    try {
-                        return lowerer.typeOf(node.arguments.nodes[1]);
-                    }
-                    catch {
-                        return null;
-                    }
-                })();
-                if (nameT?.isStringLiteralType())
-                    listenersRead.add(literalEventKey(nameT.value));
+                const key = scannedEventKey(lowerer, node.arguments.nodes[1]);
+                if (key !== null && key !== ERROR_MONITOR_EVENT)
+                    listenersRead.add(key);
                 return;
             }
             if (!ts.isPropertyAccessExpression(callee))
                 return;
-            const member = callee.name.text;
+            let member = callee.name.text;
+            let recvNode = callee.expression;
+            let callArgs = node.arguments.nodes;
+            // `R.<method>.call(thisArg, ...args)` runs the method on thisArg
+            // (lowerEmitterMethodValueCall in lower-calls.ts).
+            if (member === "call" &&
+                ts.isPropertyAccessExpression(callee.expression) &&
+                callArgs.length > 0) {
+                member = callee.expression.name.text;
+                recvNode = callArgs[0];
+                callArgs = callArgs.slice(1);
+            }
             if (member === "listeners" || member === "rawListeners") {
-                const arg = node.arguments.nodes[0];
-                let nameT = null;
+                const arg = callArgs[0];
                 try {
-                    if (!arg ||
-                        !scannedEmitterInfo(lowerer, lowerer.mapTypeOf(lowerer.typeOf(callee.expression))))
+                    if (!arg || !scannedEmitterInfo(lowerer, lowerer.mapTypeOf(lowerer.typeOf(recvNode))))
                         return;
-                    nameT = lowerer.typeOf(arg);
                 }
                 catch {
                     return;
                 }
-                if (nameT.isStringLiteralType())
-                    listenersRead.add(literalEventKey(nameT.value));
+                const key = scannedEventKey(lowerer, arg);
+                if (key !== null && key !== ERROR_MONITOR_EVENT)
+                    listenersRead.add(key);
                 return;
             }
             const isEmit = member === "emit";
             if (!isEmit && !REGISTER_MEMBERS.has(member))
                 return;
-            const arg0 = node.arguments.nodes[0];
+            const arg0 = callArgs[0];
             if (!arg0)
                 return;
             let recvT = null;
-            let nameT = null;
             try {
-                recvT = lowerer.mapTypeOf(lowerer.typeOf(callee.expression));
-                nameT = lowerer.typeOf(arg0);
+                recvT = lowerer.mapTypeOf(lowerer.typeOf(recvNode));
             }
             catch {
                 return; // checker trouble is the lowering's business, not the scan's
@@ -335,11 +337,7 @@ function emitterEvents(lowerer) {
             const info = scannedEmitterInfo(lowerer, recvT);
             if (!info)
                 return;
-            const literal = isErrorMonitorRef(lowerer, arg0)
-                ? ERROR_MONITOR_EVENT
-                : nameT.isStringLiteralType()
-                    ? literalEventKey(nameT.value)
-                    : null;
+            const literal = scannedEventKey(lowerer, arg0);
             if (literal === null) {
                 const pattern = computedEventPatternOf(lowerer, arg0);
                 if (pattern &&
@@ -354,7 +352,7 @@ function emitterEvents(lowerer) {
                 return;
             }
             const name = literal;
-            if (META_EVENTS.has(name) && !isEmit && node.arguments.nodes[1]) {
+            if (META_EVENTS.has(name) && !isEmit && callArgs[1]) {
                 // A dyn-flavored meta listener receives each added or removed
                 // listener as a checked-dynamic function value. The scan cannot
                 // lower the listener as dynListenerFlavor does, so it counts every
@@ -363,7 +361,7 @@ function emitterEvents(lowerer) {
                 // JavaScript function without parameters, and the dyn-flavored
                 // forms. Counting one too many only routes more registrations
                 // through the adapter.
-                const cbNode = node.arguments.nodes[1];
+                const cbNode = callArgs[1];
                 let typed = false;
                 try {
                     const cbCt = lowerer.typeOf(cbNode);
@@ -384,7 +382,7 @@ function emitterEvents(lowerer) {
             }
             if (isEmit && name === "error") {
                 try {
-                    const payload = node.arguments.nodes.slice(1);
+                    const payload = callArgs.slice(1);
                     if (payload.length !== 1 ||
                         !rootsAtError(lowerer, lowerer.mapTypeOf(lowerer.typeOf(payload[0])))) {
                         table.get("error").valueEmit = true;
@@ -405,12 +403,12 @@ function emitterEvents(lowerer) {
                 return;
             try {
                 if (isEmit) {
-                    mergeEmit(name, node.arguments.nodes.slice(1).map((a) => lowerer.mapTypeOf(lowerer.typeOf(a))), isJsSourceFile(sf));
+                    mergeEmit(name, callArgs.slice(1).map((a) => lowerer.mapTypeOf(lowerer.typeOf(a))), isJsSourceFile(sf));
                 }
-                else if (node.arguments.nodes[1]) {
-                    const cbCt = lowerer.typeOf(node.arguments.nodes[1]);
-                    const cbT = lowerer.mapTypeOf(cbCt) ?? dynFallbackType(lowerer, node.arguments.nodes[1], cbCt);
-                    const pack = readsArgumentsPack(lowerer, node.arguments.nodes[1]);
+                else if (callArgs[1]) {
+                    const cbCt = lowerer.typeOf(callArgs[1]);
+                    const cbT = lowerer.mapTypeOf(cbCt) ?? dynFallbackType(lowerer, callArgs[1], cbCt);
+                    const pack = readsArgumentsPack(lowerer, callArgs[1]);
                     // A TypeScript listener with no parameters is typed too: it
                     // registers without the adapter, so an untyped emit reaches it
                     // only through the event's fixed ABI. A JavaScript function
@@ -523,14 +521,108 @@ function isErrorMonitorRef(lowerer, arg) {
     const property = lowerer.checker.getPropertyOfType(lowerer.typeOf(variable.initializer), key.text);
     return property !== undefined && isMonitorType(lowerer.checker.getTypeOfSymbol(property));
 }
+/** A name expression whose evaluation has no effects: a string or number
+ * literal, a `null`, `true` or `false` keyword, a binding read, or a stored
+ * field or record entry read. A call or an accessor lowers as a run-time
+ * name so its effects still run. */
+function staticNameExpr(lowerer, arg) {
+    const expression = stripValueWrappers(arg);
+    if (ts.isStringLiteral(expression) ||
+        ts.isNoSubstitutionTemplateLiteral(expression) ||
+        ts.isNumericLiteral(expression) ||
+        expression.kind === ts.SyntaxKind.NullKeyword ||
+        expression.kind === ts.SyntaxKind.TrueKeyword ||
+        expression.kind === ts.SyntaxKind.FalseKeyword) {
+        return true;
+    }
+    return isPureReference(lowerer, expression) || staticStdlibRead(lowerer, expression);
+}
+/** A read of a standard library field (`events.errorMonitor`,
+ * `EventEmitter.errorMonitor`): a plain member of the standard library's
+ * declaration, so it runs no program code. */
+function staticStdlibRead(lowerer, node) {
+    if (!ts.isPropertyAccessExpression(node) || node.questionDotToken)
+        return false;
+    if (!isPureReference(lowerer, node.expression))
+        return false;
+    const symbol = lowerer.checker.getSymbolAtLocation(node.name);
+    return (symbol !== undefined &&
+        lowerer.isStdlibSymbol(symbol) &&
+        (symbol.flags &
+            (ts.SymbolFlags.GetAccessor | ts.SymbolFlags.SetAccessor | ts.SymbolFlags.Method)) ===
+            0);
+}
 /** 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. */
+ * staticHeaderKeyOf stance) or the errorMonitor symbol, read without
+ * effects. A number-literal type read without effects and a `null`,
+ * `undefined`, `true` or `false` literal name the string Node's listener
+ * table keys them by, the property key `String(name)`: `on(123, fn)`
+ * registers under '123'. */
 function literalEventName(lowerer, arg) {
-    if (isErrorMonitorRef(lowerer, arg))
+    const staticName = staticNameExpr(lowerer, arg);
+    if (staticName && isErrorMonitorRef(lowerer, arg))
         return ERROR_MONITOR_EVENT;
-    const t = lowerer.typeOf(arg);
-    return t.isStringLiteralType() ? literalEventKey(t.value) : null;
+    if (staticName) {
+        const t = lowerer.typeOf(arg);
+        if (t.isStringLiteralType())
+            return literalEventKey(t.value);
+        if (t.isNumberLiteralType())
+            return literalEventKey(String(t.value));
+    }
+    const unit = nullishExprUnitOf(lowerer, arg);
+    if (unit !== null)
+        return unit;
+    let expression = arg;
+    while (ts.isParenthesizedExpression(expression))
+        expression = expression.expression;
+    if (expression.kind === ts.SyntaxKind.TrueKeyword)
+        return "true";
+    if (expression.kind === ts.SyntaxKind.FalseKeyword)
+        return "false";
+    return null;
+}
+/** An event-name argument as the string Node's listener table keys it by:
+ * a compile-time key, or a string, number or boolean value (or a union of
+ * those with null and undefined) converted as a property key
+ * (`String(name)`). An untyped value converts with the dynamic ToString,
+ * as the untyped emitter entries do. Other names are refused at the
+ * argument. */
+function eventNameArg(lowerer, member, arg) {
+    const key = literalEventName(lowerer, arg);
+    if (key !== null)
+        return eventNameExpr(key, locOf(arg));
+    const value = lowerer.lowerExpr(arg);
+    if (value.type.kind === "string")
+        return value;
+    const converts = (t) => t.kind === "string" || t.kind === "f64" || t.kind === "bool" || isUnitType(t);
+    const union = value.type.kind === "union" ? lowerer.unions.get(value.type.unionId) : undefined;
+    if (value.type.kind === "f64" ||
+        value.type.kind === "bool" ||
+        value.type.kind === "dyn" ||
+        (union !== undefined && union.arms.every(converts))) {
+        return { kind: "toString", operand: value, type: STRING, loc: value.loc };
+    }
+    lowerer.noLowering(`${member} with a '${lowerer.fmt(value.type)}' event name`, arg, "event names lower as strings, numbers and booleans (symbol names have no lowering)");
+}
+/** Whether a name that is neither a compile-time key nor a computed name
+ * with a constant prefix or suffix reaches the emitter through the bridge
+ * typed code uses for untyped receivers (lowerDynamicEmitterOn and
+ * lowerDynamicEmitterEmit): the runtime matches the name against the
+ * events typed code fixes, and keeps Node's 'error' and meta-event behavior
+ * for any other name. Streams keep their fixed internal events. */
+function bridgesUnrestrictedName(lowerer, info, arg) {
+    return computedEventPatternOf(lowerer, arg) === null && streamSidesOf(lowerer, info) === null;
+}
+/** literalEventName for the event table's scan, which leaves checker
+ * trouble to the lowering: null when the name's type cannot be read. */
+function scannedEventKey(lowerer, arg) {
+    try {
+        return literalEventName(lowerer, arg);
+    }
+    catch {
+        return null;
+    }
 }
 /** The compile-time key for a literal-only operation, or a pointed fence. */
 function eventNameOf(lowerer, member, arg) {
@@ -1290,11 +1382,13 @@ function lowerListenerArg(lowerer, member, name, node, tuple) {
  * routes here): the receiver is the current method's `this`, and emit
  * NEVER dispatches through an override at-or-below the lexical class —
  * JS's static super dispatch (the nearest override STRICTLY ABOVE the
- * lexical class still answers, exactly like a prototype-chain walk). */
-export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
+ * lexical class still answers, exactly like a prototype-chain walk).
+ * `argsOverride` replaces the call's arguments (`method.call(thisArg,
+ * ...args)` passes the ones after thisArg). */
+export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv, argsOverride) {
     const member = access.name.text;
     const loc = locOf(call);
-    const args = call.arguments.nodes;
+    const args = argsOverride ?? call.arguments.nodes;
     const lowerReceiver = () => {
         if (superRecv)
             return superRecv.thisRef;
@@ -1423,11 +1517,18 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
         if (literalEventName(lowerer, args[0]) === null) {
             // An unrestricted name on a plain emitter takes the any-name path;
             // streams keep the fence (their runtime events carry fixed ABIs).
-            const anyName = computedEventPatternOf(lowerer, args[0]) === null && streamSidesOf(lowerer, info) === null;
+            const anyName = bridgesUnrestrictedName(lowerer, info, args[0]);
             if (!anyName)
                 computedEventPattern(lowerer, info, member, args[0]);
+            // The name may be a meta event, which the runtime fires internally.
+            const ov = anyName && registering ? emitOverrideComparable(info) : null;
+            if (ov) {
+                lowerer.noLowering(`'${member}' with a runtime event name while '${ov.def.jsName || ov.def.name}' overrides emit`, call, "the runtime fires meta events internally, which cannot route through an emit override");
+            }
             const receiver = lowerReceiver();
-            const name = lowerer.lowerExprExpecting(args[0], STRING);
+            const name = anyName
+                ? eventNameArg(lowerer, member, args[0])
+                : lowerer.lowerExprExpecting(args[0], STRING);
             return lowerFlexListenerCall(lowerer, member, name, receiver, args[1], registering, member === "once" || member === "prependOnceListener", member === "prependListener" || member === "prependOnceListener", loc, anyName ? "emitter.onAny" : "emitter.onFlex", anyName);
         }
         const name = eventNameOf(lowerer, member, args[0]);
@@ -1564,8 +1665,8 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
                     loc,
                 };
             }
-            if (pattern === null && streamSidesOf(lowerer, info) === null) {
-                const name = lowerer.lowerExprExpecting(args[0], STRING);
+            if (bridgesUnrestrictedName(lowerer, info, args[0])) {
+                const name = eventNameArg(lowerer, member, args[0]);
                 return lowerFlexEmit(name, "computed-name", true);
             }
             computedEventPattern(lowerer, info, member, args[0]);
@@ -1651,14 +1752,7 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
         }
         const all = args.length === 0;
         const receiver = lowerReceiver();
-        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);
-        }
+        const name = all ? strLit("", loc) : eventNameArg(lowerer, member, args[0]);
         return {
             kind: "libCall",
             fn: "emitter.removeAll",
@@ -1672,12 +1766,7 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
             lowerer.noLowering(`listenerCount with ${args.length} arguments`, call);
         }
         const receiver = lowerReceiver();
-        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]);
-        }
+        const name = eventNameArg(lowerer, member, args[0]);
         if (args.length === 2) {
             // The fn filter matches by identity — the listener's own type is
             // its word; no tuple check is needed to count.
@@ -1711,6 +1800,18 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
         if (args.length !== 1) {
             lowerer.noLowering(`${member} with ${args.length} arguments`, call, "the supported form is (eventName)");
         }
+        if (literalEventName(lowerer, args[0]) === null &&
+            bridgesUnrestrictedName(lowerer, info, args[0])) {
+            // A runtime name: the untyped array, as through an untyped receiver.
+            const receiver = lowerReceiver();
+            return {
+                kind: "libCall",
+                fn: "emitter.listenersDyn",
+                args: [receiver, eventNameArg(lowerer, member, args[0])],
+                type: DYN,
+                loc,
+            };
+        }
         const name = eventNameOf(lowerer, member, args[0]);
         const sig = table.get(name);
         if (listenerArrayIsDyn(lowerer, name, sig)) {
@@ -1935,7 +2036,7 @@ function isWriteTarget(id) {
     }
 }
 /** The nearest class at-or-above `info` declaring an emit override. */
-function emitOverrideAtOrAbove(info) {
+export function emitOverrideAtOrAbove(info) {
     for (let c = info ?? null; c; c = c.base) {
         if (c.emitOverride)
             return c;
@@ -2426,15 +2527,43 @@ export function lowerEventsOnce(lowerer, call, loc) {
         loc,
     };
 }
-/** The EventEmitter argument of an events-module helper: an emitter
- * instance (not a stream, whose listener tuples the runtime pins). */
-function helperEmitter(lowerer, member, node) {
+/** The receiver of an events-module helper: an emitter, answered by its
+ * own methods, or an EventTarget (a plain target, an AbortSignal, or a
+ * compiled subclass), which crosses as a checked-dynamic value and is
+ * answered from its listener state. */
+function helperReceiver(lowerer, member, node) {
     const value = lowerer.lowerExpr(node);
-    const info = value.type.kind === "object" ? lowerer.classes.get(value.type.className) : undefined;
-    if (!emitterRooted(lowerer, info) || streamSidesOf(lowerer, info) !== null) {
-        lowerer.noLowering(`events.${member} over this value`, node, "the argument must be an EventEmitter instance; EventTarget and stream arguments are not supported yet");
+    // A target's lowered value is a checked-dynamic handle, so the class
+    // comes from the static type the checker gives the expression.
+    const staticType = value.type.kind === "object" ? null : lowerer.mapTypeOf(lowerer.typeOf(node));
+    const type = value.type.kind === "object" ? value.type : staticType;
+    const info = type?.kind === "object" ? lowerer.classes.get(type.className) : undefined;
+    if (emitterRooted(lowerer, info)) {
+        if (streamSidesOf(lowerer, info) === null)
+            return { kind: "emitter", value };
+        lowerer.noLowering(`events.${member} over a stream`, node, "a stream's own listenerCount/getMaxListeners/setMaxListeners/listeners answer its emitter; stream arguments are not supported yet");
+    }
+    // Everything else is resolved at runtime: an EventTarget (a plain target,
+    // an AbortSignal, a compiled subclass, or a value whose static type is
+    // checked-dynamic) answers from its own state, and any other value throws
+    // Node's ERR_INVALID_ARG_TYPE.
+    const dyn = lowerer.coerceToExpected(value, DYN);
+    if (dyn.type.kind === "dyn")
+        return { kind: "target", value: dyn };
+    lowerer.noLowering(`events.${member} over this value`, node, "pass an EventEmitter instance, an EventTarget, or a value of a checked-dynamic type");
+}
+/** The event name of a helper over a target: the string itself, or a
+ * checked-dynamic value (a value that is not a string matches no event
+ * type, which the runtime answers as an empty result). */
+function helperTypeName(lowerer, node) {
+    const value = lowerer.lowerExpr(node);
+    if (value.type.kind === "string")
+        return { expr: value, dyn: false };
+    const converted = lowerer.coerceToExpected(value, DYN);
+    if (converted.type.kind !== "dyn") {
+        lowerer.noLowering(`an events helper with a '${lowerer.fmt(value.type)}' event name`, node, "pass a string, or a value whose type is checked-dynamic");
     }
-    return value;
+    return { expr: converted, dyn: true };
 }
 /** setMaxListeners(n) with no targets: the process-wide default, through
  * Node's validateNumber(n, 'setMaxListeners', 0) ladder. */
@@ -2474,7 +2603,18 @@ export function lowerEventsEmitterHelper(lowerer, call, member, loc) {
     if (member === "listenerCount") {
         if (args.length !== 2)
             lowerer.noLowering(`events.listenerCount with ${args.length} arguments`, call);
-        const receiver = helperEmitter(lowerer, member, args[0]);
+        const helper = helperReceiver(lowerer, member, args[0]);
+        if (helper.kind === "target") {
+            const type = helperTypeName(lowerer, args[1]);
+            return {
+                kind: "libCall",
+                fn: type.dyn ? "event.targetListenerCountDyn" : "event.targetListenerCount",
+                args: [helper.value, type.expr],
+                type: F64,
+                loc,
+            };
+        }
+        const receiver = helper.value;
         const name = isErrorMonitorRef(lowerer, args[1])
             ? eventNameExpr(ERROR_MONITOR_EVENT, loc)
             : lowerer.lowerExprExpecting(args[1], STRING);
@@ -2486,8 +2626,14 @@ export function lowerEventsEmitterHelper(lowerer, call, member, loc) {
     if (member === "getMaxListeners") {
         if (args.length !== 1)
             lowerer.noLowering(`events.getMaxListeners with ${args.length} arguments`, call);
-        const receiver = helperEmitter(lowerer, member, args[0]);
-        return { kind: "libCall", fn: "emitter.getMax", args: [receiver], type: F64, loc };
+        const helper = helperReceiver(lowerer, member, args[0]);
+        return {
+            kind: "libCall",
+            fn: helper.kind === "target" ? "event.targetGetMax" : "emitter.getMax",
+            args: [helper.value],
+            type: F64,
+            loc,
+        };
     }
     if (member === "setMaxListeners") {
         // An omitted n is the current default, assigned again.
@@ -2510,21 +2656,29 @@ export function lowerEventsEmitterHelper(lowerer, call, member, loc) {
         const limit = lowerer.declareHiddenLocal("%maxListeners", F64);
         const stmts = [{ kind: "varDecl", localId: limit.id, init: n, loc }];
         const targets = args.slice(1).map((node) => {
-            const value = helperEmitter(lowerer, member, node);
-            const slot = lowerer.declareHiddenLocal("%maxListenersTarget", value.type);
-            stmts.push({ kind: "varDecl", localId: slot.id, init: value, loc });
-            return varRef(slot.id, value.type, loc);
+            const helper = helperReceiver(lowerer, member, node);
+            const slot = lowerer.declareHiddenLocal("%maxListenersTarget", helper.value.type);
+            stmts.push({ kind: "varDecl", localId: slot.id, init: helper.value, loc });
+            return { kind: helper.kind, value: varRef(slot.id, helper.value.type, loc) };
         });
         for (const target of targets) {
             stmts.push({
                 kind: "exprStmt",
-                expr: {
-                    kind: "libCall",
-                    fn: "emitter.setMax",
-                    args: [target, varRef(limit.id, F64, loc)],
-                    type: target.type,
-                    loc,
-                },
+                expr: target.kind === "target"
+                    ? {
+                        kind: "libCall",
+                        fn: "event.targetSetMax",
+                        args: [target.value, varRef(limit.id, F64, loc)],
+                        type: VOID,
+                        loc,
+                    }
+                    : {
+                        kind: "libCall",
+                        fn: "emitter.setMax",
+                        args: [target.value, varRef(limit.id, F64, loc)],
+                        type: target.value.type,
+                        loc,
+                    },
                 loc,
             });
         }
@@ -2535,9 +2689,25 @@ export function lowerEventsEmitterHelper(lowerer, call, member, loc) {
     if (member === "getEventListeners") {
         if (args.length !== 2)
             lowerer.noLowering(`events.getEventListeners with ${args.length} arguments`, call);
+        const helper = helperReceiver(lowerer, member, args[0]);
+        if (helper.kind === "target") {
+            // The target's listeners of the type, in registration order.
+            const type = helperTypeName(lowerer, args[1]);
+            const listeners = {
+                kind: "libCall",
+                fn: type.dyn ? "event.targetListenersDyn" : "event.targetListeners",
+                args: [helper.value, type.expr],
+                type: DYN,
+                loc,
+            };
+            // Node returns the listeners as registered, so a listener object with
+            // handleEvent comes back as itself; typed reads of the array convert
+            // each element where it is used.
+            return { kind: "dynCheck", value: listeners, type: arrayOf(DYN), loc };
+        }
         // emitter.listeners(name): the event's listener array, typed by the
         // event's unified tuple (the instance method's rules).
-        const receiver = helperEmitter(lowerer, member, args[0]);
+        const receiver = helper.value;
         const name = eventNameOf(lowerer, "events.getEventListeners", args[1]);
         const table = emitterEvents(lowerer);
         const sig = table.get(name);