@scriptc/compiler 0.1.7 → 0.2.1

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

@@ -0,0 +1,1158 @@
+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 { varRef } from "../../ir/build.js";
+import { everyStmtList, transformExpr, transformStmtList } from "../../ir/traverse.js";
+import { dynUndefinedExpr, PoisonError } from "./lowerer.js";
+import { implicitDefaultInstance } from "./lower-calls.js";
+import { accessorCall, classValueRef, findGenericMethodOn, findMethodOn, findStaticOn, genericOverrideBelow, upcastTo } from "./lower-classes.js";
+import { classPrototypeData, hasClassPrototypeData, reflectClassPrototype } from "./class-prototypes.js";
+import { errorPropertyRead, errorPropertyWrite, errorToStringCall, errorToStringMethod, refreshErrorPropertyDispatch, refreshErrorMethodDispatch } from "./error-methods.js";
+import { GeneratorDynamicDispatch } from "./generator-dynamic-dispatch.js";
+import { classMethodValue } from "./class-method-values.js";
+import * as ts from "../ts7/adapter.js";
+import { SYMBOL_T } from "../../ir/ir.js";
+import { isClassCallback } from "./class-callbacks.js";
+import { refreshDescriptorGuards } from "./class-descriptors.js";
+import { ClassConstructionDispatch } from "./class-construction.js";
+const STREAM_METHODS = new Set(["on", "addListener", "once", "prependListener", "prependOnceListener", "off", "removeListener", "read", "pause", "resume", "isPaused", "destroy"]);
+const STREAM_BOOL_PROPERTIES = new Set(["readable", "readableEnded", "writable", "writableEnded", "writableFinished", "writableNeedDrain", "destroyed", "closed", "readableObjectMode", "writableObjectMode", "allowHalfOpen"]);
+const STREAM_NUM_PROPERTIES = new Set(["readableLength", "readableHighWaterMark", "writableLength", "writableHighWaterMark", "writableCorked"]);
+const streamProperty = (name) => STREAM_BOOL_PROPERTIES.has(name) || STREAM_NUM_PROPERTIES.has(name);
+export function classInstanceOf(lowerer, value, info, loc, classValue) {
+    const name = `%dyn.class.${classValue ? "valueInstanceof" : "instanceof"}:${info.def.name}`;
+    const params = [{ localId: "value", name: "value", type: DYN },
+        ...(classValue ? [{ localId: "class", name: "class", type: classValue.type }] : [])];
+    if (!lowerer.liftedFns.some((fn) => fn.name === name)) {
+        const candidate = varRef("candidate", DYN, loc);
+        const prototype = classPrototypeData(lowerer, info, loc, classValue ? varRef("class", classValue.type, loc) : undefined);
+        const body = prototype ? [
+            { kind: "varDecl", localId: "candidate", init: varRef("value", DYN, loc), loc },
+            { kind: "while", cond: { kind: "ternary", cond: { kind: "dynTest", test: "nullish", value: candidate, type: BOOL, loc },
+                    then: { kind: "boolLit", value: false, type: BOOL, loc }, else_: { kind: "dynTest", test: "object", value: candidate, type: BOOL, loc }, type: BOOL, loc }, body: [
+                    { kind: "assign", localId: "candidate", value: { kind: "libCall", fn: "dyn.getPrototype", args: [candidate], type: DYN, loc }, loc },
+                    { kind: "if", cond: { kind: "dynScalarEq", left: candidate, right: prototype, type: BOOL, loc }, then: [
+                            { kind: "return", value: { kind: "boolLit", value: true, type: BOOL, loc }, loc },
+                        ], else_: null, loc },
+                ], loc },
+        ] : [];
+        body.push({ kind: "return", value: { kind: "boolLit", value: false, type: BOOL, loc }, loc });
+        lowerer.liftedFns.push({
+            name, params, returnType: BOOL,
+            locals: [...params.map((p) => ({ id: p.localId, name: p.name, type: p.type, mutable: false })),
+                ...(prototype ? [{ id: "candidate", name: "candidate", type: DYN, mutable: true }] : [])], body, loc,
+        });
+    }
+    return { kind: "call", callee: name, args: [value, ...(classValue ? [classValue] : [])], type: BOOL, loc };
+}
+export function classPropertiesHelper(lowerer, loc) {
+    const name = "%dyn.class.properties";
+    const existing = lowerer.liftedFns.find((fn) => fn.name === name);
+    if (existing)
+        return existing;
+    const helper = {
+        name, params: [{ localId: "p.0", name: "value", type: DYN }], returnType: DYN,
+        locals: [{ id: "p.0", name: "value", type: DYN, mutable: false }],
+        body: [{ kind: "return", value: varRef("p.0", DYN, loc), loc }], loc,
+    };
+    lowerer.liftedFns.push(helper);
+    return helper;
+}
+/** Calls on native class capsules keep the instance's compiled methods. The
+ * reachable-body fixed point discovers both the boxed classes and method
+ * names before generating checked native dispatch; ordinary dyn receivers
+ * continue through their existing runtime implementation. */
+export class ClassDynamicDispatch {
+    asyncFree;
+    constructor(asyncFree = false) {
+        this.asyncFree = asyncFree;
+    }
+    generatorDispatch = new GeneratorDynamicDispatch();
+    constructionDispatch = new ClassConstructionDispatch();
+    boxed = new Set();
+    boxedConstructors = new Set();
+    dispatches = new Map();
+    properties = new Map();
+    computed = new Map();
+    propertyBag = null;
+    errorStrings = new Map();
+    bagClasses = new Set();
+    bagInitializers = new Map();
+    typedPropertyBags = new Map();
+    generated = new Set();
+    constructDispatch = null;
+    constructors = new Map();
+    constructed = new Set();
+    instanceTests = new Map();
+    jsonPrototypes = new Set();
+    descriptorHelper = null;
+    prototypeHelper = null;
+    prototypeClasses = new Set();
+    instancePrototypes = new Map();
+    process(lowerer, functions) {
+        let changed = refreshErrorMethodDispatch(lowerer, functions);
+        changed = refreshErrorPropertyDispatch(lowerer, functions) || changed;
+        changed = this.generatorDispatch.process(lowerer, functions, this.generated) || changed;
+        changed = this.constructionDispatch.process(lowerer, functions) || changed;
+        const seenTypes = new Set();
+        const rewrite = new Set();
+        const discover = (type) => {
+            const key = typeKey(type);
+            if (seenTypes.has(key))
+                return;
+            seenTypes.add(key);
+            if (type.kind === "object") {
+                if (isDynTypedRefType(type))
+                    this.boxed.add(type.className);
+            }
+            else if (type.kind === "classval")
+                this.boxedConstructors.add(type.className);
+            else if (type.kind === "array")
+                discover(type.elem);
+            else if (type.kind === "record") {
+                const shape = lowerer.shapes.get(type.shapeId);
+                shape?.fields.forEach((field) => discover(field.type));
+                if (shape?.indexValue)
+                    discover(shape.indexValue);
+            }
+            else if (type.kind === "union")
+                lowerer.unions.get(type.unionId)?.arms.forEach(discover);
+            else if (type.kind === "func")
+                discover(type.ret);
+            else if (type.kind === "promise")
+                discover(type.inner);
+        };
+        for (const fn of functions)
+            everyStmtList(fn.body, {
+                stmt: () => true,
+                expr: (expr) => {
+                    switch (expr.kind) {
+                        case "dynFrom":
+                            discover(expr.value.type);
+                            break;
+                        case "call":
+                            if (expr.callee === "%dyn.class.properties" && expr.args[0]?.kind === "dynFrom" && isDynTypedRefType(expr.args[0].value.type))
+                                rewrite.add(fn);
+                            break;
+                        case "dynKeyGet":
+                        case "dynInvoke":
+                            rewrite.add(fn);
+                            break;
+                        case "libCall":
+                            if (expr.fn === "bytes.construct" || expr.fn === "dyn.keySet" || expr.fn === "dyn.keySetComputed" || (expr.fn === "dyn.iterator" || expr.fn === "dyn.arrayFromIterator") || expr.fn === "dyn.toString" || expr.fn === "dyn.stringConstructor" ||
+                                expr.fn === "dyn.hasKeyComputed" || expr.fn === "dyn.hasOwnComputed" || expr.fn === "dyn.propertyIsEnumerableComputed" || expr.fn === "dyn.defineProperty" || expr.fn === "dyn.getPrototype")
+                                rewrite.add(fn);
+                            break;
+                    }
+                    return true;
+                },
+            });
+        if (this.boxed.size === 0 && rewrite.size === 0)
+            return changed;
+        for (const fn of functions) {
+            if (!fn.name.startsWith("%dyn.class.instanceof:") && !fn.name.startsWith("%dyn.class.valueInstanceof:"))
+                continue;
+            const target = fn.name.slice(fn.name.indexOf(":") + 1);
+            let checked = this.instanceTests.get(fn.name);
+            if (!checked) {
+                checked = new Set();
+                this.instanceTests.set(fn.name, checked);
+            }
+            for (const className of this.boxed) {
+                if (checked.has(className))
+                    continue;
+                checked.add(className);
+                const subtype = className === target || lowerer.isSubclassOf(className, target);
+                if (!subtype && !lowerer.isSubclassOf(target, className))
+                    continue;
+                const loc = fn.loc;
+                const value = varRef("value", DYN, loc);
+                const type = { kind: "object", className };
+                const result = subtype && fn.params[1] && lowerer.classes.get(target)?.localClass
+                    ? { kind: "instanceOfValue", value: { kind: "dynCheck", value, type, loc }, classValue: varRef("class", fn.params[1].type, loc), type: BOOL, loc }
+                    : subtype ? { kind: "boolLit", value: true, type: BOOL, loc }
+                        : { kind: "instanceOf", value: { kind: "dynCheck", value, type, loc }, className: target, type: BOOL, loc };
+                fn.body.unshift({ kind: "if", cond: { kind: "libCall", fn: "dyn.typedRefIs", args: [value,
+                            { kind: "strLit", value: typeKey(type), type: STRING, loc }], type: BOOL, loc }, then: [{ kind: "return", value: result, loc }], else_: null, loc });
+                changed = true;
+            }
+        }
+        if (!this.propertyBag) {
+            this.propertyBag = classPropertiesHelper(lowerer, functions[0].loc);
+            this.generated.add(this.propertyBag);
+            changed = true;
+        }
+        for (const className of this.boxed) {
+            const info = lowerer.classes.get(className);
+            if (!info || info.builtinEmitter || info.builtinStream || info.builtinError)
+                continue;
+            if (info.symbolFields && info.def.symbolFields === undefined) {
+                info.def.symbolFields = [...info.symbolFields].flatMap(([symbol, field]) => {
+                    const global = lowerer.globalsBySymbol.get(symbol);
+                    return global?.type.kind === "symbol" ? [{ field, globalId: global.id }] : [];
+                });
+            }
+            if (this.prototypeHelper && !this.prototypeClasses.has(className)) {
+                this.prototypeClasses.add(className);
+                const loc = this.prototypeHelper.loc;
+                const type = { kind: "object", className };
+                const value = varRef("value", DYN, loc);
+                const prototype = reflectClassPrototype(lowerer, info, loc, { kind: "dynCheck", value, type, loc });
+                if (prototype)
+                    this.prototypeHelper.body.unshift({ kind: "if", cond: { kind: "libCall", fn: "dyn.typedRefIs", args: [value,
+                                { kind: "strLit", value: typeKey(type), type: STRING, loc }], type: BOOL, loc },
+                        then: [{ kind: "return", value: prototype, loc }], else_: null, loc });
+                changed = true;
+            }
+            if (!this.jsonPrototypes.has(className) && info.decl && findMethodOn(lowerer, info, "toJSON")) {
+                this.jsonPrototypes.add(className);
+                const loc = this.propertyBag.loc;
+                const method = classMethodValue(lowerer, info.decl, info, "toJSON", loc);
+                const prototype = method ? classPrototypeData(lowerer, info, loc) : null;
+                const helper = lowerer.liftedFns.find((fn) => fn.name === info.def.prototypeDataHelper);
+                const init = helper?.body[0];
+                if (!info.prototypeReflectionReady && method && prototype && init?.kind === "if" && canConvertToDyn(method.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
+                    const descriptor = { kind: "exprStmt", expr: {
+                            kind: "libCall", fn: "dyn.defineProperty", args: [prototype,
+                                { kind: "dynFrom", value: { kind: "strLit", value: "toJSON", type: STRING, loc }, type: DYN, loc },
+                                { kind: "dynObjLit", fields: [
+                                        { key: { kind: "strLit", value: "value", type: STRING, loc }, value: { kind: "dynFrom", value: method, type: DYN, loc } },
+                                        ...["writable", "configurable"].map((key) => ({ key: { kind: "strLit", value: key, type: STRING, loc }, value: { kind: "dynFrom", value: { kind: "boolLit", value: true, type: BOOL, loc }, type: DYN, loc } })),
+                                    ], type: DYN, loc },
+                            ], type: DYN, loc
+                        }, loc };
+                    init.then.push(descriptor);
+                    changed = true;
+                }
+            }
+        }
+        for (const plan of this.propertyReceivers(lowerer)) {
+            const info = plan.info;
+            const className = info.def.name;
+            let instancePrototype = this.instancePrototypes.get(plan.capsule.def.name);
+            if (!instancePrototype && hasClassPrototypeData(info)) {
+                const name = `%class.instancePrototype:${plan.capsule.def.name}`;
+                const type = { kind: "object", className: plan.capsule.def.name };
+                const loc = this.propertyBag.loc;
+                const fn = { name, params: [{ localId: "this", name: "this", type }],
+                    locals: [{ id: "this", name: "this", type, mutable: false }], returnType: DYN,
+                    body: [{ kind: "return", value: { kind: "libCall", fn: "dyn.getPrototype",
+                                args: [{ kind: "dynObjLit", fields: [], type: DYN, loc }], type: DYN, loc }, loc }], loc };
+                plan.capsule.def.instancePrototypeHelper = name;
+                instancePrototype = { fn, classes: new Set() };
+                this.instancePrototypes.set(plan.capsule.def.name, instancePrototype);
+                this.generated.add(fn);
+                lowerer.liftedFns.push(fn);
+            }
+            if (instancePrototype && hasClassPrototypeData(info) && !instancePrototype.classes.has(className)) {
+                instancePrototype.classes.add(className);
+                const loc = instancePrototype.fn.loc;
+                const receiver = varRef("this", instancePrototype.fn.params[0].type, loc);
+                const prototype = classPrototypeData(lowerer, info, loc, info === plan.capsule ? receiver
+                    : { kind: "downcast", value: receiver, type: { kind: "object", className }, loc });
+                const returned = { kind: "return", value: prototype ?? { kind: "libCall", fn: "dyn.getPrototype",
+                        args: [{ kind: "dynObjLit", fields: [], type: DYN, loc }], type: DYN, loc }, loc };
+                if (info === plan.capsule)
+                    instancePrototype.fn.body[instancePrototype.fn.body.length - 1] = returned;
+                else
+                    instancePrototype.fn.body.unshift({ kind: "if",
+                        cond: { kind: "instanceOf", value: receiver, className, type: BOOL, loc }, then: [returned], else_: null, loc });
+                changed = true;
+            }
+            const needsPrototype = (current) => hasClassPrototypeData(current) || current.subclasses.some(needsPrototype);
+            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) {
+                    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;
+            };
+            for (const existingInit of this.bagInitializers.get(className) ?? []) {
+                if (existingInit.value.kind === "dynObjLit" && needsPrototype(info)) {
+                    const prototype = prototypeFor(info, existingInit.obj, existingInit.loc);
+                    if (prototype) {
+                        existingInit.value = { kind: "libCall", fn: "dyn.objCreate", args: [prototype], type: DYN, loc: existingInit.loc };
+                        changed = true;
+                    }
+                }
+            }
+            if (this.bagClasses.has(plan.key))
+                continue;
+            this.bagClasses.add(plan.key);
+            this.ensurePropertyBag(info);
+            const loc = this.propertyBag.loc;
+            const { receiver, condition } = this.propertyReceiver(plan, loc);
+            const bag = { kind: "fieldGet", obj: receiver, className, field: PROPERTY_BAG, type: DYN, loc };
+            const prototype = needsPrototype(info) ? prototypeFor(info, receiver, loc) : null;
+            const initialize = {
+                kind: "fieldSet", obj: receiver, className, field: PROPERTY_BAG, value: prototype
+                    ? { kind: "libCall", fn: "dyn.objCreate", args: [prototype], type: DYN, loc }
+                    : { kind: "dynObjLit", fields: [], type: DYN, loc }, loc,
+            };
+            const initializers = this.bagInitializers.get(className) ?? [];
+            initializers.push(initialize);
+            this.bagInitializers.set(className, initializers);
+            this.propertyBag.body.unshift({
+                kind: "if", cond: condition,
+                then: [
+                    { kind: "if", cond: { kind: "dynTest", test: "undefined", value: bag, type: BOOL, loc }, then: [
+                            initialize,
+                        ], else_: null, loc },
+                    { kind: "return", value: bag, loc },
+                ], else_: null, loc,
+            });
+            changed = true;
+        }
+        refreshDescriptorGuards(lowerer);
+        const byMethod = new Map();
+        const candidates = (method) => {
+            const found = byMethod.get(method);
+            if (found)
+                return found;
+            const matching = [...this.boxed].flatMap((name) => {
+                const info = lowerer.classes.get(name);
+                if (!info || info.fields.has(method) || info.builtinEmitter || info.builtinError)
+                    return [];
+                if (info.builtinStream)
+                    return STREAM_METHODS.has(method) ? [info] : [];
+                return findMethodOn(lowerer, info, method) || findGenericMethodOn(lowerer, info, method) ? [info] : [];
+            });
+            byMethod.set(method, matching);
+            return matching;
+        };
+        for (const fn of functions) {
+            // Discovery already visits every expression. Preserve bodies without
+            // dispatch sites instead of rebuilding their entire typed IR tree on
+            // every reachability pass. Recompute this set as new bodies appear.
+            if (this.generated.has(fn) || !rewrite.has(fn))
+                continue;
+            fn.body = transformStmtList(fn.body, {
+                stmt: (stmt) => stmt,
+                expr: (expr) => {
+                    if (expr.kind === "libCall" && expr.fn === "dyn.getPrototype") {
+                        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 (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: "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 };
+                    }
+                    if (expr.kind === "call" && expr.callee === this.propertyBag.name) {
+                        const boxed = expr.args[0];
+                        if (boxed?.kind === "dynFrom" && isDynTypedRefType(boxed.value.type)) {
+                            const helper = this.typedPropertyBag(lowerer, boxed.value.type, expr.loc);
+                            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);
+                            changed = true;
+                        }
+                        return { kind: "call", callee: this.constructDispatch.name, args: expr.args, type: DYN, 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, 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 },
+                                            { 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 };
+                    }
+                    const computedRead = expr.kind === "dynKeyGet" && expr.key.kind !== "strLit" ? expr : null;
+                    const computedWrite = 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 = !!computedProbe || computedWrite?.fn === "dyn.keySetComputed" || computedRead?.key.type.kind === "dyn";
+                        const key = JSON.stringify([!!computedWrite, computedRead?.optional ?? false, dynamicKey, probe]);
+                        let dispatch = this.computed.get(key);
+                        if (!dispatch) {
+                            const loc = expr.loc;
+                            const params = [
+                                { localId: "p.0", name: "value", type: DYN },
+                                { localId: "p.key", name: "key", type: dynamicKey ? DYN : STRING },
+                                ...(computedWrite ? [{ localId: "p.1", name: "stored", type: DYN }] : []),
+                            ];
+                            const keyLocal = dynamicKey ? "key.string" : "p.key";
+                            const bag = { kind: "call", callee: this.propertyBag.name, args: [varRef("p.0", DYN, loc)], type: DYN, loc };
+                            const fallback = computedProbe
+                                ? { ...computedProbe, fn: probe === "in" ? "dyn.hasKey" : 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: computedProbe ? BOOL : computedWrite ? VOID : DYN,
+                                locals: [...params.map((p) => ({ id: p.localId, name: p.name, type: p.type, mutable: false })), ...(dynamicKey ? [{ id: keyLocal, name: "key", type: STRING, mutable: false }] : [])],
+                                body: computedWrite
+                                    ? [{ kind: "exprStmt", expr: fallback, loc }, { kind: "return", value: null, loc }]
+                                    : [{ kind: "return", value: fallback, loc }], loc,
+                            };
+                            if (dynamicKey)
+                                helper.body.unshift({ kind: "if", cond: { kind: "dynTest", test: "symbol", value: varRef("p.key", DYN, loc), type: BOOL, loc }, then: computedProbe ? [
+                                        { kind: "return", value: { ...computedProbe, args: [bag, varRef("p.key", DYN, loc)] }, 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 }, { kind: "if", cond: { kind: "dynTest", test: "nullish", value: varRef("p.0", DYN, loc), type: BOOL, loc }, then: [
+                                        ...(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 });
+                            dispatch = { write: !!computedWrite, fn: helper, classes: new Set(), keyLocal, branchIndex: dynamicKey ? 3 : 0, dynamicKey, probe };
+                            this.computed.set(key, dispatch);
+                            this.generated.add(helper);
+                            lowerer.liftedFns.push(helper);
+                            changed = true;
+                        }
+                        return { kind: "call", callee: dispatch.fn.name, args: computedRead ? [computedRead.value, 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 bag = { kind: "call", callee: this.propertyBag.name, args: [varRef("p.0", DYN, loc)], type: DYN, loc };
+                            const fallback = read
+                                ? { ...read, value: bag }
+                                : { ...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 })),
+                                body: write
+                                    ? [{ kind: "exprStmt", expr: fallback, loc }, { kind: "return", value: null, loc }]
+                                    : [{ kind: "return", value: fallback, loc }], 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, loc });
+                            }
+                            dispatch = { name, write: !!write, fn: helper, classes: new Set() };
+                            this.properties.set(key, dispatch);
+                            this.generated.add(helper);
+                            lowerer.liftedFns.push(helper);
+                            changed = true;
+                        }
+                        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 : null;
+                    const invoke = iterator
+                        ? { kind: "dynInvoke", recv: iterator.args[0], method: "sym:iterator", calleeName: "value[Symbol.iterator]", args: [], type: DYN, loc: iterator.loc }
+                        : expr.kind === "dynInvoke" ? expr : null;
+                    if (!invoke || candidates(invoke.method).length === 0 && !(invoke.method === "toString" && lowerer.classes.has("%Error")))
+                        return expr;
+                    const key = JSON.stringify([invoke.method, invoke.calleeName, 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 });
+                        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 helper = {
+                            name: `%dyn.class.call.${this.dispatches.size}`, params, returnType: DYN,
+                            locals: params.map((p) => ({ id: p.localId, name: p.name, type: DYN, mutable: false })),
+                            body: [{ kind: "return", value: iterator
+                                        ? { ...iterator, args: [varRef("p.0", DYN, expr.loc), ...iterator.args.slice(1)] }
+                                        : { ...invoke, 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: "return", value: {
+                                            kind: "dynCall", callee: errorToStringMethod(lowerer, { kind: "dynCheck", value, type: { kind: "object", className: "%Error" }, loc }),
+                                            receiver: value, calleeName: invoke.calleeName, args: invoke.args.map((_, i) => varRef(`p.${i + 1}`, DYN, loc)), type: DYN, loc,
+                                        }, 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], type: DYN, loc: expr.loc,
+                        }, type: DYN, loc: expr.loc };
+                },
+            });
+        }
+        for (const dispatch of this.dispatches.values()) {
+            for (const info of candidates(dispatch.source.method)) {
+                if (dispatch.classes.has(info.def.name))
+                    continue;
+                dispatch.classes.add(info.def.name);
+                const loc = dispatch.source.loc;
+                const type = { kind: "object", className: info.def.name };
+                const receiver = varRef("p.0", DYN, loc);
+                if (isClassCallback(lowerer, info, dispatch.source.method)) {
+                    const prototypeMethod = lowerer.prototypeMethodAccesses.has(dispatch.source.method);
+                    if (prototypeMethod)
+                        classPrototypeData(lowerer, info, loc);
+                    const bag = { kind: "call", callee: this.propertyBag.name, args: [receiver], type: DYN, loc };
+                    dispatch.callback.body.unshift({ kind: "if", cond: {
+                            kind: "libCall", fn: "dyn.typedRefIs", args: [receiver, { kind: "strLit", value: typeKey(type), type: STRING, loc }], type: BOOL, loc,
+                        }, then: [{ kind: "return", value: { kind: "ternary", cond: prototypeMethod ? { kind: "boolLit", value: true, type: BOOL, loc } : { kind: "libCall", fn: "dyn.hasKey", args: [bag,
+                                            { kind: "strLit", value: dispatch.source.method, type: STRING, loc }], type: BOOL, loc }, then: { kind: "dynObjLit", fields: [
+                                            { key: { kind: "strLit", value: "value", type: STRING, loc }, value: { kind: "dynKeyGet", value: bag, key: { kind: "strLit", value: dispatch.source.method, type: STRING, loc }, type: DYN, loc } },
+                                        ], type: DYN, loc }, else_: dynUndefinedExpr(loc), type: DYN, loc }, loc }], else_: null, loc });
+                }
+                const before = lowerer.diags.length;
+                let branch;
+                try {
+                    branch = this.methodBody(lowerer, dispatch, info, { kind: "dynCheck", value: receiver, type, loc });
+                }
+                catch (error) {
+                    if (!(error instanceof PoisonError) || !info.decl)
+                        throw error;
+                    const fence = lowerer.deferToRuntimeFence(before, info.decl, { kind: "statement" });
+                    if (!fence)
+                        throw error;
+                    branch = [fence];
+                }
+                dispatch.fn.body.unshift({
+                    kind: "if", cond: {
+                        kind: "libCall", fn: "dyn.typedRefIs", args: [receiver, { kind: "strLit", value: typeKey(type), type: STRING, loc }], type: BOOL, loc,
+                    }, then: branch, else_: null, loc,
+                });
+                changed = true;
+            }
+        }
+        for (const dispatch of this.properties.values()) {
+            if (!dispatch.write)
+                for (const name of this.boxedConstructors) {
+                    const info = lowerer.classes.get(name);
+                    const field = info && findStaticOn(lowerer, info, dispatch.name)?.field;
+                    const key = `constructor:${name}`;
+                    if (!field || dispatch.name.startsWith("#") || dispatch.classes.has(key))
+                        continue;
+                    dispatch.classes.add(key);
+                    const loc = dispatch.fn.loc;
+                    const value = varRef("p.0", DYN, loc);
+                    const type = { kind: "classval", className: name };
+                    dispatch.fn.body.unshift({ kind: "if", cond: { kind: "libCall", fn: "dyn.classIs", args: [value,
+                                { kind: "strLit", value: typeKey(type), type: STRING, loc }], type: BOOL, loc }, then: [
+                            { kind: "return", value: lowerer.coerceToExpected(varRef(field.globalId, field.type, loc), DYN), loc },
+                        ], else_: null, loc });
+                    changed = true;
+                }
+            for (const plan of this.propertyReceivers(lowerer, true)) {
+                const { info } = plan;
+                if (!isClassOwnEnumerableFieldName(dispatch.name) ||
+                    !(info.builtinStream !== undefined && streamProperty(dispatch.name)) && !findMethodOn(lowerer, info, dispatch.name) && !findGenericMethodOn(lowerer, info, dispatch.name) && dispatch.name !== "constructor" && !info.fields.has(dispatch.name) && !findMethodOn(lowerer, info, `get:${dispatch.name}`) && !findMethodOn(lowerer, info, `set:${dispatch.name}`))
+                    continue;
+                if (dispatch.classes.has(plan.key))
+                    continue;
+                dispatch.classes.add(plan.key);
+                const loc = dispatch.fn.loc;
+                const { receiver, condition } = this.propertyReceiver(plan, loc);
+                const before = lowerer.diags.length;
+                let branch;
+                try {
+                    branch = this.propertyBody(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;
+                    branch = [fence];
+                }
+                dispatch.fn.body.unshift({
+                    kind: "if", cond: condition, then: branch, else_: null, loc,
+                });
+                changed = true;
+            }
+        }
+        for (const dispatch of this.computed.values()) {
+            for (const plan of this.propertyReceivers(lowerer, true)) {
+                if (dispatch.classes.has(plan.key))
+                    continue;
+                const { info } = plan;
+                dispatch.classes.add(plan.key);
+                const loc = dispatch.fn.loc;
+                const { receiver, condition } = this.propertyReceiver(plan, loc);
+                const memberBody = (name) => {
+                    if (dispatch.probe && (name === "message" || name === "name") && lowerer.isSubclassOf(info.def.name, "%Error") && dispatch.probe !== "in")
+                        return [{
+                                kind: "return", value: dispatch.probe === "own"
+                                    ? { kind: "fieldGet", obj: lowerer.upcastTo(receiver, "%Error"), className: "%Error", field: `%${name}Present`, type: BOOL, loc }
+                                    : { kind: "fieldGet", obj: lowerer.upcastTo(receiver, "%Error"), className: "%Error", field: `%${name}Enumerable`, type: BOOL, loc }, loc,
+                            }];
+                    if (info.builtinStream !== undefined && streamProperty(name) && dispatch.probe)
+                        return [{ kind: "return", value: { kind: "boolLit", value: dispatch.probe === "in", type: BOOL, loc }, loc }];
+                    if (!dispatch.probe)
+                        return this.propertyBody(lowerer, { ...dispatch, name }, info, receiver);
+                    const prototypeMethod = lowerer.prototypeMethodAccesses.has(name);
+                    if (info.fields.has(name) || dispatch.probe === "in" && !prototypeMethod) {
+                        return [{ kind: "return", value: { kind: "boolLit", value: true, type: BOOL, loc }, loc }];
+                    }
+                    if (prototypeMethod)
+                        classPrototypeData(lowerer, info, loc, receiver);
+                    const bag = { kind: "call", callee: this.propertyBag.name,
+                        args: [lowerer.coerceToExpected(receiver, DYN)], type: DYN, loc };
+                    const symbol = name.startsWith("sym:") || name.startsWith("%symbol:");
+                    const fn = dispatch.probe === "in" ? "dyn.hasKey" : dispatch.probe === "own" ? "dyn.hasOwn" : "dyn.propertyIsEnumerable";
+                    return [{ kind: "return", value: { kind: "libCall", fn: symbol ? `${fn}Computed` : fn,
+                                args: [bag, symbol ? varRef("p.key", DYN, loc) : { kind: "strLit", value: name, type: STRING, loc }], type: BOOL, loc }, loc }];
+                };
+                if (dispatch.dynamicKey) {
+                    const symbols = new Map();
+                    const symbolEntries = [];
+                    if (info.symbolFields)
+                        for (const [symbol, name] of info.symbolFields)
+                            symbolEntries.push([symbol, name]);
+                    if (info.symbolMethods)
+                        for (const [symbol, name] of info.symbolMethods)
+                            symbolEntries.push([symbol, name]);
+                    for (const [symbol, name] of symbolEntries) {
+                        const declaration = lowerer.checker.valueDeclarationOf(symbol);
+                        if (declaration && ts.isVariableDeclaration(declaration) && ts.isIdentifier(declaration.name)) {
+                            const global = lowerer.globalsBySymbol.get(symbol);
+                            if (global)
+                                symbols.set(name, lowerer.coerceToExpected(varRef(global.id, global.type, loc), DYN));
+                        }
+                    }
+                    for (let owner = info; owner; owner = owner.base) {
+                        for (const name of [...owner.methods.keys()])
+                            if (name.startsWith("sym:")) {
+                                symbols.set(name, { kind: "dynFrom", type: DYN, loc, value: {
+                                        kind: "libCall", fn: "sym.wellKnown", args: [{ kind: "strLit", value: name.slice(4), type: STRING, loc }], type: SYMBOL_T, loc,
+                                    } });
+                            }
+                    }
+                    const branches = [];
+                    if (!dispatch.write) {
+                        const value = varRef("p.0", DYN, loc);
+                        const key = varRef("p.key", DYN, loc);
+                        const bag = { kind: "call", callee: this.propertyBag.name, args: [value], type: DYN, loc };
+                        branches.push({ kind: "if", cond: { kind: "libCall", fn: "dyn.hasOwnComputed", args: [bag, key], type: BOOL, loc }, then: [
+                                { kind: "return", value: dispatch.probe ? {
+                                        kind: "libCall", fn: dispatch.probe === "enumerable" ? "dyn.propertyIsEnumerableComputed" : "dyn.hasOwnComputed", args: [bag, key], type: BOOL, loc,
+                                    } : { kind: "dynKeyGet", value: bag, key, type: DYN, loc }, loc },
+                            ], else_: null, loc });
+                    }
+                    for (const [name, symbol] of symbols) {
+                        const before = lowerer.diags.length;
+                        let then;
+                        try {
+                            then = memberBody(name);
+                        }
+                        catch (error) {
+                            if (!(error instanceof PoisonError) || !info.decl)
+                                throw error;
+                            const fence = lowerer.deferToRuntimeFence(before, info.decl, { kind: "statement" });
+                            if (!fence)
+                                throw error;
+                            then = [fence];
+                        }
+                        branches.push({ kind: "if", cond: { kind: "dynScalarEq", left: varRef("p.key", DYN, loc), right: symbol, type: BOOL, loc }, then, else_: null, loc });
+                    }
+                    if (branches.length) {
+                        dispatch.fn.body.unshift({ kind: "if", cond: condition, then: [
+                                { kind: "if", cond: { kind: "dynTest", test: "symbol", value: varRef("p.key", DYN, loc), type: BOOL, loc }, then: branches, else_: null, loc },
+                            ], else_: null, loc });
+                        dispatch.branchIndex++;
+                    }
+                }
+                const names = new Set([...info.fields.keys()].filter(isClassOwnEnumerableFieldName));
+                if (info.builtinStream)
+                    for (const name of [...STREAM_BOOL_PROPERTIES, ...STREAM_NUM_PROPERTIES])
+                        names.add(name);
+                for (let owner = info; owner; owner = owner.base) {
+                    const methodNames = [...owner.methods.keys()];
+                    if (owner.genericMethods)
+                        methodNames.push(...[...owner.genericMethods.keys()]);
+                    for (const method of methodNames) {
+                        const name = method.startsWith("get:") || method.startsWith("set:") ? method.slice(4) : method;
+                        if (isClassOwnEnumerableFieldName(name) && !name.startsWith("sym:"))
+                            names.add(name);
+                    }
+                }
+                const branch = [];
+                for (const name of names) {
+                    const before = lowerer.diags.length;
+                    let body;
+                    try {
+                        body = memberBody(name);
+                    }
+                    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];
+                    }
+                    branch.push({ kind: "if", cond: {
+                            kind: "strEq", left: varRef(dispatch.keyLocal, STRING, loc), right: { kind: "strLit", value: name, type: STRING, loc }, negated: false, type: BOOL, loc,
+                        }, then: body, else_: null, loc });
+                }
+                // Keep each class's key table in a separate function. A single
+                // function containing every boxed class grows quadratically during
+                // LLVM's control-flow optimization for large library workloads.
+                const params = [...dispatch.fn.params];
+                if (dispatch.keyLocal !== "p.key")
+                    params.push({ localId: dispatch.keyLocal, name: "key", type: STRING });
+                const helper = {
+                    name: `%dyn.class.keys.${lowerer.liftedFns.length}`, params, returnType: dispatch.fn.returnType,
+                    locals: params.map((p) => ({ id: p.localId, name: p.name, type: p.type, mutable: false })),
+                    body: [...branch, ...dispatch.fn.body.slice(dispatch.write ? -2 : -1)], loc,
+                };
+                this.generated.add(helper);
+                lowerer.liftedFns.push(helper);
+                const call = { kind: "call", callee: helper.name,
+                    args: params.map((p) => varRef(p.localId, p.type, loc)), type: helper.returnType, loc };
+                const then = dispatch.write
+                    ? [{ kind: "exprStmt", expr: call, loc }, { kind: "return", value: null, loc }]
+                    : [{ kind: "return", value: call, loc }];
+                dispatch.fn.body.splice(dispatch.branchIndex, 0, { kind: "if", cond: condition, then, else_: null, loc });
+                changed = true;
+            }
+        }
+        if (this.constructDispatch)
+            for (const [name, info] of this.constructors) {
+                if (this.constructed.has(name))
+                    continue;
+                this.constructed.add(name);
+                const loc = this.constructDispatch.loc;
+                const callee = varRef("p.0", DYN, loc), input = varRef("p.1", DYN, loc);
+                const args = [];
+                let supported = true;
+                for (let i = 0; i < info.ctorParams.length; i++) {
+                    const param = info.ctorParams[i];
+                    if (param.mode !== "required" && param.mode !== "omittable") {
+                        supported = false;
+                        break;
+                    }
+                    const value = { kind: "dynKeyGet", value: input, key: { kind: "strLit", value: String(i), type: STRING, loc }, type: DYN, loc };
+                    const arg = lowerer.coerceToExpected(value, param.type);
+                    if (!typeEquals(arg.type, param.type)) {
+                        supported = false;
+                        break;
+                    }
+                    args.push(arg);
+                }
+                if (!supported || !info.decl)
+                    continue;
+                const cls = classValueRef(lowerer, info, info.decl);
+                const result = { kind: "new", className: name, args, type: { kind: "object", className: name }, loc };
+                this.constructDispatch.body.unshift({ kind: "if", cond: { kind: "dynScalarEq", left: callee,
+                        right: lowerer.coerceToExpected(cls, DYN), type: BOOL, loc }, then: [
+                        { kind: "return", value: lowerer.coerceToExpected(result, DYN), loc },
+                    ], else_: null, loc });
+                changed = true;
+            }
+        return changed;
+    }
+    /** A known native class can access its shared bag directly. Keep the
+     * receiver as an owned parameter so calls and temporary instances retain
+     * their ordinary evaluation and lifetime rules without a boxed capsule. */
+    typedPropertyBag(lowerer, type, loc) {
+        // A superclass constructor can be the first code to access this bag.
+        // Its receiver still needs the actual subclass's prototype.
+        if (lowerer.classes.get(type.className)?.subclasses.length)
+            return null;
+        const existing = this.typedPropertyBags.get(type.className);
+        if (existing)
+            return existing;
+        const initializers = this.bagInitializers.get(type.className);
+        if (!initializers)
+            return null;
+        const receiver = varRef("p.0", type, loc);
+        const bag = { kind: "fieldGet", obj: receiver, className: type.className, field: PROPERTY_BAG, type: DYN, loc };
+        const initialize = { ...initializers[0], 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 }), loc };
+        const helper = {
+            name: `%class.properties:${type.className}`, params: [{ localId: "p.0", name: "value", type }], returnType: DYN,
+            locals: [{ id: "p.0", name: "value", type, mutable: false }], loc,
+            body: [
+                { kind: "if", cond: { kind: "dynTest", test: "undefined", value: bag, type: BOOL, loc }, then: [initialize], else_: null, loc },
+                { kind: "return", value: bag, loc },
+            ],
+        };
+        initializers.push(initialize);
+        this.typedPropertyBags.set(type.className, helper);
+        this.generated.add(helper);
+        lowerer.liftedFns.push(helper);
+        return helper;
+    }
+    /** The hidden bag is part of the native object layout, so every capsule
+     * shares it and normal class tracing/disposal owns its values. Insert it
+     * at the same prefix offset throughout a hierarchy, including classes
+     * collected before this untyped crossing was discovered. */
+    ensurePropertyBag(info) {
+        if (info.fields.has(PROPERTY_BAG))
+            return;
+        let root = info;
+        while (root.base && !root.base.def.runtime)
+            root = root.base;
+        const index = root.def.fields.length;
+        const add = (current) => {
+            if (!current.fields.has(PROPERTY_BAG)) {
+                current.fields.set(PROPERTY_BAG, DYN);
+                current.def.fields.splice(index, 0, { name: PROPERTY_BAG, type: DYN });
+            }
+            current.subclasses.forEach(add);
+        };
+        add(root);
+    }
+    /** A capsule retains its static type, while its object may be a subclass.
+     * Preorder insertion lets later branches test the most derived layout first. */
+    propertyReceivers(lowerer, streams = false) {
+        const plans = [];
+        for (const name of this.boxed) {
+            const capsule = lowerer.classes.get(name);
+            if (!capsule || capsule.builtinEmitter || capsule.builtinStream && !streams || capsule.builtinError)
+                continue;
+            const visit = (info) => {
+                plans.push({ info, capsule, key: JSON.stringify([name, info.def.name]) });
+                for (const child of info.subclasses)
+                    visit(child);
+            };
+            visit(capsule);
+        }
+        return plans;
+    }
+    propertyReceiver(plan, loc) {
+        const value = varRef("p.0", DYN, loc);
+        const type = { kind: "object", className: plan.capsule.def.name };
+        const checked = { kind: "dynCheck", value, type, loc };
+        const matches = { kind: "libCall", fn: "dyn.typedRefIs", args: [value,
+                { kind: "strLit", value: typeKey(type), type: STRING, loc }], type: BOOL, loc };
+        if (plan.info === plan.capsule)
+            return { receiver: checked, condition: matches };
+        return {
+            receiver: { kind: "downcast", value: checked, type: { kind: "object", className: plan.info.def.name }, loc },
+            condition: { kind: "ternary", cond: matches, then: { kind: "instanceOf", value: checked,
+                    className: plan.info.def.name, type: BOOL, loc }, else_: { kind: "boolLit", value: false, type: BOOL, loc }, type: BOOL, loc },
+        };
+    }
+    propertyBody(lowerer, dispatch, info, receiver) {
+        const { name, write } = dispatch;
+        const loc = dispatch.fn.loc;
+        if (info.builtinStream !== undefined && streamProperty(name)) {
+            if (write)
+                return [{ kind: "runtimeFence", code: "SC2020", message: `writing stream property '${name}' through an untyped value is not supported`, loc }];
+            return [{ kind: "return", value: lowerer.coerceToExpected({ kind: "libCall", fn: "stream.prop", args: [receiver, { kind: "strLit", value: name, type: STRING, loc }], type: STREAM_BOOL_PROPERTIES.has(name) ? BOOL : F64, loc }, DYN), loc }];
+        }
+        if ((name === "message" || name === "name") && lowerer.isSubclassOf(info.def.name, "%Error"))
+            return write
+                ? [errorPropertyWrite(lowerer, receiver, lowerer.coerceToExpected(varRef("p.1", DYN, loc), STRING), name), { kind: "return", value: null, loc }]
+                : [{ kind: "return", value: lowerer.coerceToExpected(errorPropertyRead(lowerer, receiver, name), DYN), loc }];
+        const field = info.fields.get(name);
+        const member = `${write ? "set" : "get"}:${name}`;
+        const accessor = field ? null : findMethodOn(lowerer, info, member);
+        const fence = () => [{ kind: "runtimeFence", code: "SC2020", message: `${write ? "writing" : "reading"} '${name}' on this native class through an untyped value is not supported yet`, loc }];
+        const getRecord = (id) => lowerer.shapes.get(id);
+        const getUnion = (id) => lowerer.unions.get(id);
+        if (!write) {
+            if (name === "constructor" && !field && !accessor && info.decl && !info.generic && !info.localClass && !info.classDecorators) {
+                this.constructors.set(info.def.name, info);
+                const cls = lowerer.coerceToExpected(classValueRef(lowerer, info, info.decl), DYN);
+                const bag = { kind: "call", callee: this.propertyBag.name, args: [lowerer.coerceToExpected(receiver, DYN)], type: DYN, loc };
+                const key = { kind: "strLit", value: name, type: STRING, loc };
+                return [{ kind: "return", value: { kind: "ternary", cond: { kind: "libCall", fn: "dyn.hasKey", args: [bag, key], type: BOOL, loc },
+                            then: { kind: "dynKeyGet", value: bag, key, type: DYN, loc }, else_: cls, type: DYN, loc }, loc }];
+            }
+            if (name === "toString" && findMethodOn(lowerer, info, name)?.declarer.builtinError) {
+                return [{ kind: "return", value: errorToStringMethod(lowerer, receiver), loc }];
+            }
+            if (!field && !accessor && info.decl) {
+                const declared = findMethodOn(lowerer, info, name);
+                // Untyped dispatch considers native classes that may never reach
+                // this lookup. Libraries cannot expose fibers or promises through
+                // those speculative branches. Direct typed references still reach
+                // the ordinary graph-wide async_free diagnostic.
+                if (this.asyncFree && (declared?.sig.gen || declared?.sig.async)) {
+                    return [{ kind: "runtimeFence", code: "SC4005", message: `reading async or generator method '${name}' through an untyped library lookup is not supported`, loc }];
+                }
+                const generic = findGenericMethodOn(lowerer, info, name);
+                // A computed lookup has branches for every visible name. Generic
+                // methods need a concrete specialization before they can escape;
+                // refuse only if this runtime branch is selected.
+                if (generic && (!generic.info.implicitParams || !generic.declarer.decl ||
+                    lowerer.overrideBelow(info, name) || genericOverrideBelow(lowerer, info, name)))
+                    return fence();
+                const method = classMethodValue(lowerer, info.decl, info, name, loc);
+                if (method && canConvertToDyn(method.type, getRecord, getUnion)) {
+                    // A capsule may have the base ABI even when its native object is
+                    // a subclass (for example an inherited iterator returning this).
+                    // Select the method declaration at extraction, before detaching it.
+                    const overrides = [...lowerer.classes.values()].filter((candidate) => candidate !== info && lowerer.isSubclassOf(candidate.def.name, info.def.name) &&
+                        (candidate.methods.has(name) || candidate.genericMethods?.has(name)));
+                    overrides.sort((a, b) => lowerer.isSubclassOf(a.def.name, b.def.name) ? -1 : lowerer.isSubclassOf(b.def.name, a.def.name) ? 1 : 0);
+                    const body = [];
+                    if (isClassOwnEnumerableFieldName(name) && !name.startsWith("sym:")) {
+                        const prototypeMethod = lowerer.prototypeMethodAccesses.has(name);
+                        if (prototypeMethod)
+                            classPrototypeData(lowerer, info, loc, receiver);
+                        const bag = { kind: "call", callee: this.propertyBag.name,
+                            args: [lowerer.coerceToExpected(receiver, DYN)], type: DYN, loc };
+                        const key = { kind: "strLit", value: name, type: STRING, loc };
+                        body.push({ kind: "if", cond: { kind: "libCall", fn: "dyn.hasKey", args: [bag, key], type: BOOL, loc },
+                            then: [{ kind: "return", value: { kind: "dynKeyGet", value: bag, key, type: DYN, loc }, loc }], else_: null, loc });
+                        if (prototypeMethod) {
+                            body.push({ kind: "return", value: dynUndefinedExpr(loc), loc });
+                            return body;
+                        }
+                    }
+                    for (const candidate of overrides) {
+                        const selected = classMethodValue(lowerer, info.decl, candidate, name, loc);
+                        const branch = selected && canConvertToDyn(selected.type, getRecord, getUnion)
+                            ? [{ kind: "return", value: { kind: "dynFrom", value: selected, type: DYN, loc }, loc }]
+                            : fence();
+                        body.push({ kind: "if", cond: { kind: "instanceOf", value: receiver, className: candidate.def.name, type: BOOL, loc }, then: branch, else_: null, loc });
+                    }
+                    body.push({ kind: "return", value: { kind: "dynFrom", value: method, type: DYN, loc }, loc });
+                    return body;
+                }
+            }
+            if (!field && !accessor)
+                return [{ kind: "return", value: dynUndefinedExpr(loc), loc }];
+            const type = field ?? accessor.sig.ret;
+            if (!canConvertToDyn(type, getRecord, getUnion))
+                return fence();
+            const value = field
+                ? { kind: "fieldGet", obj: receiver, className: info.def.name, field: name, type, loc }
+                : accessorCall(lowerer, info.def.name, member, receiver, [], type, loc);
+            const boxed = lowerer.coerceToExpected(value, DYN);
+            const mutable = (t) => streamTypedRefEligible(t) ||
+                (t.kind === "union" && (getUnion(t.unionId)?.arms.some(mutable) ?? false));
+            if (boxed.kind === "dynFrom" && mutable(boxed.value.type))
+                boxed.liveRef = true;
+            if (accessor) {
+                const bag = { kind: "call", callee: this.propertyBag.name,
+                    args: [lowerer.coerceToExpected(receiver, DYN)], type: DYN, loc };
+                const key = { kind: "strLit", value: name, type: STRING, loc };
+                return [{ kind: "if", cond: { kind: "libCall", fn: "dyn.hasOwn", args: [bag, key], type: BOOL, loc },
+                        then: [{ kind: "return", value: { kind: "dynKeyGet", value: bag, key, type: DYN, loc }, loc }], else_: null, loc },
+                    { kind: "return", value: boxed, loc }];
+            }
+            return [{ kind: "return", value: boxed, loc }];
+        }
+        if (!field && !accessor && isClassOwnEnumerableFieldName(name) && !name.startsWith("sym:") && !findMethodOn(lowerer, info, `get:${name}`)) {
+            const bag = { kind: "call", callee: this.propertyBag.name,
+                args: [lowerer.coerceToExpected(receiver, DYN)], type: DYN, loc };
+            return [{ kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.keySet", args: [bag,
+                            { kind: "strLit", value: name, type: STRING, loc }, varRef("p.1", DYN, loc)], type: VOID, loc }, loc },
+                { kind: "return", value: null, loc }];
+        }
+        if (!field && !accessor)
+            return [{ kind: "throw", value: {
+                        kind: "libCall", fn: "error.new", args: [{
+                                kind: "strLit", value: `Cannot set property ${name} of #<${info.def.jsName ?? info.def.name}> which has only a getter`, type: STRING, loc,
+                            }], type: { kind: "object", className: "%TypeError" }, loc,
+                    }, loc }];
+        const type = field ?? accessor.sig.params[0].type;
+        const checkable = (t) => isDynTypedRefType(t) || isUnitType(t) ||
+            (t.kind === "union" ? getUnion(t.unionId)?.arms.every(checkable) ?? false : canDynCheckTo(t, getRecord, getUnion));
+        if (!checkable(type))
+            return fence();
+        const value = lowerer.coerceToExpected(varRef("p.1", DYN, loc), type);
+        if (!typeEquals(value.type, type))
+            return fence();
+        const store = field
+            ? { kind: "fieldSet", obj: receiver, className: info.def.name, field: name, value, loc }
+            : { kind: "exprStmt", expr: accessorCall(lowerer, info.def.name, member, receiver, [value], VOID, loc), loc };
+        return [store, { kind: "return", value: null, loc }];
+    }
+    methodBody(lowerer, dispatch, info, receiver) {
+        const { method, loc } = dispatch.source;
+        const fence = () => [{ kind: "runtimeFence", code: "SC2020", message: `calling '${method}' on this native class through an untyped value is not supported yet`, loc }];
+        if (info.builtinStream) {
+            const incoming = dispatch.source.args.map((_, i) => varRef(`p.${i + 1}`, DYN, loc));
+            const registering = ["on", "addListener", "once", "prependListener", "prependOnceListener"].includes(method);
+            const removing = method === "off" || method === "removeListener";
+            const ret = (value) => [{ kind: "return", value: lowerer.coerceToExpected(value, DYN), loc }];
+            if (registering || removing) {
+                if (incoming.length < 2)
+                    return fence();
+                const event = lowerer.coerceToExpected(incoming[0], STRING);
+                const cb = incoming[1];
+                return [{ kind: "exprStmt", expr: { kind: "libCall", fn: "emitter.checkListener", args: [cb], type: VOID, loc }, loc }, ...ret({ kind: "libCall", fn: registering ? "stream.onDyn" : "emitter.offDyn", args: [receiver, event, cb, ...(registering ? [
+                                { kind: "boolLit", value: method === "once" || method === "prependOnceListener", type: BOOL, loc },
+                                { kind: "boolLit", value: method.startsWith("prepend"), type: BOOL, loc },
+                            ] : [])], type: receiver.type, loc })];
+            }
+            if (method === "read")
+                return ret({ kind: "libCall", fn: "readable.readDyn", args: [receiver, incoming[0] ?? dynUndefinedExpr(loc)], type: DYN, loc });
+            if (method === "pause" || method === "resume" || method === "isPaused")
+                return ret({ kind: "libCall", fn: method === "pause" ? "readable.pause" : method === "resume" ? "readable.resume" : "readable.isPaused", args: [receiver], type: method === "isPaused" ? BOOL : receiver.type, loc });
+            if (method === "destroy" && (!incoming.length || incoming[0]?.kind === "unitLit"))
+                return ret({ kind: "libCall", fn: "stream.destroy", args: [receiver], type: receiver.type, loc });
+            return fence();
+        }
+        const methodInfo = findMethodOn(lowerer, info, method);
+        if (this.asyncFree && (methodInfo?.sig.gen || methodInfo?.sig.async)) {
+            return [{ kind: "runtimeFence", code: "SC4005", message: `calling async or generator method '${method}' through an untyped library value is not supported`, loc }];
+        }
+        if (methodInfo?.declarer.builtinError && method === "toString") {
+            return [{ kind: "return", value: { kind: "dynFrom", value: errorToStringCall(lowerer, receiver), type: DYN, loc }, loc }];
+        }
+        const generic = methodInfo ? null : findGenericMethodOn(lowerer, info, method);
+        let params;
+        let result;
+        let callee;
+        let virtual = false;
+        let owner;
+        if (methodInfo) {
+            owner = methodInfo.declarer;
+            params = methodInfo.sig.params;
+            result = methodInfo.sig.ret;
+            callee = `%${owner.def.name}.${method}`;
+            virtual = lowerer.overrideBelow(owner, method) || methodInfo.sig.abstract === true;
+        }
+        else if (generic?.info.implicitParams && generic.declarer.decl &&
+            !lowerer.overrideBelow(info, method) && !genericOverrideBelow(lowerer, info, method)) {
+            owner = generic.declarer;
+            // A failed eager specialization leaves a signature in the instance
+            // cache, but no body. Later dispatch arities must retain the fence
+            // instead of turning that cached signature into an unresolved call.
+            const instance = implicitDefaultInstance(lowerer, generic.declarer.decl, generic.info);
+            if (!lowerer.implicitFns.some((fn) => fn.name === instance.name))
+                return fence();
+            params = instance.params;
+            result = instance.returnType;
+            callee = instance.name;
+        }
+        else
+            return fence();
+        const incoming = dispatch.source.args.map((_, i) => varRef(`p.${i + 1}`, DYN, loc));
+        const args = [];
+        let index = 0;
+        for (const param of params) {
+            if ((param.mode === "dynRest" || param.mode === "arguments") && param.type.kind === "dyn") {
+                args.push({ kind: "dynArrLit", elems: param.mode === "arguments" ? incoming : incoming.slice(index), type: DYN, loc });
+                index = incoming.length;
+                continue;
+            }
+            if (param.mode === "rest" && param.type.kind === "array") {
+                const element = param.type.elem;
+                const elems = incoming.slice(index).map((value) => lowerer.coerceToExpected(value, element));
+                if (elems.some((value) => !typeEquals(value.type, element)))
+                    return fence();
+                args.push({ kind: "arrayLit", elems, type: param.type, loc });
+                index = incoming.length;
+                continue;
+            }
+            if (param.mode !== "required" && param.mode !== "omittable")
+                return fence();
+            const value = incoming[index++] ?? param.callDefault ?? dynUndefinedExpr(loc);
+            const converted = lowerer.coerceToExpected(value, param.type);
+            if (!typeEquals(converted.type, param.type))
+                return fence();
+            args.push(converted);
+        }
+        const call = virtual
+            ? { kind: "virtualCall", className: owner.def.name, method, args: [upcastTo(lowerer, receiver, owner.def.name), ...args], type: result, loc }
+            : { kind: "call", callee, args: [upcastTo(lowerer, receiver, owner.def.name), ...args], type: result, loc };
+        let body;
+        if (result.kind === "void")
+            body = [
+                { kind: "exprStmt", expr: call, loc },
+                { kind: "return", value: dynUndefinedExpr(loc), loc },
+            ];
+        else {
+            const boxed = lowerer.coerceToExpected(call, DYN);
+            if (boxed.type.kind !== "dyn")
+                return fence();
+            body = [{ kind: "return", value: boxed, loc }];
+        }
+        if (methodInfo) {
+            if (virtual)
+                lowerer.noteVirtualEdge(owner, method);
+            else
+                lowerer.noteEdge(callee);
+        }
+        if (isClassCallback(lowerer, info, method)) {
+            const descriptor = varRef("p.callback", DYN, loc);
+            body.unshift({ kind: "if", cond: { kind: "dynTest", test: "undefined", negated: true, value: descriptor, type: BOOL, loc }, then: [
+                    { kind: "return", value: { kind: "dynCall", callee: { kind: "dynKeyGet", value: descriptor,
+                                key: { kind: "strLit", value: "value", type: STRING, loc }, type: DYN, loc }, receiver: varRef("p.0", DYN, loc),
+                            args: incoming, calleeName: dispatch.source.calleeName, type: DYN, loc }, loc },
+                ], else_: null, loc });
+        }
+        return body;
+    }
+}
+//# sourceMappingURL=class-dynamic-dispatch.js.map