@scriptc/compiler 0.2.0 → 0.2.1

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

@@ -1,26 +1,48 @@
-import { BOOL, DYN, DYN_CLASS_PROPERTIES as PROPERTY_BAG, STRING, VOID, canConvertToDyn, canDynCheckTo, isClassOwnEnumerableFieldName, isDynTypedRefType, isUnitType, typeEquals, typeKey } from "../../ir/ir.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 { varRef } from "../../ir/build.js";
-import { everyStmtList, transformStmtList } from "../../ir/traverse.js";
+import { everyStmtList, transformExpr, transformStmtList } from "../../ir/traverse.js";
 import { dynUndefinedExpr, PoisonError } from "./lowerer.js";
 import { implicitDefaultInstance } from "./lower-calls.js";
-import { accessorCall, findGenericMethodOn, findMethodOn, genericOverrideBelow, upcastTo } from "./lower-classes.js";
-import { classPrototypeData, hasClassPrototypeData } from "./class-prototypes.js";
-import { errorToStringCall, errorToStringMethod, refreshErrorMethodDispatch } from "./error-methods.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";
-export function classInstanceOf(lowerer, value, info, loc) {
-    const name = `%dyn.class.instanceof:${info.def.name}`;
-    if (!lowerer.liftedFns.some((fn) => fn.name === name))
+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: [{ localId: "value", name: "value", type: DYN }], returnType: BOOL,
-            locals: [{ id: "value", name: "value", type: DYN, mutable: false }],
-            body: [{ kind: "return", value: { kind: "boolLit", value: false, type: BOOL, loc }, loc }], loc,
+            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], type: BOOL, loc };
+    }
+    return { kind: "call", callee: name, args: [value, ...(classValue ? [classValue] : [])], type: BOOL, loc };
 }
 export function classPropertiesHelper(lowerer, loc) {
     const name = "%dyn.class.properties";
@@ -45,7 +67,9 @@ export class ClassDynamicDispatch {
         this.asyncFree = asyncFree;
     }
     generatorDispatch = new GeneratorDynamicDispatch();
+    constructionDispatch = new ClassConstructionDispatch();
     boxed = new Set();
+    boxedConstructors = new Set();
     dispatches = new Map();
     properties = new Map();
     computed = new Map();
@@ -55,10 +79,20 @@ export class ClassDynamicDispatch {
     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) => {
@@ -66,8 +100,12 @@ export class ClassDynamicDispatch {
             if (seenTypes.has(key))
                 return;
             seenTypes.add(key);
-            if (isDynTypedRefType(type))
-                this.boxed.add(type.className);
+            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") {
@@ -100,8 +138,8 @@ export class ClassDynamicDispatch {
                             rewrite.add(fn);
                             break;
                         case "libCall":
-                            if (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")
+                            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;
                     }
@@ -111,9 +149,9 @@ export class ClassDynamicDispatch {
         if (this.boxed.size === 0 && rewrite.size === 0)
             return changed;
         for (const fn of functions) {
-            if (!fn.name.startsWith("%dyn.class.instanceof:"))
+            if (!fn.name.startsWith("%dyn.class.instanceof:") && !fn.name.startsWith("%dyn.class.valueInstanceof:"))
                 continue;
-            const target = fn.name.slice("%dyn.class.instanceof:".length);
+            const target = fn.name.slice(fn.name.indexOf(":") + 1);
             let checked = this.instanceTests.get(fn.name);
             if (!checked) {
                 checked = new Set();
@@ -129,8 +167,10 @@ export class ClassDynamicDispatch {
                 const loc = fn.loc;
                 const value = varRef("value", DYN, loc);
                 const type = { kind: "object", className };
-                const result = subtype ? { kind: "boolLit", value: true, type: BOOL, loc }
-                    : { kind: "instanceOf", value: { kind: "dynCheck", value, type, loc }, className: target, type: BOOL, loc };
+                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;
@@ -145,33 +185,120 @@ export class ClassDynamicDispatch {
             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" && hasClassPrototypeData(info)) {
-                    const prototype = classPrototypeData(lowerer, info, existingInit.loc, existingInit.obj);
+                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(className))
+            if (this.bagClasses.has(plan.key))
                 continue;
-            this.bagClasses.add(className);
+            this.bagClasses.add(plan.key);
             this.ensurePropertyBag(info);
             const loc = this.propertyBag.loc;
-            const type = { kind: "object", className };
-            const value = varRef("p.0", DYN, loc);
-            const receiver = { kind: "dynCheck", value, type, loc };
+            const { receiver, condition } = this.propertyReceiver(plan, loc);
             const bag = { kind: "fieldGet", obj: receiver, className, field: PROPERTY_BAG, type: DYN, loc };
-            const prototype = hasClassPrototypeData(info) ? classPrototypeData(lowerer, info, loc, receiver) : null;
+            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,
             };
-            this.bagInitializers.set(className, [initialize]);
+            const initializers = this.bagInitializers.get(className) ?? [];
+            initializers.push(initialize);
+            this.bagInitializers.set(className, initializers);
             this.propertyBag.body.unshift({
-                kind: "if", cond: { kind: "libCall", fn: "dyn.typedRefIs", args: [value, { kind: "strLit", value: typeKey(type), type: STRING, loc }], type: BOOL, loc },
+                kind: "if", cond: condition,
                 then: [
                     { kind: "if", cond: { kind: "dynTest", test: "undefined", value: bag, type: BOOL, loc }, then: [
                             initialize,
@@ -181,6 +308,7 @@ export class ClassDynamicDispatch {
             });
             changed = true;
         }
+        refreshDescriptorGuards(lowerer);
         const byMethod = new Map();
         const candidates = (method) => {
             const found = byMethod.get(method);
@@ -188,8 +316,10 @@ export class ClassDynamicDispatch {
                 return found;
             const matching = [...this.boxed].flatMap((name) => {
                 const info = lowerer.classes.get(name);
-                if (!info || info.fields.has(method) || info.builtinEmitter || info.builtinStream || info.builtinError)
+                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);
@@ -204,6 +334,18 @@ export class ClassDynamicDispatch {
             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);
@@ -239,6 +381,43 @@ export class ClassDynamicDispatch {
                             }
                         }
                     }
+                    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;
@@ -385,11 +564,16 @@ export class ClassDynamicDispatch {
                 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: "libCall", fn: "dyn.getOwnPropertyDescriptor", args: [bag,
-                                        lowerer.coerceToExpected({ kind: "strLit", value: dispatch.source.method, type: STRING, loc }, DYN)], type: DYN, loc }, loc }], else_: null, 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;
@@ -413,11 +597,27 @@ export class ClassDynamicDispatch {
             }
         }
         for (const dispatch of this.properties.values()) {
-            for (const plan of this.propertyReceivers(lowerer)) {
+            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.fields.has(dispatch.name) && !findMethodOn(lowerer, info, `get:${dispatch.name}`) && !findMethodOn(lowerer, info, `set:${dispatch.name}`) &&
-                        !findMethodOn(lowerer, info, dispatch.name) && !findGenericMethodOn(lowerer, info, 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;
@@ -444,16 +644,37 @@ export class ClassDynamicDispatch {
             }
         }
         for (const dispatch of this.computed.values()) {
-            for (const plan of this.propertyReceivers(lowerer)) {
+            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) => dispatch.probe
-                    ? [{ kind: "return", value: { kind: "boolLit", value: info.fields.has(name) || dispatch.probe === "in", type: BOOL, loc }, loc }]
-                    : this.propertyBody(lowerer, { ...dispatch, name }, info, receiver);
+                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 = [];
@@ -480,6 +701,16 @@ export class ClassDynamicDispatch {
                             }
                     }
                     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;
@@ -504,6 +735,9 @@ export class ClassDynamicDispatch {
                     }
                 }
                 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)
@@ -533,16 +767,71 @@ export class ClassDynamicDispatch {
                             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 });
                 }
-                dispatch.fn.body.splice(dispatch.branchIndex, 0, { kind: "if", cond: condition, then: branch, 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;
@@ -551,11 +840,8 @@ export class ClassDynamicDispatch {
             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 info = lowerer.classes.get(type.className);
-        const prototype = hasClassPrototypeData(info) ? classPrototypeData(lowerer, info, loc, receiver) : null;
-        const initialize = { ...initializers[0], obj: receiver, value: prototype
-                ? { kind: "libCall", fn: "dyn.objCreate", args: [prototype], type: DYN, loc }
-                : { kind: "dynObjLit", fields: [], type: DYN, loc }, 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,
@@ -592,11 +878,11 @@ export class ClassDynamicDispatch {
     }
     /** 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) {
+    propertyReceivers(lowerer, streams = false) {
         const plans = [];
         for (const name of this.boxed) {
             const capsule = lowerer.classes.get(name);
-            if (!capsule || capsule.builtinEmitter || capsule.builtinStream || capsule.builtinError)
+            if (!capsule || capsule.builtinEmitter || capsule.builtinStream && !streams || capsule.builtinError)
                 continue;
             const visit = (info) => {
                 plans.push({ info, capsule, key: JSON.stringify([name, info.def.name]) });
@@ -624,6 +910,15 @@ export class ClassDynamicDispatch {
     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);
@@ -631,6 +926,14 @@ export class ClassDynamicDispatch {
         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 }];
             }
@@ -659,6 +962,20 @@ export class ClassDynamicDispatch {
                         (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)
@@ -683,8 +1000,23 @@ export class ClassDynamicDispatch {
                 (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: [{
@@ -707,6 +1039,29 @@ export class ClassDynamicDispatch {
     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 }];