@scriptc/compiler 0.2.9 → 0.3.0

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

@@ -164,8 +164,36 @@ export function classInstanceOf(lowerer, value, info, loc, classValue) {
         loc,
     };
 }
+const READ_PROPERTIES = "%dyn.class.readProperties";
+const READ_PROPERTIES_OR_EMPTY = "%dyn.class.readPropertiesOrEmpty";
+function isEmptyBag(value) {
+    return value.kind === "dynObjLit" && value.fields?.length === 0;
+}
+/** The property-bag dispatch's class branches without their lazy stores:
+ * `if (bag === undefined) bag = init` becomes `return init` (not stored), or
+ * nothing for an empty bag unless `orEmpty` asks for a fresh empty object. */
+function readOnlyBagBody(body, orEmpty = false) {
+    for (const branch of body) {
+        if (branch.kind !== "if")
+            continue;
+        const absent = branch.then[0];
+        const store = absent?.kind === "if" ? absent.then[0] : undefined;
+        if (absent?.kind !== "if" ||
+            absent.cond.kind !== "dynTest" ||
+            absent.cond.test !== "undefined" ||
+            absent.then.length !== 1 ||
+            store?.kind !== "fieldSet" ||
+            store.field !== PROPERTY_BAG)
+            continue;
+        if (isEmptyBag(store.value) && !orEmpty)
+            branch.then.shift();
+        else
+            absent.then = [{ kind: "return", value: store.value, loc: store.loc }];
+    }
+    return body;
+}
 export function classPropertiesHelper(lowerer, loc, readOnly = false) {
-    const name = readOnly ? "%dyn.class.readProperties" : "%dyn.class.properties";
+    const name = readOnly ? READ_PROPERTIES : "%dyn.class.properties";
     const existing = lowerer.liftedFns.find((fn) => fn.name === name);
     if (existing)
         return existing;
@@ -1329,13 +1357,15 @@ export class ClassDynamicDispatch {
                                 ...(reflect ? [{ localId: "p.reflectReceiver", name: "receiver", 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 bag = computedWrite
+                                ? {
+                                    kind: "call",
+                                    callee: this.propertyBag.name,
+                                    args: [varRef("p.0", DYN, loc)],
+                                    type: DYN,
+                                    loc,
+                                }
+                                : this.readPropertyBagOrEmpty(lowerer, varRef("p.0", DYN, loc), loc);
                             const reflectionFallback = (target, property) => ({
                                 kind: "libCall",
                                 fn: computedWrite ? "dyn.reflectSet" : "dyn.reflectGet",
@@ -1561,13 +1591,15 @@ export class ClassDynamicDispatch {
                                 name: `p${i}`,
                                 type: DYN,
                             }));
-                            const instanceBag = {
-                                kind: "call",
-                                callee: this.propertyBag.name,
-                                args: [varRef("p.0", DYN, loc)],
-                                type: DYN,
-                                loc,
-                            };
+                            const instanceBag = read
+                                ? this.readPropertyBagOrEmpty(lowerer, varRef("p.0", DYN, loc), loc)
+                                : {
+                                    kind: "call",
+                                    callee: this.propertyBag.name,
+                                    args: [varRef("p.0", DYN, loc)],
+                                    type: DYN,
+                                    loc,
+                                };
                             const bag = read && !["name", "length", "apply"].includes(name)
                                 ? {
                                     kind: "call",
@@ -1953,13 +1985,7 @@ export class ClassDynamicDispatch {
                     const prototypeMethod = lowerer.prototypeMethodAccesses.has(dispatch.source.method);
                     if (prototypeMethod)
                         classPrototypeData(lowerer, info, loc);
-                    const bag = {
-                        kind: "call",
-                        callee: this.propertyBag.name,
-                        args: [value],
-                        type: DYN,
-                        loc,
-                    };
+                    const bag = this.readPropertyBagOrEmpty(lowerer, value, loc);
                     dispatch.callback.body.unshift({
                         kind: "if",
                         cond: condition,
@@ -2196,13 +2222,7 @@ export class ClassDynamicDispatch {
                     const prototypeMethod = lowerer.prototypeMethodAccesses.has(name);
                     if (info.fields.has(name) || (dispatch.probe === "in" && !prototypeMethod)) {
                         if (info.fields.has(name) && info.def.tracksOwnFields) {
-                            const bag = {
-                                kind: "call",
-                                callee: this.propertyBag.name,
-                                args: [lowerer.coerceToExpected(receiver, DYN)],
-                                type: DYN,
-                                loc,
-                            };
+                            const bag = this.readPropertyBagOrEmpty(lowerer, lowerer.coerceToExpected(receiver, DYN), loc);
                             const symbol = symbolMemberKey(lowerer, info, name, loc);
                             const fn = dispatch.probe === "in"
                                 ? "dyn.hasKey"
@@ -2229,13 +2249,7 @@ export class ClassDynamicDispatch {
                     }
                     if (prototypeMethod)
                         classPrototypeData(lowerer, info, loc, receiver);
-                    const bag = {
-                        kind: "call",
-                        callee: this.propertyBag.name,
-                        args: [lowerer.coerceToExpected(receiver, DYN)],
-                        type: DYN,
-                        loc,
-                    };
+                    const bag = this.readPropertyBagOrEmpty(lowerer, lowerer.coerceToExpected(receiver, DYN), loc);
                     const symbol = name.startsWith("sym:") || name.startsWith("%symbol:");
                     const fn = dispatch.probe === "in"
                         ? "dyn.hasKey"
@@ -2301,13 +2315,7 @@ export class ClassDynamicDispatch {
                     if (!dispatch.write && !dispatch.reflect && !info.def.tracksOwnFields) {
                         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,
-                        };
+                        const bag = this.readPropertyBagOrEmpty(lowerer, value, loc);
                         branches.push({
                             kind: "if",
                             cond: {
@@ -2507,13 +2515,7 @@ export class ClassDynamicDispatch {
                 this.enumerationClasses.add(plan.key);
                 const loc = this.enumeration.loc;
                 const { condition } = this.propertyReceiver(plan, loc);
-                const bag = {
-                    kind: "call",
-                    callee: this.propertyBag.name,
-                    args: [varRef("p.0", DYN, loc)],
-                    type: DYN,
-                    loc,
-                };
+                const bag = this.readPropertyBagOrEmpty(lowerer, varRef("p.0", DYN, loc), loc);
                 this.enumeration.body.unshift({
                     kind: "if",
                     cond: condition,
@@ -2624,6 +2626,95 @@ export class ClassDynamicDispatch {
             fn.speculativeDispatch = true;
         return changed;
     }
+    /** The receiver's own dynamic properties for a read: undefined while it has
+     * none, and never stored, so reads stay valid on published objects. */
+    readPropertyBag(lowerer, receiver, loc) {
+        const helper = classPropertiesHelper(lowerer, loc, true);
+        this.generated.add(helper);
+        return {
+            kind: "call",
+            callee: helper.name,
+            args: [receiver.type.kind === "dyn" ? receiver : lowerer.coerceToExpected(receiver, DYN)],
+            type: DYN,
+            loc,
+        };
+    }
+    /** The bag a read looks a key up in (`%dyn.class.readPropertiesOrEmpty`):
+     * the receiver's own properties, or a fresh empty object (not stored) while
+     * an instance has none, so inherited Object.prototype members still resolve
+     * as on an empty bag. A non-instance is its own bag; an undefined receiver
+     * stays undefined so the read throws Node's TypeError. */
+    /** A key test on a read-only bag, which is undefined while the object has no
+     * own dynamic properties. A shared helper evaluates the bag once and keeps
+     * each class branch as small as the storing form. */
+    readBagHas(lowerer, fn, bag, key, loc) {
+        const name = fn === "dyn.hasKey" ? "%dyn.class.bagHas" : "%dyn.class.bagHasComputed";
+        let helper = lowerer.liftedFns.find((item) => item.name === name);
+        if (!helper) {
+            const keyType = fn === "dyn.hasKey" ? STRING : DYN;
+            const value = varRef("p.0", DYN, loc);
+            helper = {
+                name,
+                params: [
+                    { localId: "p.0", name: "bag", type: DYN },
+                    { localId: "p.1", name: "key", type: keyType },
+                ],
+                returnType: BOOL,
+                locals: [
+                    { id: "p.0", name: "bag", type: DYN, mutable: false },
+                    { id: "p.1", name: "key", type: keyType, 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,
+                            args: [value, varRef("p.1", keyType, 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 };
+    }
+    readPropertyBagOrEmpty(lowerer, receiver, loc) {
+        // One call per read site: large JS programs have a branch per class and
+        // property, so the absent-bag handling lives in the shared helper.
+        let helper = lowerer.liftedFns.find((fn) => fn.name === READ_PROPERTIES_OR_EMPTY);
+        if (!helper) {
+            // Settled by finalize; until then, the read-only bag's own dispatch.
+            helper = {
+                ...classPropertiesHelper(lowerer, loc, true),
+                name: READ_PROPERTIES_OR_EMPTY,
+            };
+            helper = structuredClone(helper);
+            lowerer.liftedFns.push(helper);
+        }
+        this.generated.add(helper);
+        return {
+            kind: "call",
+            callee: helper.name,
+            args: [receiver.type.kind === "dyn" ? receiver : lowerer.coerceToExpected(receiver, DYN)],
+            type: DYN,
+            loc,
+        };
+    }
     /** 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. */
@@ -2684,13 +2775,27 @@ export class ClassDynamicDispatch {
         lowerer.liftedFns.push(helper);
         return helper;
     }
-    /** Prototype state may appear in a later reachable body. Only after the
-     * dispatch worklist closes can an empty bag initializer be omitted; a
-     * prototype-backed bag must still be initialized before inherited reads. */
-    finalize() {
+    /** Prototype state may appear in a later reachable body, so read-only bags
+     * settle only after the dispatch worklist closes. A read never stores: an
+     * absent empty bag stays undefined (callers test it), and an absent
+     * prototype-backed bag is produced for this read only. A published object
+     * cannot take the store, and Node's reads never write. */
+    finalize(lowerer) {
         for (const { helper, initialize } of this.readPropertyBags) {
-            if (initialize.value.kind === "dynObjLit" && initialize.value.fields?.length === 0)
+            const absent = helper.body[0];
+            if (isEmptyBag(initialize.value))
                 helper.body.shift();
+            else if (absent?.kind === "if")
+                absent.then = [{ kind: "return", value: initialize.value, loc: initialize.loc }];
+        }
+        // The untyped read-only accessor selects the receiver's class as the
+        // complete property-bag dispatch does, without its lazy stores.
+        for (const fn of lowerer?.liftedFns ?? []) {
+            if (!this.propertyBag ||
+                (fn.name !== READ_PROPERTIES && fn.name !== READ_PROPERTIES_OR_EMPTY))
+                continue;
+            fn.locals = structuredClone(this.propertyBag.locals);
+            fn.body = readOnlyBagBody(structuredClone(this.propertyBag.body), fn.name === READ_PROPERTIES_OR_EMPTY);
         }
     }
     normalizedDispatches() {
@@ -3089,20 +3194,14 @@ export class ClassDynamicDispatch {
                 !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 bag = this.readPropertyBag(lowerer, receiver, 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 },
+                            cond: this.readBagHas(lowerer, "dyn.hasKey", bag, key, loc),
                             then: {
                                 kind: "libCall",
                                 fn: "dyn.bagGet",
@@ -3167,23 +3266,12 @@ export class ClassDynamicDispatch {
                         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,
-                        };
+                        // Selecting the method must not give the object own storage.
+                        const bag = this.readPropertyBag(lowerer, receiver, loc);
                         const key = symbol ?? { kind: "strLit", value: name, type: STRING, loc };
                         body.push({
                             kind: "if",
-                            cond: {
-                                kind: "libCall",
-                                fn: symbol ? "dyn.hasOwnComputed" : "dyn.hasKey",
-                                args: [bag, key],
-                                type: BOOL,
-                                loc,
-                            },
+                            cond: this.readBagHas(lowerer, symbol ? "dyn.hasOwnComputed" : "dyn.hasKey", bag, key, loc),
                             then: [
                                 {
                                     kind: "return",
@@ -3240,13 +3328,7 @@ export class ClassDynamicDispatch {
             }
             if (!field && !accessor) {
                 const instance = lowerer.coerceToExpected(receiver, DYN);
-                const bag = {
-                    kind: "call",
-                    callee: this.propertyBag.name,
-                    args: [instance],
-                    type: DYN,
-                    loc,
-                };
+                const bag = this.readPropertyBagOrEmpty(lowerer, instance, loc);
                 return [
                     {
                         kind: "return",
@@ -3273,13 +3355,7 @@ export class ClassDynamicDispatch {
             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 bag = this.readPropertyBagOrEmpty(lowerer, lowerer.coerceToExpected(receiver, DYN), loc);
                 const key = { kind: "strLit", value: name, type: STRING, loc };
                 return [
                     {
@@ -3306,13 +3382,7 @@ export class ClassDynamicDispatch {
             }
             if (field && info.def.tracksOwnFields) {
                 const instance = lowerer.coerceToExpected(receiver, DYN);
-                const bag = {
-                    kind: "call",
-                    callee: this.propertyBag.name,
-                    args: [instance],
-                    type: DYN,
-                    loc,
-                };
+                const bag = this.readPropertyBagOrEmpty(lowerer, instance, loc);
                 const symbol = symbolMemberKey(lowerer, info, name, loc);
                 const key = symbol ?? { kind: "strLit", value: name, type: STRING, loc };
                 return [