@scriptc/compiler 0.4.3 → 0.4.5

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

@@ -1,4 +1,5 @@
 import { primitiveConstructorOr } from "./lower-exprs.js";
+import { TO_STRING_TAG_FIELD, wellKnownSymbolOfField } from "./symbol-fields.js";
 import { InternalCompilerError } from "../../errors.js";
 import { dynUndefinedExpr, helperLoc, nodeThrowExpr, varRef } from "../../ir/build.js";
 import { constructedValue } from "./constructor-returns.js";
@@ -12,7 +13,7 @@ import { PoisonError } from "./lowerer.js";
 import { erasedGenericInstance, implicitDefaultInstance } from "./generic-functions.js";
 import {} from "./call-signatures.js";
 import { accessorCall, classValueRef, findGenericMethodOn, findGenericStaticOn, findMethodOn, findStaticOn, genericOverrideBelow, upcastTo, } from "./lower-classes.js";
-import { classPrototypeData, hasClassPrototypeData, observedPrototypeMethod, reflectClassPrototype, } from "./class-prototypes.js";
+import { classPrototypeData, hasClassPrototypeData, prototypeReflectedFlag, observedPrototypeMethod, reflectClassPrototype, } from "./class-prototypes.js";
 import { perEvaluationPrivateNames } from "./private-brands.js";
 import { errorPropertyRead, errorPropertyWrite, errorToStringCall, errorToStringMethod, refreshErrorPropertyDispatch, refreshErrorMethodDispatch, } from "./error-methods.js";
 import { GeneratorDynamicDispatch } from "./generator-dynamic-dispatch.js";
@@ -94,6 +95,34 @@ const STREAM_NUM_PROPERTIES = new Set([
     "writableCorked",
 ]);
 const streamProperty = (name) => STREAM_BOOL_PROPERTIES.has(name) || STREAM_NUM_PROPERTIES.has(name);
