@scriptc/compiler 0.3.4 → 0.3.6

package/dist/frontend/lowering/lower-stream.d.ts

@@ -1,6 +1,6 @@
 import * as ts from "../ts7/adapter.js";
 import type { Lowerer } from "./lowerer.js";
-import type { ClassInfo } from "./lower-classes.js";
+import { type ClassInfo } from "./lower-classes.js";
 import { type IrExpr, type IrStmt, type IrType, type SrcLoc } from "../../ir/ir.js";
 /** The stream sides of a receiver class: the nearest stream-class
  * ancestor's, or null off the stream hierarchy. */
@@ -86,8 +86,6 @@ export declare function lowerStreamModuleCall(lowerer: Lowerer, call: ts.CallExp
 }, loc: SrcLoc): IrExpr | null;
 /** The Readable operators (scr_stream_ops.c — Node's operators.js). */
 export declare const STREAM_OPERATORS: ReadonlySet<string>;
-/** `recv.<member>(...)` over a stream-rooted receiver. Returns null only
- * for members this spoke does not own. */
 export declare function lowerStreamMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, info: ClassInfo): IrExpr | null;
 export declare function lowerStreamStateProperty(lowerer: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
 /** Property reads on stream-rooted receivers (`r.readableEnded`,

package/dist/frontend/lowering/lower-stream.js

@@ -1,4 +1,5 @@
 import { nodeThrowExpr, boolLit, numLit, strLit } from "../../ir/build.js";
+import { hashStreamOf, isHashValueType } from "./builtins/hash-stream.js";
 import { InternalCompilerError } from "../../errors.js";
 /* The node:stream lowering (the spoke-module pattern, like
  * lower-event-emitter.ts): construction of the five runtime stream classes
@@ -30,6 +31,7 @@ import { InternalCompilerError } from "../../errors.js";
  * its Node signature (the emitter listener rule). */
 import * as ts from "../ts7/adapter.js";
 import { dynFallbackType } from "./lowerer.js";
+import { accessorCall, classIteratorNextCall, classIteratorOf, classIteratorOpenCall, } from "./lower-classes.js";
 import { isJsSourceFile, locOf } from "../program.js";
 import { newFnCtx, own } from "./lowerer.js";
 import { appendImplicitUndefinedReturn } from "./function-returns.js";
@@ -159,6 +161,9 @@ export const STREAM_FORCED_EVENT_NAMES = new Set([
     "finish",
     "pipe",
     "unpipe",
+    "open",
+    "ready",
+    "keypress",
 ]);
 /** The per-base FORCED event tuples (runtime-emitted payloads): consulted
  * by the emitter spoke BEFORE the program-global table, so a stream's
@@ -168,6 +173,8 @@ export function streamForcedTuple(lowerer, info, name) {
     const sides = streamSidesOf(lowerer, info);
     if (!sides)
         return null;
+    // 'open' (the fd) and 'ready' are fs.ReadStream / fs.WriteStream's
+    // (scr_fs_stream.c).
     const readable = {
         data: [BYTES],
         end: [],
@@ -175,8 +182,14 @@ export function streamForcedTuple(lowerer, info, name) {
         readable: [],
         pause: [],
         resume: [],
+        open: [F64],
+        ready: [],
+        // readline.emitKeypressEvents' (str, key), as checked-dynamic values
+        keypress: [DYN, DYN],
     };
     const writable = {
+        open: [F64],
+        ready: [],
         drain: [],
         prefinish: [],
         finish: [],
@@ -1183,21 +1196,66 @@ export function lowerStreamStaticCall(lowerer, call, access) {
     const single = typedElem(srcT);
     const elem = srcT?.kind === "array" ? typedElem(srcT.elem) : null;
     const opts = optsNode ? fromOptions(lowerer, optsNode) : { flags: 0, hwm: null };
-    if (srcNode && srcT?.kind === "generator" && opts && fromGenChunk(lowerer, srcT.yieldT)) {
+    // A class whose [Symbol.iterator]() or [Symbol.asyncIterator]() is a
+    // generator method: from.js calls the method when the stream is built,
+    // then reads the generator like any other.
+    const genMethod = srcT?.kind === "object" ? classGeneratorMethodOf(lowerer, srcT) : null;
+    const genT = srcT?.kind === "generator" ? srcT : (genMethod?.gen ?? null);
+    if (srcNode && genT && opts && fromGenChunk(lowerer, genT.yieldT)) {
         // A compiled generator: the runtime pulls it through interned helpers.
-        const gen = lowerer.lowerExpr(srcNode);
-        const helpers = fromGenHelpers(lowerer, srcT, loc);
+        const recv = lowerer.lowerExpr(srcNode);
+        const gen = genMethod && srcT?.kind === "object"
+            ? accessorCall(lowerer, srcT.className, genMethod.method, recv, [], genT, loc)
+            : recv;
+        const helpers = fromGenHelpers(lowerer, genT, loc);
         if (helpers) {
             const hwm = opts.hwm ? lowerer.lowerExprExpecting(opts.hwm, F64) : numLit(0, loc);
             return {
                 kind: "libCall",
-                fn: srcT.async ? "readable.fromAsyncGen" : "readable.fromGen",
+                fn: genT.async ? "readable.fromAsyncGen" : "readable.fromGen",
                 args: [gen, ...helpers, numLit(opts.flags, loc), hwm],
                 type,
                 loc,
             };
         }
     }
+    // from.js prefers Symbol.asyncIterator: a class declaring one takes the
+    // async route.
+    const asyncOpen = srcT?.kind === "object" &&
+        lowerer.classes.has(srcT.className) &&
+        lowerer.findMethodOn(lowerer.classes.get(srcT.className), "sym:asyncIterator") !== null;
+    const cit = srcT?.kind === "object" && !asyncOpen ? classIteratorOf(lowerer, srcT) : null;
+    if (srcNode && cit && opts && fromGenChunk(lowerer, cit.valueT)) {
+        // A class iterable: from.js takes the iterator when the stream is
+        // built (the typed [Symbol.iterator]() call here), and the runtime
+        // pulls it through a checked-dynamic { next } object. Class iterators
+        // declare no return() or throw(), so destroy calls neither.
+        const recv = lowerer.lowerExpr(srcNode);
+        const hwm = opts.hwm ? lowerer.lowerExprExpecting(opts.hwm, F64) : numLit(0, loc);
+        return {
+            kind: "libCall",
+            fn: "readable.fromIter",
+            args: [
+                classIteratorObject(lowerer, cit, classIteratorOpenCall(lowerer, cit, recv, loc), loc),
+                numLit(opts.flags, loc),
+                hwm,
+            ],
+            type,
+            loc,
+        };
+    }
+    const acit = srcT?.kind === "object" && asyncOpen ? classAsyncIteratorOf(lowerer, srcT) : null;
+    if (srcNode && acit && opts && fromGenChunk(lowerer, acit.valueT)) {
+        const recv = lowerer.lowerExpr(srcNode);
+        const hwm = opts.hwm ? lowerer.lowerExprExpecting(opts.hwm, F64) : numLit(0, loc);
+        return {
+            kind: "libCall",
+            fn: "readable.fromAsyncIter",
+            args: [classAsyncIteratorObject(lowerer, acit, recv, loc), numLit(opts.flags, loc), hwm],
+            type,
+            loc,
+        };
+    }
     if (srcNode && (single || elem) && opts) {
         const v = lowerer.lowerExpr(srcNode);
         const hwm = opts.hwm ? lowerer.lowerExprExpecting(opts.hwm, F64) : numLit(0, loc);
@@ -1214,6 +1272,7 @@ export function lowerStreamStaticCall(lowerer, call, access) {
         };
     }
     const anySrc = srcT?.kind === "dyn" ||
+        (srcT?.kind === "set" && typedElem(srcT.elem) !== null) ||
         (srcNode !== undefined &&
             srcT === null &&
             (lowerer.typeOf(srcNode).flags & ts.TypeFlags.Any) !== 0);
@@ -1227,7 +1286,7 @@ export function lowerStreamStaticCall(lowerer, call, access) {
     if (srcNode && (single || elem)) {
         lowerer.noLowering("Readable.from with these options", optsNode, "an object literal with 'objectMode' (true or false) and a number 'highWaterMark' is supported");
     }
-    lowerer.noLowering(`Readable.from over a '${srcT ? lowerer.fmt(srcT) : "?"}' source`, srcNode ?? call, "string[] / Buffer[] arrays (and a single string or Buffer) are the supported sources — generators and async iterables have no lowering yet");
+    lowerer.noLowering(`Readable.from over a '${srcT ? lowerer.fmt(srcT) : "?"}' source`, srcNode ?? call, "the supported sources are a string or Buffer, and arrays, Sets, generators and class iterables of strings or Buffers");
 }
 /** Whether a generator's yields are stream chunks: strings, Buffers, a
  * union of them (null included: the runtime destroys the stream with
@@ -1355,6 +1414,210 @@ function fromGenHelpers(lowerer, gen, loc) {
         define("throw", [g, e], DYN, viaRecord("throw"), [r]),
     ];
 }
+/** `{ next() { const r = it.next(); return { value: r.value, done: r.done }; } }`
+ * over a class iterator `it`, as a checked-dynamic object: an interned
+ * lifted function per iterator class takes the iterator and answers the
+ * object, whose `next` closure captures it. */
+function classIteratorObject(lowerer, cit, iter, loc) {
+    const key = `streamFromIter:${cit.iterT.className}`;
+    let name = lowerer.valueHelpers.get(key);
+    if (!name) {
+        name = `%stream.fromIter.${lowerer.valueHelpers.size}`;
+        lowerer.valueHelpers.set(key, name);
+        const nextName = `${name}.next`;
+        const nextT = funcOf([], DYN);
+        const it = { id: "it.0", name: "it", type: cit.iterT, mutable: false, boxed: true };
+        const r = { id: "res.0", name: "res", type: cit.resultT, mutable: false };
+        const field = (f, t) => ({
+            kind: "recordGet",
+            obj: varRef(r.id, cit.resultT, loc),
+            shapeId: cit.resultT.shapeId,
+            field: f,
+            type: t,
+            loc,
+        });
+        const str = (value) => ({ kind: "strLit", value, type: STRING, loc });
+        lowerer.liftedFns.push({
+            name: nextName,
+            params: [],
+            returnType: DYN,
+            captures: [{ localId: it.id, name: it.name, type: it.type }],
+            locals: [it, r],
+            body: [
+                {
+                    kind: "varDecl",
+                    localId: r.id,
+                    init: classIteratorNextCall(lowerer, cit, varRef(it.id, cit.iterT, loc), loc),
+                    loc,
+                },
+                {
+                    kind: "return",
+                    value: {
+                        kind: "dynObjLit",
+                        fields: [
+                            {
+                                key: str("value"),
+                                value: lowerer.coerceToExpected(field("value", cit.valueT), DYN),
+                            },
+                            {
+                                key: str("done"),
+                                value: {
+                                    kind: "dynFrom",
+                                    value: cit.hasDone ? field("done", BOOL) : boolLit(false, loc),
+                                    type: DYN,
+                                    loc,
+                                },
+                            },
+                        ],
+                        type: DYN,
+                        loc,
+                    },
+                    loc,
+                },
+            ],
+            loc,
+        });
+        lowerer.liftedFns.push({
+            name,
+            params: [{ localId: it.id, name: it.name, type: it.type }],
+            returnType: DYN,
+            locals: [it],
+            body: [
+                {
+                    kind: "return",
+                    value: {
+                        kind: "dynObjLit",
+                        fields: [
+                            {
+                                key: str("next"),
+                                value: {
+                                    kind: "dynFrom",
+                                    value: { kind: "closure", fnName: nextName, captures: [it.id], type: nextT, loc },
+                                    type: DYN,
+                                    loc,
+                                },
+                            },
+                        ],
+                        type: DYN,
+                        loc,
+                    },
+                    loc,
+                },
+            ],
+            loc,
+        });
+    }
+    return { kind: "call", callee: name, args: [iter], type: DYN, loc };
+}
+/** A class's zero-parameter `[Symbol.asyncIterator]()` (checked first, as
+ * from.js does) or `[Symbol.iterator]()` method that returns a generator,
+ * with its method slot. */
+function classGeneratorMethodOf(lowerer, t) {
+    const info = lowerer.classes.get(t.className);
+    if (!info)
+        return null;
+    for (const method of ["sym:asyncIterator", "sym:iterator"]) {
+        const m = lowerer.findMethodOn(info, method);
+        if (!m)
+            continue;
+        const ret = m.sig.ret;
+        if (m.sig.abstract === true || m.sig.params.length !== 0 || ret.kind !== "generator")
+            return null;
+        return { method, gen: ret };
+    }
+    return null;
+}
+function classAsyncIteratorOf(lowerer, t) {
+    const info = lowerer.classes.get(t.className);
+    const open = info ? lowerer.findMethodOn(info, "sym:asyncIterator") : null;
+    if (!open || open.sig.abstract === true || open.sig.params.length !== 0)
+        return null;
+    const iterT = open.sig.ret;
+    if (iterT.kind !== "object")
+        return null;
+    const itInfo = lowerer.classes.get(iterT.className);
+    if (!itInfo || lowerer.findMethodOn(itInfo, "throw"))
+        return null;
+    const record = (name) => {
+        const m = lowerer.findMethodOn(itInfo, name);
+        if (!m || m.sig.abstract === true || m.sig.params.length !== 0)
+            return null;
+        const ret = m.sig.ret;
+        return ret.kind === "promise" && ret.inner.kind === "record" ? ret.inner : null;
+    };
+    const resultT = record("next");
+    if (!resultT)
+        return null;
+    const shape = lowerer.shapes.get(resultT.shapeId);
+    const value = shape?.fields.find((f) => f.name === "value");
+    const done = shape?.fields.find((f) => f.name === "done");
+    if (!value || (done && done.type.kind !== "bool"))
+        return null;
+    const hasReturn = lowerer.findMethodOn(itInfo, "return") !== null;
+    if (hasReturn && !record("return"))
+        return null;
+    return { className: t.className, iterT, resultT, valueT: value.type, hasReturn };
+}
+/** The checked-dynamic iterator object over an async class iterable:
+ * `recv[Symbol.asyncIterator]()` runs when the stream is built, and the
+ * object's `next` (and `return`, when the class declares one) answer the
+ * iterator's own promises boxed. */
+function classAsyncIteratorObject(lowerer, cit, recv, loc) {
+    const key = `streamFromAsyncIter:${cit.className}`;
+    let name = lowerer.valueHelpers.get(key);
+    if (!name) {
+        name = `%stream.fromAsyncIter.${lowerer.valueHelpers.size}`;
+        lowerer.valueHelpers.set(key, name);
+        const it = { id: "it.0", name: "it", type: cit.iterT, mutable: false, boxed: true };
+        const src = {
+            id: "src.0",
+            name: "src",
+            type: { kind: "object", className: cit.className },
+            mutable: false,
+        };
+        const str = (value) => ({ kind: "strLit", value, type: STRING, loc });
+        const method = (m) => {
+            const fnName = `${name}.${m}`;
+            const call = accessorCall(lowerer, cit.iterT.className, m, varRef(it.id, cit.iterT, loc), [], { kind: "promise", inner: cit.resultT }, loc);
+            lowerer.liftedFns.push({
+                name: fnName,
+                params: [],
+                returnType: DYN,
+                captures: [{ localId: it.id, name: it.name, type: it.type }],
+                locals: [it],
+                body: [{ kind: "return", value: { kind: "dynFrom", value: call, type: DYN, loc }, loc }],
+                loc,
+            });
+            return {
+                key: str(m),
+                value: {
+                    kind: "dynFrom",
+                    value: { kind: "closure", fnName, captures: [it.id], type: funcOf([], DYN), loc },
+                    type: DYN,
+                    loc,
+                },
+            };
+        };
+        const fields = [method("next"), ...(cit.hasReturn ? [method("return")] : [])];
+        lowerer.liftedFns.push({
+            name,
+            params: [{ localId: src.id, name: src.name, type: src.type }],
+            returnType: DYN,
+            locals: [src, it],
+            body: [
+                {
+                    kind: "varDecl",
+                    localId: it.id,
+                    init: accessorCall(lowerer, cit.className, "sym:asyncIterator", varRef(src.id, src.type, loc), [], cit.iterT, loc),
+                    loc,
+                },
+                { kind: "return", value: { kind: "dynObjLit", fields, type: DYN, loc }, loc },
+            ],
+            loc,
+        });
+    }
+    return { kind: "call", callee: name, args: [recv], type: DYN, loc };
+}
 /** Readable.from's typed options: an object literal of `objectMode`
  * (a boolean literal) and `highWaterMark` (a number), as SCR_FROM_* flag
  * bits and the hwm expression; null for any other shape. */
@@ -1421,7 +1684,12 @@ const PIPELINE_STAGE_EXPECTED = "of type function or an instance of Blob, Readab
  * { readable, writable } pairs — those shapes fence instead of throwing
  * a ladder Node never throws. */
 function lowerStreamArg(lowerer, node, what) {
-    const v = lowerer.lowerExpr(node);
+    const lowered = lowerer.lowerExpr(node);
+    // A Hash or Hmac stage is its Transform; pipeline and compose stages
+    // keep the value alive until the stream settles.
+    const v = isHashValueType(lowered.type)
+        ? hashStreamOf(lowered, what === "pipeline" || what === "compose")
+        : lowered;
     const info = v.type.kind === "object" ? lowerer.classes.get(v.type.className) : undefined;
     if (!streamSidesOf(lowerer, info)) {
         // A provably-non-stream value in a JS source (the invalid-input
@@ -2412,6 +2680,22 @@ function checkUtf8Encoding(lowerer, member, arg) {
 }
 /** `recv.<member>(...)` over a stream-rooted receiver. Returns null only
  * for members this spoke does not own. */
+/** pipe()'s `{ end }` option: true when absent. */
+function pipeEndOption(lowerer, options, loc) {
+    let end = boolLit(true, loc);
+    if (options === undefined)
+        return end;
+    if (!ts.isObjectLiteralExpression(options)) {
+        lowerer.noLowering("pipe with a non-literal options argument", options, "{ end: <bool> } inline is the supported form");
+    }
+    for (const prop of options.properties) {
+        if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name) || prop.name.text !== "end") {
+            lowerer.noLowering("a pipe option other than 'end'", prop);
+        }
+        end = lowerer.lowerExprExpecting(prop.initializer, BOOL);
+    }
+    return end;
+}
 export function lowerStreamMethodCall(lowerer, call, access, info) {
     const member = access.name.text;
     if (STREAM_OPERATORS.has(member)) {
@@ -2596,26 +2880,47 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
         if (args.length === 0 || args.length > 2) {
             lowerer.noLowering(`pipe with ${args.length} arguments`, call, "the supported forms are (destination) and (destination, { end })");
         }
+        // A Hash or Hmac destination pipes into its Transform, and pipe()
+        // answers the Hash itself (the receiver evaluates first, as in JS).
+        if (isHashValueType(lowerer.mapTypeOf(lowerer.typeOf(args[0])))) {
+            const receiverValue = lowerer.lowerExpr(access.expression);
+            const source = lowerer.declareHiddenLocal("%pipeSource", receiverValue.type);
+            const hashValue = lowerer.lowerExpr(args[0]);
+            const hash = lowerer.declareHiddenLocal("%pipeHash", hashValue.type);
+            const end = pipeEndOption(lowerer, args[1], loc);
+            return {
+                kind: "seqExpr",
+                stmts: [
+                    { kind: "varDecl", localId: source.id, init: receiverValue, loc },
+                    { kind: "varDecl", localId: hash.id, init: hashValue, loc },
+                    {
+                        kind: "exprStmt",
+                        expr: {
+                            kind: "libCall",
+                            fn: "readable.pipe",
+                            args: [
+                                { kind: "varRef", localId: source.id, type: receiverValue.type, loc },
+                                hashStreamOf({ kind: "varRef", localId: hash.id, type: hashValue.type, loc }, true),
+                                end,
+                            ],
+                            type: { kind: "object", className: "%Transform" },
+                            loc,
+                        },
+                        loc,
+                    },
+                ],
+                result: { kind: "varRef", localId: hash.id, type: hashValue.type, loc },
+                type: hashValue.type,
+                loc,
+            };
+        }
         const dst = lowerer.lowerExpr(args[0]);
         const dstInfo = dst.type.kind === "object" ? lowerer.classes.get(dst.type.className) : undefined;
         const dstSides = streamSidesOf(lowerer, dstInfo);
         if (dstSides !== "w" && dstSides !== "rw") {
             lowerer.noLowering(`pipe into a '${lowerer.fmt(dst.type)}'`, args[0], "the destination must be a stream Writable/Duplex (process streams and sockets are not pipe destinations yet)");
         }
-        let end = boolLit(true, loc);
-        if (args[1] !== undefined) {
-            if (!ts.isObjectLiteralExpression(args[1])) {
-                lowerer.noLowering("pipe with a non-literal options argument", args[1], "{ end: <bool> } inline is the supported form");
-            }
-            for (const prop of args[1].properties) {
-                if (!ts.isPropertyAssignment(prop) ||
-                    !ts.isIdentifier(prop.name) ||
-                    prop.name.text !== "end") {
-                    lowerer.noLowering("a pipe option other than 'end'", prop);
-                }
-                end = lowerer.lowerExprExpecting(prop.initializer, BOOL);
-            }
-        }
+        const end = pipeEndOption(lowerer, args[1], loc);
         const receiver = lowerer.lowerExpr(access.expression);
         return {
             kind: "libCall",