@scriptc/compiler 0.3.1 → 0.3.3

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

@@ -1,4 +1,5 @@
 import { dynUndefinedExpr, varRef } from "../../ir/build.js";
+import { eventTargetApiMembers, eventTargetInheritedMember } from "./lower-event-target.js";
 import { BOOL, DYN, F64, DYN_CLASS_PROPERTIES as PROPERTY_BAG, STRING, VOID, canConvertToDyn, canDynCheckTo, isClassOwnEnumerableFieldName, isDynTypedRefType, isUnitType, typeEquals, typeKey, } from "../../ir/ir.js";
 import { streamTypedRefEligible } from "../../ir/analysis.js";
 import { everyStmtList, transformExpr, transformStmtList } from "../../ir/traverse.js";
@@ -19,6 +20,7 @@ import { CaughtValueDispatch } from "./caught-value-dispatch.js";
 import { refreshDescriptorGuards } from "./class-descriptors.js";
 import { ClassConstructionDispatch } from "./class-construction.js";
 import { emitterRooted } from "./lower-event-emitter.js";
+import { protocolArm, protocolFieldArm } from "./class-protocol-dispatch.js";
 const STREAM_METHODS = new Set([
     "on",
     "addListener",
@@ -222,8 +224,10 @@ export function classPropertiesHelper(lowerer, loc, readOnly = false) {
     lowerer.liftedFns.push(helper);
     return helper;
 }
-/** A for-in presence recheck needs only the live property table, avoiding
- * value conversion or a dispatch branch for every possible member name. */
+/** A for-in presence recheck asks the live property table first, avoiding
+ * value conversion or a dispatch branch for every possible member name.
+ * Declared fields of a compiled class live in its native layout rather
+ * than that table, so a miss rechecks the instance itself. */
 export function classForInHasKey(lowerer, value, key, loc) {
     const name = "%dyn.class.forInHasKey";
     if (!lowerer.liftedFns.some((fn) => fn.name === name)) {
@@ -242,18 +246,31 @@ export function classForInHasKey(lowerer, value, key, loc) {
                 {
                     kind: "return",
                     value: {
-                        kind: "libCall",
-                        fn: "dyn.hasKey",
-                        args: [
-                            {
-                                kind: "call",
-                                callee: classPropertiesHelper(lowerer, loc).name,
-                                args: [varRef("value", DYN, loc)],
-                                type: DYN,
-                                loc,
-                            },
-                            varRef("key", STRING, loc),
-                        ],
+                        kind: "logical",
+                        op: "||",
+                        left: {
+                            kind: "libCall",
+                            fn: "dyn.hasKey",
+                            args: [
+                                {
+                                    kind: "call",
+                                    callee: classPropertiesHelper(lowerer, loc).name,
+                                    args: [varRef("value", DYN, loc)],
+                                    type: DYN,
+                                    loc,
+                                },
+                                varRef("key", STRING, loc),
+                            ],
+                            type: BOOL,
+                            loc,
+                        },
+                        right: {
+                            kind: "libCall",
+                            fn: "dyn.hasKey",
+                            args: [varRef("value", DYN, loc), varRef("key", STRING, loc)],
+                            type: BOOL,
+                            loc,
+                        },
                         type: BOOL,
                         loc,
                     },
@@ -450,6 +467,8 @@ export class ClassDynamicDispatch {
     typedPropertyBags = new Map();
     readPropertyBags = [];
     generated = new Set();
+    /** Protocol dispatch helpers and callee reads whose receivers normalize. */
+    protocols = [];
     constructDispatch = null;
     constructors = new Map();
     constructed = new Set();
@@ -463,7 +482,8 @@ export class ClassDynamicDispatch {
     prototypeIdentityClasses = new Set();
     instancePrototypes = new Map();
     checkedCasts = new Map();
-    enumeration = null;
+    /** The for-in key helpers, by libCall (dyn and native string[] keys). */
+    enumerations = new Map();
     enumerationClasses = new Set();
     process(lowerer, functions) {
         // Dispatch tables grow between worklist waves. Keep their normalization
@@ -559,6 +579,7 @@ export class ClassDynamicDispatch {
                                 expr.fn === "dyn.toString" ||
                                 expr.fn === "dyn.stringConstructor" ||
                                 expr.fn === "dyn.forInKeys" ||
+                                expr.fn === "dyn.forInKeyStrings" ||
                                 expr.fn === "dyn.hasKeyComputed" ||
                                 expr.fn === "dyn.hasOwnComputed" ||
                                 expr.fn === "dyn.propertyIsEnumerableComputed" ||
@@ -1198,27 +1219,32 @@ export class ClassDynamicDispatch {
                             loc: expr.loc,
                         };
                     }
-                    if (expr.kind === "libCall" && expr.fn === "dyn.forInKeys") {
-                        if (!this.enumeration) {
+                    if (expr.kind === "libCall" &&
+                        (expr.fn === "dyn.forInKeys" || expr.fn === "dyn.forInKeyStrings")) {
+                        let enumeration = this.enumerations.get(expr.fn);
+                        if (!enumeration) {
                             const loc = expr.loc;
                             const value = varRef("p.0", DYN, loc);
-                            this.enumeration = {
-                                name: "%dyn.class.forInKeys",
+                            enumeration = {
+                                name: expr.fn === "dyn.forInKeys"
+                                    ? "%dyn.class.forInKeys"
+                                    : "%dyn.class.forInKeyStrings",
                                 params: [{ localId: "p.0", name: "value", type: DYN }],
-                                returnType: DYN,
+                                returnType: expr.type,
                                 locals: [{ id: "p.0", name: "value", type: DYN, mutable: false }],
                                 body: [{ kind: "return", value: { ...expr, args: [value] }, loc }],
                                 loc,
                             };
-                            this.generated.add(this.enumeration);
-                            lowerer.liftedFns.push(this.enumeration);
+                            this.enumerations.set(expr.fn, enumeration);
+                            this.generated.add(enumeration);
+                            lowerer.liftedFns.push(enumeration);
                             changed = true;
                         }
                         return {
                             kind: "call",
-                            callee: this.enumeration.name,
+                            callee: enumeration.name,
                             args: expr.args,
-                            type: DYN,
+                            type: expr.type,
                             loc: expr.loc,
                         };
                     }
@@ -1384,7 +1410,7 @@ export class ClassDynamicDispatch {
                                     ? {
                                         ...computedProbe,
                                         fn: probe === "in"
-                                            ? "dyn.hasKey"
+                                            ? "dyn.in"
                                             : probe === "own"
                                                 ? "dyn.hasOwn"
                                                 : "dyn.propertyIsEnumerable",
@@ -2057,6 +2083,56 @@ export class ClassDynamicDispatch {
                 changed = true;
             }
         }
+        for (const dispatch of lowerer.protocolDispatches.values()) {
+            if (!this.generated.has(dispatch.fn)) {
+                this.generated.add(dispatch.fn);
+                this.protocols.push(dispatch.fn, ...(dispatch.probe ? [dispatch.probe] : []));
+            }
+            // Normalized receivers name their exact class, so one key pointer
+            // test selects an arm; any other capsule takes the fallback.
+            for (const plan of this.propertyReceivers(lowerer)) {
+                if (plan.info !== plan.capsule ||
+                    dispatch.classes.has(plan.key) ||
+                    (!dispatch.field && !candidates(dispatch.method).includes(plan.info)))
+                    continue;
+                dispatch.classes.add(plan.key);
+                const loc = dispatch.fn.loc;
+                const type = { kind: "object", className: plan.info.def.name };
+                const receiver = {
+                    kind: "dynCheck",
+                    value: varRef("p.0", DYN, loc),
+                    exact: true,
+                    type,
+                    loc,
+                };
+                const arm = dispatch.field
+                    ? protocolFieldArm(lowerer, dispatch, plan.info, receiver)
+                    : protocolArm(lowerer, dispatch, plan.info, receiver, this.asyncFree);
+                if (!arm)
+                    continue;
+                const condition = () => ({
+                    kind: "libCall",
+                    fn: "dyn.typedRefKeyIs",
+                    args: [
+                        varRef("p.0", DYN, loc),
+                        { kind: "strLit", value: typeKey(type), type: STRING, loc },
+                    ],
+                    type: BOOL,
+                    loc,
+                });
+                dispatch.fn.body.unshift({ kind: "if", cond: condition(), then: arm, else_: null, loc });
+                // The method of a native arm is never an own property, so reading
+                // it ahead of the arguments observes nothing.
+                dispatch.probe?.body.unshift({
+                    kind: "if",
+                    cond: condition(),
+                    then: [{ kind: "return", value: dynUndefinedExpr(loc), loc }],
+                    else_: null,
+                    loc,
+                });
+                changed = true;
+            }
+        }
         for (const dispatch of this.properties.values()) {
             if (!dispatch.write)
                 for (const name of this.boxedConstructors) {
@@ -2104,6 +2180,7 @@ export class ClassDynamicDispatch {
                 const { info } = plan;
                 if (!isClassOwnEnumerableFieldName(dispatch.name) ||
                     (!(info.builtinStream !== undefined && streamProperty(dispatch.name)) &&
+                        !eventTargetInheritedMember(info, dispatch.name) &&
                         !findMethodOn(lowerer, info, dispatch.name) &&
                         !findGenericMethodOn(lowerer, info, dispatch.name) &&
                         dispatch.name !== "constructor" &&
@@ -2207,7 +2284,9 @@ export class ClassDynamicDispatch {
                                 loc,
                             },
                         ];
-                    if (info.builtinStream !== undefined && streamProperty(name) && dispatch.probe)
+                    if (((info.builtinStream !== undefined && streamProperty(name)) ||
+                        eventTargetInheritedMember(info, name)) &&
+                        dispatch.probe)
                         return [
                             {
                                 kind: "return",
@@ -2413,6 +2492,10 @@ export class ClassDynamicDispatch {
                 if (info.builtinStream)
                     for (const name of [...STREAM_BOOL_PROPERTIES, ...STREAM_NUM_PROPERTIES])
                         names.add(name);
+                const inherited = eventTargetApiMembers(info);
+                if (inherited)
+                    for (const name of inherited)
+                        names.add(name);
                 for (let owner = info; owner; owner = owner.base) {
                     const methodNames = [...owner.methods.keys()];
                     if (owner.genericMethods)
@@ -2508,21 +2591,22 @@ export class ClassDynamicDispatch {
                 changed = true;
             }
         }
-        if (this.enumeration)
+        for (const [fn, enumeration] of this.enumerations)
             for (const plan of this.propertyReceivers(lowerer, false, false)) {
-                if (!plan.info.def.tracksOwnFields || this.enumerationClasses.has(plan.key))
+                const classKey = `${fn}:${plan.key}`;
+                if (!plan.info.def.tracksOwnFields || this.enumerationClasses.has(classKey))
                     continue;
-                this.enumerationClasses.add(plan.key);
-                const loc = this.enumeration.loc;
+                this.enumerationClasses.add(classKey);
+                const loc = enumeration.loc;
                 const { condition } = this.propertyReceiver(plan, loc);
                 const bag = this.readPropertyBagOrEmpty(lowerer, varRef("p.0", DYN, loc), loc);
-                this.enumeration.body.unshift({
+                enumeration.body.unshift({
                     kind: "if",
                     cond: condition,
                     then: [
                         {
                             kind: "return",
-                            value: { kind: "libCall", fn: "dyn.forInKeys", args: [bag], type: DYN, loc },
+                            value: { kind: "libCall", fn, args: [bag], type: enumeration.returnType, loc },
                             loc,
                         },
                     ],
@@ -2804,6 +2888,7 @@ export class ClassDynamicDispatch {
             ...[...this.properties.values()].map((dispatch) => dispatch.fn),
             ...[...this.computed.values()].map((dispatch) => dispatch.fn),
             ...[...this.dispatches.values()].flatMap((dispatch) => [dispatch.fn, dispatch.callback]),
+            ...this.protocols,
         ];
     }
     constructorPropertyBag(lowerer, loc) {
@@ -3134,6 +3219,48 @@ export class ClassDynamicDispatch {
     propertyBody(lowerer, dispatch, info, receiver) {
         const { name, write } = dispatch;
         const loc = dispatch.fn.loc;
+        // The inherited EventTarget/Event members of a subclass instance: the
+        // runtime's capsule view answers the accessors and method values.
+        if (eventTargetInheritedMember(info, name)) {
+            const key = { kind: "strLit", value: name, type: STRING, loc };
+            if (!write)
+                return [
+                    {
+                        kind: "return",
+                        value: {
+                            kind: "dynKeyGet",
+                            value: lowerer.coerceToExpected(receiver, DYN),
+                            key,
+                            type: DYN,
+                            loc,
+                        },
+                        loc,
+                    },
+                ];
+            if (name !== "returnValue" && name !== "cancelBubble")
+                return [
+                    {
+                        kind: "runtimeFence",
+                        code: "SC2020",
+                        message: `writing the inherited member '${name}' through an untyped value is not supported`,
+                        loc,
+                    },
+                ];
+            return [
+                {
+                    kind: "exprStmt",
+                    expr: {
+                        kind: "libCall",
+                        fn: "event.set",
+                        args: [receiver, key, varRef("p.1", DYN, loc)],
+                        type: VOID,
+                        loc,
+                    },
+                    loc,
+                },
+                { kind: "return", value: null, loc },
+            ];
+        }
         if (info.builtinStream !== undefined && streamProperty(name)) {
             if (write)
                 return [