@scriptc/compiler 0.3.2 → 0.3.4

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,8 @@ 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";
+import { STREAM_OPERATORS } from "./lower-stream.js";
 const STREAM_METHODS = new Set([
     "on",
     "addListener",
@@ -465,6 +468,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();
@@ -956,8 +961,12 @@ export class ClassDynamicDispatch {
                     return [];
                 if (emitterRooted(lowerer, info) && EMITTER_METHODS.has(method))
                     return [info];
-                if (info.builtinStream)
-                    return STREAM_METHODS.has(method) ? [info] : [];
+                if (info.builtinStream) {
+                    return STREAM_METHODS.has(method) ||
+                        (STREAM_OPERATORS.has(method) && info.builtinStream !== "w")
+                        ? [info]
+                        : [];
+                }
                 return findMethodOn(lowerer, info, method) || findGenericMethodOn(lowerer, info, method)
                     ? [info]
                     : [];
@@ -1443,6 +1452,9 @@ export class ClassDynamicDispatch {
                                         ]
                                         : [{ kind: "return", value: fallback, loc }],
                                 loc,
+                                ...(numericKey && computedRead && !reflect && !dynamicKey
+                                    ? { fastRead: "index" }
+                                    : {}),
                             };
                             if (dynamicKey)
                                 helper.body.unshift({
@@ -1631,21 +1643,24 @@ export class ClassDynamicDispatch {
                                     loc,
                                 }
                                 : instanceBag;
+                            // A read compares the bag with the receiver and then reads it:
+                            // evaluate it once, so each read retains the receiver once.
+                            const bagRead = varRef("bag.0", DYN, loc);
                             const fallback = read
                                 ? {
                                     kind: "ternary",
                                     cond: {
                                         kind: "dynScalarEq",
-                                        left: bag,
+                                        left: bagRead,
                                         right: varRef("p.0", DYN, loc),
                                         type: BOOL,
                                         loc,
                                     },
-                                    then: { ...read, value: bag },
+                                    then: { ...read, value: bagRead },
                                     else_: {
                                         kind: "libCall",
                                         fn: "dyn.bagGet",
-                                        args: [bag, read.key, varRef("p.0", DYN, loc)],
+                                        args: [bagRead, read.key, varRef("p.0", DYN, loc)],
                                         type: DYN,
                                         loc,
                                     },
@@ -1657,18 +1672,24 @@ export class ClassDynamicDispatch {
                                 name: `%dyn.class.property.${this.properties.size}`,
                                 params,
                                 returnType: write ? VOID : DYN,
-                                locals: params.map((p) => ({
-                                    id: p.localId,
-                                    name: p.name,
-                                    type: DYN,
-                                    mutable: false,
-                                })),
+                                locals: [
+                                    ...params.map((p) => ({
+                                        id: p.localId,
+                                        name: p.name,
+                                        type: DYN,
+                                        mutable: false,
+                                    })),
+                                    ...(read ? [{ id: "bag.0", name: "bag", type: DYN, mutable: false }] : []),
+                                ],
                                 body: write
                                     ? [
                                         { kind: "exprStmt", expr: fallback, loc },
                                         { kind: "return", value: null, loc },
                                     ]
-                                    : [{ kind: "return", value: fallback, loc }],
+                                    : [
+                                        { kind: "varDecl", localId: "bag.0", init: bag, loc },
+                                        { kind: "return", value: fallback, loc },
+                                    ],
                                 loc,
                             };
                             if (!write && name === "toString" && lowerer.classes.has("%Error")) {
@@ -2079,6 +2100,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) {
@@ -2126,6 +2197,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" &&
@@ -2229,7 +2301,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",
@@ -2435,6 +2509,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)
@@ -2827,6 +2905,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) {
@@ -3157,6 +3236,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 [
@@ -3611,6 +3732,43 @@ export class ClassDynamicDispatch {
                     type: method === "isPaused" ? BOOL : receiver.type,
                     loc,
                 });
+            if (STREAM_OPERATORS.has(method) && info.builtinStream && info.builtinStream !== "w") {
+                // The Readable operators over a checked-dynamic receiver: every
+                // argument is already a checked value.
+                const arg = (i) => incoming[i] ?? dynUndefinedExpr(loc);
+                const readableT = { kind: "object", className: "%Readable" };
+                const op = (fn, args, type) => ret({ kind: "libCall", fn: fn, args: [receiver, ...args], type, loc });
+                switch (method) {
+                    case "map":
+                        return op("readable.opMap", [arg(0), arg(1)], readableT);
+                    case "filter":
+                        return op("readable.opFilter", [arg(0), arg(1)], readableT);
+                    case "flatMap":
+                        return op("readable.opFlatMap", [arg(0), arg(1)], readableT);
+                    case "drop":
+                        return op("readable.opDrop", [arg(0), arg(1)], readableT);
+                    case "take":
+                        return op("readable.opTake", [arg(0), arg(1)], readableT);
+                    case "toArray":
+                        return op("readable.opToArray", [arg(0)], { kind: "promise", inner: DYN });
+                    case "forEach":
+                        return op("readable.opForEach", [arg(0), arg(1)], { kind: "promise", inner: VOID });
+                    case "some":
+                        return op("readable.opSome", [arg(0), arg(1)], { kind: "promise", inner: BOOL });
+                    case "every":
+                        return op("readable.opEvery", [arg(0), arg(1)], { kind: "promise", inner: BOOL });
+                    case "find":
+                        return op("readable.opFind", [arg(0), arg(1)], { kind: "promise", inner: DYN });
+                    case "reduce":
+                        return op("readable.opReduce", [
+                            arg(0),
+                            arg(1),
+                            { kind: "boolLit", value: dispatch.source.args.length >= 2, type: BOOL, loc },
+                            arg(2),
+                            { kind: "numLit", value: 0, type: F64, loc },
+                        ], { kind: "promise", inner: DYN });
+                }
+            }
             if (method === "destroy" && (!incoming.length || incoming[0]?.kind === "unitLit"))
                 return ret({
                     kind: "libCall",