@scriptc/compiler 0.4.0 → 0.4.2

package/dist/frontend/lowering/class-dynamic-dispatch.js

@@ -1,8 +1,11 @@
 import { primitiveConstructorOr } from "./lower-exprs.js";
+import { InternalCompilerError } from "../../errors.js";
 import { dynUndefinedExpr, helperLoc, nodeThrowExpr, varRef } from "../../ir/build.js";
 import { constructedValue } from "./constructor-returns.js";
 import { eventTargetApiMembers, eventTargetInheritedMember } from "./lower-event-target.js";
-import { BOOL, DYN, F64, DYN_CLASS_PROPERTIES as PROPERTY_BAG, STRING, VOID, canConvertToDyn, canDynCheckTo, isClassOwnEnumerableFieldName, isDynTypedRefType, isUnitType, typeEquals, typeKey, } from "../../ir/ir.js";
+import { DATE_PROTOTYPE_METHOD_NAMES, DATE_TIME_FIELD, dateInheritedMember, dateRootOf, programDeclaresDateClass, } from "./builtins/date-classes.js";
+import { dateValueMethod } from "./builtins/dates.js";
+import { BOOL, DATE_T, DYN, F64, DYN_CLASS_PROPERTIES as PROPERTY_BAG, STRING, VOID, canConvertToDyn, canDynCheckTo, isClassOwnEnumerableFieldName, isDynTypedRefType, isUnitType, typeEquals, typeKey, } from "../../ir/ir.js";
 import { streamTypedRefEligible } from "../../ir/analysis.js";
 import { everyStmtList, transformExpr, transformStmtList } from "../../ir/traverse.js";
 import { PoisonError } from "./lowerer.js";
@@ -22,7 +25,8 @@ import { isClassCallback } from "./class-callbacks.js";
 import { CaughtValueDispatch } from "./caught-value-dispatch.js";
 import { refreshDescriptorGuards } from "./class-descriptors.js";
 import { ClassConstructionDispatch } from "./class-construction.js";
-import { emitterRooted } from "./lower-event-emitter.js";
+import { DispatchSites } from "./dispatch-sites.js";
+import { emitterRooted, lowerDynamicEmitterEmit, lowerDynamicEmitterOn, } from "./lower-event-emitter.js";
 import { protocolArm, protocolFieldArm } from "./class-protocol-dispatch.js";
 import { STREAM_OPERATORS } from "./lower-stream.js";
 import { deletedPropertyNames, fixedFieldFamily } from "./js-class-fields.js";
@@ -50,6 +54,25 @@ const EMITTER_METHODS = new Set([
     "off",
     "removeListener",
 ]);
