@scriptc/compiler 0.4.6 → 0.4.8

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

@@ -1,7 +1,8 @@
 import { primitiveConstructorOr } from "./lower-exprs.js";
 import { TO_STRING_TAG_FIELD, wellKnownSymbolOfField } from "./symbol-fields.js";
 import { InternalCompilerError } from "../../errors.js";
-import { dynUndefinedExpr, helperLoc, nodeThrowExpr, varRef } from "../../ir/build.js";
+import { dynUndefinedExpr, helperLoc, nodeThrowExpr, numLit, varRef } from "../../ir/build.js";
+import { classKeyHash } from "../../ir/class-key-index.js";
 import { constructedValue } from "./constructor-returns.js";
 import { eventTargetApiMembers, eventTargetInheritedMember } from "./lower-event-target.js";
 import { DATE_PROTOTYPE_METHOD_NAMES, DATE_TIME_FIELD, dateInheritedMember, dateRootOf, programDeclaresDateClass, } from "./builtins/date-classes.js";
@@ -15,6 +16,7 @@ import { erasedGenericInstance, implicitDefaultInstance } from "./generic-functi
 import {} from "./call-signatures.js";
 import { accessorCall, classValueRef, findGenericMethodOn, findGenericStaticOn, findMethodOn, findStaticOn, genericOverrideBelow, upcastTo, } from "./lower-classes.js";
 import { classPrototypeData, hasClassPrototypeData, prototypeReflectedFlag, observedPrototypeMethod, reflectClassPrototype, } from "./class-prototypes.js";
+import { runtimeStaticDefines } from "./class-runtime-statics.js";
 import { perEvaluationPrivateNames } from "./private-brands.js";
 import { errorPropertyRead, errorPropertyWrite, errorToStringCall, errorToStringMethod, refreshErrorPropertyDispatch, refreshErrorMethodDispatch, } from "./error-methods.js";
 import { GeneratorDynamicDispatch } from "./generator-dynamic-dispatch.js";
@@ -33,6 +35,8 @@ import { emitterRooted, lowerDynamicEmitterEmit, lowerDynamicEmitterOn, } from "
 import { protocolArm, protocolFieldArm } from "./class-protocol-dispatch.js";
 import { STREAM_OPERATORS, operatorSignalOptions, reduceSignalSetup } from "./lower-stream.js";
 import { deletedPropertyNames, fixedFieldFamily } from "./js-class-fields.js";
