@scriptc/compiler 0.3.3 → 0.3.5

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

@@ -21,6 +21,7 @@ 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",
@@ -231,6 +232,45 @@ export function classPropertiesHelper(lowerer, loc, readOnly = false) {
 export function classForInHasKey(lowerer, value, key, loc) {
     const name = "%dyn.class.forInHasKey";
     if (!lowerer.liftedFns.some((fn) => fn.name === name)) {
+        // The read-only table: a recheck never creates an instance's table, which
+        // is undefined while the instance has no own dynamic properties.
+        const bagHas = "%dyn.class.forInBagHas";
+        const bag = varRef("bag", DYN, loc);
+        lowerer.liftedFns.push({
+            name: bagHas,
+            params: [
+                { localId: "bag", name: "bag", type: DYN },
+                { localId: "key", name: "key", type: STRING },
+            ],
+            returnType: BOOL,
+            locals: [
+                { id: "bag", name: "bag", type: DYN, mutable: false },
+                { id: "key", name: "key", type: STRING, mutable: false },
+            ],
+            body: [
+                {
+                    kind: "if",
+                    cond: { kind: "dynTest", test: "undefined", value: bag, 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.hasKey",
+                        args: [bag, varRef("key", STRING, loc)],
+                        type: BOOL,
+                        loc,
+                    },
+                    loc,
+                },
+            ],
+            loc,
+        });
         lowerer.liftedFns.push({
             name,
             params: [
@@ -249,12 +289,12 @@ export function classForInHasKey(lowerer, value, key, loc) {
                         kind: "logical",
                         op: "||",
                         left: {
-                            kind: "libCall",
-                            fn: "dyn.hasKey",
+                            kind: "call",
+                            callee: bagHas,
                             args: [
                                 {
                                     kind: "call",
-                                    callee: classPropertiesHelper(lowerer, loc).name,
+                                    callee: classPropertiesHelper(lowerer, loc, true).name,
                                     args: [varRef("value", DYN, loc)],
                                     type: DYN,
                                     loc,
@@ -960,8 +1000,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]
                     : [];
@@ -1365,6 +1409,17 @@ export class ClassDynamicDispatch {
                         const numericKey = sourceKey.type.kind === "f64" ||
                             (sourceKey.kind === "dynFrom" && sourceKey.value.type.kind === "f64") ||
                             (sourceKey.kind === "toString" && sourceKey.operand.type.kind === "f64");
+                        // `value[i]` with a number `i`: the helper takes the number and
+                        // reads a dense checked array element directly, formatting the
+                        // property name only when that does not apply.
+                        const indexKey = computedRead &&
+                            !reflect &&
+                            !dynamicKey &&
+                            !computedRead.optional &&
+                            computedRead.key.kind === "toString" &&
+                            computedRead.key.operand.type.kind === "f64"
+                            ? computedRead.key
+                            : null;
                         const key = JSON.stringify([
                             !!computedWrite,
                             computedRead?.optional ?? false,
@@ -1372,13 +1427,16 @@ export class ClassDynamicDispatch {
                             probe,
                             numericKey,
                             reflect,
+                            !!indexKey,
                         ]);
                         let dispatch = this.computed.get(key);
                         if (!dispatch) {
                             const loc = expr.loc;
                             const params = [
                                 { localId: "p.0", name: "value", type: DYN },
-                                { localId: "p.key", name: "key", type: dynamicKey ? DYN : STRING },
+                                indexKey
+                                    ? { localId: "p.index", name: "index", type: F64 }
+                                    : { localId: "p.key", name: "key", type: dynamicKey ? DYN : STRING },
                                 ...(computedWrite ? [{ localId: "p.1", name: "stored", type: DYN }] : []),
                                 ...(reflect ? [{ localId: "p.reflectReceiver", name: "receiver", type: DYN }] : []),
                             ];
@@ -1434,7 +1492,7 @@ export class ClassDynamicDispatch {
                                         type: p.type,
                                         mutable: false,
                                     })),
-                                    ...(dynamicKey
+                                    ...(dynamicKey || indexKey
                                         ? [{ id: keyLocal, name: "key", type: STRING, mutable: false }]
                                         : []),
                                 ],
@@ -1447,6 +1505,9 @@ export class ClassDynamicDispatch {
                                         ]
                                         : [{ kind: "return", value: fallback, loc }],
                                 loc,
+                                ...(numericKey && computedRead && !reflect && !dynamicKey
+                                    ? { fastRead: "index" }
+                                    : {}),
                             };
                             if (dynamicKey)
                                 helper.body.unshift({
@@ -1570,13 +1631,81 @@ export class ClassDynamicDispatch {
                                     },
                                     loc,
                                 });
+                            if (indexKey) {
+                                // An integer index below a checked array's length names an
+                                // element (-0 included: its property name is "0"); dyn.arrLen
+                                // answers 0 for every other kind. Holes keep dyn.arrAt's
+                                // ordinary named lookup.
+                                const index = varRef("p.index", F64, loc);
+                                const elementRead = {
+                                    kind: "if",
+                                    cond: { kind: "libCall", fn: "number.isInteger", args: [index], type: BOOL, loc },
+                                    then: [
+                                        {
+                                            kind: "if",
+                                            cond: {
+                                                kind: "bin",
+                                                op: ">=",
+                                                left: index,
+                                                right: { kind: "numLit", value: 0, type: F64, loc },
+                                                type: BOOL,
+                                                loc,
+                                            },
+                                            then: [
+                                                {
+                                                    kind: "if",
+                                                    cond: {
+                                                        kind: "bin",
+                                                        op: "<",
+                                                        left: index,
+                                                        right: {
+                                                            kind: "libCall",
+                                                            fn: "dyn.arrLen",
+                                                            args: [varRef("p.0", DYN, loc)],
+                                                            type: F64,
+                                                            loc,
+                                                        },
+                                                        type: BOOL,
+                                                        loc,
+                                                    },
+                                                    then: [
+                                                        {
+                                                            kind: "return",
+                                                            value: {
+                                                                kind: "libCall",
+                                                                fn: "dyn.arrAt",
+                                                                args: [varRef("p.0", DYN, loc), index],
+                                                                type: DYN,
+                                                                loc,
+                                                            },
+                                                            loc,
+                                                        },
+                                                    ],
+                                                    else_: null,
+                                                    loc,
+                                                },
+                                            ],
+                                            else_: null,
+                                            loc,
+                                        },
+                                    ],
+                                    else_: null,
+                                    loc,
+                                };
+                                helper.body.unshift(elementRead, {
+                                    kind: "varDecl",
+                                    localId: keyLocal,
+                                    init: { ...indexKey, operand: index },
+                                    loc,
+                                });
+                            }
                             dispatch = {
                                 write: !!computedWrite,
                                 reflect,
                                 fn: helper,
                                 classes: new Set(),
                                 keyLocal,
-                                branchIndex: dynamicKey ? 3 : 0,
+                                branchIndex: dynamicKey ? 3 : indexKey ? 2 : 0,
                                 dynamicKey,
                                 numericKey,
                                 probe,
@@ -1592,7 +1721,7 @@ export class ClassDynamicDispatch {
                             args: reflect
                                 ? (reflectRead ?? reflectWrite).args
                                 : computedRead
-                                    ? [computedRead.value, computedRead.key]
+                                    ? [computedRead.value, indexKey ? indexKey.operand : computedRead.key]
                                     : (computedWrite ?? computedProbe).args,
                             type: dispatch.fn.returnType,
                             loc: expr.loc,
@@ -1635,21 +1764,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,
                                     },
@@ -1661,18 +1793,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")) {
@@ -2545,7 +2683,9 @@ export class ClassDynamicDispatch {
                     ...dispatch.fn.params,
                     { localId: "p.receiver", name: "receiver", type: receiverType },
                 ];
-                if (dispatch.keyLocal !== "p.key")
+                // A derived key (a dynamic key's string, or an index's name) is a
+                // local of the dispatch helper; pass it along.
+                if (!dispatch.fn.params.some((param) => param.localId === dispatch.keyLocal))
                     params.push({ localId: dispatch.keyLocal, name: "key", type: STRING });
                 const helper = {
                     name: `%dyn.class.keys.${lowerer.liftedFns.length}`,
@@ -3261,6 +3401,25 @@ export class ClassDynamicDispatch {
                 { kind: "return", value: null, loc },
             ];
         }
+        // fs.ReadStream / fs.WriteStream's members (undefined on other
+        // streams, as in Node).
+        if (info.builtinStream !== undefined &&
+            !write &&
+            (name === "bytesRead" || name === "bytesWritten" || name === "pending" || name === "path")) {
+            return [
+                {
+                    kind: "return",
+                    value: {
+                        kind: "libCall",
+                        fn: "fs.fsStreamPropDyn",
+                        args: [receiver, { kind: "strLit", value: name, type: STRING, loc }],
+                        type: DYN,
+                        loc,
+                    },
+                    loc,
+                },
+            ];
+        }
         if (info.builtinStream !== undefined && streamProperty(name)) {
             if (write)
                 return [
@@ -3715,6 +3874,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",