+/** `(instance) => string`, the string a class's inherited
+ * Symbol.toStringTag getter answers, which the runtime reads for
+ * Object.prototype.toString and util.inspect of an instance seen as
+ * `unknown`. None for a class without a string getter, or whose own tag
+ * field shadows it. */
+function stringTagHelper(lowerer, info, loc) {
+    if (info.fields.has(TO_STRING_TAG_FIELD))
+        return null;
+    const getter = findMethodOn(lowerer, info, "get:sym:toStringTag");
+    if (getter?.sig.ret.kind !== "string")
+        return null;
+    const type = { kind: "object", className: info.def.name };
+    const owner = getter.declarer.def.name;
+    return {
+        name: `%class.stringTag:${info.def.name}`,
+        params: [{ localId: "this", name: "this", type }],
+        locals: [{ id: "this", name: "this", type, mutable: false }],
+        returnType: STRING,
+        body: [
+            {
+                kind: "return",
+                value: accessorCall(lowerer, owner, "get:sym:toStringTag", lowerer.upcastTo(varRef("this", type, loc), owner), [], STRING, loc),
+                loc,
+            },
+        ],
+        loc,
+    };
+}
 function symbolMemberKey(lowerer, info, name, loc) {
     if (name.startsWith("sym:"))
         return lowerer.coerceToExpected({
@@ -149,6 +178,7 @@ const KEY_CALLS = new Map([
     ["dyn.propertyIsEnumerableComputed", "any"],
     ["dyn.hasOwnComputed", "value"],
     ["dyn.keyDeleteComputed", "value"],
+    ["dyn.reflectDeleteProperty", "object"],
     ["dyn.keySetComputed", "value"],
 ]);
 export function toPrimitiveHint(expr) {
@@ -580,6 +610,111 @@ export function classForInHasKey(lowerer, value, key, loc) {
     }
     return { kind: "call", callee: name, args: [value, key], type: BOOL, loc };
 }
+/** Box class instances at their exact class. `%dyn.class.normalize` turns a
+ * capsule of a class with subclasses into a capsule of the instance's own
+ * class before any member table reads it, so every such box was followed
+ * by a second capsule. Each conversion of a value whose static class has a
+ * normalization branch now selects the exact class at the conversion, with
+ * the same tests in the same order (%dyn.class.boxExact:C), and the
+ * normalization of the resulting capsule falls through. Only JavaScript
+ * class hierarchies, whose instances live in untyped code, take the exact
+ * box. */
+export function boxClassInstancesExactly(lowerer, functions) {
+    const normalize = lowerer.liftedFnNamed("%dyn.class.normalize");
+    if (!normalize)
+        return;
+    // Static class → its constructible descendants in normalization order.
+    const branches = new Map();
+    for (const stmt of normalize.body) {
+        if (stmt.kind !== "if" || stmt.cond.kind !== "libCall" || stmt.cond.fn !== "dyn.typedRefIs")
+            continue;
+        const key = stmt.cond.args[1];
+        if (key?.kind !== "strLit" || !key.value.startsWith("object:"))
+            continue;
+        const children = [];
+        for (const inner of stmt.then) {
+            if (inner.kind !== "if" || inner.cond.kind !== "instanceOf")
+                continue;
+            children.push(inner.cond.className);
+        }
+        // TypeScript hierarchies keep their static-class capsules: their boxes
+        // are rarer, and an exact box would emit each subclass's checked view.
+        const className = key.value.slice("object:".length);
+        const decl = lowerer.classes.get(className)?.decl;
+        if (!decl || !isJsSourceFile(ts.getSourceFileOfNode(decl)))
+            continue;
+        if (children.length)
+            branches.set(className, children);
+    }
+    if (branches.size === 0)
+        return;
+    const loc = normalize.loc;
+    const helpers = new Map();
+    const helperFor = (className) => {
+        const known = helpers.get(className);
+        if (known !== undefined)
+            return known;
+        const name = `%dyn.class.boxExact:${className}`;
+        helpers.set(className, name);
+        const type = { kind: "object", className };
+        const value = varRef("value", type, loc);
+        functions.push({
+            name,
+            params: [{ localId: "value", name: "value", type }],
+            returnType: DYN,
+            locals: [{ id: "value", name: "value", type, mutable: false }],
+            body: [
+                ...branches.get(className).map((child) => ({
+                    kind: "if",
+                    cond: { kind: "instanceOf", value, className: child, type: BOOL, loc },
+                    then: [
+                        {
+                            kind: "return",
+                            value: {
+                                kind: "dynFrom",
+                                value: {
+                                    kind: "downcast",
+                                    value,
+                                    type: { kind: "object", className: child },
+                                    loc,
+                                },
+                                type: DYN,
+                                loc,
+                            },
+                            loc,
+                        },
+                    ],
+                    else_: null,
+                    loc,
+                })),
+                { kind: "return", value: { kind: "dynFrom", value, type: DYN, loc }, loc },
+            ],
+            loc,
+        });
+        return name;
+    };
+    const rewrite = (fn) => {
+        fn.body = transformStmtList(fn.body, {
+            stmt: (statement) => statement,
+            expr: (expression) => expression.kind === "dynFrom" &&
+                expression.value.type.kind === "object" &&
+                branches.has(expression.value.type.className)
+                ? {
+                    kind: "call",
+                    callee: helperFor(expression.value.type.className),
+                    args: [expression.value],
+                    type: DYN,
+                    loc: expression.loc,
+                }
+                : expression,
+        });
+    };
+    for (const fn of [...functions]) {
+        if (fn === normalize || fn.name.startsWith("%dyn.class.boxExact:"))
+            continue;
+        rewrite(fn);
+    }
+}
 /** Record field creation after the dispatch worklist closes, including writes
  * in generated member tables. Native values stay in their slots; the bag
  * owns only their property presence, attributes, and insertion position. */
@@ -1121,9 +1256,27 @@ export class ClassDynamicDispatch {
             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 (global?.type.kind === "symbol")
+                        return [{ field, globalId: global.id }];
+                    const wellKnown = wellKnownSymbolOfField(field);
+                    return wellKnown === null ? [] : [{ field, wellKnown }];
                 });
             }
+            const tagged = (current) => [
+                current,
+                ...current.subclasses.flatMap(tagged),
+            ];
+            for (const current of tagged(info)) {
+                if (current.def.stringTagHelper !== undefined)
+                    continue;
+                const fn = stringTagHelper(lowerer, current, functions[0].loc);
+                if (!fn)
+                    continue;
+                current.def.stringTagHelper = fn.name;
+                this.generated.add(fn);
+                lowerer.liftedFns.push(fn);
+                changed = true;
+            }
             if (this.prototypeHelper && !this.prototypeClasses.has(className)) {
                 this.prototypeClasses.add(className);
                 const loc = this.prototypeHelper.loc;
@@ -1462,6 +1615,15 @@ export class ClassDynamicDispatch {
                     this.deletedNames = deletedPropertyNames(lowerer.moduleOrder);
                 if (!root.base?.def.runtime && !fixedFieldFamily(root, this.deletedNames))
                     track(root);
+                // An Error family's bag records where `name` and `message` were
+                // created, which the error slots do not.
+                if (root.base?.def.name === "%Error") {
+                    const order = (current) => {
+                        current.def.errorBagOrder = true;
+                        current.subclasses.forEach(order);
+                    };
+                    order(info);
+                }
             }
             const loc = this.propertyBag.loc;
             const { receiver, condition } = this.propertyReceiver(plan, loc);
@@ -2549,15 +2711,19 @@ export class ClassDynamicDispatch {
                         };
                     }
                     const iterator = expr.kind === "libCall" &&
-                        (expr.fn === "dyn.iterator" || expr.fn === "dyn.arrayFromIterator")
+                        (expr.fn === "dyn.iterator" ||
+                            expr.fn === "dyn.arrayFromIterator" ||
+                            expr.fn === "dyn.asyncIteratorOpen")
                         ? expr
                         : null;
+                    // `for await` opens a class instance's [Symbol.asyncIterator]().
+                    const asyncOpen = iterator?.fn === "dyn.asyncIteratorOpen";
                     const invoke = iterator
                         ? {
                             kind: "dynInvoke",
                             recv: iterator.args[0],
-                            method: "sym:iterator",
-                            calleeName: "value[Symbol.iterator]",
+                            method: asyncOpen ? "sym:asyncIterator" : "sym:iterator",
+                            calleeName: asyncOpen ? "value[Symbol.asyncIterator]" : "value[Symbol.iterator]",
                             args: [],
                             type: DYN,
                             loc: iterator.loc,
@@ -3310,9 +3476,28 @@ export class ClassDynamicDispatch {
                             if (global)
                                 symbols.set(name, lowerer.coerceToExpected(varRef(global.id, global.type, loc), DYN));
                         }
+                        else if (wellKnownSymbolOfField(name) !== null) {
+                            // A field keyed by a well-known symbol (Symbol.toStringTag).
+                            symbols.set(name, {
+                                kind: "dynFrom",
+                                type: DYN,
+                                loc,
+                                value: {
+                                    kind: "libCall",
+                                    fn: "sym.wellKnown",
+                                    args: [
+                                        { kind: "strLit", value: wellKnownSymbolOfField(name), type: STRING, loc },
+                                    ],
+                                    type: SYMBOL_T,
+                                    loc,
+                                },
+                            });
+                        }
                     }
                     for (let owner = info; owner; owner = owner.base) {
-                        for (const name of [...owner.methods.keys()])
+                        for (const method of [...owner.methods.keys()]) {
+                            // Accessors key by the property they define (`get [Symbol.toStringTag]`).
+                            const name = method.startsWith("get:") || method.startsWith("set:") ? method.slice(4) : method;
                             if (name.startsWith("sym:")) {
                                 symbols.set(name, {
                                     kind: "dynFrom",
@@ -3327,6 +3512,7 @@ export class ClassDynamicDispatch {
                                     },
                                 });
                             }
+                        }
                     }
                     const branches = [];
                     if (!dispatch.write && !dispatch.reflect && !info.def.tracksOwnFields) {
@@ -3753,6 +3939,95 @@ export class ClassDynamicDispatch {
         this.generated.add(helper);
         return { kind: "call", callee: name, args: [bag, key], type: BOOL, loc };
     }
+    /** `%dyn.class.bagHasOwn`: whether an instance's property bag holds `key`
+     * as its own property. False before the instance has a bag. */
+    readBagHasOwn(lowerer, bag, key, loc) {
+        const name = "%dyn.class.bagHasOwn";
+        let helper = lowerer.liftedFnNamed(name);
+        if (!helper) {
+            const value = varRef("p.0", DYN, loc);
+            helper = {
+                name,
+                params: [
+                    { localId: "p.0", name: "bag", type: DYN },
+                    { localId: "p.1", name: "key", type: STRING },
+                ],
+                returnType: BOOL,
+                locals: [
+                    { id: "p.0", name: "bag", type: DYN, mutable: false },
+                    { id: "p.1", name: "key", type: STRING, mutable: false },
+                ],
+                body: [
+                    {
+                        kind: "if",
+                        cond: { kind: "dynTest", test: "undefined", value, type: BOOL, loc },
+                        then: [
+                            { kind: "return", value: { kind: "boolLit", value: false, type: BOOL, loc }, loc },
+                        ],
+                        else_: null,
+                        loc,
+                    },
+                    {
+                        kind: "return",
+                        value: {
+                            kind: "libCall",
+                            fn: "dyn.hasOwn",
+                            args: [value, varRef("p.1", STRING, loc)],
+                            type: BOOL,
+                            loc,
+                        },
+                        loc,
+                    },
+                ],
+                loc,
+            };
+            lowerer.liftedFns.push(helper);
+        }
+        this.generated.add(helper);
+        return { kind: "call", callee: name, args: [bag, key], type: BOOL, loc };
+    }
+    /** The `constructor` an instance of `info` inherits when it has no own
+     * one. The class's prototype view answers its own `constructor` (a
+     * replacement, or the class once reflection installed it). A view
+     * without one answers the class itself unless reflection had populated it
+     * (prototypeReflectedFlag, set when the view initializes): then the
+     * program deleted the property, and the read continues to the base
+     * class's prototype and past the last one to Object.prototype, as in
+     * Node. A prototype's own `constructor` is read with the instance
+     * `receiver` as `this`, so an accessor's getter runs on the instance. */
+    inheritedConstructor(lowerer, info, key, receiver, loc) {
+        const cls = lowerer.coerceToExpected(classValueRef(lowerer, info, info.decl), DYN);
+        const prototype = hasClassPrototypeData(info) ? classPrototypeData(lowerer, info, loc) : null;
+        if (!prototype)
+            return cls;
+        const base = info.base;
+        const read = () => ({
+            kind: "libCall",
+            fn: "dyn.reflectGet",
+            args: [prototype, lowerer.coerceToExpected(key, DYN), receiver],
+            type: DYN,
+            loc,
+        });
+        // Past the last class prototype, the read continues to Object.prototype's data property.
+        const next = base && !base.builtinError && base.decl && !base.generic && !base.localClass
+            ? this.inheritedConstructor(lowerer, base, key, receiver, loc)
+            : { kind: "dynKeyGet", value: prototype, key, type: DYN, loc };
+        return {
+            kind: "ternary",
+            cond: { kind: "libCall", fn: "dyn.hasOwn", args: [prototype, key], type: BOOL, loc },
+            then: read(),
+            else_: {
+                kind: "ternary",
+                cond: varRef(prototypeReflectedFlag(lowerer, info), BOOL, loc),
+                then: next,
+                else_: cls,
+                type: DYN,
+                loc,
+            },
+            type: DYN,
+            loc,
+        };
+    }
     /** The hints for which some boxed class declares a conversion method. A
      * string conversion calls toString first, so without a declared toString
      * or Symbol.toPrimitive it answers Object.prototype.toString's
@@ -5398,15 +5673,19 @@ export class ClassDynamicDispatch {
                 !info.localClass &&
                 !info.classDecorators) {
                 this.constructors.set(info.def.name, info);
-                const cls = lowerer.coerceToExpected(classValueRef(lowerer, info, info.decl), DYN);
                 const bag = this.branchPropertyBag(lowerer, info, receiver, false, loc);
                 const key = { kind: "strLit", value: name, type: STRING, loc };
+                // `constructor` is an own property of every class prototype, so an
+                // ancestor's prototype answers for an instance of this class only
+                // after the program deletes the class's own: the instance's own
+                // property answers, then the class's prototype (inheritedConstructor).
+                const answered = this.readBagHasOwn(lowerer, bag, key, loc);
                 return [
                     {
                         kind: "return",
                         value: {
                             kind: "ternary",
-                            cond: this.readBagHas(lowerer, "dyn.hasKey", bag, key, loc),
+                            cond: answered,
                             then: {
                                 kind: "libCall",
                                 fn: "dyn.bagGet",
@@ -5414,7 +5693,7 @@ export class ClassDynamicDispatch {
                                 type: DYN,
                                 loc,
                             },
-                            else_: cls,
+                            else_: this.inheritedConstructor(lowerer, info, key, lowerer.coerceToExpected(receiver, DYN), loc),
                             type: DYN,
                             loc,
                         },