+/** The receiver local of a call rewritten for a getter-only name. */
+const GETTER_RECEIVER = "%dispatch.getter.receiver.";
 const STREAM_METHODS = new Set([
     "on",
     "addListener",
@@ -358,6 +362,217 @@ function branchKind(cond, param) {
         return branchKind(cond.left, param);
     return null;
 }
+/** The fewest distinct classes a run can dispatch on. Indexing costs a key
+ * load, a multiply and a compare tree whatever the table's size, while the
+ * chain costs a key test per class it skips: measured per read over tables
+ * read in rotation, indexing is 1.2 ns a read ahead at 20 classes, 4.1 ns at
+ * 40, 8.3 ns at 60 and 15 to 48 ns at 200. The crossover is far below this
+ * threshold, so what it decides is which tables change at all. Whole
+ * programs whose largest table holds fewer than this many classes measured
+ * within noise; the ones that gained (a nested decode -36.5%, 200-class reads
+ * -47%) gained through tables above it, and every smaller table keeps the
+ * chain it had. */
+const MIN_CLASS_DISPATCH_CASES = 64;
+/** A class table's branch whose condition tests one class's type key on a
+ * receiver local, or null for a statement of another form. A branch
+ * qualifies when it returns: a run is a dispatch, so the branch the switch
+ * selects leaves the helper rather than continuing into the statements after
+ * the run, which only the unselected branches would reach. */
+function classBranch(stmt) {
+    if (stmt.kind !== "if" || stmt.else_ !== null)
+        return null;
+    const test = classKeyTest(stmt.cond);
+    if (test === null)
+        return null;
+    if (stmt.then[stmt.then.length - 1]?.kind !== "return")
+        return null;
+    if (assignsLocal(stmt.then, test.receiver))
+        return null;
+    if (leavesSwitch(stmt.then))
+        return null;
+    return test;
+}
+/** Whether the branch would `break` the switch its body moves into: an
+ * unlabeled break that no loop or switch inside the body binds. A labeled
+ * break and an unlabeled one already bound inside the body keep their
+ * targets. */
+function leavesSwitch(statements) {
+    let found = false;
+    const scan = (body, bound) => {
+        for (const stmt of body) {
+            if (found)
+                return;
+            switch (stmt.kind) {
+                case "break":
+                    if (stmt.label === undefined && bound === 0)
+                        found = true;
+                    break;
+                case "while":
+                case "doWhile":
+                case "for":
+                case "forOf":
+                    scan(stmt.body, bound + 1);
+                    break;
+                case "switch":
+                    for (const { body: caseBody } of stmt.cases)
+                        scan(caseBody, bound + 1);
+                    break;
+                case "if":
+                    scan(stmt.then, bound);
+                    if (stmt.else_)
+                        scan(stmt.else_, bound);
+                    break;
+                case "block":
+                    scan(stmt.body, bound);
+                    break;
+                case "tryCatch":
+                    scan(stmt.tryBody, bound);
+                    if (stmt.catchBody)
+                        scan(stmt.catchBody, bound);
+                    if (stmt.finallyBody)
+                        scan(stmt.finallyBody, bound);
+                    break;
+                default:
+                    break;
+            }
+        }
+    };
+    scan(statements, 0);
+    return found;
+}
+/** The receiver local and interned type key of `dyn.typedRefIs(v, "object:C")`,
+ * or of the branch-conditional form `test ? instanceOf(v, C) : false`. The
+ * key must be ASCII: the dispatch indexes on the key's length and last four
+ * bytes, which for ASCII are the key text's own. */
+function classKeyTest(cond) {
+    if (cond.kind === "ternary" && cond.else_.kind === "boolLit" && cond.else_.value === false)
+        return classKeyTest(cond.cond);
+    if (cond.kind !== "libCall" || cond.fn !== "dyn.typedRefIs" || cond.args.length !== 2)
+        return null;
+    const [value, key] = cond.args;
+    if (value?.kind !== "varRef" || key?.kind !== "strLit")
+        return null;
+    if (!key.value.startsWith("object:") || !/^[\x20-\x7e]*$/.test(key.value))
+        return null;
+    return { value, receiver: value.localId, key: key.value };
+}
+/** Whether the branch writes its receiver local, which would make the
+ * dispatch read a value the branch tests do not. */
+function assignsLocal(statements, localId) {
+    let found = false;
+    everyStmtList(statements, {
+        stmt: (stmt) => {
+            if ((stmt.kind === "assign" || stmt.kind === "varDecl" || stmt.kind === "forOf") &&
+                stmt.localId === localId)
+                found = true;
+            return !found;
+        },
+        expr: () => !found,
+    });
+    return found;
+}
+/** The class branches of a generated table, whether its body lists them or
+ * reaches them through the indexed dispatch indexBranchRuns builds. The
+ * passes that read a table's branches run after it: the switch selects a
+ * branch by its class's key and the branch keeps its own key guard, so a
+ * reader treats the branches as the chain they were lowered from. */
+function classTableBranches(body) {
+    if (!body.some(isClassDispatch))
+        return body;
+    const branches = [];
+    for (const stmt of body) {
+        if (isClassDispatch(stmt))
+            for (const { body: caseBody } of stmt.cases)
+                branches.push(...caseBody);
+        else
+            branches.push(stmt);
+    }
+    return branches;
+}
+/** The switch indexBranchRuns builds over a table's branches. */
+function isClassDispatch(stmt) {
+    return stmt.kind === "switch" && stmt.disc.kind === "libCall" && stmt.disc.fn === "dyn.classHash";
+}
+/** The run's leading branches that stay in the chain ahead of the switch.
+ * Indexing costs a key load, a multiply and a walk of the compare tree before
+ * the matching branch's own guard runs, so a class the table tests early is
+ * cheaper in the chain: a read that hits one of them never computes the
+ * index. Keeping the first two measured the difference: one effect program
+ * whose tables are large but read near their front ran 3.3% slower with every
+ * branch in the switch (757.0 ms against 735.5 ms over 30 interleaved rounds)
+ * and at the baseline time with two peeled (737.5 ms), while a 200-class read,
+ * where the hit sits deep, keeps its gain. */
+const CLASS_DISPATCH_HEAD = 2;
+/** Replace each run of consecutive class branches on one receiver (at least
+ * MIN_CLASS_DISPATCH_CASES distinct classes) with a switch that selects the
+ * receiver's class. The branches move into the switch's cases unchanged and
+ * in order, branches whose keys hash together in one case; a key shared
+ * with a class outside the table selects that case, whose guards are false,
+ * and the switch's fallthrough reaches the remaining guards and the
+ * statements after the run exactly as the chain would. The run's first
+ * CLASS_DISPATCH_HEAD branches stay in the chain ahead of the switch: they
+ * run in order before it, and a class they select returns as it always did,
+ * so the switch only sees the receiver once those tests have failed. */
+function indexBranchRuns(body) {
+    let rebuilt = null;
+    let i = 0;
+    while (i < body.length) {
+        const start = i;
+        const first = classBranch(body[i]);
+        if (first === null) {
+            rebuilt?.push(body[i]);
+            i++;
+            continue;
+        }
+        const run = [];
+        let branch = first;
+        while (branch !== null && branch.receiver === first.receiver) {
+            run.push({ value: branch.value, receiver: branch.receiver, key: branch.key, stmt: body[i] });
+            i++;
+            branch = i < body.length ? classBranch(body[i]) : null;
+        }
+        const keys = [...new Set(run.map((branch) => branch.key))];
+        if (keys.length < MIN_CLASS_DISPATCH_CASES) {
+            if (rebuilt)
+                for (const branch of run)
+                    rebuilt.push(branch.stmt);
+            continue;
+        }
+        rebuilt ??= body.slice(0, start);
+        const head = Math.min(CLASS_DISPATCH_HEAD, run.length - 1);
+        for (const branch of run.slice(0, head))
+            rebuilt.push(branch.stmt);
+        rebuilt.push(classDispatch(run.slice(head)));
+    }
+    return rebuilt ?? body;
+}
+/** The switch that selects one of the run's branches, keyed by the class
+ * hash the emitted code computes from the receiver's key. */
+function classDispatch(run) {
+    const first = run[0];
+    const loc = first.stmt.loc;
+    const branches = new Map();
+    for (const branch of run) {
+        const hash = classKeyHash(branch.key);
+        const ofHash = branches.get(hash);
+        if (ofHash)
+            ofHash.push(branch.stmt);
+        else
+            branches.set(hash, [branch.stmt]);
+    }
+    return {
+        kind: "switch",
+        disc: {
+            kind: "libCall",
+            fn: "dyn.classHash",
+            args: [varRef(first.receiver, first.value.type, loc)],
+            type: F64,
+            loc,
+        },
+        cases: [...branches].map(([hash, body]) => ({ test: numLit(hash, loc), body })),
+        loc,
+    };
+}
 const READ_PROPERTIES = "%dyn.class.readProperties";
 const READ_PROPERTIES_OR_EMPTY = "%dyn.class.readPropertiesOrEmpty";
 function isEmptyBag(value) {
@@ -627,7 +842,7 @@ export function boxClassInstancesExactly(lowerer, functions) {
         return;
     // Static class → its constructible descendants in normalization order.
     const branches = new Map();
-    for (const stmt of normalize.body) {
+    for (const stmt of classTableBranches(normalize.body)) {
         if (stmt.kind !== "if" || stmt.cond.kind !== "libCall" || stmt.cond.fn !== "dyn.typedRefIs")
             continue;
         const key = stmt.cond.args[1];
@@ -1056,6 +1271,11 @@ export class ClassDynamicDispatch {
      * classes included: the value's capsule can be any of its subclasses. */
     boxedStatic = new Set();
     dispatches = new Map();
+    /** Per receiver local of a call rewritten for a getter-only name, the
+     * classes whose instances it already reads the getter on. A later wave
+     * that reaches another class with the getter rewrites the fallback call
+     * for that class. */
+    getterReceivers = new Map();
     properties = new Map();
     computed = new Map();
     computedClassHelpers = new Map();
@@ -1720,6 +1940,102 @@ export class ClassDynamicDispatch {
             byMethod.set(method, matching);
             return matching;
         };
+        // A name some class declares as a getter, and no class as a method: on
+        // an instance of such a class the call reads the member (running the
+        // getter) before it evaluates the arguments, as JavaScript reads the
+        // callee first, and then calls what it read. Any other receiver keeps
+        // the runtime's method dispatch, which answers builtin methods of the
+        // same name (`n.toFixed(2)` while a class declares `get toFixed()`).
+        // The runtime reads fields and other own properties of class instances
+        // that early itself (scr_dyn_prepare_method).
+        const getterCapsules = (method) => {
+            const keys = new Set();
+            for (const { info, capsule } of this.propertyReceivers(lowerer, true))
+                if (findMethodOn(lowerer, info, `get:${method}`))
+                    keys.add(typeKey({ kind: "object", className: capsule.def.name }));
+            return [...keys];
+        };
+        const getterCall = (fn, invoke, capsules, covered) => {
+            const loc = invoke.loc;
+            const receiverLocal = {
+                id: `${GETTER_RECEIVER}${this.getterReceivers.size}`,
+                name: "receiver",
+                type: DYN,
+                mutable: false,
+            };
+            fn.locals.push(receiverLocal);
+            const keys = new Set(capsules);
+            if (covered)
+                for (const key of covered)
+                    keys.add(key);
+            this.getterReceivers.set(receiverLocal.id, keys);
+            const calleeLocal = {
+                id: `%dispatch.callee.${fn.locals.length}`,
+                name: "callee",
+                type: DYN,
+                mutable: false,
+            };
+            fn.locals.push(calleeLocal);
+            const receiver = varRef(receiverLocal.id, DYN, loc);
+            const isCapsule = (key) => ({
+                kind: "libCall",
+                fn: "dyn.typedRefIs",
+                args: [receiver, { kind: "strLit", value: key, type: STRING, loc }],
+                type: BOOL,
+                loc,
+            });
+            const cond = capsules.slice(1).reduce((rest, key) => ({
+                kind: "ternary",
+                cond: isCapsule(key),
+                then: { kind: "boolLit", value: true, type: BOOL, loc },
+                else_: rest,
+                type: BOOL,
+                loc,
+            }), isCapsule(capsules[0]));
+            const read = {
+                kind: "seqExpr",
+                stmts: [
+                    {
+                        kind: "varDecl",
+                        localId: calleeLocal.id,
+                        init: {
+                            kind: "dynKeyGet",
+                            key: { kind: "strLit", value: invoke.method, type: STRING, loc },
+                            value: receiver,
+                            type: DYN,
+                            loc,
+                        },
+                        loc,
+                    },
+                ],
+                result: {
+                    kind: "dynCall",
+                    callee: varRef(calleeLocal.id, DYN, loc),
+                    receiver,
+                    calleeName: invoke.calleeName,
+                    ...(invoke.calleeNameValue ? { calleeNameValue: invoke.calleeNameValue } : {}),
+                    args: invoke.args,
+                    type: DYN,
+                    loc,
+                },
+                type: DYN,
+                loc,
+            };
+            return {
+                kind: "seqExpr",
+                stmts: [{ kind: "varDecl", localId: receiverLocal.id, init: invoke.recv, loc }],
+                result: {
+                    kind: "ternary",
+                    cond,
+                    then: read,
+                    else_: { ...invoke, recv: receiver },
+                    type: DYN,
+                    loc,
+                },
+                type: DYN,
+                loc,
+            };
+        };
         const candidateSets = new Map();
         const candidateSet = (method) => {
             let set = candidateSets.get(method);
@@ -1735,23 +2051,33 @@ export class ClassDynamicDispatch {
             // every reachability pass. Recompute this set as new bodies appear.
             if (this.generated.has(fn) || !rewrite.has(fn))
                 continue;
-            const keyInitializers = new Map();
-            const written = new Set();
-            everyStmtList(fn.body, {
-                expr: (expression) => {
-                    if (expression.kind === "incDec" || expression.kind === "assignExpr")
-                        written.add(expression.localId);
-                    return true;
-                },
-                stmt: (statement) => {
-                    if (statement.kind === "varDecl" && statement.init)
-                        keyInitializers.set(statement.localId, statement.init);
-                    if (statement.kind === "assign")
-                        written.add(statement.localId);
-                    return true;
-                },
-            });
+            // The bindings a key expression reads through, and the ones a write
+            // rebinds. Only a dynamic-key site asks for them, so a body without one
+            // keeps its IR walk.
+            let keyTables = null;
+            const keysOf = () => {
+                if (keyTables !== null)
+                    return keyTables;
+                const initializers = new Map();
+                const written = new Set();
+                everyStmtList(fn.body, {
+                    expr: (expression) => {
+                        if (expression.kind === "incDec" || expression.kind === "assignExpr")
+                            written.add(expression.localId);
+                        return true;
+                    },
+                    stmt: (statement) => {
+                        if (statement.kind === "varDecl" && statement.init)
+                            initializers.set(statement.localId, statement.init);
+                        if (statement.kind === "assign")
+                            written.add(statement.localId);
+                        return true;
+                    },
+                });
+                return (keyTables = { initializers, written });
+            };
             const keyValue = (value) => {
+                const { initializers: keyInitializers, written } = keysOf();
                 const visited = new Set();
                 while (true) {
                     if (value.kind === "dynFrom") {
@@ -1773,562 +2099,603 @@ export class ClassDynamicDispatch {
                     return value;
                 }
             };
-            fn.body = transformStmtList(fn.body, {
-                stmt: (stmt) => stmt,
-                expr: (expr) => {
-                    if (expr.kind === "dynHasKey" && prototypeMembers.has(expr.key)) {
-                        // A class instance's snapshot can carry its class's prototype
-                        // data, which holds only the methods the program reads through
-                        // the prototype. The computed-key form answers methods and
-                        // accessors from the class itself.
+            const rewriteExpr = (expr) => {
+                if (expr.kind === "dynHasKey" && prototypeMembers.has(expr.key)) {
+                    // A class instance's snapshot can carry its class's prototype
+                    // data, which holds only the methods the program reads through
+                    // the prototype. The computed-key form answers methods and
+                    // accessors from the class itself.
+                    const loc = expr.loc;
+                    const test = {
+                        kind: "libCall",
+                        fn: "dyn.hasKeyComputed",
+                        args: [
+                            expr.value,
+                            {
+                                kind: "dynFrom",
+                                value: { kind: "strLit", value: expr.key, type: STRING, loc },
+                                type: DYN,
+                                loc,
+                            },
+                        ],
+                        type: BOOL,
+                        loc,
+                    };
+                    changed = true;
+                    return {
+                        kind: "seqExpr",
+                        stmts: [],
+                        result: expr.negated
+                            ? { kind: "unary", op: "!", operand: test, type: BOOL, loc }
+                            : test,
+                        type: BOOL,
+                        loc,
+                    };
+                }
+                const called = calling.size ? this.convertMethodCall(lowerer, fn, expr, calling) : null;
+                if (called) {
+                    changed = true;
+                    return called;
+                }
+                const converted = converting.size
+                    ? this.convertOperands(lowerer, fn, expr, converting)
+                    : null;
+                if (converted) {
+                    changed = true;
+                    // A hoisting sequence revisits the operation as its child; a
+                    // wrapped operation continues through the rewrites below.
+                    if (converted.kind === "seqExpr")
+                        return converted;
+                    expr = converted;
+                }
+                if (expr.kind === "dynCheck" && isDynTypedRefType(expr.type)) {
+                    const type = expr.type;
+                    let cast = this.checkedCasts.get(type.className);
+                    if (!cast) {
                         const loc = expr.loc;
-                        const test = {
-                            kind: "libCall",
-                            fn: "dyn.hasKeyComputed",
-                            args: [
-                                expr.value,
-                                {
-                                    kind: "dynFrom",
-                                    value: { kind: "strLit", value: expr.key, type: STRING, loc },
-                                    type: DYN,
-                                    loc,
-                                },
-                            ],
-                            type: BOOL,
+                        const fn = {
+                            name: `%dyn.class.cast:${type.className}`,
+                            params: [{ localId: "value", name: "value", type: DYN }],
+                            locals: [{ id: "value", name: "value", type: DYN, mutable: false }],
+                            returnType: type,
+                            body: [{ kind: "return", value: { ...expr, value: varRef("value", DYN, loc) }, loc }],
                             loc,
                         };
+                        cast = { fn, classes: new Set() };
+                        this.checkedCasts.set(type.className, cast);
+                        this.generated.add(fn);
+                        lowerer.liftedFns.push(fn);
                         changed = true;
-                        return {
-                            kind: "seqExpr",
-                            stmts: [],
-                            result: expr.negated
-                                ? { kind: "unary", op: "!", operand: test, type: BOOL, loc }
-                                : test,
-                            type: BOOL,
+                    }
+                    return { kind: "call", callee: cast.fn.name, args: [expr.value], type, loc: expr.loc };
+                }
+                if (expr.kind === "libCall" && expr.fn === "dyn.inheritsErrorPrototype") {
+                    if (!this.errorPrototypeHelper) {
+                        const loc = expr.loc;
+                        this.errorPrototypeHelper = {
+                            name: "%dyn.class.inheritsErrorPrototype",
+                            params: [{ localId: "value", name: "value", type: DYN }],
+                            locals: [{ id: "value", name: "value", type: DYN, mutable: false }],
+                            returnType: BOOL,
                             loc,
+                            body: [
+                                { kind: "return", value: { ...expr, args: [varRef("value", DYN, loc)] }, loc },
+                            ],
                         };
-                    }
-                    const called = calling.size ? this.convertMethodCall(lowerer, fn, expr, calling) : null;
-                    if (called) {
-                        changed = true;
-                        return called;
-                    }
-                    const converted = converting.size
-                        ? this.convertOperands(lowerer, fn, expr, converting)
-                        : null;
-                    if (converted) {
+                        lowerer.liftedFns.push(this.errorPrototypeHelper);
+                        this.generated.add(this.errorPrototypeHelper);
                         changed = true;
-                        // A hoisting sequence revisits the operation as its child; a
-                        // wrapped operation continues through the rewrites below.
-                        if (converted.kind === "seqExpr")
-                            return converted;
-                        expr = converted;
                     }
-                    if (expr.kind === "dynCheck" && isDynTypedRefType(expr.type)) {
-                        const type = expr.type;
-                        let cast = this.checkedCasts.get(type.className);
-                        if (!cast) {
-                            const loc = expr.loc;
-                            const fn = {
-                                name: `%dyn.class.cast:${type.className}`,
-                                params: [{ localId: "value", name: "value", type: DYN }],
-                                locals: [{ id: "value", name: "value", type: DYN, mutable: false }],
-                                returnType: type,
-                                body: [
-                                    { kind: "return", value: { ...expr, value: varRef("value", DYN, loc) }, loc },
-                                ],
-                                loc,
-                            };
-                            cast = { fn, classes: new Set() };
-                            this.checkedCasts.set(type.className, cast);
-                            this.generated.add(fn);
-                            lowerer.liftedFns.push(fn);
-                            changed = true;
-                        }
-                        return { kind: "call", callee: cast.fn.name, args: [expr.value], type, loc: expr.loc };
-                    }
-                    if (expr.kind === "libCall" && expr.fn === "dyn.inheritsErrorPrototype") {
-                        if (!this.errorPrototypeHelper) {
+                    return {
+                        kind: "call",
+                        callee: this.errorPrototypeHelper.name,
+                        args: expr.args,
+                        type: BOOL,
+                        loc: expr.loc,
+                    };
+                }
+                if (expr.kind === "libCall" &&
+                    (expr.fn === "dyn.getPrototype" || expr.fn === "dyn.getPrototypeForIdentity") &&
+                    expr.args[0]?.kind !== "dynObjLit") {
+                    if (expr.prototypeIdentityOnly) {
+                        let helper = this.prototypeIdentityHelpers.get(expr.fn);
+                        if (!helper) {
                             const loc = expr.loc;
-                            this.errorPrototypeHelper = {
-                                name: "%dyn.class.inheritsErrorPrototype",
-                                params: [{ localId: "value", name: "value", type: DYN }],
-                                locals: [{ id: "value", name: "value", type: DYN, mutable: false }],
-                                returnType: BOOL,
-                                loc,
-                                body: [
-                                    { kind: "return", value: { ...expr, args: [varRef("value", DYN, loc)] }, loc },
-                                ],
+                            helper = {
+                                fn: {
+                                    name: expr.fn === "dyn.getPrototype"
+                                        ? "%dyn.class.prototypeIdentity"
+                                        : "%dyn.class.prototypeChainIdentity",
+                                    params: [{ localId: "value", name: "value", type: DYN }],
+                                    locals: [{ id: "value", name: "value", type: DYN, mutable: false }],
+                                    returnType: DYN,
+                                    loc,
+                                    body: [
+                                        {
+                                            kind: "return",
+                                            value: { ...expr, args: [varRef("value", DYN, loc)] },
+                                            loc,
+                                        },
+                                    ],
+                                },
+                                classes: new Set(),
                             };
-                            lowerer.liftedFns.push(this.errorPrototypeHelper);
-                            this.generated.add(this.errorPrototypeHelper);
+                            this.prototypeIdentityHelpers.set(expr.fn, helper);
+                            lowerer.liftedFns.push(helper.fn);
+                            this.generated.add(helper.fn);
                             changed = true;
                         }
                         return {
                             kind: "call",
-                            callee: this.errorPrototypeHelper.name,
+                            callee: helper.fn.name,
                             args: expr.args,
-                            type: BOOL,
+                            type: DYN,
                             loc: expr.loc,
                         };
                     }
-                    if (expr.kind === "libCall" &&
-                        (expr.fn === "dyn.getPrototype" || expr.fn === "dyn.getPrototypeForIdentity") &&
-                        expr.args[0]?.kind !== "dynObjLit") {
-                        if (expr.prototypeIdentityOnly) {
-                            let helper = this.prototypeIdentityHelpers.get(expr.fn);
-                            if (!helper) {
-                                const loc = expr.loc;
-                                helper = {
-                                    fn: {
-                                        name: expr.fn === "dyn.getPrototype"
-                                            ? "%dyn.class.prototypeIdentity"
-                                            : "%dyn.class.prototypeChainIdentity",
-                                        params: [{ localId: "value", name: "value", type: DYN }],
-                                        locals: [{ id: "value", name: "value", type: DYN, mutable: false }],
-                                        returnType: DYN,
-                                        loc,
-                                        body: [
-                                            {
-                                                kind: "return",
-                                                value: { ...expr, args: [varRef("value", DYN, loc)] },
-                                                loc,
-                                            },
-                                        ],
-                                    },
-                                    classes: new Set(),
-                                };
-                                this.prototypeIdentityHelpers.set(expr.fn, helper);
-                                lowerer.liftedFns.push(helper.fn);
-                                this.generated.add(helper.fn);
-                                changed = true;
-                            }
-                            return {
-                                kind: "call",
-                                callee: helper.fn.name,
-                                args: expr.args,
-                                type: DYN,
-                                loc: expr.loc,
-                            };
-                        }
-                        if (!this.prototypeHelper) {
-                            const loc = expr.loc;
-                            this.prototypeHelper = {
-                                name: "%dyn.class.getPrototype",
-                                params: [{ localId: "value", name: "value", type: DYN }],
-                                locals: [{ id: "value", name: "value", type: DYN, mutable: false }],
-                                returnType: DYN,
-                                loc,
-                                body: [
-                                    { kind: "return", value: { ...expr, args: [varRef("value", DYN, loc)] }, loc },
-                                ],
-                            };
-                            lowerer.liftedFns.push(this.prototypeHelper);
-                            this.generated.add(this.prototypeHelper);
-                            changed = true;
-                        }
-                        return {
-                            kind: "call",
-                            callee: this.prototypeHelper.name,
-                            args: expr.args,
-                            type: DYN,
-                            loc: expr.loc,
+                    if (!this.prototypeHelper) {
+                        const loc = expr.loc;
+                        this.prototypeHelper = {
+                            name: "%dyn.class.getPrototype",
+                            params: [{ localId: "value", name: "value", type: DYN }],
+                            locals: [{ id: "value", name: "value", type: DYN, mutable: false }],
+                            returnType: DYN,
+                            loc,
+                            body: [
+                                { kind: "return", value: { ...expr, args: [varRef("value", DYN, loc)] }, loc },
+                            ],
                         };
+                        lowerer.liftedFns.push(this.prototypeHelper);
+                        this.generated.add(this.prototypeHelper);
+                        changed = true;
                     }
-                    if (expr.kind === "libCall" &&
-                        (expr.fn === "dyn.toString" || expr.fn === "dyn.stringConstructor") &&
-                        lowerer.classes.has("%Error")) {
-                        const key = JSON.stringify([expr.fn, ...expr.args.map((arg) => typeKey(arg.type))]);
-                        let errorString = this.errorStrings.get(key);
-                        if (!errorString) {
-                            const loc = expr.loc;
-                            const params = expr.args.map((arg, i) => ({
-                                localId: `p.${i}`,
-                                name: `p${i}`,
-                                type: arg.type,
-                            }));
-                            const value = varRef("p.0", DYN, loc);
-                            errorString = {
-                                name: `%dyn.error.${expr.fn.slice(4)}.${this.errorStrings.size}`,
-                                params,
-                                returnType: STRING,
-                                locals: params.map((p) => ({
-                                    id: p.localId,
-                                    name: p.name,
-                                    type: p.type,
-                                    mutable: false,
-                                })),
-                                loc,
-                                body: [
-                                    {
-                                        kind: "if",
-                                        cond: { kind: "dynTest", test: "error", value, type: BOOL, loc },
-                                        then: [
-                                            {
-                                                kind: "return",
+                    return {
+                        kind: "call",
+                        callee: this.prototypeHelper.name,
+                        args: expr.args,
+                        type: DYN,
+                        loc: expr.loc,
+                    };
+                }
+                if (expr.kind === "libCall" &&
+                    (expr.fn === "dyn.toString" || expr.fn === "dyn.stringConstructor") &&
+                    lowerer.classes.has("%Error")) {
+                    const key = JSON.stringify([expr.fn, ...expr.args.map((arg) => typeKey(arg.type))]);
+                    let errorString = this.errorStrings.get(key);
+                    if (!errorString) {
+                        const loc = expr.loc;
+                        const params = expr.args.map((arg, i) => ({
+                            localId: `p.${i}`,
+                            name: `p${i}`,
+                            type: arg.type,
+                        }));
+                        const value = varRef("p.0", DYN, loc);
+                        errorString = {
+                            name: `%dyn.error.${expr.fn.slice(4)}.${this.errorStrings.size}`,
+                            params,
+                            returnType: STRING,
+                            locals: params.map((p) => ({
+                                id: p.localId,
+                                name: p.name,
+                                type: p.type,
+                                mutable: false,
+                            })),
+                            loc,
+                            body: [
+                                {
+                                    kind: "if",
+                                    cond: { kind: "dynTest", test: "error", value, type: BOOL, loc },
+                                    then: [
+                                        {
+                                            kind: "return",
+                                            value: {
+                                                kind: "dynCheck",
+                                                type: STRING,
+                                                loc,
                                                 value: {
-                                                    kind: "dynCheck",
-                                                    type: STRING,
-                                                    loc,
-                                                    value: {
-                                                        kind: "dynCall",
-                                                        callee: errorToStringMethod(lowerer, {
-                                                            kind: "dynCheck",
-                                                            value,
-                                                            type: { kind: "object", className: "%Error" },
-                                                            loc,
-                                                        }),
-                                                        receiver: value,
-                                                        calleeName: "value.toString",
-                                                        args: params
-                                                            .slice(1)
-                                                            .map((p) => lowerer.coerceToExpected(varRef(p.localId, p.type, loc), DYN)),
-                                                        type: DYN,
+                                                    kind: "dynCall",
+                                                    callee: errorToStringMethod(lowerer, {
+                                                        kind: "dynCheck",
+                                                        value,
+                                                        type: { kind: "object", className: "%Error" },
                                                         loc,
-                                                    },
+                                                    }),
+                                                    receiver: value,
+                                                    calleeName: "value.toString",
+                                                    args: params
+                                                        .slice(1)
+                                                        .map((p) => lowerer.coerceToExpected(varRef(p.localId, p.type, loc), DYN)),
+                                                    type: DYN,
+                                                    loc,
                                                 },
-                                                loc,
                                             },
-                                        ],
-                                        else_: null,
-                                        loc,
-                                    },
-                                    {
-                                        kind: "return",
-                                        value: { ...expr, args: params.map((p) => varRef(p.localId, p.type, loc)) },
-                                        loc,
-                                    },
-                                ],
-                            };
-                            this.errorStrings.set(key, errorString);
-                            this.generated.add(errorString);
-                            lowerer.liftedFns.push(errorString);
-                            changed = true;
-                        }
-                        return {
-                            kind: "call",
-                            callee: errorString.name,
-                            args: expr.args,
-                            type: STRING,
-                            loc: expr.loc,
+                                            loc,
+                                        },
+                                    ],
+                                    else_: null,
+                                    loc,
+                                },
+                                {
+                                    kind: "return",
+                                    value: { ...expr, args: params.map((p) => varRef(p.localId, p.type, loc)) },
+                                    loc,
+                                },
+                            ],
                         };
+                        this.errorStrings.set(key, errorString);
+                        this.generated.add(errorString);
+                        lowerer.liftedFns.push(errorString);
+                        changed = true;
                     }
-                    if (expr.kind === "call" &&
-                        (expr.callee === this.propertyBag.name || expr.callee === "%dyn.class.readProperties")) {
-                        const boxed = expr.args[0];
-                        if (boxed?.kind === "dynFrom" && isDynTypedRefType(boxed.value.type)) {
-                            const helper = this.typedPropertyBag(lowerer, boxed.value.type, expr.loc, expr.callee === "%dyn.class.readProperties");
-                            if (helper) {
-                                changed = true;
-                                return { ...expr, callee: helper.name, args: [boxed.value] };
-                            }
-                        }
-                    }
-                    if (expr.kind === "libCall" && expr.fn === "bytes.construct") {
-                        if (!this.constructDispatch) {
-                            const loc = expr.loc;
-                            const params = [DYN, DYN, STRING].map((type, i) => ({
-                                localId: `p.${i}`,
-                                name: `p${i}`,
-                                type,
-                            }));
-                            this.constructDispatch = {
-                                name: "%dyn.class.construct",
-                                params,
-                                returnType: DYN,
-                                locals: params.map((p) => ({
-                                    id: p.localId,
-                                    name: p.name,
-                                    type: p.type,
-                                    mutable: false,
-                                })),
-                                body: [
-                                    {
-                                        kind: "return",
-                                        value: { ...expr, args: params.map((p) => varRef(p.localId, p.type, loc)) },
-                                        loc,
-                                    },
-                                ],
-                                loc,
-                            };
-                            this.generated.add(this.constructDispatch);
-                            lowerer.liftedFns.push(this.constructDispatch);
+                    return {
+                        kind: "call",
+                        callee: errorString.name,
+                        args: expr.args,
+                        type: STRING,
+                        loc: expr.loc,
+                    };
+                }
+                if (expr.kind === "call" &&
+                    (expr.callee === this.propertyBag.name || expr.callee === "%dyn.class.readProperties")) {
+                    const boxed = expr.args[0];
+                    if (boxed?.kind === "dynFrom" && isDynTypedRefType(boxed.value.type)) {
+                        const helper = this.typedPropertyBag(lowerer, boxed.value.type, expr.loc, expr.callee === "%dyn.class.readProperties");
+                        if (helper) {
                             changed = true;
+                            return { ...expr, callee: helper.name, args: [boxed.value] };
                         }
-                        return {
-                            kind: "call",
-                            callee: this.constructDispatch.name,
-                            args: expr.args,
-                            type: DYN,
-                            loc: expr.loc,
-                        };
                     }
-                    if (expr.kind === "libCall" &&
-                        (expr.fn === "dyn.forInKeys" || expr.fn === "dyn.forInKeyStrings")) {
-                        let enumeration = this.enumerations.get(expr.fn);
-                        if (!enumeration) {
-                            const loc = expr.loc;
-                            const value = varRef("p.0", DYN, loc);
-                            enumeration = {
-                                name: expr.fn === "dyn.forInKeys"
-                                    ? "%dyn.class.forInKeys"
-                                    : "%dyn.class.forInKeyStrings",
-                                params: [{ localId: "p.0", name: "value", type: DYN }],
-                                returnType: expr.type,
-                                locals: [{ id: "p.0", name: "value", type: DYN, mutable: false }],
-                                body: [{ kind: "return", value: { ...expr, args: [value] }, loc }],
-                                loc,
-                            };
-                            this.enumerations.set(expr.fn, enumeration);
-                            this.generated.add(enumeration);
-                            lowerer.liftedFns.push(enumeration);
-                            changed = true;
-                        }
-                        return {
-                            kind: "call",
-                            callee: enumeration.name,
-                            args: expr.args,
-                            type: expr.type,
-                            loc: expr.loc,
+                }
+                if (expr.kind === "libCall" && expr.fn === "bytes.construct") {
+                    if (!this.constructDispatch) {
+                        const loc = expr.loc;
+                        const params = [DYN, DYN, STRING].map((type, i) => ({
+                            localId: `p.${i}`,
+                            name: `p${i}`,
+                            type,
+                        }));
+                        this.constructDispatch = {
+                            name: "%dyn.class.construct",
+                            params,
+                            returnType: DYN,
+                            locals: params.map((p) => ({
+                                id: p.localId,
+                                name: p.name,
+                                type: p.type,
+                                mutable: false,
+                            })),
+                            body: [
+                                {
+                                    kind: "return",
+                                    value: { ...expr, args: params.map((p) => varRef(p.localId, p.type, loc)) },
+                                    loc,
+                                },
+                            ],
+                            loc,
                         };
+                        this.generated.add(this.constructDispatch);
+                        lowerer.liftedFns.push(this.constructDispatch);
+                        changed = true;
                     }
-                    if (expr.kind === "libCall" && expr.fn === "dyn.defineProperty") {
+                    return {
+                        kind: "call",
+                        callee: this.constructDispatch.name,
+                        args: expr.args,
+                        type: DYN,
+                        loc: expr.loc,
+                    };
+                }
+                if (expr.kind === "libCall" &&
+                    (expr.fn === "dyn.forInKeys" || expr.fn === "dyn.forInKeyStrings")) {
+                    let enumeration = this.enumerations.get(expr.fn);
+                    if (!enumeration) {
                         const loc = expr.loc;
-                        if (!this.descriptorHelper) {
-                            const params = ["target", "key", "descriptor"].map((name) => ({
-                                localId: name,
-                                name,
+                        const value = varRef("p.0", DYN, loc);
+                        enumeration = {
+                            name: expr.fn === "dyn.forInKeys" ? "%dyn.class.forInKeys" : "%dyn.class.forInKeyStrings",
+                            params: [{ localId: "p.0", name: "value", type: DYN }],
+                            returnType: expr.type,
+                            locals: [{ id: "p.0", name: "value", type: DYN, mutable: false }],
+                            body: [{ kind: "return", value: { ...expr, args: [value] }, loc }],
+                            loc,
+                        };
+                        this.enumerations.set(expr.fn, enumeration);
+                        this.generated.add(enumeration);
+                        lowerer.liftedFns.push(enumeration);
+                        changed = true;
+                    }
+                    return {
+                        kind: "call",
+                        callee: enumeration.name,
+                        args: expr.args,
+                        type: expr.type,
+                        loc: expr.loc,
+                    };
+                }
+                if (expr.kind === "libCall" && expr.fn === "dyn.defineProperty") {
+                    const loc = expr.loc;
+                    if (!this.descriptorHelper) {
+                        const params = ["target", "key", "descriptor"].map((name) => ({
+                            localId: name,
+                            name,
+                            type: DYN,
+                        }));
+                        const target = varRef("target", DYN, loc);
+                        const key = varRef("key", DYN, loc);
+                        const descriptor = varRef("descriptor", DYN, loc);
+                        this.descriptorHelper = {
+                            name: "%dyn.class.defineProperty",
+                            params,
+                            returnType: DYN,
+                            locals: params.map((param) => ({
+                                id: param.localId,
+                                name: param.name,
                                 type: DYN,
-                            }));
-                            const target = varRef("target", DYN, loc);
-                            const key = varRef("key", DYN, loc);
-                            const descriptor = varRef("descriptor", DYN, loc);
-                            this.descriptorHelper = {
-                                name: "%dyn.class.defineProperty",
-                                params,
-                                returnType: DYN,
-                                locals: params.map((param) => ({
-                                    id: param.localId,
-                                    name: param.name,
-                                    type: DYN,
-                                    mutable: false,
-                                })),
-                                body: [
-                                    {
-                                        kind: "if",
-                                        cond: { kind: "dynTest", test: "symbol", value: key, type: BOOL, loc },
-                                        then: [
-                                            {
-                                                kind: "exprStmt",
-                                                expr: {
-                                                    ...expr,
-                                                    args: [
-                                                        {
-                                                            kind: "call",
-                                                            callee: this.propertyBag.name,
-                                                            args: [target],
-                                                            type: DYN,
-                                                            loc,
-                                                        },
-                                                        key,
-                                                        descriptor,
-                                                    ],
-                                                },
-                                                loc,
+                                mutable: false,
+                            })),
+                            body: [
+                                {
+                                    kind: "if",
+                                    cond: { kind: "dynTest", test: "symbol", value: key, type: BOOL, loc },
+                                    then: [
+                                        {
+                                            kind: "exprStmt",
+                                            expr: {
+                                                ...expr,
+                                                args: [
+                                                    {
+                                                        kind: "call",
+                                                        callee: this.propertyBag.name,
+                                                        args: [target],
+                                                        type: DYN,
+                                                        loc,
+                                                    },
+                                                    key,
+                                                    descriptor,
+                                                ],
                                             },
-                                            { kind: "return", value: target, loc },
-                                        ],
-                                        else_: null,
-                                        loc,
-                                    },
-                                    { kind: "return", value: { ...expr, args: [target, key, descriptor] }, loc },
-                                ],
-                                loc,
-                            };
-                            this.generated.add(this.descriptorHelper);
-                            lowerer.liftedFns.push(this.descriptorHelper);
-                            changed = true;
-                        }
-                        return {
-                            kind: "call",
-                            callee: this.descriptorHelper.name,
-                            args: expr.args,
-                            type: DYN,
+                                            loc,
+                                        },
+                                        { kind: "return", value: target, loc },
+                                    ],
+                                    else_: null,
+                                    loc,
+                                },
+                                { kind: "return", value: { ...expr, args: [target, key, descriptor] }, loc },
+                            ],
                             loc,
                         };
+                        this.generated.add(this.descriptorHelper);
+                        lowerer.liftedFns.push(this.descriptorHelper);
+                        changed = true;
                     }
-                    if (expr.kind === "dynKeyGet" && expr.value.kind === "dynObjLit")
-                        return expr;
-                    const reflectRead = expr.kind === "libCall" && expr.fn === "dyn.reflectGet" ? expr : null;
-                    const reflectWrite = expr.kind === "libCall" && expr.fn === "dyn.reflectSet" ? expr : null;
-                    const reflect = !!reflectRead || !!reflectWrite;
-                    const computedRead = reflectRead
-                        ? {
-                            kind: "dynKeyGet",
-                            value: reflectRead.args[0],
-                            key: reflectRead.args[1],
-                            type: DYN,
-                            loc: expr.loc,
-                        }
-                        : expr.kind === "dynKeyGet" && expr.key.kind !== "strLit"
-                            ? expr
-                            : null;
-                    const computedWrite = reflectWrite
-                        ? {
-                            ...reflectWrite,
-                            fn: "dyn.keySetComputed",
-                            args: reflectWrite.args.slice(0, 3),
-                            type: VOID,
-                        }
-                        : expr.kind === "libCall" &&
-                            (expr.fn === "dyn.keySetComputed" ||
-                                (expr.fn === "dyn.keySet" && expr.args[1]?.kind !== "strLit"))
-                            ? expr
-                            : null;
-                    const computedProbe = expr.kind === "libCall" &&
-                        [
-                            "dyn.hasKeyComputed",
-                            "dyn.hasOwnComputed",
-                            "dyn.propertyIsEnumerableComputed",
-                        ].includes(expr.fn)
+                    return {
+                        kind: "call",
+                        callee: this.descriptorHelper.name,
+                        args: expr.args,
+                        type: DYN,
+                        loc,
+                    };
+                }
+                if (expr.kind === "dynKeyGet" && expr.value.kind === "dynObjLit")
+                    return expr;
+                const reflectRead = expr.kind === "libCall" && expr.fn === "dyn.reflectGet" ? expr : null;
+                const reflectWrite = expr.kind === "libCall" && expr.fn === "dyn.reflectSet" ? expr : null;
+                const reflect = !!reflectRead || !!reflectWrite;
+                const computedRead = reflectRead
+                    ? {
+                        kind: "dynKeyGet",
+                        value: reflectRead.args[0],
+                        key: reflectRead.args[1],
+                        type: DYN,
+                        loc: expr.loc,
+                    }
+                    : expr.kind === "dynKeyGet" && expr.key.kind !== "strLit"
                         ? expr
                         : null;
-                    if (computedRead || computedWrite || computedProbe) {
-                        const probe = computedProbe
-                            ? computedProbe.fn === "dyn.hasKeyComputed"
-                                ? "in"
-                                : computedProbe.fn === "dyn.hasOwnComputed"
-                                    ? "own"
-                                    : "enumerable"
-                            : undefined;
-                        const dynamicKey = reflect ||
-                            !!computedProbe ||
-                            computedWrite?.fn === "dyn.keySetComputed" ||
-                            computedRead?.key.type.kind === "dyn";
-                        const sourceKey = keyValue(computedRead?.key ?? (computedWrite ?? computedProbe).args[1]);
-                        const numericKey = sourceKey.type.kind === "f64" ||
-                            (sourceKey.kind === "dynFrom" && sourceKey.value.type.kind === "f64") ||
-                            (sourceKey.kind === "toString" && sourceKey.operand.type.kind === "f64");
-                        // `value[i]` with a number `i`: the helper takes the number and
-                        // reads a dense checked array element directly, formatting the
-                        // property name only when that does not apply.
-                        const indexKey = computedRead &&
-                            !reflect &&
-                            !dynamicKey &&
-                            !computedRead.optional &&
-                            computedRead.key.kind === "toString" &&
-                            computedRead.key.operand.type.kind === "f64"
-                            ? computedRead.key
-                            : null;
-                        // A sloppy-mode write ignores a refused assignment
-                        // (sloppyDynamicWrites), so its sites share their own helper,
-                        // whose write takes the first such site's source range.
-                        const sloppyWrite = !!computedWrite && !reflect && isSloppyAt(lowerer, computedWrite.loc);
-                        const key = JSON.stringify([
-                            !!computedWrite,
-                            computedRead?.optional ?? false,
-                            dynamicKey,
-                            probe,
-                            numericKey,
-                            reflect,
-                            !!indexKey,
-                            ...(sloppyWrite ? ["sloppy"] : []),
-                        ]);
-                        let dispatch = this.computed.get(key);
-                        if (!dispatch) {
-                            const loc = expr.loc;
-                            const params = [
-                                { localId: "p.0", name: "value", type: DYN },
-                                indexKey
-                                    ? { localId: "p.index", name: "index", type: F64 }
-                                    : { localId: "p.key", name: "key", type: dynamicKey ? DYN : STRING },
-                                ...(computedWrite ? [{ localId: "p.1", name: "stored", type: DYN }] : []),
-                                ...(reflect ? [{ localId: "p.reflectReceiver", name: "receiver", type: DYN }] : []),
-                            ];
-                            const keyLocal = dynamicKey ? "key.string" : "p.key";
-                            const bag = computedWrite
+                const computedWrite = reflectWrite
+                    ? {
+                        ...reflectWrite,
+                        fn: "dyn.keySetComputed",
+                        args: reflectWrite.args.slice(0, 3),
+                        type: VOID,
+                    }
+                    : expr.kind === "libCall" &&
+                        (expr.fn === "dyn.keySetComputed" ||
+                            (expr.fn === "dyn.keySet" && expr.args[1]?.kind !== "strLit"))
+                        ? expr
+                        : null;
+                const computedProbe = expr.kind === "libCall" &&
+                    ["dyn.hasKeyComputed", "dyn.hasOwnComputed", "dyn.propertyIsEnumerableComputed"].includes(expr.fn)
+                    ? expr
+                    : null;
+                if (computedRead || computedWrite || computedProbe) {
+                    const probe = computedProbe
+                        ? computedProbe.fn === "dyn.hasKeyComputed"
+                            ? "in"
+                            : computedProbe.fn === "dyn.hasOwnComputed"
+                                ? "own"
+                                : "enumerable"
+                        : undefined;
+                    const dynamicKey = reflect ||
+                        !!computedProbe ||
+                        computedWrite?.fn === "dyn.keySetComputed" ||
+                        computedRead?.key.type.kind === "dyn";
+                    const sourceKey = keyValue(computedRead?.key ?? (computedWrite ?? computedProbe).args[1]);
+                    const numericKey = sourceKey.type.kind === "f64" ||
+                        (sourceKey.kind === "dynFrom" && sourceKey.value.type.kind === "f64") ||
+                        (sourceKey.kind === "toString" && sourceKey.operand.type.kind === "f64");
+                    // `value[i]` with a number `i`: the helper takes the number and
+                    // reads a dense checked array element directly, formatting the
+                    // property name only when that does not apply.
+                    const indexKey = computedRead &&
+                        !reflect &&
+                        !dynamicKey &&
+                        !computedRead.optional &&
+                        computedRead.key.kind === "toString" &&
+                        computedRead.key.operand.type.kind === "f64"
+                        ? computedRead.key
+                        : null;
+                    // A sloppy-mode write ignores a refused assignment
+                    // (sloppyDynamicWrites), so its sites share their own helper,
+                    // whose write takes the first such site's source range.
+                    const sloppyWrite = !!computedWrite && !reflect && isSloppyAt(lowerer, computedWrite.loc);
+                    const key = JSON.stringify([
+                        !!computedWrite,
+                        computedRead?.optional ?? false,
+                        dynamicKey,
+                        probe,
+                        numericKey,
+                        reflect,
+                        !!indexKey,
+                        ...(sloppyWrite ? ["sloppy"] : []),
+                    ]);
+                    let dispatch = this.computed.get(key);
+                    if (!dispatch) {
+                        const loc = expr.loc;
+                        const params = [
+                            { localId: "p.0", name: "value", type: DYN },
+                            indexKey
+                                ? { localId: "p.index", name: "index", type: F64 }
+                                : { localId: "p.key", name: "key", type: dynamicKey ? DYN : STRING },
+                            ...(computedWrite ? [{ localId: "p.1", name: "stored", type: DYN }] : []),
+                            ...(reflect ? [{ localId: "p.reflectReceiver", name: "receiver", type: DYN }] : []),
+                        ];
+                        const keyLocal = dynamicKey ? "key.string" : "p.key";
+                        const bag = computedWrite
+                            ? {
+                                kind: "call",
+                                callee: this.propertyBag.name,
+                                args: [varRef("p.0", DYN, loc)],
+                                type: DYN,
+                                loc,
+                            }
+                            : this.readPropertyBagOrEmpty(lowerer, varRef("p.0", DYN, loc), loc);
+                        const reflectionFallback = (target, property) => ({
+                            kind: "libCall",
+                            fn: computedWrite ? "dyn.reflectSet" : "dyn.reflectGet",
+                            args: [
+                                target,
+                                lowerer.coerceToExpected(property, DYN),
+                                ...(computedWrite ? [varRef("p.1", DYN, loc)] : []),
+                                varRef("p.reflectReceiver", DYN, loc),
+                            ],
+                            type: computedWrite ? BOOL : DYN,
+                            loc,
+                        });
+                        const fallback = reflect
+                            ? reflectionFallback(bag, varRef(keyLocal, STRING, loc))
+                            : computedProbe
                                 ? {
-                                    kind: "call",
-                                    callee: this.propertyBag.name,
-                                    args: [varRef("p.0", DYN, loc)],
-                                    type: DYN,
-                                    loc,
+                                    ...computedProbe,
+                                    fn: probe === "in"
+                                        ? "dyn.in"
+                                        : probe === "own"
+                                            ? "dyn.hasOwn"
+                                            : "dyn.propertyIsEnumerable",
+                                    args: [bag, varRef(keyLocal, STRING, loc)],
                                 }
-                                : this.readPropertyBagOrEmpty(lowerer, varRef("p.0", DYN, loc), loc);
-                            const reflectionFallback = (target, property) => ({
-                                kind: "libCall",
-                                fn: computedWrite ? "dyn.reflectSet" : "dyn.reflectGet",
-                                args: [
-                                    target,
-                                    lowerer.coerceToExpected(property, DYN),
-                                    ...(computedWrite ? [varRef("p.1", DYN, loc)] : []),
-                                    varRef("p.reflectReceiver", DYN, loc),
-                                ],
-                                type: computedWrite ? BOOL : DYN,
-                                loc,
-                            });
-                            const fallback = reflect
-                                ? reflectionFallback(bag, varRef(keyLocal, STRING, loc))
-                                : computedProbe
-                                    ? {
-                                        ...computedProbe,
-                                        fn: probe === "in"
-                                            ? "dyn.in"
-                                            : probe === "own"
-                                                ? "dyn.hasOwn"
-                                                : "dyn.propertyIsEnumerable",
-                                        args: [bag, varRef(keyLocal, STRING, loc)],
-                                    }
-                                    : computedRead
-                                        ? { ...computedRead, value: bag, key: varRef(keyLocal, STRING, loc) }
-                                        : {
-                                            ...computedWrite,
-                                            fn: "dyn.keySet",
-                                            args: [bag, varRef(keyLocal, STRING, loc), varRef("p.1", DYN, loc)],
-                                        };
-                            const helper = {
-                                name: `%dyn.class.computed.${this.computed.size}`,
-                                params,
-                                returnType: (reflect && computedWrite) || computedProbe ? BOOL : computedWrite ? VOID : DYN,
-                                locals: [
-                                    ...params.map((p) => ({
-                                        id: p.localId,
-                                        name: p.name,
-                                        type: p.type,
-                                        mutable: false,
-                                    })),
-                                    ...(dynamicKey || indexKey
-                                        ? [{ id: keyLocal, name: "key", type: STRING, mutable: false }]
-                                        : []),
-                                ],
-                                body: reflect
-                                    ? [{ kind: "return", value: fallback, loc }]
-                                    : computedWrite
+                                : computedRead
+                                    ? { ...computedRead, value: bag, key: varRef(keyLocal, STRING, loc) }
+                                    : {
+                                        ...computedWrite,
+                                        fn: "dyn.keySet",
+                                        args: [bag, varRef(keyLocal, STRING, loc), varRef("p.1", DYN, loc)],
+                                    };
+                        const helper = {
+                            name: `%dyn.class.computed.${this.computed.size}`,
+                            params,
+                            returnType: (reflect && computedWrite) || computedProbe ? BOOL : computedWrite ? VOID : DYN,
+                            locals: [
+                                ...params.map((p) => ({
+                                    id: p.localId,
+                                    name: p.name,
+                                    type: p.type,
+                                    mutable: false,
+                                })),
+                                ...(dynamicKey || indexKey
+                                    ? [{ id: keyLocal, name: "key", type: STRING, mutable: false }]
+                                    : []),
+                            ],
+                            body: reflect
+                                ? [{ kind: "return", value: fallback, loc }]
+                                : computedWrite
+                                    ? [
+                                        { kind: "exprStmt", expr: fallback, loc },
+                                        { kind: "return", value: null, loc },
+                                    ]
+                                    : [{ kind: "return", value: fallback, loc }],
+                            loc,
+                            ...(numericKey && computedRead && !reflect && !dynamicKey
+                                ? { fastRead: "index" }
+                                : {}),
+                        };
+                        if (dynamicKey)
+                            helper.body.unshift({
+                                kind: "if",
+                                cond: {
+                                    kind: "dynTest",
+                                    test: "symbol",
+                                    value: varRef("p.key", DYN, loc),
+                                    type: BOOL,
+                                    loc,
+                                },
+                                then: reflect
+                                    ? [
+                                        {
+                                            kind: "return",
+                                            value: reflectionFallback(bag, varRef("p.key", DYN, loc)),
+                                            loc,
+                                        },
+                                    ]
+                                    : computedProbe
                                         ? [
-                                            { kind: "exprStmt", expr: fallback, loc },
-                                            { kind: "return", value: null, loc },
+                                            {
+                                                kind: "return",
+                                                value: { ...computedProbe, args: [bag, varRef("p.key", DYN, loc)] },
+                                                loc,
+                                            },
                                         ]
-                                        : [{ kind: "return", value: fallback, loc }],
+                                        : computedRead
+                                            ? [
+                                                {
+                                                    kind: "return",
+                                                    value: {
+                                                        ...computedRead,
+                                                        value: bag,
+                                                        key: varRef("p.key", DYN, loc),
+                                                    },
+                                                    loc,
+                                                },
+                                            ]
+                                            : [
+                                                {
+                                                    kind: "exprStmt",
+                                                    expr: {
+                                                        ...computedWrite,
+                                                        args: [bag, varRef("p.key", DYN, loc), varRef("p.1", DYN, loc)],
+                                                    },
+                                                    loc,
+                                                },
+                                                { kind: "return", value: null, loc },
+                                            ],
+                                else_: null,
                                 loc,
-                                ...(numericKey && computedRead && !reflect && !dynamicKey
-                                    ? { fastRead: "index" }
-                                    : {}),
-                            };
-                            if (dynamicKey)
-                                helper.body.unshift({
-                                    kind: "if",
-                                    cond: {
-                                        kind: "dynTest",
-                                        test: "symbol",
-                                        value: varRef("p.key", DYN, loc),
-                                        type: BOOL,
-                                        loc,
-                                    },
-                                    then: reflect
+                            }, {
+                                kind: "if",
+                                cond: {
+                                    kind: "dynTest",
+                                    test: "nullish",
+                                    value: varRef("p.0", DYN, loc),
+                                    type: BOOL,
+                                    loc,
+                                },
+                                then: [
+                                    ...(reflect
                                         ? [
                                             {
                                                 kind: "return",
-                                                value: reflectionFallback(bag, varRef("p.key", DYN, loc)),
+                                                value: reflectionFallback(varRef("p.0", DYN, loc), varRef("p.key", DYN, loc)),
                                                 loc,
                                             },
                                         ]
@@ -2336,7 +2703,10 @@ export class ClassDynamicDispatch {
                                             ? [
                                                 {
                                                     kind: "return",
-                                                    value: { ...computedProbe, args: [bag, varRef("p.key", DYN, loc)] },
+                                                    value: {
+                                                        ...computedProbe,
+                                                        args: [varRef("p.0", DYN, loc), varRef("p.key", DYN, loc)],
+                                                    },
                                                     loc,
                                                 },
                                             ]
@@ -2346,7 +2716,7 @@ export class ClassDynamicDispatch {
                                                         kind: "return",
                                                         value: {
                                                             ...computedRead,
-                                                            value: bag,
+                                                            value: varRef("p.0", DYN, loc),
                                                             key: varRef("p.key", DYN, loc),
                                                         },
                                                         loc,
@@ -2357,461 +2727,257 @@ export class ClassDynamicDispatch {
                                                         kind: "exprStmt",
                                                         expr: {
                                                             ...computedWrite,
-                                                            args: [bag, varRef("p.key", DYN, loc), varRef("p.1", DYN, loc)],
+                                                            args: [
+                                                                varRef("p.0", DYN, loc),
+                                                                varRef("p.key", DYN, loc),
+                                                                varRef("p.1", DYN, loc),
+                                                            ],
                                                         },
                                                         loc,
                                                     },
                                                     { kind: "return", value: null, loc },
-                                                ],
-                                    else_: null,
-                                    loc,
-                                }, {
-                                    kind: "if",
-                                    cond: {
-                                        kind: "dynTest",
-                                        test: "nullish",
-                                        value: varRef("p.0", DYN, loc),
-                                        type: BOOL,
-                                        loc,
-                                    },
-                                    then: [
-                                        ...(reflect
-                                            ? [
-                                                {
-                                                    kind: "return",
-                                                    value: reflectionFallback(varRef("p.0", DYN, loc), varRef("p.key", DYN, loc)),
-                                                    loc,
-                                                },
-                                            ]
-                                            : computedProbe
-                                                ? [
-                                                    {
-                                                        kind: "return",
-                                                        value: {
-                                                            ...computedProbe,
-                                                            args: [varRef("p.0", DYN, loc), varRef("p.key", DYN, loc)],
-                                                        },
-                                                        loc,
-                                                    },
-                                                ]
-                                                : computedRead
-                                                    ? [
-                                                        {
-                                                            kind: "return",
-                                                            value: {
-                                                                ...computedRead,
-                                                                value: varRef("p.0", DYN, loc),
-                                                                key: varRef("p.key", DYN, loc),
-                                                            },
-                                                            loc,
-                                                        },
-                                                    ]
-                                                    : [
-                                                        {
-                                                            kind: "exprStmt",
-                                                            expr: {
-                                                                ...computedWrite,
-                                                                args: [
-                                                                    varRef("p.0", DYN, loc),
-                                                                    varRef("p.key", DYN, loc),
-                                                                    varRef("p.1", DYN, loc),
-                                                                ],
-                                                            },
-                                                            loc,
-                                                        },
-                                                        { kind: "return", value: null, loc },
-                                                    ]),
-                                    ],
-                                    else_: null,
-                                    loc,
-                                }, {
-                                    kind: "varDecl",
-                                    localId: keyLocal,
-                                    init: {
-                                        kind: "libCall",
-                                        fn: "dyn.toStringCoerce",
-                                        args: [varRef("p.key", DYN, loc)],
-                                        type: STRING,
-                                        loc,
-                                    },
-                                    loc,
-                                });
-                            if (indexKey) {
-                                // An integer index below a checked array's length names an
-                                // element (-0 included: its property name is "0"); dyn.arrLen
-                                // answers 0 for every other kind. Holes keep dyn.arrAt's
-                                // ordinary named lookup.
-                                const index = varRef("p.index", F64, loc);
-                                const elementRead = {
-                                    kind: "if",
-                                    cond: { kind: "libCall", fn: "number.isInteger", args: [index], type: BOOL, loc },
-                                    then: [
-                                        {
-                                            kind: "if",
-                                            cond: {
-                                                kind: "bin",
-                                                op: ">=",
-                                                left: index,
-                                                right: { kind: "numLit", value: 0, type: F64, loc },
-                                                type: BOOL,
-                                                loc,
-                                            },
-                                            then: [
-                                                {
-                                                    kind: "if",
-                                                    cond: {
-                                                        kind: "bin",
-                                                        op: "<",
-                                                        left: index,
-                                                        right: {
-                                                            kind: "libCall",
-                                                            fn: "dyn.arrLen",
-                                                            args: [varRef("p.0", DYN, loc)],
-                                                            type: F64,
-                                                            loc,
-                                                        },
-                                                        type: BOOL,
-                                                        loc,
-                                                    },
-                                                    then: [
-                                                        {
-                                                            kind: "return",
-                                                            value: {
-                                                                kind: "libCall",
-                                                                fn: "dyn.arrAt",
-                                                                args: [varRef("p.0", DYN, loc), index],
-                                                                type: DYN,
-                                                                loc,
-                                                            },
-                                                            loc,
-                                                        },
-                                                    ],
-                                                    else_: null,
-                                                    loc,
-                                                },
-                                            ],
-                                            else_: null,
-                                            loc,
-                                        },
-                                    ],
-                                    else_: null,
-                                    loc,
-                                };
-                                helper.body.unshift(elementRead, {
-                                    kind: "varDecl",
-                                    localId: keyLocal,
-                                    init: { ...indexKey, operand: index },
-                                    loc,
-                                });
-                            }
-                            dispatch = {
-                                write: !!computedWrite,
-                                reflect,
-                                fn: helper,
-                                classes: new Set(),
-                                keyLocal,
-                                branchIndex: dynamicKey ? 3 : indexKey ? 2 : 0,
-                                dynamicKey,
-                                numericKey,
-                                probe,
-                            };
-                            this.computed.set(key, dispatch);
-                            this.generated.add(helper);
-                            lowerer.liftedFns.push(helper);
-                            changed = true;
-                        }
-                        return {
-                            kind: "call",
-                            callee: dispatch.fn.name,
-                            args: reflect
-                                ? (reflectRead ?? reflectWrite).args
-                                : computedRead
-                                    ? [computedRead.value, indexKey ? indexKey.operand : computedRead.key]
-                                    : (computedWrite ?? computedProbe).args,
-                            type: dispatch.fn.returnType,
-                            loc: expr.loc,
-                        };
-                    }
-                    const read = expr.kind === "dynKeyGet" && expr.key.kind === "strLit" ? expr : null;
-                    const write = expr.kind === "libCall" && expr.fn === "dyn.keySet" && expr.args[1]?.kind === "strLit"
-                        ? expr
-                        : null;
-                    const name = read?.key.kind === "strLit"
-                        ? read.key.value
-                        : write?.args[1]?.kind === "strLit"
-                            ? write.args[1].value
-                            : null;
-                    if (name !== null) {
-                        const key = JSON.stringify([name, !!write, read?.optional ?? false]);
-                        let dispatch = this.properties.get(key);
-                        if (!dispatch) {
-                            const loc = expr.loc;
-                            const params = (write ? [0, 1] : [0]).map((i) => ({
-                                localId: `p.${i}`,
-                                name: `p${i}`,
-                                type: DYN,
-                            }));
-                            const instanceBag = read
-                                ? this.readPropertyBagOrEmpty(lowerer, varRef("p.0", DYN, loc), loc)
-                                : {
-                                    kind: "call",
-                                    callee: this.propertyBag.name,
-                                    args: [varRef("p.0", DYN, loc)],
-                                    type: DYN,
-                                    loc,
-                                };
-                            const bag = read && !["name", "length", "apply"].includes(name)
-                                ? {
-                                    kind: "call",
-                                    callee: this.constructorPropertyBag(lowerer, loc).name,
-                                    args: [instanceBag],
-                                    type: DYN,
-                                    loc,
-                                }
-                                : instanceBag;
-                            // A read compares the bag with the receiver and then reads it:
-                            // evaluate it once, so each read retains the receiver once.
-                            const bagRead = varRef("bag.0", DYN, loc);
-                            const bagGet = read
-                                ? {
-                                    kind: "libCall",
-                                    fn: "dyn.bagGet",
-                                    args: [bagRead, read.key, varRef("p.0", DYN, loc)],
-                                    type: DYN,
-                                    loc,
-                                }
-                                : null;
-                            // A class instance whose class chain declares no member of an
-                            // Object.prototype method's name (classes that do answer in
-                            // their own branches) inherits it unless an own property
-                            // shadows it; a class constructor's static bag reads as before.
-                            const instanceRead = read && INHERITED_OBJECT_METHODS.has(name)
-                                ? {
-                                    kind: "ternary",
-                                    cond: {
-                                        kind: "dynTest",
-                                        test: "function",
-                                        value: varRef("p.0", DYN, loc),
-                                        type: BOOL,
-                                        loc,
-                                    },
-                                    then: bagGet,
-                                    else_: {
-                                        kind: "ternary",
-                                        cond: this.readBagHas(lowerer, "dyn.hasKey", bagRead, read.key, loc),
-                                        then: bagGet,
-                                        else_: {
-                                            kind: "libCall",
-                                            fn: "dyn.builtinMethod",
-                                            args: [{ kind: "strLit", value: "Object", type: STRING, loc }, read.key],
-                                            type: DYN,
-                                            loc,
-                                        },
-                                        type: DYN,
-                                        loc,
-                                    },
-                                    type: DYN,
-                                    loc,
-                                }
-                                : bagGet;
-                            const fallback = read
-                                ? {
-                                    kind: "ternary",
-                                    cond: {
-                                        kind: "dynScalarEq",
-                                        left: bagRead,
-                                        right: varRef("p.0", DYN, loc),
-                                        type: BOOL,
-                                        loc,
-                                    },
-                                    then: { ...read, value: bagRead },
-                                    else_: instanceRead,
-                                    type: DYN,
-                                    loc,
-                                }
-                                : { ...write, args: [bag, write.args[1], varRef("p.1", DYN, loc)] };
-                            const helper = {
-                                name: `%dyn.class.property.${this.properties.size}`,
-                                params,
-                                returnType: write ? VOID : DYN,
-                                locals: [
-                                    ...params.map((p) => ({
-                                        id: p.localId,
-                                        name: p.name,
-                                        type: DYN,
-                                        mutable: false,
-                                    })),
-                                    ...(read ? [{ id: "bag.0", name: "bag", type: DYN, mutable: false }] : []),
+                                                ]),
                                 ],
-                                body: write
-                                    ? [
-                                        { kind: "exprStmt", expr: fallback, loc },
-                                        { kind: "return", value: null, loc },
-                                    ]
-                                    : [
-                                        { kind: "varDecl", localId: "bag.0", init: bag, loc },
-                                        {
-                                            kind: "return",
-                                            // Primitives answer their wrapper constructors.
-                                            value: name === "constructor"
-                                                ? primitiveConstructorOr(lowerer, varRef("p.0", DYN, loc), fallback, loc)
-                                                : fallback,
-                                            loc,
-                                        },
-                                    ],
+                                else_: null,
                                 loc,
-                            };
-                            if (!write && name === "toString" && lowerer.classes.has("%Error")) {
-                                const value = varRef("p.0", DYN, loc);
-                                helper.body.unshift({
-                                    kind: "if",
-                                    cond: { kind: "dynTest", test: "error", value, type: BOOL, loc },
-                                    then: [
-                                        {
-                                            kind: "return",
-                                            value: errorToStringMethod(lowerer, {
-                                                kind: "dynCheck",
-                                                value,
-                                                type: { kind: "object", className: "%Error" },
-                                                loc,
-                                            }),
-                                            loc,
-                                        },
-                                    ],
-                                    else_: null,
+                            }, {
+                                kind: "varDecl",
+                                localId: keyLocal,
+                                init: {
+                                    kind: "libCall",
+                                    fn: "dyn.toStringCoerce",
+                                    args: [varRef("p.key", DYN, loc)],
+                                    type: STRING,
                                     loc,
-                                });
-                            }
-                            const receiverAccess = read
-                                ? [{ kind: "return", value: { ...read, value: varRef("p.0", DYN, loc) }, loc }]
-                                : [
+                                },
+                                loc,
+                            });
+                        if (indexKey) {
+                            // An integer index below a checked array's length names an
+                            // element (-0 included: its property name is "0"); dyn.arrLen
+                            // answers 0 for every other kind. Holes keep dyn.arrAt's
+                            // ordinary named lookup.
+                            const index = varRef("p.index", F64, loc);
+                            const elementRead = {
+                                kind: "if",
+                                cond: { kind: "libCall", fn: "number.isInteger", args: [index], type: BOOL, loc },
+                                then: [
                                     {
-                                        kind: "exprStmt",
-                                        expr: {
-                                            ...write,
-                                            args: [varRef("p.0", DYN, loc), write.args[1], varRef("p.1", DYN, loc)],
+                                        kind: "if",
+                                        cond: {
+                                            kind: "bin",
+                                            op: ">=",
+                                            left: index,
+                                            right: { kind: "numLit", value: 0, type: F64, loc },
+                                            type: BOOL,
+                                            loc,
                                         },
+                                        then: [
+                                            {
+                                                kind: "if",
+                                                cond: {
+                                                    kind: "bin",
+                                                    op: "<",
+                                                    left: index,
+                                                    right: {
+                                                        kind: "libCall",
+                                                        fn: "dyn.arrLen",
+                                                        args: [varRef("p.0", DYN, loc)],
+                                                        type: F64,
+                                                        loc,
+                                                    },
+                                                    type: BOOL,
+                                                    loc,
+                                                },
+                                                then: [
+                                                    {
+                                                        kind: "return",
+                                                        value: {
+                                                            kind: "libCall",
+                                                            fn: "dyn.arrAt",
+                                                            args: [varRef("p.0", DYN, loc), index],
+                                                            type: DYN,
+                                                            loc,
+                                                        },
+                                                        loc,
+                                                    },
+                                                ],
+                                                else_: null,
+                                                loc,
+                                            },
+                                        ],
+                                        else_: null,
                                         loc,
                                     },
-                                    { kind: "return", value: null, loc },
-                                ];
-                            dispatch = {
-                                name,
-                                write: !!write,
-                                fn: helper,
-                                classes: new Set(),
-                                ...(name !== "constructor" && name !== "toString"
-                                    ? { plain: { tail: [...helper.body], access: receiverAccess } }
-                                    : {}),
+                                ],
+                                else_: null,
+                                loc,
                             };
-                            this.properties.set(key, dispatch);
-                            this.generated.add(helper);
-                            lowerer.liftedFns.push(helper);
-                            changed = true;
+                            helper.body.unshift(elementRead, {
+                                kind: "varDecl",
+                                localId: keyLocal,
+                                init: { ...indexKey, operand: index },
+                                loc,
+                            });
                         }
-                        return {
-                            kind: "call",
-                            callee: dispatch.fn.name,
-                            args: read ? [read.value] : [write.args[0], write.args[2]],
-                            type: dispatch.fn.returnType,
-                            loc: expr.loc,
+                        dispatch = {
+                            write: !!computedWrite,
+                            reflect,
+                            fn: helper,
+                            classes: new Set(),
+                            keyLocal,
+                            branchIndex: dynamicKey ? 3 : indexKey ? 2 : 0,
+                            dynamicKey,
+                            numericKey,
+                            probe,
                         };
+                        this.computed.set(key, dispatch);
+                        this.generated.add(helper);
+                        lowerer.liftedFns.push(helper);
+                        changed = true;
                     }
-                    const iterator = expr.kind === "libCall" &&
-                        (expr.fn === "dyn.iterator" ||
-                            expr.fn === "dyn.arrayFromIterator" ||
-                            expr.fn === "dyn.asyncIteratorOpen")
-                        ? expr
+                    return {
+                        kind: "call",
+                        callee: dispatch.fn.name,
+                        args: reflect
+                            ? (reflectRead ?? reflectWrite).args
+                            : computedRead
+                                ? [computedRead.value, indexKey ? indexKey.operand : computedRead.key]
+                                : (computedWrite ?? computedProbe).args,
+                        type: dispatch.fn.returnType,
+                        loc: expr.loc,
+                    };
+                }
+                const read = expr.kind === "dynKeyGet" && expr.key.kind === "strLit" ? expr : null;
+                const write = expr.kind === "libCall" && expr.fn === "dyn.keySet" && expr.args[1]?.kind === "strLit"
+                    ? expr
+                    : null;
+                const name = read?.key.kind === "strLit"
+                    ? read.key.value
+                    : write?.args[1]?.kind === "strLit"
+                        ? write.args[1].value
                         : null;
-                    // `for await` opens a class instance's [Symbol.asyncIterator]().
-                    const asyncOpen = iterator?.fn === "dyn.asyncIteratorOpen";
-                    const invoke = iterator
-                        ? {
-                            kind: "dynInvoke",
-                            recv: iterator.args[0],
-                            method: asyncOpen ? "sym:asyncIterator" : "sym:iterator",
-                            calleeName: asyncOpen ? "value[Symbol.asyncIterator]" : "value[Symbol.iterator]",
-                            args: [],
-                            type: DYN,
-                            loc: iterator.loc,
-                        }
-                        : expr.kind === "dynInvoke"
-                            ? expr
-                            : null;
-                    // 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(invoke.method) &&
-                            !(invoke.method === "toString" && lowerer.classes.has("%Error"))))
-                        return expr;
-                    const key = JSON.stringify([
-                        invoke.method,
-                        invoke.args.length,
-                        iterator?.fn,
-                        iterator?.args[1],
-                    ]);
-                    let dispatch = this.dispatches.get(key);
+                if (name !== null) {
+                    const key = JSON.stringify([name, !!write, read?.optional ?? false]);
+                    let dispatch = this.properties.get(key);
                     if (!dispatch) {
-                        const params = [invoke.recv, ...invoke.args].map((_, i) => ({
+                        const loc = expr.loc;
+                        const params = (write ? [0, 1] : [0]).map((i) => ({
                             localId: `p.${i}`,
                             name: `p${i}`,
                             type: DYN,
                         }));
-                        params.splice(1, 0, { localId: "p.callback", name: "callback", type: DYN });
-                        iterator?.args.slice(1).forEach((argument, i) => params.push({
-                            localId: `p.iterator.${i}`,
-                            name: `iterator${i}`,
-                            type: argument.type,
-                        }));
-                        params.push({ localId: "p.calleeName", name: "calleeName", type: STRING });
-                        const callback = {
-                            name: `%dyn.class.callback.${this.dispatches.size}`,
-                            params: [params[0]],
-                            returnType: DYN,
-                            locals: [{ id: "p.0", name: "receiver", type: DYN, mutable: false }],
-                            body: [{ kind: "return", value: dynUndefinedExpr(expr.loc), loc: expr.loc }],
-                            loc: expr.loc,
-                        };
+                        const instanceBag = read
+                            ? this.readPropertyBagOrEmpty(lowerer, varRef("p.0", DYN, loc), loc)
+                            : {
+                                kind: "call",
+                                callee: this.propertyBag.name,
+                                args: [varRef("p.0", DYN, loc)],
+                                type: DYN,
+                                loc,
+                            };
+                        const bag = read && !["name", "length", "apply"].includes(name)
+                            ? {
+                                kind: "call",
+                                callee: this.constructorPropertyBag(lowerer, loc).name,
+                                args: [instanceBag],
+                                type: DYN,
+                                loc,
+                            }
+                            : instanceBag;
+                        // A read compares the bag with the receiver and then reads it:
+                        // evaluate it once, so each read retains the receiver once.
+                        const bagRead = varRef("bag.0", DYN, loc);
+                        const bagGet = read
+                            ? {
+                                kind: "libCall",
+                                fn: "dyn.bagGet",
+                                args: [bagRead, read.key, varRef("p.0", DYN, loc)],
+                                type: DYN,
+                                loc,
+                            }
+                            : null;
+                        // A class instance whose class chain declares no member of an
+                        // Object.prototype method's name (classes that do answer in
+                        // their own branches) inherits it unless an own property
+                        // shadows it; a class constructor's static bag reads as before.
+                        const instanceRead = read && INHERITED_OBJECT_METHODS.has(name)
+                            ? {
+                                kind: "ternary",
+                                cond: {
+                                    kind: "dynTest",
+                                    test: "function",
+                                    value: varRef("p.0", DYN, loc),
+                                    type: BOOL,
+                                    loc,
+                                },
+                                then: bagGet,
+                                else_: {
+                                    kind: "ternary",
+                                    cond: this.readBagHas(lowerer, "dyn.hasKey", bagRead, read.key, loc),
+                                    then: bagGet,
+                                    else_: {
+                                        kind: "libCall",
+                                        fn: "dyn.builtinMethod",
+                                        args: [{ kind: "strLit", value: "Object", type: STRING, loc }, read.key],
+                                        type: DYN,
+                                        loc,
+                                    },
+                                    type: DYN,
+                                    loc,
+                                },
+                                type: DYN,
+                                loc,
+                            }
+                            : bagGet;
+                        const fallback = read
+                            ? {
+                                kind: "ternary",
+                                cond: {
+                                    kind: "dynScalarEq",
+                                    left: bagRead,
+                                    right: varRef("p.0", DYN, loc),
+                                    type: BOOL,
+                                    loc,
+                                },
+                                then: { ...read, value: bagRead },
+                                else_: instanceRead,
+                                type: DYN,
+                                loc,
+                            }
+                            : { ...write, args: [bag, write.args[1], varRef("p.1", DYN, loc)] };
                         const helper = {
-                            name: `%dyn.class.call.${this.dispatches.size}`,
+                            name: `%dyn.class.property.${this.properties.size}`,
                             params,
-                            returnType: DYN,
-                            locals: params.map((p) => ({
-                                id: p.localId,
-                                name: p.name,
-                                type: p.type,
-                                mutable: false,
-                            })),
-                            body: [
-                                {
-                                    kind: "return",
-                                    value: iterator
-                                        ? {
-                                            ...iterator,
-                                            args: [
-                                                varRef("p.0", DYN, expr.loc),
-                                                ...iterator.args
-                                                    .slice(1)
-                                                    .map((argument, i) => varRef(`p.iterator.${i}`, argument.type, expr.loc)),
-                                            ],
-                                        }
-                                        : {
-                                            ...invoke,
-                                            calleeNameValue: varRef("p.calleeName", STRING, expr.loc),
-                                            recv: varRef("p.0", DYN, expr.loc),
-                                            args: invoke.args.map((_, i) => varRef(`p.${i + 1}`, DYN, expr.loc)),
-                                        },
-                                    loc: expr.loc,
-                                },
+                            returnType: write ? VOID : DYN,
+                            locals: [
+                                ...params.map((p) => ({
+                                    id: p.localId,
+                                    name: p.name,
+                                    type: DYN,
+                                    mutable: false,
+                                })),
+                                ...(read ? [{ id: "bag.0", name: "bag", type: DYN, mutable: false }] : []),
                             ],
-                            loc: expr.loc,
+                            body: write
+                                ? [
+                                    { kind: "exprStmt", expr: fallback, loc },
+                                    { kind: "return", value: null, loc },
+                                ]
+                                : [
+                                    { kind: "varDecl", localId: "bag.0", init: bag, loc },
+                                    {
+                                        kind: "return",
+                                        // Primitives answer their wrapper constructors.
+                                        value: name === "constructor"
+                                            ? primitiveConstructorOr(lowerer, varRef("p.0", DYN, loc), fallback, loc)
+                                            : fallback,
+                                        loc,
+                                    },
+                                ],
+                            loc,
                         };
-                        if (invoke.method === "toString" && lowerer.classes.has("%Error")) {
-                            const loc = expr.loc;
+                        if (!write && name === "toString" && lowerer.classes.has("%Error")) {
                             const value = varRef("p.0", DYN, loc);
                             helper.body.unshift({
                                 kind: "if",
@@ -2819,21 +2985,12 @@ export class ClassDynamicDispatch {
                                 then: [
                                     {
                                         kind: "return",
-                                        value: {
-                                            kind: "dynCall",
-                                            callee: errorToStringMethod(lowerer, {
-                                                kind: "dynCheck",
-                                                value,
-                                                type: { kind: "object", className: "%Error" },
-                                                loc,
-                                            }),
-                                            receiver: value,
-                                            calleeName: invoke.calleeName,
-                                            calleeNameValue: varRef("p.calleeName", STRING, loc),
-                                            args: invoke.args.map((_, i) => varRef(`p.${i + 1}`, DYN, loc)),
-                                            type: DYN,
+                                        value: errorToStringMethod(lowerer, {
+                                            kind: "dynCheck",
+                                            value,
+                                            type: { kind: "object", className: "%Error" },
                                             loc,
-                                        },
+                                        }),
                                         loc,
                                     },
                                 ],
@@ -2841,54 +2998,237 @@ export class ClassDynamicDispatch {
                                 loc,
                             });
                         }
-                        dispatch = { source: invoke, fn: helper, callback, classes: new Set() };
-                        this.dispatches.set(key, dispatch);
+                        const receiverAccess = read
+                            ? [{ kind: "return", value: { ...read, value: varRef("p.0", DYN, loc) }, loc }]
+                            : [
+                                {
+                                    kind: "exprStmt",
+                                    expr: {
+                                        ...write,
+                                        args: [varRef("p.0", DYN, loc), write.args[1], varRef("p.1", DYN, loc)],
+                                    },
+                                    loc,
+                                },
+                                { kind: "return", value: null, loc },
+                            ];
+                        dispatch = {
+                            name,
+                            write: !!write,
+                            fn: helper,
+                            classes: new Set(),
+                            ...(name !== "constructor" && name !== "toString"
+                                ? { plain: { tail: [...helper.body], access: receiverAccess } }
+                                : {}),
+                        };
+                        this.properties.set(key, dispatch);
                         this.generated.add(helper);
-                        this.generated.add(callback);
-                        lowerer.liftedFns.push(helper, callback);
+                        lowerer.liftedFns.push(helper);
                         changed = true;
                     }
-                    // Resolve an own callback before argument effects can replace it.
-                    const local = {
-                        id: `%dispatch.receiver.${fn.locals.length}`,
-                        name: "receiver",
+                    return {
+                        kind: "call",
+                        callee: dispatch.fn.name,
+                        args: read ? [read.value] : [write.args[0], write.args[2]],
+                        type: dispatch.fn.returnType,
+                        loc: expr.loc,
+                    };
+                }
+                const iterator = expr.kind === "libCall" &&
+                    (expr.fn === "dyn.iterator" ||
+                        expr.fn === "dyn.arrayFromIterator" ||
+                        expr.fn === "dyn.asyncIteratorOpen")
+                    ? expr
+                    : null;
+                // `for await` opens a class instance's [Symbol.asyncIterator]().
+                const asyncOpen = iterator?.fn === "dyn.asyncIteratorOpen";
+                const invoke = iterator
+                    ? {
+                        kind: "dynInvoke",
+                        recv: iterator.args[0],
+                        method: asyncOpen ? "sym:asyncIterator" : "sym:iterator",
+                        calleeName: asyncOpen ? "value[Symbol.asyncIterator]" : "value[Symbol.iterator]",
+                        args: [],
                         type: DYN,
-                        mutable: false,
+                        loc: iterator.loc,
+                    }
+                    : expr.kind === "dynInvoke"
+                        ? expr
+                        : null;
+                // 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 &&
+                    expr.kind === "dynInvoke" &&
+                    candidates(invoke.method).length === 0 &&
+                    !staticCandidates(invoke.method)) {
+                    // The other receivers' call a rewrite left in place tests only
+                    // the classes that rewrite did not.
+                    const covered = expr.recv.kind === "varRef" ? this.getterReceivers.get(expr.recv.localId) : undefined;
+                    const capsules = getterCapsules(invoke.method).filter((key) => !covered?.has(key));
+                    if (capsules.length > 0)
+                        return getterCall(fn, expr, capsules, covered);
+                }
+                if (!invoke ||
+                    (candidates(invoke.method).length === 0 &&
+                        !staticCandidates(invoke.method) &&
+                        !(invoke.method === "toString" && lowerer.classes.has("%Error"))))
+                    return expr;
+                const key = JSON.stringify([
+                    invoke.method,
+                    invoke.args.length,
+                    iterator?.fn,
+                    iterator?.args[1],
+                ]);
+                let dispatch = this.dispatches.get(key);
+                if (!dispatch) {
+                    const params = [invoke.recv, ...invoke.args].map((_, i) => ({
+                        localId: `p.${i}`,
+                        name: `p${i}`,
+                        type: DYN,
+                    }));
+                    params.splice(1, 0, { localId: "p.callback", name: "callback", type: DYN });
+                    iterator?.args.slice(1).forEach((argument, i) => params.push({
+                        localId: `p.iterator.${i}`,
+                        name: `iterator${i}`,
+                        type: argument.type,
+                    }));
+                    params.push({ localId: "p.calleeName", name: "calleeName", type: STRING });
+                    const callback = {
+                        name: `%dyn.class.callback.${this.dispatches.size}`,
+                        params: [params[0]],
+                        returnType: DYN,
+                        locals: [{ id: "p.0", name: "receiver", type: DYN, mutable: false }],
+                        body: [{ kind: "return", value: dynUndefinedExpr(expr.loc), loc: expr.loc }],
+                        loc: expr.loc,
                     };
-                    fn.locals.push(local);
-                    const receiver = varRef(local.id, DYN, expr.loc);
-                    return {
-                        kind: "seqExpr",
-                        stmts: [{ kind: "varDecl", localId: local.id, init: invoke.recv, loc: expr.loc }],
-                        result: {
-                            kind: "call",
-                            callee: dispatch.fn.name,
-                            args: [
-                                receiver,
+                    const helper = {
+                        name: `%dyn.class.call.${this.dispatches.size}`,
+                        params,
+                        returnType: DYN,
+                        locals: params.map((p) => ({
+                            id: p.localId,
+                            name: p.name,
+                            type: p.type,
+                            mutable: false,
+                        })),
+                        body: [
+                            {
+                                kind: "return",
+                                value: iterator
+                                    ? {
+                                        ...iterator,
+                                        args: [
+                                            varRef("p.0", DYN, expr.loc),
+                                            ...iterator.args
+                                                .slice(1)
+                                                .map((argument, i) => varRef(`p.iterator.${i}`, argument.type, expr.loc)),
+                                        ],
+                                    }
+                                    : {
+                                        ...invoke,
+                                        calleeNameValue: varRef("p.calleeName", STRING, expr.loc),
+                                        recv: varRef("p.0", DYN, expr.loc),
+                                        args: invoke.args.map((_, i) => varRef(`p.${i + 1}`, DYN, expr.loc)),
+                                    },
+                                loc: expr.loc,
+                            },
+                        ],
+                        loc: expr.loc,
+                    };
+                    if (invoke.method === "toString" && lowerer.classes.has("%Error")) {
+                        const loc = expr.loc;
+                        const value = varRef("p.0", DYN, loc);
+                        helper.body.unshift({
+                            kind: "if",
+                            cond: { kind: "dynTest", test: "error", value, type: BOOL, loc },
+                            then: [
                                 {
-                                    kind: "call",
-                                    callee: dispatch.callback.name,
-                                    args: [receiver],
-                                    type: DYN,
-                                    loc: expr.loc,
-                                },
-                                ...invoke.args,
-                                ...(iterator?.args.slice(1) ?? []),
-                                invoke.calleeNameValue ?? {
-                                    kind: "strLit",
-                                    value: invoke.calleeName,
-                                    type: STRING,
-                                    loc: expr.loc,
+                                    kind: "return",
+                                    value: {
+                                        kind: "dynCall",
+                                        callee: errorToStringMethod(lowerer, {
+                                            kind: "dynCheck",
+                                            value,
+                                            type: { kind: "object", className: "%Error" },
+                                            loc,
+                                        }),
+                                        receiver: value,
+                                        calleeName: invoke.calleeName,
+                                        calleeNameValue: varRef("p.calleeName", STRING, loc),
+                                        args: invoke.args.map((_, i) => varRef(`p.${i + 1}`, DYN, loc)),
+                                        type: DYN,
+                                        loc,
+                                    },
+                                    loc,
                                 },
                             ],
-                            type: DYN,
-                            loc: expr.loc,
-                        },
+                            else_: null,
+                            loc,
+                        });
+                    }
+                    dispatch = { source: invoke, fn: helper, callback, classes: new Set() };
+                    this.dispatches.set(key, dispatch);
+                    this.generated.add(helper);
+                    this.generated.add(callback);
+                    lowerer.liftedFns.push(helper, callback);
+                    changed = true;
+                }
+                // Resolve an own callback before argument effects can replace it.
+                const local = {
+                    id: `%dispatch.receiver.${fn.locals.length}`,
+                    name: "receiver",
+                    type: DYN,
+                    mutable: false,
+                };
+                fn.locals.push(local);
+                const receiver = varRef(local.id, DYN, expr.loc);
+                return {
+                    kind: "seqExpr",
+                    stmts: [{ kind: "varDecl", localId: local.id, init: invoke.recv, loc: expr.loc }],
+                    result: {
+                        kind: "call",
+                        callee: dispatch.fn.name,
+                        args: [
+                            receiver,
+                            {
+                                kind: "call",
+                                callee: dispatch.callback.name,
+                                args: [receiver],
+                                type: DYN,
+                                loc: expr.loc,
+                            },
+                            ...invoke.args,
+                            ...(iterator?.args.slice(1) ?? []),
+                            invoke.calleeNameValue ?? {
+                                kind: "strLit",
+                                value: invoke.calleeName,
+                                type: STRING,
+                                loc: expr.loc,
+                            },
+                        ],
                         type: DYN,
                         loc: expr.loc,
-                    };
+                    },
+                    type: DYN,
+                    loc: expr.loc,
+                };
+            };
+            let touched = false;
+            const body = transformStmtList(fn.body, {
+                stmt: (stmt) => stmt,
+                expr: (expr) => {
+                    const rewritten = rewriteExpr(expr);
+                    if (rewritten !== expr)
+                        touched = true;
+                    return rewritten;
                 },
             });
+            // A body the rewrite did not change keeps its statement list, so the
+            // dispatch-site summaries the pass keeps stay valid.
+            if (touched)
+                fn.body = body;
         }
         for (const [target, cast] of this.checkedCasts) {
             for (const source of this.boxed) {
@@ -2932,6 +3272,11 @@ export class ClassDynamicDispatch {
         for (const dispatch of this.dispatches.values()) {
             for (const name of this.boxedConstructors) {
                 const info = lowerer.classes.get(name);
+                // The class value's property table answers a static its chain defines
+                // there, computed names included; the declarer's method is not what
+                // the class value holds.
+                if (info && runtimeStaticDefines(lowerer, info, dispatch.source.method))
+                    continue;
                 const found = info && findStaticOn(lowerer, info, dispatch.source.method);
                 const key = `constructor:${name}`;
                 if (!found?.method || dispatch.classes.has(key))
@@ -3222,6 +3567,9 @@ export class ClassDynamicDispatch {
             if (!dispatch.write)
                 for (const name of this.boxedConstructors) {
                     const info = lowerer.classes.get(name);
+                    // A table the chain defines the name in answers the read itself.
+                    if (info && runtimeStaticDefines(lowerer, info, dispatch.name))
+                        continue;
                     const found = info && findStaticOn(lowerer, info, dispatch.name);
                     const field = found?.field;
                     const key = `constructor:${name}`;
@@ -4906,6 +5254,25 @@ export class ClassDynamicDispatch {
             this.guardClassTables(lowerer);
         if (lowerer)
             this.guardPropertyHelpers(lowerer);
+        if (lowerer)
+            this.indexClassBranches(lowerer);
+    }
+    /** Each generated class table tests its classes in order, one exact type
+     * key test per class, so a receiver costs time linear in the program's
+     * class count. Replace each run of such branches with a switch on the
+     * length and last four bytes of the receiver's key: the branches
+     * themselves stay, each still guarded by its key test, and the switch
+     * selects the class the receiver is. Runs whose branches continue instead
+     * of leaving the helper, or that hold fewer than sixty-four distinct classes,
+     * keep the chain. */
+    indexClassBranches(lowerer) {
+        const seen = new Set();
+        for (const fn of [...this.generated, ...lowerer.liftedFns]) {
+            if (seen.has(fn))
+                continue;
+            seen.add(fn);
+            fn.body = indexBranchRuns(fn.body);
+        }
     }
     /** Each tracked class's bag initializer over a typed receiver (`this`),
      * for the per-class field-creation helpers (trackClassFieldCreation),