@scriptc/compiler 0.3.5 → 0.4.0

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

@@ -1,13 +1,16 @@
-import { dynUndefinedExpr, varRef } from "../../ir/build.js";
+import { primitiveConstructorOr } from "./lower-exprs.js";
+import { dynUndefinedExpr, helperLoc, nodeThrowExpr, varRef } from "../../ir/build.js";
+import { constructedValue } from "./constructor-returns.js";
 import { eventTargetApiMembers, eventTargetInheritedMember } from "./lower-event-target.js";
 import { BOOL, DYN, F64, DYN_CLASS_PROPERTIES as PROPERTY_BAG, STRING, VOID, canConvertToDyn, canDynCheckTo, isClassOwnEnumerableFieldName, isDynTypedRefType, isUnitType, typeEquals, typeKey, } from "../../ir/ir.js";
 import { streamTypedRefEligible } from "../../ir/analysis.js";
 import { everyStmtList, transformExpr, transformStmtList } from "../../ir/traverse.js";
 import { PoisonError } from "./lowerer.js";
-import { implicitDefaultInstance } from "./generic-functions.js";
+import { erasedGenericInstance, implicitDefaultInstance } from "./generic-functions.js";
 import {} from "./call-signatures.js";
 import { accessorCall, classValueRef, findGenericMethodOn, findGenericStaticOn, findMethodOn, findStaticOn, genericOverrideBelow, upcastTo, } from "./lower-classes.js";
-import { classPrototypeData, hasClassPrototypeData, reflectClassPrototype, } from "./class-prototypes.js";
+import { classPrototypeData, hasClassPrototypeData, observedPrototypeMethod, reflectClassPrototype, } from "./class-prototypes.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";
 import { classMethodValue, reflectedClassStaticMethodValue, refreshClassMethodValueSelections, } from "./class-method-values.js";
@@ -22,6 +25,7 @@ import { ClassConstructionDispatch } from "./class-construction.js";
 import { emitterRooted } from "./lower-event-emitter.js";
 import { protocolArm, protocolFieldArm } from "./class-protocol-dispatch.js";
 import { STREAM_OPERATORS } from "./lower-stream.js";