+/** The rest of EventEmitter.prototype, answered through an untyped value
+ * on emitters that are not streams (streams keep their own surface). */
+const EMITTER_INTROSPECTION_METHODS = new Set([
+    "listenerCount",
+    "eventNames",
+    "removeAllListeners",
+    "listeners",
+    "rawListeners",
+    "setMaxListeners",
+    "getMaxListeners",
+]);
+/** True when the class is or extends one of the runtime stream classes. */
+function streamRooted(info) {
+    for (let c = info; c; c = c.base) {
+        if (c.builtinStream !== undefined)
+            return true;
+    }
+    return false;
+}
 const STREAM_BOOL_PROPERTIES = new Set([
     "readable",
     "readableEnded",
@@ -128,7 +151,7 @@ const KEY_CALLS = new Map([
     ["dyn.keyDeleteComputed", "value"],
     ["dyn.keySetComputed", "value"],
 ]);
-function toPrimitiveHint(expr) {
+export function toPrimitiveHint(expr) {
     if (expr.kind === "toString")
         return expr.operand.type.kind === "dyn" ? "string" : null;
     if (expr.kind === "dynKeyGet")
@@ -176,6 +199,7 @@ function isPrimitive(value, loc) {
 }
 export function classInstanceOf(lowerer, value, info, loc, classValue) {
     const name = `%dyn.class.${classValue ? "valueInstanceof" : "instanceof"}:${info.def.name}`;
+    lowerer.shareHelper(name);
     const params = [
         { localId: "value", name: "value", type: DYN },
         ...(classValue ? [{ localId: "class", name: "class", type: classValue.type }] : []),
@@ -185,6 +209,32 @@ export function classInstanceOf(lowerer, value, info, loc, classValue) {
         const prototype = classPrototypeData(lowerer, info, loc, classValue ? varRef("class", classValue.type, loc) : undefined);
         const body = prototype
             ? [
+                // In a program that declares a class extending Date, a Date can
+                // meet a class test (`date instanceof Moment`): its prototype
+                // chain holds no class prototype.
+                ...(programDeclaresDateClass(lowerer)
+                    ? [
+                        {
+                            kind: "if",
+                            cond: {
+                                kind: "libCall",
+                                fn: "dyn.nativeDateHandleIs",
+                                args: [varRef("value", DYN, loc)],
+                                type: BOOL,
+                                loc,
+                            },
+                            then: [
+                                {
+                                    kind: "return",
+                                    value: { kind: "boolLit", value: false, type: BOOL, loc },
+                                    loc,
+                                },
+                            ],
+                            else_: null,
+                            loc,
+                        },
+                    ]
+                    : []),
                 { kind: "varDecl", localId: "candidate", init: varRef("value", DYN, loc), loc },
                 {
                     kind: "while",
@@ -273,9 +323,106 @@ function readOnlyBagBody(body, orEmpty = false) {
     }
     return body;
 }
+/** `value` with the class branch's checked receiver (`p.0` as a dynamic
+ * value, possibly cast to the branch's class) replaced by `receiver`, the
+ * typed receiver of a per-class helper. */
+function withTypedReceiver(value, receiver) {
+    const checked = (e) => e.kind === "dynCheck" && e.value.kind === "varRef" && e.value.localId === "p.0";
+    return transformExpr(value, {
+        stmt: (stmt) => stmt,
+        expr: (expr) => (expr.kind === "downcast" &&
+            checked(expr.value) &&
+            expr.type.kind === "object" &&
+            receiver.type.kind === "object" &&
+            expr.type.className === receiver.type.className) ||
+            checked(expr)
+            ? receiver
+            : expr,
+    });
+}
+/** Re-adds the classes of `set` after the first `from` in a fixed order:
+ * the program's classes by name, then the classes the runtime implements by
+ * name. The dispatch helpers add each class's branch in front of the
+ * earlier ones, so a runtime class's branch, which answers its methods for
+ * instances of the program's subclasses too, is tested before the
+ * subclasses' own branches. */
+function sortAdded(lowerer, set, from) {
+    const runtime = (name) => {
+        const info = lowerer.classes.get(name);
+        return !!(info &&
+            (info.def.runtime || info.builtinEmitter || info.builtinStream || info.builtinError));
+    };
+    const added = [...set]
+        .slice(from)
+        .sort((left, right) => Number(runtime(left)) - Number(runtime(right)) ||
+        (left < right ? -1 : left > right ? 1 : 0));
+    for (const name of added)
+        set.delete(name);
+    for (const name of added)
+        set.add(name);
+}
+function receiverIndex(lowerer, plans) {
+    const methods = new Map();
+    const members = new Map();
+    const rooted = [];
+    const add = (table, name, position) => {
+        const positions = table.get(name);
+        if (positions === undefined)
+            table.set(name, [position]);
+        else if (positions[positions.length - 1] !== position)
+            positions.push(position);
+    };
+    plans.forEach(({ info }, position) => {
+        if (emitterRooted(lowerer, info) ||
+            info.builtinStream !== undefined ||
+            eventTargetApiMembers(info) !== null ||
+            dateRootOf(info) !== null) {
+            rooted.push(position);
+            return;
+        }
+        for (let c = info; c; c = c.base) {
+            for (const name of c.methods.keys()) {
+                add(methods, name, position);
+                // A `get:`/`set:` key is an accessor of the property after the
+                // prefix, or a method whose quoted name has that prefix; the test
+                // looks up both.
+                add(members, name, position);
+                if (name.startsWith("get:") || name.startsWith("set:"))
+                    add(members, name.slice(4), position);
+            }
+            if (c.genericMethods)
+                for (const name of c.genericMethods.keys()) {
+                    add(methods, name, position);
+                    add(members, name, position);
+                }
+        }
+        for (const name of info.fields.keys())
+            add(members, name, position);
+    });
+    for (const table of [methods, members])
+        for (const positions of table.values())
+            positions.sort((a, b) => a - b);
+    return { plans, methods, members, rooted };
+}
+/** The ascending union of two ascending position lists. */
+function mergePositions(left, right) {
+    const out = [];
+    let i = 0;
+    let j = 0;
+    while (i < left.length || j < right.length) {
+        const next = j >= right.length || (i < left.length && left[i] <= right[j]) ? left[i++] : right[j++];
+        if (out[out.length - 1] !== next)
+            out.push(next);
+    }
+    return out;
+}
+/** SCRIPTC_CHECK_DISPATCH_CANDIDATES=1 checks every indexed receiver selection
+ * against a test of every receiver. */
+const CHECK_CANDIDATES = process.env["SCRIPTC_CHECK_DISPATCH_CANDIDATES"] === "1";
 export function classPropertiesHelper(lowerer, loc, readOnly = false) {
     const name = readOnly ? READ_PROPERTIES : "%dyn.class.properties";
-    const existing = lowerer.liftedFns.find((fn) => fn.name === name);
+    lowerer.shareHelper(name);
+    const existing = lowerer.liftedFnNamed(name);
     if (existing)
         return existing;
     const helper = {
@@ -309,6 +456,8 @@ export function classPropertiesHelper(lowerer, loc, readOnly = false) {
  * than that table, so a miss rechecks the instance itself. */
 export function classForInHasKey(lowerer, value, key, loc) {
     const name = "%dyn.class.forInHasKey";
+    lowerer.shareHelper(name);
+    lowerer.shareHelper("%dyn.class.forInBagHas");
     if (!lowerer.liftedFns.some((fn) => fn.name === name)) {
         // The read-only table: a recheck never creates an instance's table, which
         // is undefined while the instance has no own dynamic properties.
@@ -568,6 +717,8 @@ export class ClassDynamicDispatch {
     generatorDispatch = new GeneratorDynamicDispatch();
     caughtDispatch = new CaughtValueDispatch();
     constructionDispatch = new ClassConstructionDispatch();
+    /** What each function's body holds for this pass and its sub-passes. */
+    sites = new DispatchSites();
     /** Property names a delete can remove (null: any name), for the field
      * creation tracking decision. */
     deletedNames;
@@ -589,6 +740,9 @@ export class ClassDynamicDispatch {
     /** Per-class prototype selection for new property bags (bagPrototypeHelper). */
     bagPrototypeHelpers = new Map();
     readPropertyBags = [];
+    /** Read-only bags of exactly one class (exactPropertyBag), by class and
+     * whether an absent bag reads as a fresh empty object. */
+    exactPropertyBags = new Map();
     generated = new Set();
     /** Protocol dispatch helpers and callee reads whose receivers normalize. */
     protocols = [];
@@ -625,16 +779,18 @@ export class ClassDynamicDispatch {
                 first.value.callee === this.normalization?.name)
                 fn.body.shift();
         }
-        let changed = this.caughtDispatch.process(lowerer, functions);
+        let changed = this.caughtDispatch.process(lowerer, functions, this.sites);
         changed = refreshErrorMethodDispatch(lowerer, functions) || changed;
         changed = refreshClassMethodValueSelections(lowerer) || changed;
         changed = refreshErrorPropertyDispatch(lowerer, functions) || changed;
-        changed = this.generatorDispatch.process(lowerer, functions, this.generated) || changed;
-        changed = this.constructionDispatch.process(lowerer, functions) || changed;
+        changed =
+            this.generatorDispatch.process(lowerer, functions, this.generated, this.sites) || changed;
+        changed = this.constructionDispatch.process(lowerer, functions, this.sites) || changed;
         const seenTypes = new Set();
         const rewrite = new Set();
         const toPrimitiveSites = new Set();
         const hasKeySites = new Set();
+        const caughtSites = new Set();
         const discover = (type) => {
             const key = typeKey(type);
             if (seenTypes.has(key))
@@ -661,83 +817,30 @@ export class ClassDynamicDispatch {
             else if (type.kind === "promise")
                 discover(type.inner);
         };
-        for (const fn of functions)
-            everyStmtList(fn.body, {
-                stmt: (statement) => {
-                    // Field-creation instrumentation can box a base-constructor receiver
-                    // even when only its derived instances otherwise cross the boundary.
-                    if (statement.kind === "fieldSet" &&
-                        lowerer.classes.get(statement.className)?.def.tracksOwnFields &&
-                        isClassOwnEnumerableFieldName(statement.field))
-                        discover(statement.obj.type);
-                    return true;
-                },
-                expr: (expr) => {
-                    if (expr.kind === "jsonStringify" ||
-                        (expr.kind === "libCall" &&
-                            (expr.fn === "json.stringifyValue" || expr.fn === "json.stringifyReplacer"))) {
-                        this.serializesClasses = true;
-                    }
-                    if (toPrimitiveHint(expr) !== null ||
-                        (expr.kind === "libCall" && (expr.fn === "dyn.valueOf" || expr.fn === "dyn.toString")))
-                        toPrimitiveSites.add(fn);
-                    switch (expr.kind) {
-                        case "dynFrom":
-                            discover(expr.value.type);
-                            break;
-                        case "fieldIncDec":
-                            if (lowerer.classes.get(expr.className)?.def.tracksOwnFields &&
-                                isClassOwnEnumerableFieldName(expr.field))
-                                discover(expr.obj.type);
-                            break;
-                        case "call":
-                            if ((expr.callee === "%dyn.class.properties" ||
-                                expr.callee === "%dyn.class.readProperties") &&
-                                expr.args[0]?.kind === "dynFrom" &&
-                                isDynTypedRefType(expr.args[0].value.type))
-                                rewrite.add(fn);
-                            break;
-                        case "dynHasKey":
-                            hasKeySites.add(fn);
-                            break;
-                        case "dynKeyGet":
-                        case "dynInvoke":
-                            rewrite.add(fn);
-                            break;
-                        case "dynCheck":
-                            if (isDynTypedRefType(expr.type))
-                                rewrite.add(fn);
-                            // A dynamic function checked into a native function type
-                            // receives its arguments as dynamic values: class instances
-                            // passed to it cross the boundary when it is called (a JS
-                            // `list.map((rec) => rec.match(x))` callback with an untyped
-                            // parameter).
-                            if (expr.type.kind === "func")
-                                expr.type.params.forEach(discover);
-                            break;
-                        case "libCall":
-                            if (expr.fn === "bytes.construct" ||
-                                expr.fn === "dyn.keySet" ||
-                                expr.fn === "dyn.keySetComputed" ||
-                                expr.fn === "dyn.iterator" ||
-                                expr.fn === "dyn.arrayFromIterator" ||
-                                expr.fn === "dyn.toString" ||
-                                expr.fn === "dyn.stringConstructor" ||
-                                expr.fn === "dyn.forInKeys" ||
-                                expr.fn === "dyn.forInKeyStrings" ||
-                                expr.fn === "dyn.hasKeyComputed" ||
-                                expr.fn === "dyn.hasOwnComputed" ||
-                                expr.fn === "dyn.propertyIsEnumerableComputed" ||
-                                expr.fn === "dyn.defineProperty" ||
-                                expr.fn === "dyn.getPrototype" ||
-                                expr.fn === "dyn.reflectGet" ||
-                                expr.fn === "dyn.reflectSet")
-                                rewrite.add(fn);
-                            break;
-                    }
-                    return true;
-                },
-            });
+        const boxedBefore = this.boxed.size;
+        const boxedConstructorsBefore = this.boxedConstructors.size;
+        for (const fn of functions) {
+            const found = this.sites.of(fn);
+            // A class starts tracking its own fields during this pass.
+            for (const { type, fieldClass } of found.boxing)
+                if (fieldClass === undefined || lowerer.classes.get(fieldClass)?.def.tracksOwnFields)
+                    discover(type);
+            if (found.serializes)
+                this.serializesClasses = true;
+            if (found.conversions)
+                toPrimitiveSites.add(fn);
+            if (found.dispatches)
+                rewrite.add(fn);
+            if (found.keyTests)
+                hasKeySites.add(fn);
+            if (found.caughtClassTests)
+                caughtSites.add(fn);
+        }
+        // The classes this pass found join the tables in a fixed order, not in
+        // the order the scan met them.
+        sortAdded(lowerer, this.boxed, boxedBefore);
+        sortAdded(lowerer, this.boxedConstructors, boxedConstructorsBefore);
+        changed = this.caughtDispatch.dynamicPayloads(lowerer, caughtSites, this.boxed) || changed;
         if (this.boxed.size === 0 && rewrite.size === 0)
             return changed;
         const converting = this.convertingHints(lowerer);
@@ -879,7 +982,7 @@ export class ClassDynamicDispatch {
                 const loc = this.propertyBag.loc;
                 const method = classMethodValue(lowerer, info.decl, info, "toJSON", loc);
                 const prototype = method ? classPrototypeData(lowerer, info, loc) : null;
-                const helper = lowerer.liftedFns.find((fn) => fn.name === info.def.prototypeDataHelper);
+                const helper = lowerer.liftedFnNamed(info.def.prototypeDataHelper);
                 const init = helper?.body[0];
                 if (!info.prototypeReflectionReady &&
                     method &&
@@ -1079,15 +1182,36 @@ export class ClassDynamicDispatch {
         }
         refreshDescriptorGuards(lowerer);
         const byMethod = new Map();
+        // A query asks every receiver about one name, and the program's dispatch
+        // sites ask about thousands: index the receivers by name once per list.
+        let index = null;
+        const indexOf = (plans) => index?.plans === plans ? index : (index = receiverIndex(lowerer, plans));
+        /** The receivers of `plans` that can answer `name`, in list order: those
+         * `table` lists under it and the rooted ones. Emit-override
+         * specializations (`emit:<event>`) join a class's methods while bodies
+         * lower, so they keep every receiver. */
+        const receiversFor = (plans, name, table) => {
+            if (name.startsWith("emit:"))
+                return plans;
+            const found = indexOf(plans);
+            const positions = (table === "methods" ? found.methods : found.members).get(name);
+            return mergePositions(positions ?? [], found.rooted).map((position) => plans[position]);
+        };
         const candidates = (method) => {
             const found = byMethod.get(method);
             if (found)
                 return found;
-            const matching = this.propertyReceivers(lowerer, true).flatMap(({ info }) => {
+            const plans = this.propertyReceivers(lowerer, true);
+            const test = ({ info }) => {
                 if (!info || info.fields.has(method) || info.builtinError)
                     return [];
                 if (emitterRooted(lowerer, info) && EMITTER_METHODS.has(method))
                     return [info];
+                if (emitterRooted(lowerer, info) &&
+                    !streamRooted(info) &&
+                    EMITTER_INTROSPECTION_METHODS.has(method) &&
+                    !findMethodOn(lowerer, info, method))
+                    return [info];
                 if (info.builtinStream) {
                     return STREAM_METHODS.has(method) ||
                         (STREAM_OPERATORS.has(method) && info.builtinStream !== "w")
@@ -1097,10 +1221,25 @@ export class ClassDynamicDispatch {
                 return findMethodOn(lowerer, info, method) || findGenericMethodOn(lowerer, info, method)
                     ? [info]
                     : [];
-            });
+            };
+            const matching = receiversFor(plans, method, "methods").flatMap(test);
+            if (CHECK_CANDIDATES) {
+                const every = plans.flatMap(test);
+                if (every.length !== matching.length || every.some((info, i) => info !== matching[i]))
+                    throw new InternalCompilerError(`indexed candidates for ${method} differ`);
+            }
             byMethod.set(method, matching);
             return matching;
         };
+        const candidateSets = new Map();
+        const candidateSet = (method) => {
+            let set = candidateSets.get(method);
+            if (!set) {
+                set = new Set(candidates(method));
+                candidateSets.set(method, set);
+            }
+            return set;
+        };
         for (const fn of functions) {
             // Discovery already visits every expression. Preserve bodies without
             // dispatch sites instead of rebuilding their entire typed IR tree on
@@ -2044,14 +2183,14 @@ export class ClassDynamicDispatch {
                         : expr.kind === "dynInvoke"
                             ? expr
                             : null;
-                    const staticCandidates = invoke &&
-                        [...this.boxedConstructors].some((name) => {
-                            const info = lowerer.classes.get(name);
-                            return info && findStaticOn(lowerer, info, invoke.method)?.method;
-                        });
+                    // Static methods matter only for methods no instance answers.
+                    const staticCandidates = (method) => [...this.boxedConstructors].some((name) => {
+                        const info = lowerer.classes.get(name);
+                        return info && findStaticOn(lowerer, info, method)?.method;
+                    });
                     if (!invoke ||
                         (candidates(invoke.method).length === 0 &&
-                            !staticCandidates &&
+                            !staticCandidates(invoke.method) &&
                             !(invoke.method === "toString" && lowerer.classes.has("%Error"))))
                         return expr;
                     const key = JSON.stringify([
@@ -2316,17 +2455,41 @@ export class ClassDynamicDispatch {
                 });
                 changed = true;
             }
-            for (const plan of this.propertyReceivers(lowerer, true)) {
+            // Compute the candidates where the first plan would have, so the
+            // memoized set is the same whichever plans are already answered.
+            const plans = this.propertyReceivers(lowerer, true);
+            const matching = plans.length ? candidateSet(dispatch.source.method) : null;
+            for (const plan of plans) {
                 const { info } = plan;
-                if (!candidates(dispatch.source.method).includes(info) || dispatch.classes.has(plan.key))
+                if (dispatch.classes.has(plan.key) || !matching.has(info))
                     continue;
                 dispatch.classes.add(plan.key);
                 const loc = dispatch.source.loc;
-                const value = varRef("p.0", DYN, loc);
                 const { receiver, condition } = this.propertyReceiver(plan, loc);
                 if (isClassCallback(lowerer, info, dispatch.source.method)) {
                     const prototypeMethod = observedPrototypeMethod(lowerer, info, dispatch.source.method, loc, receiver);
-                    const bag = this.readPropertyBagOrEmpty(lowerer, value, loc);
+                    const bag = this.branchPropertyBag(lowerer, info, receiver, true, loc);
+                    const methodKey = {
+                        kind: "strLit",
+                        value: dispatch.source.method,
+                        type: STRING,
+                        loc,
+                    };
+                    const bagHas = {
+                        kind: "libCall",
+                        fn: "dyn.hasKey",
+                        args: [bag, methodKey],
+                        type: BOOL,
+                        loc,
+                    };
+                    // An observed prototype slot answers through the bag when the bag
+                    // holds the name (own or through its prototype). A bag read as a
+                    // fresh empty object (an instance with no own dynamic properties
+                    // whose bag initializer predates the class's prototype data) does
+                    // not, so the method then comes from the class's prototype data.
+                    const prototype = prototypeMethod
+                        ? classPrototypeData(lowerer, info, loc, receiver)
+                        : null;
                     dispatch.callback.body.unshift({
                         kind: "if",
                         cond: condition,
@@ -2335,18 +2498,7 @@ export class ClassDynamicDispatch {
                                 kind: "return",
                                 value: {
                                     kind: "ternary",
-                                    cond: prototypeMethod
-                                        ? { kind: "boolLit", value: true, type: BOOL, loc }
-                                        : {
-                                            kind: "libCall",
-                                            fn: "dyn.hasKey",
-                                            args: [
-                                                bag,
-                                                { kind: "strLit", value: dispatch.source.method, type: STRING, loc },
-                                            ],
-                                            type: BOOL,
-                                            loc,
-                                        },
+                                    cond: prototype ? { kind: "boolLit", value: true, type: BOOL, loc } : bagHas,
                                     then: {
                                         kind: "dynObjLit",
                                         fields: [
@@ -2354,8 +2506,17 @@ export class ClassDynamicDispatch {
                                                 key: { kind: "strLit", value: "value", type: STRING, loc },
                                                 value: {
                                                     kind: "dynKeyGet",
-                                                    value: bag,
-                                                    key: { kind: "strLit", value: dispatch.source.method, type: STRING, loc },
+                                                    value: prototype
+                                                        ? {
+                                                            kind: "ternary",
+                                                            cond: bagHas,
+                                                            then: bag,
+                                                            else_: prototype,
+                                                            type: DYN,
+                                                            loc,
+                                                        }
+                                                        : bag,
+                                                    key: methodKey,
                                                     type: DYN,
                                                     loc,
                                                 },
@@ -2462,7 +2623,7 @@ export class ClassDynamicDispatch {
             for (const plan of this.propertyReceivers(lowerer)) {
                 if (plan.info !== plan.capsule ||
                     dispatch.classes.has(plan.key) ||
-                    (!dispatch.field && !candidates(dispatch.method).includes(plan.info)))
+                    (!dispatch.field && !candidateSet(dispatch.method).has(plan.info)))
                     continue;
                 dispatch.classes.add(plan.key);
                 const loc = dispatch.fn.loc;
@@ -2545,28 +2706,52 @@ export class ClassDynamicDispatch {
                     });
                     changed = true;
                 }
-            for (const plan of this.propertyReceivers(lowerer, true)) {
+            // Only the receivers that declare or hold the name, and the rooted
+            // ones, can pass the test, except for names it decides on every
+            // receiver. Fields added while bodies lower (the property bag and the
+            // attribute words) have compiler names, which take every receiver.
+            const plans = this.propertyReceivers(lowerer, true);
+            const anyReceiver = !isClassOwnEnumerableFieldName(dispatch.name) ||
+                dispatch.name === "constructor" ||
+                dispatch.name === "stack";
+            const skips = (plan) => !isClassOwnEnumerableFieldName(dispatch.name) ||
+                (!(plan.info.builtinStream !== undefined && streamProperty(dispatch.name)) &&
+                    !eventTargetInheritedMember(plan.info, dispatch.name) &&
+                    !dateInheritedMember(lowerer, plan.info, dispatch.name) &&
+                    !findMethodOn(lowerer, plan.info, dispatch.name) &&
+                    !findGenericMethodOn(lowerer, plan.info, dispatch.name) &&
+                    dispatch.name !== "constructor" &&
+                    !plan.info.fields.has(dispatch.name) &&
+                    !(dispatch.name === "stack" && lowerer.isSubclassOf(plan.info.def.name, "%Error")) &&
+                    !findMethodOn(lowerer, plan.info, `get:${dispatch.name}`) &&
+                    !findMethodOn(lowerer, plan.info, `set:${dispatch.name}`));
+            const selected = anyReceiver ? plans : receiversFor(plans, dispatch.name, "members");
+            if (CHECK_CANDIDATES &&
+                plans.some((plan) => !dispatch.classes.has(plan.key) && !skips(plan) && !selected.includes(plan)))
+                throw new InternalCompilerError(`indexed receivers for ${dispatch.name} differ`);
+            for (const plan of selected) {
                 const { info } = plan;
-                if (!isClassOwnEnumerableFieldName(dispatch.name) ||
-                    (!(info.builtinStream !== undefined && streamProperty(dispatch.name)) &&
-                        !eventTargetInheritedMember(info, dispatch.name) &&
-                        !findMethodOn(lowerer, info, dispatch.name) &&
-                        !findGenericMethodOn(lowerer, info, dispatch.name) &&
-                        dispatch.name !== "constructor" &&
-                        !info.fields.has(dispatch.name) &&
-                        !(dispatch.name === "stack" && lowerer.isSubclassOf(info.def.name, "%Error")) &&
-                        !findMethodOn(lowerer, info, `get:${dispatch.name}`) &&
-                        !findMethodOn(lowerer, info, `set:${dispatch.name}`)))
-                    continue;
+                // Classes answered in an earlier pass skip the member lookups.
                 if (dispatch.classes.has(plan.key))
                     continue;
+                if (skips(plan))
+                    continue;
                 dispatch.classes.add(plan.key);
                 const loc = dispatch.fn.loc;
                 const { receiver, condition } = this.propertyReceiver(plan, loc);
+                // The branch checks its receiver once: each use of the checked
+                // receiver would repeat the check.
+                const local = `receiver.${dispatch.fn.locals.length}`;
+                dispatch.fn.locals.push({
+                    id: local,
+                    name: "receiver",
+                    type: receiver.type,
+                    mutable: false,
+                });
                 const before = lowerer.diags.length;
                 let branch;
                 try {
-                    branch = this.propertyBody(lowerer, dispatch, info, receiver);
+                    branch = this.propertyBody(lowerer, dispatch, info, varRef(local, receiver.type, loc));
                 }
                 catch (error) {
                     if (!(error instanceof PoisonError) || !info.decl)
@@ -2579,7 +2764,7 @@ export class ClassDynamicDispatch {
                 dispatch.fn.body.unshift({
                     kind: "if",
                     cond: condition,
-                    then: branch,
+                    then: [{ kind: "varDecl", localId: local, init: receiver, loc }, ...branch],
                     else_: null,
                     loc,
                 });
@@ -2655,7 +2840,8 @@ export class ClassDynamicDispatch {
                             },
                         ];
                     if (((info.builtinStream !== undefined && streamProperty(name)) ||
-                        eventTargetInheritedMember(info, name)) &&
+                        eventTargetInheritedMember(info, name) ||
+                        dateInheritedMember(lowerer, info, name)) &&
                         dispatch.probe)
                         return [
                             {
@@ -2671,7 +2857,7 @@ export class ClassDynamicDispatch {
                     const prototypeMethod = !info.fields.has(name) && observedPrototypeMethod(lowerer, info, name, loc, receiver);
                     if (info.fields.has(name) || (dispatch.probe === "in" && !prototypeMethod)) {
                         if (info.fields.has(name) && info.def.tracksOwnFields) {
-                            const bag = this.readPropertyBagOrEmpty(lowerer, lowerer.coerceToExpected(receiver, DYN), loc);
+                            const bag = this.branchPropertyBag(lowerer, info, receiver, true, loc);
                             const symbol = symbolMemberKey(lowerer, info, name, loc);
                             const fn = dispatch.probe === "in"
                                 ? "dyn.hasKey"
@@ -2696,7 +2882,7 @@ export class ClassDynamicDispatch {
                             { kind: "return", value: { kind: "boolLit", value: true, type: BOOL, loc }, loc },
                         ];
                     }
-                    const bag = this.readPropertyBagOrEmpty(lowerer, lowerer.coerceToExpected(receiver, DYN), loc);
+                    const bag = this.branchPropertyBag(lowerer, info, receiver, true, loc);
                     const symbol = name.startsWith("sym:") || name.startsWith("%symbol:");
                     const fn = dispatch.probe === "in"
                         ? "dyn.hasKey"
@@ -2762,9 +2948,8 @@ export class ClassDynamicDispatch {
                     }
                     const branches = [];
                     if (!dispatch.write && !dispatch.reflect && !info.def.tracksOwnFields) {
-                        const value = varRef("p.0", DYN, loc);
                         const key = varRef("p.key", DYN, loc);
-                        const bag = this.readPropertyBagOrEmpty(lowerer, value, loc);
+                        const bag = this.branchPropertyBag(lowerer, info, receiver, true, loc);
                         branches.push({
                             kind: "if",
                             cond: {
@@ -2866,6 +3051,10 @@ export class ClassDynamicDispatch {
                 if (inherited)
                     for (const name of inherited)
                         names.add(name);
+                if (dateRootOf(info))
+                    for (const name of DATE_PROTOTYPE_METHOD_NAMES)
+                        if (dateInheritedMember(lowerer, info, name))
+                            names.add(name);
                 for (let owner = info; owner; owner = owner.base) {
                     const methodNames = [...owner.methods.keys()];
                     if (owner.genericMethods)
@@ -3105,7 +3294,7 @@ export class ClassDynamicDispatch {
      * each class branch as small as the storing form. */
     readBagHas(lowerer, fn, bag, key, loc) {
         const name = fn === "dyn.hasKey" ? "%dyn.class.bagHas" : "%dyn.class.bagHasComputed";
-        let helper = lowerer.liftedFns.find((item) => item.name === name);
+        let helper = lowerer.liftedFnNamed(name);
         if (!helper) {
             const keyType = fn === "dyn.hasKey" ? STRING : DYN;
             const value = varRef("p.0", DYN, loc);
@@ -3498,6 +3687,66 @@ export class ClassDynamicDispatch {
             ];
             return { kind: "if", cond: condition, then: body, else_: null, loc };
         }
+        // Date.prototype[Symbol.toPrimitive] takes "default" as "string", and a
+        // class declared `extends Date` inherits Date's toString and valueOf,
+        // which answer primitives from the time value.
+        const dateRoot = dateRootOf(info);
+        if (dateRoot) {
+            const dateOrder = hint === "number" ? ["valueOf", "toString"] : ["toString", "valueOf"];
+            const { receiver } = this.propertyReceiver(plan, loc);
+            const body = [];
+            for (const method of dateOrder) {
+                if (!conversionMethod(lowerer, info, method)) {
+                    const time = {
+                        kind: "fieldGet",
+                        obj: upcastTo(lowerer, receiver, dateRoot.def.name),
+                        className: dateRoot.def.name,
+                        field: DATE_TIME_FIELD,
+                        type: DATE_T,
+                        loc,
+                    };
+                    body.push({
+                        kind: "return",
+                        value: lowerer.coerceToExpected(dateValueMethod(method, time, loc), DYN),
+                        loc,
+                    });
+                    break;
+                }
+                const result = `%toPrimitive.${method}.${helper.locals.length}`;
+                helper.locals.push({ id: result, name: method, type: DYN, mutable: false });
+                body.push({
+                    kind: "varDecl",
+                    localId: result,
+                    init: {
+                        kind: "call",
+                        callee: this.toPrimitiveCall(lowerer, plan, method, 0, loc),
+                        args: [varRef("p.0", DYN, loc)],
+                        type: DYN,
+                        loc,
+                    },
+                    loc,
+                }, {
+                    kind: "if",
+                    cond: isPrimitive(varRef(result, DYN, loc), loc),
+                    then: [{ kind: "return", value: varRef(result, DYN, loc), loc }],
+                    else_: null,
+                    loc,
+                });
+            }
+            if (body.at(-1)?.kind !== "return")
+                body.push({
+                    kind: "return",
+                    value: nodeThrowExpr(1, "", "Cannot convert object to primitive value", DYN, loc),
+                    loc,
+                });
+            return {
+                kind: "if",
+                cond: this.propertyReceiver(plan, loc).condition,
+                then: body,
+                else_: null,
+                loc,
+            };
+        }
         const order = hint === "string" ? ["toString", "valueOf"] : ["valueOf", "toString"];
         if (!order.some((method) => conversionMethod(lowerer, info, method)))
             return null;
@@ -3665,7 +3914,7 @@ export class ClassDynamicDispatch {
     readPropertyBagOrEmpty(lowerer, receiver, loc) {
         // One call per read site: large JS programs have a branch per class and
         // property, so the absent-bag handling lives in the shared helper.
-        let helper = lowerer.liftedFns.find((fn) => fn.name === READ_PROPERTIES_OR_EMPTY);
+        let helper = lowerer.liftedFnNamed(READ_PROPERTIES_OR_EMPTY);
         if (!helper) {
             // Settled by finalize; until then, the read-only bag's own dispatch.
             helper = {
@@ -3752,6 +4001,86 @@ export class ClassDynamicDispatch {
         lowerer.liftedFns.push(helper);
         return helper;
     }
+    /** The read-only bag a class branch reads for its receiver: the
+     * receiver's own field when the branch selected the receiver's exact
+     * class, otherwise the dispatch over every class (readPropertyBag, or
+     * readPropertyBagOrEmpty with `orEmpty`). */
+    branchPropertyBag(lowerer, info, receiver, orEmpty, loc) {
+        const helper = this.exactPropertyBag(lowerer, info, receiver, orEmpty, loc);
+        if (helper)
+            return { kind: "call", callee: helper.name, args: [receiver], type: DYN, loc };
+        return orEmpty
+            ? this.readPropertyBagOrEmpty(lowerer, lowerer.coerceToExpected(receiver, DYN), loc)
+            : this.readPropertyBag(lowerer, receiver, loc);
+    }
+    /** `%class.branchProperties[OrEmpty]:<class>(receiver)`: the read-only bag of
+     * an instance of exactly `info`. A class branch of the dispatch helpers
+     * selects a canonical receiver (normalizeDispatches gives an instance its
+     * actual class's capsule), so its branch for `info` sees only instances
+     * of `info`; instances of its subclasses take their own branches. Such a
+     * receiver needs neither the dispatch over every class nor a boxed copy of
+     * itself. Null
+     * when `receiver` is not typed as `info`, when a runtime or builtin class
+     * in the family keeps its own property contract, or before the class has
+     * a bag. */
+    exactPropertyBag(lowerer, info, receiver, orEmpty, loc) {
+        const type = receiver.type;
+        if (type.kind !== "object" || type.className !== info.def.name)
+            return null;
+        for (let current = info; current; current = current.base)
+            if (current.def.runtime ||
+                current.builtinEmitter ||
+                current.builtinStream ||
+                current.builtinError)
+                return null;
+        const key = `${type.className}:${orEmpty}`;
+        const existing = this.exactPropertyBags.get(key);
+        if (existing)
+            return existing;
+        const initializers = this.bagInitializers.get(type.className);
+        if (!initializers)
+            return null;
+        const self = varRef("p.0", type, loc);
+        const bag = {
+            kind: "fieldGet",
+            obj: self,
+            className: type.className,
+            field: PROPERTY_BAG,
+            type: DYN,
+            loc,
+        };
+        const initialize = {
+            ...initializers[0],
+            obj: self,
+            value: withTypedReceiver(initializers[0].value, self),
+            loc,
+        };
+        const helper = {
+            name: `%class.branchProperties${orEmpty ? "OrEmpty" : ""}:${type.className}`,
+            params: [{ localId: "p.0", name: "value", type }],
+            returnType: DYN,
+            locals: [{ id: "p.0", name: "value", type, mutable: false }],
+            loc,
+            body: [
+                {
+                    kind: "if",
+                    cond: { kind: "dynTest", test: "undefined", value: bag, type: BOOL, loc },
+                    then: [initialize],
+                    else_: null,
+                    loc,
+                },
+                { kind: "return", value: bag, loc },
+            ],
+        };
+        // Initializers gain their prototype as subclasses become constructible;
+        // finalize then turns the lazy store into the read's result.
+        initializers.push(initialize);
+        this.exactPropertyBags.set(key, helper);
+        this.readPropertyBags.push({ helper, initialize, orEmpty });
+        this.generated.add(helper);
+        lowerer.liftedFns.push(helper);
+        return helper;
+    }
     /** The prototype a new property bag of `current` (or of the subclass the
      * receiver is) starts from, or null when `current` has no prototype data.
      * A class with constructible subclasses that have prototype data selects
@@ -3826,9 +4155,13 @@ export class ClassDynamicDispatch {
      * prototype-backed bag is produced for this read only. A published object
      * cannot take the store, and Node's reads never write. */
     finalize(lowerer) {
-        for (const { helper, initialize } of this.readPropertyBags) {
+        // Each table serves every site that reaches it.
+        if (lowerer)
+            for (const fn of this.generated)
+                lowerer.shareHelper(fn);
+        for (const { helper, initialize, orEmpty } of this.readPropertyBags) {
             const absent = helper.body[0];
-            if (isEmptyBag(initialize.value))
+            if (isEmptyBag(initialize.value) && !orEmpty)
                 helper.body.shift();
             else if (absent?.kind === "if")
                 absent.then = [{ kind: "return", value: initialize.value, loc: initialize.loc }];
@@ -3997,21 +4330,43 @@ export class ClassDynamicDispatch {
         };
         add(root);
     }
+    /** propertyReceivers results by mode, with the class graph they were
+     * computed from: the boxed classes, the registered classes, the subclass
+     * links and the constructed classes only grow, so equal counts and the
+     * same capsules give the same plans. */
+    receiverPlans = new Map();
     /** A capsule retains its static type, while its object may be a subclass.
      * Preorder insertion lets later branches test the most derived layout first. */
     propertyReceivers(lowerer, streams = false, normalize = true) {
+        const mode = `${streams}:${normalize}`;
+        const revision = `${this.boxed.size}:${lowerer.classes.size}:${lowerer.subclassLinks}:${lowerer.constructedClassCount()}`;
+        const cached = this.receiverPlans.get(mode);
+        if (cached?.revision === revision) {
+            let i = 0;
+            let same = true;
+            for (const name of this.boxed)
+                if (lowerer.classes.get(name) !== cached.capsules[i++])
+                    same = false;
+            if (same)
+                return cached.plans;
+        }
+        const capsules = [];
         const plans = [];
         const seen = new Set();
         for (const name of this.boxed) {
             const capsule = lowerer.classes.get(name);
+            capsules.push(capsule);
             if (!capsule ||
                 ((capsule.builtinEmitter || capsule.builtinStream) && !streams) ||
                 capsule.builtinError)
                 continue;
             const canonical = normalize && !capsule.builtinStream && !capsule.builtinEmitter;
             const visit = (info) => {
-                if ((!canonical || !seen.has(info.def.name)) &&
-                    (info === capsule || lowerer.classCanBeConstructed(info))) {
+                // A seen class was visited with its whole subtree, and a canonical
+                // visit adds no plan for a seen class.
+                if (canonical && seen.has(info.def.name))
+                    return;
+                if (info === capsule || lowerer.classCanBeConstructed(info)) {
                     seen.add(info.def.name);
                     plans.push({
                         info,
@@ -4024,6 +4379,7 @@ export class ClassDynamicDispatch {
             };
             visit(capsule);
         }
+        this.receiverPlans.set(mode, { revision, capsules, plans });
         return plans;
     }
     propertyReceiver(plan, loc) {
@@ -4204,9 +4560,11 @@ export class ClassDynamicDispatch {
     propertyBody(lowerer, dispatch, info, receiver) {
         const { name, write } = dispatch;
         const loc = dispatch.fn.loc;
-        // The inherited EventTarget/Event members of a subclass instance: the
-        // runtime's capsule view answers the accessors and method values.
-        if (eventTargetInheritedMember(info, name)) {
+        // The inherited EventTarget/Event members of a subclass instance, and
+        // the inherited Date methods of an instance of a class declared
+        // `extends Date`: the runtime's capsule view answers the accessors and
+        // method values.
+        if (eventTargetInheritedMember(info, name) || dateInheritedMember(lowerer, info, name)) {
             const key = { kind: "strLit", value: name, type: STRING, loc };
             if (!write)
                 return [
@@ -4348,7 +4706,7 @@ export class ClassDynamicDispatch {
                             },
                             {
                                 kind: "if",
-                                cond: this.readBagHas(lowerer, "dyn.hasKey", this.readPropertyBag(lowerer, receiver, loc), key, loc),
+                                cond: this.readBagHas(lowerer, "dyn.hasKey", this.branchPropertyBag(lowerer, info, receiver, false, loc), key, loc),
                                 then: [store],
                                 else_: null,
                                 loc,
@@ -4360,7 +4718,7 @@ export class ClassDynamicDispatch {
                     { kind: "return", value: null, loc },
                 ];
             }
-            const bag = this.readPropertyBag(lowerer, receiver, loc);
+            const bag = this.branchPropertyBag(lowerer, info, receiver, false, loc);
             return [
                 {
                     kind: "return",
@@ -4418,7 +4776,7 @@ export class ClassDynamicDispatch {
                 !info.classDecorators) {
                 this.constructors.set(info.def.name, info);
                 const cls = lowerer.coerceToExpected(classValueRef(lowerer, info, info.decl), DYN);
-                const bag = this.readPropertyBag(lowerer, receiver, loc);
+                const bag = this.branchPropertyBag(lowerer, info, receiver, false, loc);
                 const key = { kind: "strLit", value: name, type: STRING, loc };
                 return [
                     {
@@ -4489,7 +4847,7 @@ export class ClassDynamicDispatch {
                     if (symbol || (isClassOwnEnumerableFieldName(name) && !name.startsWith("sym:"))) {
                         const prototypeMethod = observedPrototypeMethod(lowerer, info, name, loc, receiver);
                         // Selecting the method must not give the object own storage.
-                        const bag = this.readPropertyBag(lowerer, receiver, loc);
+                        const bag = this.branchPropertyBag(lowerer, info, receiver, false, loc);
                         const key = symbol ?? { kind: "strLit", value: name, type: STRING, loc };
                         body.push({
                             kind: "if",
@@ -4550,7 +4908,7 @@ export class ClassDynamicDispatch {
             }
             if (!field && !accessor) {
                 const instance = lowerer.coerceToExpected(receiver, DYN);
-                const bag = this.readPropertyBagOrEmpty(lowerer, instance, loc);
+                const bag = this.branchPropertyBag(lowerer, info, receiver, true, loc);
                 const key = { kind: "strLit", value: name, type: STRING, loc };
                 const own = {
                     kind: "libCall",
@@ -4598,7 +4956,7 @@ export class ClassDynamicDispatch {
             if (boxed.kind === "dynFrom" && mutable(boxed.value.type))
                 boxed.liveRef = true;
             if (accessor) {
-                const bag = this.readPropertyBagOrEmpty(lowerer, lowerer.coerceToExpected(receiver, DYN), loc);
+                const bag = this.branchPropertyBag(lowerer, info, receiver, true, loc);
                 const key = { kind: "strLit", value: name, type: STRING, loc };
                 return [
                     {
@@ -4625,7 +4983,7 @@ export class ClassDynamicDispatch {
             }
             if (field && info.def.tracksOwnFields) {
                 const instance = lowerer.coerceToExpected(receiver, DYN);
-                const bag = this.readPropertyBagOrEmpty(lowerer, instance, loc);
+                const bag = this.branchPropertyBag(lowerer, info, receiver, true, loc);
                 const symbol = symbolMemberKey(lowerer, info, name, loc);
                 const key = symbol ?? { kind: "strLit", value: name, type: STRING, loc };
                 return [
@@ -4730,6 +5088,50 @@ export class ClassDynamicDispatch {
             };
         return [store, { kind: "return", value: null, loc }];
     }
+    /** EventEmitter.prototype's introspection and bookkeeping members on an
+     * emitter seen through an untyped value: Node's results over the native
+     * listener registry. */
+    emitterIntrospection(lowerer, dispatch, receiver) {
+        const { method, loc } = dispatch.source;
+        const incoming = dispatch.source.args.map((_, i) => varRef(`p.${i + 1}`, DYN, loc));
+        const ret = (value) => [
+            { kind: "return", value: lowerer.coerceToExpected(value, DYN), loc },
+        ];
+        const call = (fn, args, type) => ({
+            kind: "libCall",
+            fn,
+            args: [receiver, ...args],
+            type,
+            loc,
+        });
+        // Node indexes _events with the argument itself: an omitted name is
+        // the key "undefined".
+        const eventName = () => incoming.length
+            ? lowerer.coerceToExpected(incoming[0], STRING)
+            : { kind: "strLit", value: "undefined", type: STRING, loc };
+        switch (method) {
+            case "listenerCount":
+                return ret(incoming.length >= 2
+                    ? call("emitter.countDyn", [eventName(), incoming[1]], F64)
+                    : call("emitter.count", [eventName()], F64));
+            case "eventNames":
+                return ret(call("emitter.names", [], { kind: "array", elem: STRING }));
+            case "removeAllListeners":
+                return ret(incoming.length
+                    ? call("emitter.removeAll", [eventName(), { kind: "boolLit", value: false, type: BOOL, loc }], receiver.type)
+                    : call("emitter.removeAll", [
+                        { kind: "strLit", value: "", type: STRING, loc },
+                        { kind: "boolLit", value: true, type: BOOL, loc },
+                    ], receiver.type));
+            case "listeners":
+            case "rawListeners":
+                return ret(call("emitter.listenersDyn", [eventName()], DYN));
+            case "setMaxListeners":
+                return ret(call("emitter.setMaxChk", [incoming[0] ?? dynUndefinedExpr(loc)], receiver.type));
+            default:
+                return ret(call("emitter.getMax", [], F64));
+        }
+    }
     methodBody(lowerer, dispatch, info, receiver) {
         const { method, loc } = dispatch.source;
         const fence = () => [
@@ -4740,6 +5142,12 @@ export class ClassDynamicDispatch {
                 loc,
             },
         ];
+        if (emitterRooted(lowerer, info) &&
+            !streamRooted(info) &&
+            EMITTER_INTROSPECTION_METHODS.has(method) &&
+            !findMethodOn(lowerer, info, method)) {
+            return this.emitterIntrospection(lowerer, dispatch, receiver);
+        }
         if (info.builtinStream ||
             (emitterRooted(lowerer, info) &&
                 EMITTER_METHODS.has(method) &&
@@ -4759,10 +5167,14 @@ export class ClassDynamicDispatch {
             if (method === "emit") {
                 if (!incoming.length)
                     return fence();
-                return ret({
+                const event = lowerer.coerceToExpected(incoming[0], STRING);
+                const bridged = streamRooted(info)
+                    ? null
+                    : lowerDynamicEmitterEmit(lowerer, receiver, event, incoming.slice(1), loc);
+                return ret(bridged ?? {
                     kind: "libCall",
-                    fn: "emitter.emitFlex",
-                    args: [receiver, lowerer.coerceToExpected(incoming[0], STRING), ...incoming.slice(1)],
+                    fn: "emitter.emitAny",
+                    args: [receiver, event, ...incoming.slice(1)],
                     type: BOOL,
                     loc,
                 });
@@ -4772,6 +5184,11 @@ export class ClassDynamicDispatch {
                     return fence();
                 const event = lowerer.coerceToExpected(incoming[0], STRING);
                 const cb = incoming[1];
+                const bridged = registering && !streamRooted(info)
+                    ? lowerDynamicEmitterOn(lowerer, receiver, event, cb, method === "once" || method === "prependOnceListener", method.startsWith("prepend"), loc)
+                    : null;
+                if (bridged)
+                    return ret(bridged);
                 return [
                     {
                         kind: "exprStmt",
@@ -4783,7 +5200,7 @@ export class ClassDynamicDispatch {
                         fn: registering
                             ? info.builtinStream
                                 ? "stream.onDyn"
-                                : "emitter.onFlex"
+                                : "emitter.onAny"
                             : "emitter.offDyn",
                         args: [
                             receiver,
@@ -4909,7 +5326,15 @@ export class ClassDynamicDispatch {
         if (methodInfo) {
             owner = methodInfo.declarer;
             params = methodInfo.sig.params;
-            result = methodInfo.sig.ret;
+            // An untyped async method's `dyn` result is its promise's payload; the
+            // call answers the promise. An async generator method answers its
+            // generator object, which its signature already returns.
+            result =
+                methodInfo.sig.async === true &&
+                    !methodInfo.sig.gen &&
+                    methodInfo.sig.ret.kind !== "promise"
+                    ? { kind: "promise", inner: methodInfo.sig.ret }
+                    : methodInfo.sig.ret;
             callee = `%${owner.def.name}.${method}`;
             virtual = lowerer.overrideBelow(owner, method) || methodInfo.sig.abstract === true;
         }