+import { deletedPropertyNames, fixedFieldFamily } from "./js-class-fields.js";
 const STREAM_METHODS = new Set([
     "on",
     "addListener",
@@ -96,6 +100,80 @@ function symbolMemberKey(lowerer, info, name, loc) {
     }
     return null;
 }
+const CONVERSION_CALL_PREFIX = "%conversionCall.";
+const TO_PRIMITIVE_PREFIX = "%dyn.class.toPrimitive.";
+/** Operations that convert their dynamic operands with ToPrimitive: `+`
+ * and `==` take the default hint, the arithmetic, bitwise, relational and
+ * numeric conversions the number hint, and the string conversions the
+ * string hint. */
+const DEFAULT_HINT_CALLS = new Set(["dyn.abstractEq", "dyn.add"]);
+const NUMBER_HINT_CALLS = new Set([
+    "dyn.arithmetic",
+    "dyn.bigintConstructor",
+    "dyn.bitwise",
+    "dyn.compare",
+    "dyn.numberConstructor",
+    "dyn.toNumberCoerce",
+    "dyn.toNumeric",
+]);
+const STRING_HINT_CALLS = new Set(["dyn.stringConstructor", "dyn.toStringCoerce"]);
+/** Operations whose second operand is a property key, converted with the
+ * string hint when the receiver admits a key: `in` needs an object,
+ * propertyIsEnumerable converts before checking its receiver, and the
+ * others need a receiver other than null and undefined. */
+const KEY_CALLS = new Map([
+    ["dyn.hasKeyComputed", "object"],
+    ["dyn.propertyIsEnumerableComputed", "any"],
+    ["dyn.hasOwnComputed", "value"],
+    ["dyn.keyDeleteComputed", "value"],
+    ["dyn.keySetComputed", "value"],
+]);
+function toPrimitiveHint(expr) {
+    if (expr.kind === "toString")
+        return expr.operand.type.kind === "dyn" ? "string" : null;
+    if (expr.kind === "dynKeyGet")
+        return expr.key.type.kind === "dyn" ? "string" : null;
+    if (expr.kind !== "libCall")
+        return null;
+    if (DEFAULT_HINT_CALLS.has(expr.fn))
+        return "default";
+    if (NUMBER_HINT_CALLS.has(expr.fn))
+        return "number";
+    if (STRING_HINT_CALLS.has(expr.fn) || KEY_CALLS.has(expr.fn))
+        return "string";
+    return null;
+}
+/** An operand that needs no conversion: already passed through a
+ * conversion helper (loose equality converts conditionally), or boxed from
+ * a statically primitive value. */
+function isConversion(expr) {
+    if (expr.kind === "ternary")
+        return isConversion(expr.then);
+    if (expr.kind === "dynFrom")
+        return PRIMITIVE_KINDS.has(expr.value.type.kind);
+    return expr.kind === "call" && expr.callee.startsWith(TO_PRIMITIVE_PREFIX);
+}
+const PRIMITIVE_KINDS = new Set([
+    "f64",
+    "string",
+    "bool",
+    "bigint",
+    "symbol",
+    "undefinedT",
+    "nullT",
+]);
+/** A declared conversion method, own or inherited. */
+function conversionMethod(lowerer, info, method) {
+    if (info.fields.has(method))
+        return false;
+    const found = findMethodOn(lowerer, info, method);
+    return !!found && !found.declarer.builtinError;
+}
+function isPrimitive(value, loc) {
+    return ["number", "string", "boolean", "undefined", "null", "bigint", "symbol"]
+        .map((test) => ({ kind: "dynTest", test, value, type: BOOL, loc }))
+        .reduce((a, b) => ({ kind: "logical", op: "||", left: a, right: b, type: BOOL, loc }));
+}
 export function classInstanceOf(lowerer, value, info, loc, classValue) {
     const name = `%dyn.class.${classValue ? "valueInstanceof" : "instanceof"}:${info.def.name}`;
     const params = [
@@ -490,6 +568,9 @@ export class ClassDynamicDispatch {
     generatorDispatch = new GeneratorDynamicDispatch();
     caughtDispatch = new CaughtValueDispatch();
     constructionDispatch = new ClassConstructionDispatch();
+    /** Property names a delete can remove (null: any name), for the field
+     * creation tracking decision. */
+    deletedNames;
     boxed = new Set();
     boxedConstructors = new Set();
     dispatches = new Map();
@@ -505,6 +586,8 @@ export class ClassDynamicDispatch {
     bagClasses = new Set();
     bagInitializers = new Map();
     typedPropertyBags = new Map();
+    /** Per-class prototype selection for new property bags (bagPrototypeHelper). */
+    bagPrototypeHelpers = new Map();
     readPropertyBags = [];
     generated = new Set();
     /** Protocol dispatch helpers and callee reads whose receivers normalize. */
@@ -525,6 +608,13 @@ export class ClassDynamicDispatch {
     /** The for-in key helpers, by libCall (dyn and native string[] keys). */
     enumerations = new Map();
     enumerationClasses = new Set();
+    /** OrdinaryToPrimitive over boxed class instances, by hint, and the
+     * per-class method calls its arms make. */
+    toPrimitives = new Map();
+    toPrimitiveCalls = new Map();
+    /** `value.valueOf()` and `value.toString()` on a dynamic receiver: a test
+     * for boxed instances of classes declaring the method, and the call. */
+    conversionCalls = new Map();
     process(lowerer, functions) {
         // Dispatch tables grow between worklist waves. Keep their normalization
         // entry ahead of every newly inserted branch after rebuilding the tables.
@@ -543,6 +633,8 @@ export class ClassDynamicDispatch {
         changed = this.constructionDispatch.process(lowerer, functions) || changed;
         const seenTypes = new Set();
         const rewrite = new Set();
+        const toPrimitiveSites = new Set();
+        const hasKeySites = new Set();
         const discover = (type) => {
             const key = typeKey(type);
             if (seenTypes.has(key))
@@ -586,6 +678,9 @@ export class ClassDynamicDispatch {
                             (expr.fn === "json.stringifyValue" || expr.fn === "json.stringifyReplacer"))) {
                         this.serializesClasses = true;
                     }
+                    if (toPrimitiveHint(expr) !== null ||
+                        (expr.kind === "libCall" && (expr.fn === "dyn.valueOf" || expr.fn === "dyn.toString")))
+                        toPrimitiveSites.add(fn);
                     switch (expr.kind) {
                         case "dynFrom":
                             discover(expr.value.type);
@@ -602,6 +697,9 @@ export class ClassDynamicDispatch {
                                 isDynTypedRefType(expr.args[0].value.type))
                                 rewrite.add(fn);
                             break;
+                        case "dynHasKey":
+                            hasKeySites.add(fn);
+                            break;
                         case "dynKeyGet":
                         case "dynInvoke":
                             rewrite.add(fn);
@@ -609,6 +707,13 @@ export class ClassDynamicDispatch {
                         case "dynCheck":
                             if (isDynTypedRefType(expr.type))
                                 rewrite.add(fn);
+                            // A dynamic function checked into a native function type
+                            // receives its arguments as dynamic values: class instances
+                            // passed to it cross the boundary when it is called (a JS
+                            // `list.map((rec) => rec.match(x))` callback with an untyped
+                            // parameter).
+                            if (expr.type.kind === "func")
+                                expr.type.params.forEach(discover);
                             break;
                         case "libCall":
                             if (expr.fn === "bytes.construct" ||
@@ -635,6 +740,15 @@ export class ClassDynamicDispatch {
             });
         if (this.boxed.size === 0 && rewrite.size === 0)
             return changed;
+        const converting = this.convertingHints(lowerer);
+        const calling = this.calledConversions(lowerer);
+        if (converting.size || calling.size)
+            for (const fn of toPrimitiveSites)
+                rewrite.add(fn);
+        const prototypeMembers = this.prototypeMemberNames(lowerer);
+        if (prototypeMembers.size)
+            for (const fn of hasKeySites)
+                rewrite.add(fn);
         for (const fn of functions) {
             if (!fn.name.startsWith("%dyn.class.instanceof:") &&
                 !fn.name.startsWith("%dyn.class.valueInstanceof:"))
@@ -884,38 +998,7 @@ export class ClassDynamicDispatch {
             }
             const needsPrototype = (current) => hasClassPrototypeData(current) ||
                 current.subclasses.some((child) => lowerer.classCanBeConstructed(child) && needsPrototype(child));
-            const prototypeFor = (current, receiver, loc) => {
-                const currentReceiver = receiver.type.kind === "object" && receiver.type.className !== current.def.name
-                    ? {
-                        kind: "downcast",
-                        value: receiver,
-                        type: { kind: "object", className: current.def.name },
-                        loc,
-                    }
-                    : receiver;
-                let result = classPrototypeData(lowerer, current, loc, currentReceiver);
-                for (const child of current.subclasses) {
-                    if (!lowerer.classCanBeConstructed(child))
-                        continue;
-                    const selected = prototypeFor(child, receiver, loc);
-                    if (selected && result)
-                        result = {
-                            kind: "ternary",
-                            cond: {
-                                kind: "instanceOf",
-                                value: receiver,
-                                className: child.def.name,
-                                type: BOOL,
-                                loc,
-                            },
-                            then: selected,
-                            else_: result,
-                            type: DYN,
-                            loc,
-                        };
-                }
-                return result;
-            };
+            const prototypeFor = (current, receiver, loc) => this.bagPrototype(lowerer, current, receiver, loc);
             for (const existingInit of this.bagInitializers.get(className) ?? []) {
                 if (existingInit.value.kind === "dynObjLit" && needsPrototype(info)) {
                     const prototype = prototypeFor(info, existingInit.obj, existingInit.loc);
@@ -935,7 +1018,7 @@ export class ClassDynamicDispatch {
                 continue;
             this.bagClasses.add(plan.key);
             this.ensurePropertyBag(info);
-            if (info.decl && isJsSourceFile(info.decl.getSourceFile())) {
+            if (info.decl && isJsSourceFile(ts.getSourceFileOfNode(info.decl))) {
                 let root = info;
                 while (root.base && !root.base.def.runtime)
                     root = root.base;
@@ -943,8 +1026,13 @@ export class ClassDynamicDispatch {
                     current.def.tracksOwnFields = true;
                     current.subclasses.forEach(track);
                 };
-                // Runtime-owned roots keep their dedicated property contracts.
-                if (!root.base?.def.runtime)
+                // Runtime-owned roots keep their dedicated property contracts. A
+                // family whose fields all exist from construction and are never
+                // deleted keeps a fixed layout, as TypeScript classes do.
+                // null is a result too; undefined means not computed yet.
+                if (this.deletedNames === undefined)
+                    this.deletedNames = deletedPropertyNames(lowerer.moduleOrder);
+                if (!root.base?.def.runtime && !fixedFieldFamily(root, this.deletedNames))
                     track(root);
             }
             const loc = this.propertyBag.loc;
@@ -1060,6 +1148,54 @@ export class ClassDynamicDispatch {
             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 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);
@@ -1767,6 +1903,48 @@ export class ClassDynamicDispatch {
                             // 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",
@@ -1778,13 +1956,7 @@ export class ClassDynamicDispatch {
                                         loc,
                                     },
                                     then: { ...read, value: bagRead },
-                                    else_: {
-                                        kind: "libCall",
-                                        fn: "dyn.bagGet",
-                                        args: [bagRead, read.key, varRef("p.0", DYN, loc)],
-                                        type: DYN,
-                                        loc,
-                                    },
+                                    else_: instanceRead,
                                     type: DYN,
                                     loc,
                                 }
@@ -1809,7 +1981,14 @@ export class ClassDynamicDispatch {
                                     ]
                                     : [
                                         { kind: "varDecl", localId: "bag.0", init: bag, loc },
-                                        { kind: "return", value: fallback, loc },
+                                        {
+                                            kind: "return",
+                                            // Primitives answer their wrapper constructors.
+                                            value: name === "constructor"
+                                                ? primitiveConstructorOr(lowerer, varRef("p.0", DYN, loc), fallback, loc)
+                                                : fallback,
+                                            loc,
+                                        },
                                     ],
                                 loc,
                             };
@@ -2146,9 +2325,7 @@ export class ClassDynamicDispatch {
                 const value = varRef("p.0", DYN, loc);
                 const { receiver, condition } = this.propertyReceiver(plan, loc);
                 if (isClassCallback(lowerer, info, dispatch.source.method)) {
-                    const prototypeMethod = lowerer.prototypeMethodAccesses.has(dispatch.source.method);
-                    if (prototypeMethod)
-                        classPrototypeData(lowerer, info, loc);
+                    const prototypeMethod = observedPrototypeMethod(lowerer, info, dispatch.source.method, loc, receiver);
                     const bag = this.readPropertyBagOrEmpty(lowerer, value, loc);
                     dispatch.callback.body.unshift({
                         kind: "if",
@@ -2221,6 +2398,60 @@ export class ClassDynamicDispatch {
                 changed = true;
             }
         }
+        for (const [method, conversion] of this.conversionCalls) {
+            for (const plan of this.propertyReceivers(lowerer)) {
+                if (conversion.classes.has(plan.key))
+                    continue;
+                conversion.classes.add(plan.key);
+                if (!conversionMethod(lowerer, plan.info, method))
+                    continue;
+                const loc = conversion.call.loc;
+                const { condition } = this.propertyReceiver(plan, loc);
+                const value = varRef("p.0", DYN, loc);
+                const result = {
+                    kind: "call",
+                    callee: this.toPrimitiveCall(lowerer, plan, method, method === "toString" ? 1 : 0, loc),
+                    args: method === "toString" ? [value, varRef("p.1", DYN, loc)] : [value],
+                    type: DYN,
+                    loc,
+                };
+                conversion.test.body.unshift({
+                    kind: "if",
+                    cond: condition,
+                    then: [{ kind: "return", value: { kind: "boolLit", value: true, type: BOOL, loc }, loc }],
+                    else_: null,
+                    loc,
+                });
+                conversion.call.body.unshift({
+                    kind: "if",
+                    cond: condition,
+                    then: [
+                        {
+                            kind: "return",
+                            value: method === "toString"
+                                ? { kind: "dynCheck", value: result, type: STRING, loc }
+                                : result,
+                            loc,
+                        },
+                    ],
+                    else_: null,
+                    loc,
+                });
+                changed = true;
+            }
+        }
+        for (const [hint, conversion] of this.toPrimitives) {
+            for (const plan of this.propertyReceivers(lowerer)) {
+                if (conversion.classes.has(plan.key))
+                    continue;
+                conversion.classes.add(plan.key);
+                const arm = this.toPrimitiveArm(lowerer, plan, hint, conversion.fn);
+                if (!arm)
+                    continue;
+                conversion.fn.body.unshift(arm);
+                changed = true;
+            }
+        }
         for (const dispatch of lowerer.protocolDispatches.values()) {
             if (!this.generated.has(dispatch.fn)) {
                 this.generated.add(dispatch.fn);
@@ -2323,6 +2554,7 @@ export class ClassDynamicDispatch {
                         !findGenericMethodOn(lowerer, info, dispatch.name) &&
                         dispatch.name !== "constructor" &&
                         !info.fields.has(dispatch.name) &&
+                        !(dispatch.name === "stack" && lowerer.isSubclassOf(info.def.name, "%Error")) &&
                         !findMethodOn(lowerer, info, `get:${dispatch.name}`) &&
                         !findMethodOn(lowerer, info, `set:${dispatch.name}`)))
                     continue;
@@ -2436,7 +2668,7 @@ export class ClassDynamicDispatch {
                         return dispatch.reflect
                             ? this.reflectPropertyBody(lowerer, { ...dispatch, name }, info, receiver)
                             : this.propertyBody(lowerer, { ...dispatch, name }, info, receiver);
-                    const prototypeMethod = lowerer.prototypeMethodAccesses.has(name);
+                    const prototypeMethod = !info.fields.has(name) && observedPrototypeMethod(lowerer, info, name, loc, receiver);
                     if (info.fields.has(name) || (dispatch.probe === "in" && !prototypeMethod)) {
                         if (info.fields.has(name) && info.def.tracksOwnFields) {
                             const bag = this.readPropertyBagOrEmpty(lowerer, lowerer.coerceToExpected(receiver, DYN), loc);
@@ -2464,8 +2696,6 @@ export class ClassDynamicDispatch {
                             { kind: "return", value: { kind: "boolLit", value: true, type: BOOL, loc }, loc },
                         ];
                     }
-                    if (prototypeMethod)
-                        classPrototypeData(lowerer, info, loc, receiver);
                     const bag = this.readPropertyBagOrEmpty(lowerer, lowerer.coerceToExpected(receiver, DYN), loc);
                     const symbol = name.startsWith("sym:") || name.startsWith("%symbol:");
                     const fn = dispatch.probe === "in"
@@ -2502,10 +2732,12 @@ export class ClassDynamicDispatch {
                         for (const [symbol, name] of info.symbolMethods)
                             symbolEntries.push([symbol, name]);
                     for (const [symbol, name] of symbolEntries) {
-                        const declaration = lowerer.checker.valueDeclarationOf(symbol);
+                        const declaration = symbol.valueDeclaration;
+                        // Module-scope consts and CommonJS key-table properties
+                        // (classSymbolKeyOfSymbol) both hold their key in a global.
                         if (declaration &&
-                            ts.isVariableDeclaration(declaration) &&
-                            ts.isIdentifier(declaration.name)) {
+                            ((ts.isVariableDeclaration(declaration) && ts.isIdentifier(declaration.name)) ||
+                                ts.isPropertyAssignment(declaration))) {
                             const global = lowerer.globalsBySymbol.get(symbol);
                             if (global)
                                 symbols.set(name, lowerer.coerceToExpected(varRef(global.id, global.type, loc), DYN));
@@ -2787,13 +3019,13 @@ export class ClassDynamicDispatch {
                 if (!supported || !info.decl)
                     continue;
                 const cls = classValueRef(lowerer, info, info.decl);
-                const result = {
+                const result = constructedValue(lowerer, info, {
                     kind: "new",
                     className: name,
                     args,
                     type: { kind: "object", className: name },
                     loc,
-                };
+                });
                 this.constructDispatch.body.unshift({
                     kind: "if",
                     cond: {
@@ -2814,7 +3046,7 @@ export class ClassDynamicDispatch {
                 if (this.staticBagClasses.has(name))
                     continue;
                 const info = lowerer.classes.get(name);
-                if (!info?.decl || !isJsSourceFile(info.decl.getSourceFile()))
+                if (!info?.decl || !isJsSourceFile(ts.getSourceFileOfNode(info.decl)))
                     continue;
                 const loc = this.staticPropertyBag.loc;
                 const bag = classStaticData(lowerer, info, loc);
@@ -2917,6 +3149,519 @@ export class ClassDynamicDispatch {
         this.generated.add(helper);
         return { kind: "call", callee: name, args: [bag, key], type: BOOL, loc };
     }
+    /** The hints for which some boxed class declares a conversion method. A
+     * string conversion calls toString first, so without a declared toString
+     * or Symbol.toPrimitive it answers Object.prototype.toString's
+     * "[object Object]" as before. */
+    convertingHints(lowerer) {
+        const hints = new Set();
+        for (const { info } of this.propertyReceivers(lowerer)) {
+            if (conversionMethod(lowerer, info, "sym:toPrimitive") ||
+                conversionMethod(lowerer, info, "toString")) {
+                hints.add("string");
+                hints.add("number");
+                hints.add("default");
+            }
+            else if (conversionMethod(lowerer, info, "valueOf")) {
+                hints.add("number");
+                hints.add("default");
+            }
+        }
+        return hints;
+    }
+    /** An operation that converts dynamic operands to primitives, with each
+     * operand passed through the hint's conversion helper first. Operations
+     * with two dynamic operands evaluate both before converting the left one,
+     * as JavaScript does. Returns null when `expr` needs no conversion. */
+    convertOperands(lowerer, fn, expr, converting) {
+        const hint = toPrimitiveHint(expr);
+        if (hint === null || !converting.has(hint))
+            return null;
+        const loc = expr.loc;
+        const convert = (value) => ({
+            kind: "call",
+            callee: this.toPrimitiveHelper(lowerer, hint, loc),
+            args: [value],
+            type: DYN,
+            loc,
+        });
+        if (expr.kind === "toString") {
+            if (isConversion(expr.operand))
+                return null;
+            return { ...expr, operand: convert(expr.operand) };
+        }
+        if (expr.kind === "dynKeyGet") {
+            // A computed read converts its key after evaluating the receiver,
+            // unless the receiver is null or undefined.
+            if (expr.key.type.kind !== "dyn" || isConversion(expr.key))
+                return null;
+            const [receiver, key] = this.hoistOperands(fn, [expr.value, expr.key], loc);
+            return {
+                kind: "seqExpr",
+                stmts: receiver.stmts.concat(key.stmts),
+                result: {
+                    ...expr,
+                    value: receiver.value,
+                    key: {
+                        kind: "ternary",
+                        cond: {
+                            kind: "dynTest",
+                            test: "nullish",
+                            negated: true,
+                            value: receiver.value,
+                            type: BOOL,
+                            loc,
+                        },
+                        then: convert(key.value),
+                        else_: key.value,
+                        type: DYN,
+                        loc,
+                    },
+                },
+                type: expr.type,
+                loc,
+            };
+        }
+        if (expr.kind !== "libCall")
+            return null;
+        const receiverNeeds = KEY_CALLS.get(expr.fn);
+        if (receiverNeeds) {
+            if (expr.args[1]?.type.kind !== "dyn" || isConversion(expr.args[1]))
+                return null;
+            // Every operand is evaluated before the key converts, as in
+            // `obj[key] = value`, where the value is evaluated first.
+            const hoisted = this.hoistOperands(fn, expr.args, loc);
+            const args = hoisted.map((operand) => operand.value);
+            const receiver = args[0];
+            const admits = receiverNeeds === "any"
+                ? null
+                : receiverNeeds === "object"
+                    ? { kind: "unary", op: "!", operand: isPrimitive(receiver, loc), type: BOOL, loc }
+                    : { kind: "dynTest", test: "nullish", negated: true, value: receiver, type: BOOL, loc };
+            args[1] = admits
+                ? {
+                    kind: "ternary",
+                    cond: admits,
+                    then: convert(args[1]),
+                    else_: args[1],
+                    type: DYN,
+                    loc,
+                }
+                : convert(args[1]);
+            return {
+                kind: "seqExpr",
+                stmts: hoisted.flatMap((operand) => operand.stmts),
+                result: { ...expr, args },
+                type: expr.type,
+                loc,
+            };
+        }
+        const dynamic = expr.args.flatMap((arg, i) => (arg.type.kind === "dyn" ? [i] : []));
+        if (dynamic.some((i) => isConversion(expr.args[i]) && expr.args[i].kind !== "dynFrom"))
+            return null;
+        const operands = dynamic.filter((i) => !isConversion(expr.args[i]));
+        if (operands.length === 0)
+            return null;
+        if (expr.args.length === 1)
+            return { ...expr, args: [convert(expr.args[0])] };
+        // Every operand is evaluated before the first conversion.
+        const hoisted = expr.args.map((arg) => arg.kind === "strLit" || arg.kind === "numLit" || arg.kind === "boolLit"
+            ? { stmts: [], value: arg }
+            : this.hoistOperands(fn, [arg], loc)[0]);
+        const args = hoisted.map((operand) => operand.value);
+        if (expr.fn === "dyn.abstractEq") {
+            // Loose equality converts an object only when the other operand is a
+            // primitive other than null and undefined.
+            if (dynamic.length !== 2)
+                return null;
+            const primitive = (value) => ["number", "string", "boolean", "bigint", "symbol"]
+                .map((test) => ({ kind: "dynTest", test, value, type: BOOL, loc }))
+                .reduce((a, b) => ({ kind: "logical", op: "||", left: a, right: b, type: BOOL, loc }));
+            const [left, right] = [args[0], args[1]];
+            for (const i of operands)
+                args[i] = {
+                    kind: "ternary",
+                    cond: primitive(i === 0 ? right : left),
+                    then: convert(args[i]),
+                    else_: args[i],
+                    type: DYN,
+                    loc,
+                };
+        }
+        else
+            for (const i of operands)
+                args[i] = convert(args[i]);
+        return {
+            kind: "seqExpr",
+            stmts: hoisted.flatMap((operand) => operand.stmts),
+            result: { ...expr, args },
+            type: expr.type,
+            loc,
+        };
+    }
+    /** The method and accessor names of boxed classes whose instances can
+     * carry their class's prototype data. */
+    prototypeMemberNames(lowerer) {
+        const names = new Set();
+        for (const { info } of this.propertyReceivers(lowerer)) {
+            if (!hasClassPrototypeData(info))
+                continue;
+            for (let c = info; c; c = c.base)
+                for (const name of c.methods.keys())
+                    names.add(name.startsWith("get:") || name.startsWith("set:") ? name.slice(4) : name);
+        }
+        return names;
+    }
+    /** The methods some boxed class declares among valueOf and toString. */
+    calledConversions(lowerer) {
+        const methods = new Set();
+        for (const { info } of this.propertyReceivers(lowerer)) {
+            if (conversionMethod(lowerer, info, "valueOf"))
+                methods.add("valueOf");
+            if (conversionMethod(lowerer, info, "toString"))
+                methods.add("toString");
+        }
+        return methods;
+    }
+    /** `value.valueOf()` or `value.toString(argument)` on a dynamic receiver:
+     * a boxed instance of a class declaring the method calls it, any other
+     * value keeps the runtime method call. The toString result must be a
+     * string, as for the runtime's own-member call. */
+    convertMethodCall(lowerer, fn, expr, calling) {
+        if (expr.kind !== "libCall" || (expr.fn !== "dyn.valueOf" && expr.fn !== "dyn.toString"))
+            return null;
+        const method = expr.fn === "dyn.valueOf" ? "valueOf" : "toString";
+        const receiver = expr.args[0];
+        if (!calling.has(method))
+            return null;
+        if (receiver.kind === "varRef" && receiver.localId.startsWith(CONVERSION_CALL_PREFIX))
+            return null;
+        const loc = expr.loc;
+        const operands = this.hoistOperands(fn, method === "toString" ? [receiver, expr.args[1]] : [receiver], loc, CONVERSION_CALL_PREFIX);
+        const values = operands.map((operand) => operand.value);
+        const helpers = this.conversionCallHelpers(lowerer, method, loc);
+        return {
+            kind: "seqExpr",
+            stmts: operands.flatMap((operand) => operand.stmts),
+            result: {
+                kind: "ternary",
+                cond: { kind: "call", callee: helpers.test.name, args: [values[0]], type: BOOL, loc },
+                then: { kind: "call", callee: helpers.call.name, args: values, type: expr.type, loc },
+                else_: { ...expr, args: [...values, ...expr.args.slice(values.length)] },
+                type: expr.type,
+                loc,
+            },
+            type: expr.type,
+            loc,
+        };
+    }
+    conversionCallHelpers(lowerer, method, loc) {
+        let helpers = this.conversionCalls.get(method);
+        if (!helpers) {
+            const at = helperLoc(loc);
+            const params = [
+                { localId: "p.0", name: "value", type: DYN },
+                ...(method === "toString" ? [{ localId: "p.1", name: "argument", type: DYN }] : []),
+            ];
+            const locals = params.map((param) => ({
+                id: param.localId,
+                name: param.name,
+                type: param.type,
+                mutable: false,
+            }));
+            const name = { kind: "strLit", value: method, type: STRING, loc: at };
+            const test = {
+                name: `${TO_PRIMITIVE_PREFIX}${method}.test`,
+                params: params.slice(0, 1),
+                locals: locals.slice(0, 1),
+                returnType: BOOL,
+                body: [
+                    {
+                        kind: "return",
+                        value: { kind: "boolLit", value: false, type: BOOL, loc: at },
+                        loc: at,
+                    },
+                ],
+                loc: at,
+            };
+            const call = {
+                name: `${TO_PRIMITIVE_PREFIX}${method}.call`,
+                params,
+                locals,
+                returnType: method === "toString" ? STRING : DYN,
+                body: [
+                    {
+                        kind: "return",
+                        value: method === "toString"
+                            ? {
+                                kind: "libCall",
+                                fn: "dyn.toString",
+                                args: [varRef("p.0", DYN, at), varRef("p.1", DYN, at), name],
+                                type: STRING,
+                                loc: at,
+                            }
+                            : {
+                                kind: "libCall",
+                                fn: "dyn.valueOf",
+                                args: [varRef("p.0", DYN, at), name],
+                                type: DYN,
+                                loc: at,
+                            },
+                        loc: at,
+                    },
+                ],
+                loc: at,
+            };
+            helpers = { test, call, classes: new Set() };
+            this.conversionCalls.set(method, helpers);
+            this.generated.add(test);
+            this.generated.add(call);
+            lowerer.liftedFns.push(test, call);
+        }
+        return helpers;
+    }
+    /** Evaluates each operand into a fresh local, in order. */
+    hoistOperands(fn, operands, loc, prefix = "%toPrimitive.operand.") {
+        return operands.map((operand) => {
+            const id = `${prefix}${fn.locals.length}`;
+            fn.locals.push({ id, name: "operand", type: operand.type, mutable: false });
+            const stmts = [{ kind: "varDecl", localId: id, init: operand, loc }];
+            return { stmts, value: varRef(id, operand.type, loc) };
+        });
+    }
+    /** The conversion helper for `hint`: a boxed class instance answers its
+     * OrdinaryToPrimitive result, any other value is returned unchanged for
+     * the runtime operation to convert. Arms are added per boxed class. */
+    toPrimitiveHelper(lowerer, hint, loc) {
+        let conversion = this.toPrimitives.get(hint);
+        if (!conversion) {
+            const at = helperLoc(loc);
+            const fn = {
+                name: `${TO_PRIMITIVE_PREFIX}${hint}`,
+                params: [{ localId: "p.0", name: "value", type: DYN }],
+                locals: [{ id: "p.0", name: "value", type: DYN, mutable: false }],
+                returnType: DYN,
+                body: [{ kind: "return", value: varRef("p.0", DYN, at), loc: at }],
+                loc: at,
+            };
+            conversion = { fn, classes: new Set() };
+            this.toPrimitives.set(hint, conversion);
+            this.generated.add(fn);
+            lowerer.liftedFns.push(fn);
+        }
+        return conversion.fn.name;
+    }
+    /** OrdinaryToPrimitive for one boxed class: the declared conversion
+     * methods in hint order, each result returned when it is a primitive.
+     * Object.prototype.valueOf answers the object itself and its toString
+     * answers "[object Object]". */
+    toPrimitiveArm(lowerer, plan, hint, helper) {
+        const { info } = plan;
+        const loc = helper.loc;
+        const { condition } = this.propertyReceiver(plan, loc);
+        if (conversionMethod(lowerer, info, "sym:toPrimitive")) {
+            // A Symbol.toPrimitive method decides alone: its result must be a
+            // primitive.
+            const result = `%toPrimitive.exotic.${helper.locals.length}`;
+            helper.locals.push({ id: result, name: "exotic", type: DYN, mutable: false });
+            const hintValue = {
+                kind: "dynFrom",
+                value: { kind: "strLit", value: hint, type: STRING, loc },
+                type: DYN,
+                loc,
+            };
+            const body = [
+                {
+                    kind: "varDecl",
+                    localId: result,
+                    init: {
+                        kind: "call",
+                        callee: this.toPrimitiveCall(lowerer, plan, "sym:toPrimitive", 1, loc),
+                        args: [varRef("p.0", DYN, loc), hintValue],
+                        type: DYN,
+                        loc,
+                    },
+                    loc,
+                },
+                {
+                    kind: "if",
+                    cond: isPrimitive(varRef(result, DYN, loc), loc),
+                    then: [{ kind: "return", value: varRef(result, DYN, loc), loc }],
+                    else_: null,
+                    loc,
+                },
+                {
+                    kind: "return",
+                    value: nodeThrowExpr(1, "", "Cannot convert object to primitive value", DYN, loc),
+                    loc,
+                },
+            ];
+            return { kind: "if", cond: condition, then: body, else_: null, loc };
+        }
+        const order = hint === "string" ? ["toString", "valueOf"] : ["valueOf", "toString"];
+        if (!order.some((method) => conversionMethod(lowerer, info, method)))
+            return null;
+        if (hint === "string" && !conversionMethod(lowerer, info, "toString"))
+            return null;
+        const body = [];
+        let settled = false;
+        for (const method of order) {
+            if (!conversionMethod(lowerer, info, method)) {
+                if (method === "toString") {
+                    body.push({
+                        kind: "return",
+                        value: {
+                            kind: "dynFrom",
+                            value: { kind: "strLit", value: "[object Object]", type: STRING, loc },
+                            type: DYN,
+                            loc,
+                        },
+                        loc,
+                    });
+                    settled = true;
+                    break;
+                }
+                continue;
+            }
+            const result = `%toPrimitive.${method}.${helper.locals.length}`;
+            helper.locals.push({ id: result, name: method, type: DYN, mutable: false });
+            body.push({
+                kind: "varDecl",
+                localId: result,
+                init: {
+                    kind: "call",
+                    callee: this.toPrimitiveCall(lowerer, plan, method, 0, loc),
+                    args: [varRef("p.0", DYN, loc)],
+                    type: DYN,
+                    loc,
+                },
+                loc,
+            }, {
+                kind: "if",
+                cond: isPrimitive(varRef(result, DYN, loc), loc),
+                then: [{ kind: "return", value: varRef(result, DYN, loc), loc }],
+                else_: null,
+                loc,
+            });
+        }
+        if (!settled)
+            body.push({
+                kind: "return",
+                value: nodeThrowExpr(1, "", "Cannot convert object to primitive value", DYN, loc),
+                loc,
+            });
+        return { kind: "if", cond: condition, then: body, else_: null, loc };
+    }
+    /** A function calling `method` with `arity` arguments on a boxed instance
+     * of `plan`'s class, as a dynamic method call would: an own replacement on
+     * the instance answers first for methods the program can replace. */
+    toPrimitiveCall(lowerer, plan, method, arity, loc) {
+        const key = JSON.stringify([plan.key, method, arity]);
+        const existing = this.toPrimitiveCalls.get(key);
+        if (existing)
+            return existing.name;
+        const { info } = plan;
+        const { receiver } = this.propertyReceiver(plan, loc);
+        const args = Array.from({ length: arity }, (_, i) => varRef(`p.${i + 1}`, DYN, loc));
+        const source = {
+            kind: "dynInvoke",
+            recv: varRef("p.0", DYN, loc),
+            method,
+            calleeName: method === "sym:toPrimitive" ? "value[Symbol.toPrimitive]" : `value.${method}`,
+            args,
+            type: DYN,
+            loc,
+        };
+        const value = varRef("p.0", DYN, loc);
+        let callback = dynUndefinedExpr(loc);
+        if (isClassCallback(lowerer, info, method)) {
+            const prototypeMethod = lowerer.prototypeMethodAccesses.has(method);
+            if (prototypeMethod)
+                classPrototypeData(lowerer, info, loc);
+            const bag = this.readPropertyBagOrEmpty(lowerer, value, loc);
+            callback = {
+                kind: "ternary",
+                cond: prototypeMethod
+                    ? { kind: "boolLit", value: true, type: BOOL, loc }
+                    : {
+                        kind: "libCall",
+                        fn: "dyn.hasKey",
+                        args: [bag, { kind: "strLit", value: method, type: STRING, loc }],
+                        type: BOOL,
+                        loc,
+                    },
+                then: {
+                    kind: "dynObjLit",
+                    fields: [
+                        {
+                            key: { kind: "strLit", value: "value", type: STRING, loc },
+                            value: {
+                                kind: "dynKeyGet",
+                                value: bag,
+                                key: { kind: "strLit", value: method, type: STRING, loc },
+                                type: DYN,
+                                loc,
+                            },
+                        },
+                    ],
+                    type: DYN,
+                    loc,
+                },
+                else_: dynUndefinedExpr(loc),
+                type: DYN,
+                loc,
+            };
+        }
+        const params = [
+            { localId: "p.0", name: "value", type: DYN },
+            ...args.map((_, i) => ({ localId: `p.${i + 1}`, name: `p${i + 1}`, type: DYN })),
+        ];
+        const fn = {
+            name: `${TO_PRIMITIVE_PREFIX}call.${this.toPrimitiveCalls.size}`,
+            params,
+            locals: [
+                ...params.map((param) => ({
+                    id: param.localId,
+                    name: param.name,
+                    type: param.type,
+                    mutable: false,
+                })),
+                { id: "p.callback", name: "callback", type: DYN, mutable: false },
+                { id: "p.calleeName", name: "calleeName", type: STRING, mutable: false },
+            ],
+            returnType: DYN,
+            body: [],
+            loc,
+        };
+        const dispatch = { source, fn, callback: fn, classes: new Set() };
+        const before = lowerer.diags.length;
+        let body;
+        try {
+            body = this.methodBody(lowerer, dispatch, info, receiver);
+        }
+        catch (error) {
+            if (!(error instanceof PoisonError) || !info.decl)
+                throw error;
+            const fence = lowerer.deferToRuntimeFence(before, info.decl, { kind: "statement" });
+            if (!fence)
+                throw error;
+            body = [fence];
+        }
+        fn.body = [
+            { kind: "varDecl", localId: "p.callback", init: callback, loc },
+            {
+                kind: "varDecl",
+                localId: "p.calleeName",
+                init: { kind: "strLit", value: source.calleeName, type: STRING, loc },
+                loc,
+            },
+            ...body,
+        ];
+        this.toPrimitiveCalls.set(key, fn);
+        this.generated.add(fn);
+        lowerer.liftedFns.push(fn);
+        return fn.name;
+    }
     readPropertyBagOrEmpty(lowerer, receiver, loc) {
         // One call per read site: large JS programs have a branch per class and
         // property, so the absent-bag handling lives in the shared helper.
@@ -2968,9 +3713,17 @@ export class ClassDynamicDispatch {
             obj: receiver,
             value: transformExpr(initializers[0].value, {
                 stmt: (stmt) => stmt,
-                expr: (expr) => expr.kind === "dynCheck" && expr.value.kind === "varRef" && expr.value.localId === "p.0"
-                    ? receiver
-                    : expr,
+                expr: (expr) => {
+                    const checked = (e) => e.kind === "dynCheck" && e.value.kind === "varRef" && e.value.localId === "p.0";
+                    // The checked receiver, possibly cast to this class (the prototype
+                    // helper's argument), is the typed parameter itself.
+                    if (expr.kind === "downcast" &&
+                        checked(expr.value) &&
+                        expr.type.kind === "object" &&
+                        expr.type.className === type.className)
+                        return receiver;
+                    return checked(expr) ? receiver : expr;
+                },
             }),
             loc,
         };
@@ -2999,6 +3752,74 @@ export class ClassDynamicDispatch {
         lowerer.liftedFns.push(helper);
         return helper;
     }
+    /** The prototype a new property bag of `current` (or of the subclass the
+     * receiver is) starts from, or null when `current` has no prototype data.
+     * A class with constructible subclasses that have prototype data selects
+     * it through its `%class.bagPrototype` helper; any other class reads its
+     * own prototype data. */
+    bagPrototype(lowerer, current, receiver, loc) {
+        const arg = receiver.type.kind === "object" && receiver.type.className !== current.def.name
+            ? {
+                kind: "downcast",
+                value: receiver,
+                type: { kind: "object", className: current.def.name },
+                loc,
+            }
+            : receiver;
+        const helper = this.bagPrototypeHelper(lowerer, current, loc);
+        return helper
+            ? { kind: "call", callee: helper.name, args: [arg], type: DYN, loc }
+            : classPrototypeData(lowerer, current, loc, arg);
+    }
+    /** `%class.bagPrototype:<class>(this)`: the prototype data of the most
+     * derived constructible class `this` is an instance of, tested from the
+     * last subclass to the first and then the class itself. One helper per
+     * class, calling its subclasses' helpers, keeps every property-bag branch
+     * a single call: a whole hierarchy inlined into each branch grows with the
+     * square of its depth. Null when the class has no prototype data, in which
+     * case its subclasses are not tested either, or while no constructible
+     * subclass has any. The body is rebuilt on each use, as classes become
+     * constructible. */
+    bagPrototypeHelper(lowerer, current, loc) {
+        const type = { kind: "object", className: current.def.name };
+        const self = varRef("this", type, loc);
+        const own = classPrototypeData(lowerer, current, loc, self);
+        if (!own)
+            return null;
+        const body = [];
+        const children = current.subclasses.filter((child) => lowerer.classCanBeConstructed(child));
+        for (const child of children.reverse()) {
+            const selected = this.bagPrototype(lowerer, child, self, loc);
+            if (!selected)
+                continue;
+            body.push({
+                kind: "if",
+                cond: { kind: "instanceOf", value: self, className: child.def.name, type: BOOL, loc },
+                then: [{ kind: "return", value: selected, loc }],
+                else_: null,
+                loc,
+            });
+        }
+        let helper = this.bagPrototypeHelpers.get(current.def.name);
+        if (!helper && body.length === 0)
+            return null;
+        body.push({ kind: "return", value: own, loc });
+        if (!helper) {
+            helper = {
+                name: `%class.bagPrototype:${current.def.name}`,
+                params: [{ localId: "this", name: "this", type }],
+                returnType: DYN,
+                locals: [{ id: "this", name: "this", type, mutable: false }],
+                body,
+                loc,
+            };
+            this.bagPrototypeHelpers.set(current.def.name, helper);
+            this.generated.add(helper);
+            lowerer.liftedFns.push(helper);
+        }
+        helper.body = body;
+        return helper;
+    }
     /** Prototype state may appear in a later reachable body, so read-only bags
      * settle only after the dispatch worklist closes. A read never stores: an
      * absent empty bag stays undefined (callers test it), and an absent
@@ -3270,19 +4091,43 @@ export class ClassDynamicDispatch {
             loc,
         };
         if (accessor && info.decl) {
-            const method = classMethodValue(lowerer, info.decl, info, member, loc);
-            if (method) {
-                const call = {
-                    kind: "libCall",
-                    fn: "dyn.reflectApply",
-                    args: [
-                        lowerer.coerceToExpected(method, DYN),
-                        actualReceiver,
-                        { kind: "dynArrLit", elems: write ? [varRef("p.1", DYN, loc)] : [], type: DYN, loc },
-                    ],
-                    type: DYN,
-                    loc,
-                };
+            // An accessor whose private names belong to one evaluation runs as
+            // the instance's own evaluation's prototype accessor.
+            const declarer = accessor.declarer;
+            const prototype = perEvaluationPrivateNames(declarer)
+                ? classPrototypeData(lowerer, declarer, loc, upcastTo(lowerer, receiver, declarer.def.name))
+                : null;
+            const method = prototype ? null : classMethodValue(lowerer, info.decl, info, member, loc);
+            if (prototype || method) {
+                const call = prototype
+                    ? {
+                        kind: "libCall",
+                        fn: write ? "dyn.reflectSet" : "dyn.reflectGet",
+                        args: [
+                            prototype,
+                            lowerer.coerceToExpected(key, DYN),
+                            ...(write ? [varRef("p.1", DYN, loc)] : []),
+                            actualReceiver,
+                        ],
+                        type: write ? BOOL : DYN,
+                        loc,
+                    }
+                    : {
+                        kind: "libCall",
+                        fn: "dyn.reflectApply",
+                        args: [
+                            lowerer.coerceToExpected(method, DYN),
+                            actualReceiver,
+                            {
+                                kind: "dynArrLit",
+                                elems: write ? [varRef("p.1", DYN, loc)] : [],
+                                type: DYN,
+                                loc,
+                            },
+                        ],
+                        type: DYN,
+                        loc,
+                    };
                 return [
                     {
                         kind: "if",
@@ -3444,6 +4289,99 @@ export class ClassDynamicDispatch {
                 },
             ];
         }
+        // An Error's own `stack`: a string is the native error's stack, which
+        // typed reads share; any other value is kept with the instance's own
+        // properties, which a read checks first. A class whose chain declares
+        // a `stack` accessor answers through it (the accessor code below).
+        if (name === "stack" &&
+            !info.fields.has(name) &&
+            lowerer.isSubclassOf(info.def.name, "%Error") &&
+            !findMethodOn(lowerer, info, "get:stack") &&
+            !findMethodOn(lowerer, info, "set:stack")) {
+            const key = { kind: "strLit", value: name, type: STRING, loc };
+            const error = lowerer.upcastTo(receiver, "%Error");
+            if (write) {
+                const helper = classPropertiesHelper(lowerer, loc);
+                this.generated.add(helper);
+                const store = {
+                    kind: "exprStmt",
+                    expr: {
+                        kind: "libCall",
+                        fn: "dyn.keySet",
+                        args: [
+                            {
+                                kind: "call",
+                                callee: helper.name,
+                                args: [lowerer.coerceToExpected(receiver, DYN)],
+                                type: DYN,
+                                loc,
+                            },
+                            key,
+                            varRef("p.1", DYN, loc),
+                        ],
+                        type: VOID,
+                        loc,
+                    },
+                    loc,
+                };
+                return [
+                    {
+                        kind: "if",
+                        cond: {
+                            kind: "dynTest",
+                            test: "string",
+                            value: varRef("p.1", DYN, loc),
+                            type: BOOL,
+                            loc,
+                        },
+                        then: [
+                            {
+                                kind: "exprStmt",
+                                expr: {
+                                    kind: "libCall",
+                                    fn: "error.setStack",
+                                    args: [error, lowerer.coerceToExpected(varRef("p.1", DYN, loc), STRING)],
+                                    type: VOID,
+                                    loc,
+                                },
+                                loc,
+                            },
+                            {
+                                kind: "if",
+                                cond: this.readBagHas(lowerer, "dyn.hasKey", this.readPropertyBag(lowerer, receiver, loc), key, loc),
+                                then: [store],
+                                else_: null,
+                                loc,
+                            },
+                        ],
+                        else_: [store],
+                        loc,
+                    },
+                    { kind: "return", value: null, loc },
+                ];
+            }
+            const bag = this.readPropertyBag(lowerer, receiver, loc);
+            return [
+                {
+                    kind: "return",
+                    value: {
+                        kind: "ternary",
+                        cond: this.readBagHas(lowerer, "dyn.hasKey", bag, key, loc),
+                        then: {
+                            kind: "libCall",
+                            fn: "dyn.bagGet",
+                            args: [bag, key, lowerer.coerceToExpected(receiver, DYN)],
+                            type: DYN,
+                            loc,
+                        },
+                        else_: lowerer.coerceToExpected({ kind: "libCall", fn: "error.stack", args: [error], type: STRING, loc }, DYN),
+                        type: DYN,
+                        loc,
+                    },
+                    loc,
+                },
+            ];
+        }
         if ((name === "message" || name === "name") && lowerer.isSubclassOf(info.def.name, "%Error"))
             return write
                 ? [
@@ -3549,9 +4487,7 @@ export class ClassDynamicDispatch {
                     const body = [];
                     const symbol = symbolMemberKey(lowerer, info, name, loc);
                     if (symbol || (isClassOwnEnumerableFieldName(name) && !name.startsWith("sym:"))) {
-                        const prototypeMethod = lowerer.prototypeMethodAccesses.has(name);
-                        if (prototypeMethod)
-                            classPrototypeData(lowerer, info, loc, receiver);
+                        const prototypeMethod = observedPrototypeMethod(lowerer, info, name, loc, receiver);
                         // Selecting the method must not give the object own storage.
                         const bag = this.readPropertyBag(lowerer, receiver, loc);
                         const key = symbol ?? { kind: "strLit", value: name, type: STRING, loc };
@@ -3615,19 +4551,40 @@ export class ClassDynamicDispatch {
             if (!field && !accessor) {
                 const instance = lowerer.coerceToExpected(receiver, DYN);
                 const bag = this.readPropertyBagOrEmpty(lowerer, instance, loc);
-                return [
-                    {
-                        kind: "return",
-                        value: {
-                            kind: "libCall",
-                            fn: "dyn.bagGet",
-                            args: [bag, { kind: "strLit", value: name, type: STRING, loc }, instance],
-                            type: DYN,
+                const key = { kind: "strLit", value: name, type: STRING, loc };
+                const own = {
+                    kind: "libCall",
+                    fn: "dyn.bagGet",
+                    args: [bag, key, instance],
+                    type: DYN,
+                    loc,
+                };
+                // An Object.prototype method no class in the chain declares: an
+                // own property shadows it, otherwise the read answers the same
+                // interned value `Object.prototype.<name>` reads.
+                if (INHERITED_OBJECT_METHODS.has(name) && !findMethodOn(lowerer, info, name)) {
+                    return [
+                        {
+                            kind: "return",
+                            value: {
+                                kind: "ternary",
+                                cond: this.readBagHas(lowerer, "dyn.hasKey", bag, key, loc),
+                                then: own,
+                                else_: {
+                                    kind: "libCall",
+                                    fn: "dyn.builtinMethod",
+                                    args: [{ kind: "strLit", value: "Object", type: STRING, loc }, key],
+                                    type: DYN,
+                                    loc,
+                                },
+                                type: DYN,
+                                loc,
+                            },
                             loc,
                         },
-                        loc,
-                    },
-                ];
+                    ];
+                }
+                return [{ kind: "return", value: own, loc }];
             }
             const type = field ?? accessor.sig.ret;
             if (!canConvertToDyn(type, getRecord, getUnion))
@@ -3947,6 +4904,8 @@ export class ClassDynamicDispatch {
         let callee;
         let virtual = false;
         let owner;
+        /** Erased instances of subclasses that redeclare a generic method. */
+        const overrides = [];
         if (methodInfo) {
             owner = methodInfo.declarer;
             params = methodInfo.sig.params;
@@ -3969,6 +4928,42 @@ export class ClassDynamicDispatch {
             result = instance.returnType;
             callee = instance.name;
         }
+        else if (generic &&
+            !generic.info.implicitParams &&
+            generic.info.typeParams.length > 0 &&
+            generic.declarer.decl &&
+            !lowerer.overrideBelow(info, method)) {
+            // A generic method called by name runs its erased instance; a
+            // subclass that redeclares it runs its own, selected by the
+            // receiver's runtime class (most derived first).
+            owner = generic.declarer;
+            const instance = erasedGenericInstance(lowerer, generic.declarer.decl, generic.info);
+            params = instance.params;
+            result = instance.returnType;
+            callee = instance.name;
+            if (genericOverrideBelow(info, method)) {
+                const subclasses = [];
+                const collect = (c) => {
+                    for (const sub of c.subclasses) {
+                        collect(sub);
+                        if (sub.genericMethods?.has(method) && lowerer.classCanBeConstructed(sub))
+                            subclasses.push(sub);
+                    }
+                };
+                collect(info);
+                for (const sub of subclasses) {
+                    const own = sub.genericMethods.get(method);
+                    if (!sub.decl || own.implicitParams || own.typeParams.length === 0)
+                        return fence();
+                    const subInstance = erasedGenericInstance(lowerer, sub.decl, own);
+                    if (subInstance.params.length !== params.length ||
+                        subInstance.params.some((p, i) => !typeEquals(p.type, params[i].type)) ||
+                        !typeEquals(subInstance.returnType, result))
+                        return fence();
+                    overrides.push({ cls: sub, callee: subInstance.name });
+                }
+            }
+        }
         else
             return fence();
         const incoming = dispatch.source.args.map((_, i) => varRef(`p.${i + 1}`, DYN, loc));
@@ -4004,7 +4999,7 @@ export class ClassDynamicDispatch {
                 return fence();
             args.push(converted);
         }
-        const call = virtual
+        let call = virtual
             ? {
                 kind: "virtualCall",
                 className: owner.def.name,
@@ -4020,6 +5015,29 @@ export class ClassDynamicDispatch {
                 type: result,
                 loc,
             };
+        for (const override of overrides.toReversed()) {
+            const subType = { kind: "object", className: override.cls.def.name };
+            call = {
+                kind: "ternary",
+                cond: {
+                    kind: "instanceOf",
+                    value: receiver,
+                    className: override.cls.def.name,
+                    type: BOOL,
+                    loc,
+                },
+                then: {
+                    kind: "call",
+                    callee: override.callee,
+                    args: [{ kind: "downcast", value: receiver, type: subType, loc }, ...args],
+                    type: result,
+                    loc,
+                },
+                else_: call,
+                type: result,
+                loc,
+            };
+        }
         let body;
         if (result.kind === "void")
             body = [
@@ -4079,4 +5097,12 @@ export class ClassDynamicDispatch {
         return body;
     }
 }
+/** Object.prototype methods every class instance inherits unless its class
+ * chain declares them. */
+const INHERITED_OBJECT_METHODS = new Set([
+    "valueOf",
+    "toString",
+    "hasOwnProperty",
+    "propertyIsEnumerable",
+]);
 //# sourceMappingURL=class-dynamic-dispatch.js.map