@scriptc/compiler 0.0.10 → 0.0.12

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

@@ -31,7 +31,7 @@ import { dynFallbackType, nodeThrowExpr } from "./lowerer.js";
 import { isJsSourceFile, locOf } from "../program.js";
 import { newFnCtx, own } from "./lowerer.js";
 import { appendImplicitUndefinedReturn } from "./lower-calls.js";
-import { bufEncoding } from "./lower-containers.js";
+import { bufEncoding, knownBufEncoding } from "./lower-containers.js";
 import { probeLower } from "./lower-exprs.js";
 import { BOOL, DYN, F64, RUNTIME_STREAM_CLASSES, STRING, VOID, arrayOf, bytesOf, canBoxFuncIntoDyn, funcOf, typeEquals, typeKey } from "../../ir/nodes.js";
 const BYTES = bytesOf("u8");
@@ -337,7 +337,7 @@ function followOptionsArg(L, arg) {
  * values as they are), then dynCheck'd into the all-dyn full Node tuple.
  * The emitted option thunk recognizes the THISLESS shape (its first
  * param is not the stream) and boxes each position by kind — the chunk
- * as DOM bytes, the error via the boundary's encoding, the completion
+ * as dyn bytes, the error via the boundary's encoding, the completion
  * callback as a callable dyn whose glue reports to the runtime's *_done.
  * DIVERGENCE (SEMANTICS.md): Node binds `this` to the stream when it
  * calls option callbacks; a value adapted through the dyn boundary is
@@ -412,6 +412,8 @@ fallbackCb) {
         readableSide: true,
         writableSide: true,
         encoding: null,
+        badEncoding: null,
+        pushEncoding: null,
         flags: 0,
         cbs: [],
     };
@@ -517,19 +519,41 @@ fallbackCb) {
             }
             case "encoding": {
                 // The readable-side string-chunk mode: a literal encoding, folded
-                // to its canonical name (Writable has no such option).
+                // to its canonical name (Writable has no such option). A literal
+                // spelling Node does not know is Node's RUNTIME rejection —
+                // ERR_UNKNOWN_ENCODING at construction, not a compile fence.
                 if (ctorName === "Writable")
                     L.noLowering(`the Writable option 'encoding'`, prop);
+                {
+                    const t = L.typeOf(value);
+                    if (t.isStringLiteralType() && knownBufEncoding(t.value) === undefined) {
+                        out.badEncoding = t.value;
+                        break;
+                    }
+                }
                 out.encoding = bufEncoding(L, `the ${ctorName} option 'encoding'`, value);
                 break;
             }
             case "defaultEncoding":
-                // The WRITE-side default: utf8 is the byte default — admit the
-                // literal; other encodings would change what write(string) means.
+                // utf8 is the byte default — admit the literal. A literal Node
+                // does not know throws ERR_UNKNOWN_ENCODING at construction (the
+                // state ctor validates it), Node's ladder. On a pure Readable a
+                // valid non-utf8 name governs how push(string) DECODES chunks
+                // (Buffer.from(chunk, enc)) — lowered as a follow-up
+                // readable.pushEncoding. The write-side meaning (what
+                // write(string) does) stays fenced on the writable classes.
                 {
                     const t = L.typeOf(value);
                     if (t.isStringLiteralType() && (t.value === "utf8" || t.value === "utf-8"))
                         break;
+                    if (t.isStringLiteralType() && knownBufEncoding(t.value) === undefined) {
+                        out.badEncoding = t.value;
+                        break;
+                    }
+                    if (t.isStringLiteralType() && ctorName === "Readable") {
+                        out.pushEncoding = knownBufEncoding(t.value);
+                        break;
+                    }
                 }
                 L.noLowering(`the ${ctorName} option 'defaultEncoding'`, prop, "utf8 (the default) is the supported write-side string encoding");
                 break;
@@ -602,7 +626,7 @@ function streamCtorArgs(L, cls, arg, thisType, loc, fallbackCb) {
         ? [o.hwmR, o.hwmW, o.autoDestroy, o.emitClose, o.allowHalfOpen,
             boolLit(o.readableSide, loc), boolLit(o.writableSide, loc), f64Lit(o.flags, loc)]
         : [cls === "%Writable" ? o.hwmW : o.hwmR, o.autoDestroy, o.emitClose, f64Lit(o.flags, loc)];
-    return { args: [...head, ...o.cbs], encoding: o.encoding };
+    return { args: [...head, ...o.cbs], encoding: o.encoding, badEncoding: o.badEncoding, pushEncoding: o.pushEncoding };
 }
 /** `new Readable(opts?)` and friends — called from lowerNew once the
  * callee resolved to a builtin stream class. */
@@ -624,7 +648,17 @@ export function lowerStreamNew(L, expr, info) {
     }
     const fn = `${streamCtorShape(cls).fn}.new`;
     const parsed = streamCtorArgs(L, cls, args[0], thisType, loc);
-    const built = { kind: "libCall", fn, args: parsed.args, type: thisType, loc };
+    if (parsed.badEncoding !== null) {
+        // Node's state constructors validate encodings first: an unknown
+        // spelling never constructs — the whole expression throws.
+        return nodeThrowExpr(1, "ERR_UNKNOWN_ENCODING", `Unknown encoding: ${parsed.badEncoding}`, thisType, loc);
+    }
+    let built = { kind: "libCall", fn, args: parsed.args, type: thisType, loc };
+    if (parsed.pushEncoding !== null) {
+        // { defaultEncoding }: chain the push-side decode default (the
+        // setEncoding chaining shape — answers the receiver +1).
+        built = { kind: "libCall", fn: "readable.pushEncoding", args: [built, strLit(parsed.pushEncoding, loc)], type: thisType, loc };
+    }
     if (parsed.encoding === null)
         return built;
     // { encoding }: chain a setEncoding over the fresh stream (the operand
@@ -781,11 +815,27 @@ export function lowerStreamSuperCall(L, info, base, argNodes, thisLocal, loc, bl
         }
     }
     const parsed = streamCtorArgs(L, cls, argNodes[0], thisType, loc, fallback);
+    if (parsed.badEncoding !== null) {
+        // super(options) with an unknown literal encoding: the state ctor
+        // rejects before any initialization, Node's ladder.
+        return [{
+                kind: "exprStmt",
+                expr: nodeThrowExpr(1, "ERR_UNKNOWN_ENCODING", `Unknown encoding: ${parsed.badEncoding}`, VOID, loc),
+                loc,
+            }];
+    }
     const out = [{
             kind: "exprStmt",
             expr: { kind: "libCall", fn: `${shape.fn}.init`, args: [thisRef(), ...parsed.args], type: VOID, loc },
             loc,
         }];
+    if (parsed.pushEncoding !== null) {
+        out.push({
+            kind: "exprStmt",
+            expr: { kind: "libCall", fn: "readable.pushEncoding", args: [thisRef(), strLit(parsed.pushEncoding, loc)], type: thisType, loc },
+            loc,
+        });
+    }
     if (parsed.encoding !== null) {
         out.push({
             kind: "exprStmt",
@@ -969,32 +1019,57 @@ export function streamClassAliasDecl(L, nameNode, init) {
     return L.builtinNamespaceModuleOf(init.expression) === "stream";
 }
 /* ── the module functions (finished / pipeline — the callback forms) ──── */
+/** Node's pipeline stage ladder text (lib/internal/streams/pipeline.js's
+ * makeAsyncIterable — every stage position renders the same "body"
+ * clause). finished() keeps its narrower isNodeStream wording. */
+const PIPELINE_STAGE_EXPECTED = "of type function or an instance of Blob, ReadableStream, WritableStream, Stream, Iterable, AsyncIterable, or Promise or { readable, writable } pair";
 /** A stream-rooted argument, lowered — or the pointed fence (pipeline's
- * iterable/generator/function stages have no lowering yet). */
+ * iterable/generator/function stages have no lowering yet). `what` picks
+ * the validation ladder: finished() rejects EVERY non-stream through
+ * isNodeStream, while pipeline() accepts iterables (strings, arrays) and
+ * { readable, writable } pairs — those shapes fence instead of throwing
+ * a ladder Node never throws. */
 function lowerStreamArg(L, node, what) {
     const v = L.lowerExpr(node);
     const info = v.type.kind === "object" ? L.classes.get(v.type.className) : undefined;
     if (!streamSidesOf(L, info)) {
         // A provably-non-stream value in a JS source (the invalid-input
-        // probes: finished({}, cb)): Node's isNodeStream gate throws
-        // ERR_INVALID_ARG_TYPE before any watcher exists.
-        if (isJsSourceFile(node.getSourceFile()) &&
-            (v.type.kind === "record" || v.type.kind === "string" || v.type.kind === "f64" ||
-                v.type.kind === "bool" || v.type.kind === "array") &&
-            L.dynConvertible(v.type)) {
+        // probes: finished({}, cb), pipeline(42, dst, cb)): Node's gate
+        // throws ERR_INVALID_ARG_TYPE before any watcher exists.
+        const argTypeThrow = (argName, expected) => {
             throw new StreamArgTypeThrow({
                 kind: "libCall",
                 fn: "error.argTypeThrow",
                 args: [
-                    { kind: "strLit", value: "stream", type: STRING, loc: locOf(node) },
-                    { kind: "strLit", value: "an instance of ReadableStream, WritableStream, or Stream", type: STRING, loc: locOf(node) },
+                    { kind: "strLit", value: argName, type: STRING, loc: locOf(node) },
+                    { kind: "strLit", value: expected, type: STRING, loc: locOf(node) },
                     { kind: "dynFrom", value: v, type: DYN, loc: locOf(node) },
                 ],
                 type: VOID,
                 loc: locOf(node),
             });
+        };
+        if (isJsSourceFile(node.getSourceFile()) && L.dynConvertible(v.type)) {
+            if (what === "pipeline") {
+                // Strings and arrays are iterables — VALID pipeline stages in
+                // Node — and a record carrying a readable/writable member may be
+                // the duplex-pair form; none of those shapes has a lowering, so
+                // they take the pointed fence below, never a throw.
+                const pairish = v.type.kind === "record" &&
+                    (L.shapes.get(v.type.shapeId)?.fields ?? []).some((f) => f.name === "readable" || f.name === "writable");
+                if ((v.type.kind === "record" && !pairish) || v.type.kind === "f64" ||
+                    v.type.kind === "bool" || v.type.kind === "nullT") {
+                    argTypeThrow("body", PIPELINE_STAGE_EXPECTED);
+                }
+            }
+            else if (v.type.kind === "record" || v.type.kind === "string" || v.type.kind === "f64" ||
+                v.type.kind === "bool" || v.type.kind === "array" || v.type.kind === "nullT") {
+                argTypeThrow("stream", "an instance of ReadableStream, WritableStream, or Stream");
+            }
         }
-        L.noLowering(`${what} over a '${L.fmt(v.type)}'`, node, "stream arguments are the lowered surface (iterables, generators, and plain functions have no lowering yet)");
+        L.noLowering(`${what} over a '${L.fmt(v.type)}'`, node, what === "pipeline"
+            ? "stream stages are the lowered surface — Node also accepts iterables (strings, arrays), generators, plain functions, and { readable, writable } pairs, but those have no lowering yet"
+            : "stream arguments are the lowered surface (iterables, generators, and plain functions have no lowering yet)");
     }
     return v;
 }
@@ -1095,7 +1170,15 @@ export function lowerStreamModuleCall(L, call, bi, loc) {
             if (args.length < 2) {
                 L.noLowering(`stream/promises.pipeline with ${args.length} arguments`, call, "the supported form is pipeline(source, ...streams)");
             }
-            const streams = args.map((a) => lowerStreamArg(L, a, "pipeline"));
+            let streams;
+            try {
+                streams = args.map((a) => lowerStreamArg(L, a, "pipeline"));
+            }
+            catch (e) {
+                if (e instanceof StreamArgTypeThrow)
+                    return e.expr;
+                throw e;
+            }
             return {
                 kind: "libCall",
                 fn: "sp.pipeline",
@@ -1106,6 +1189,43 @@ export function lowerStreamModuleCall(L, call, bi, loc) {
         }
         return null;
     }
+    if (bi.module === "stream/consumers") {
+        const args = call.arguments;
+        // text/json/buffer(stream) → a pending promise the accumulate-and-
+        // settle machinery resolves at the terminal point (the utf8 decode / the parsed
+        // JSON DOM / the concatenated bytes) or rejects — with the stream's
+        // error, ERR_STREAM_PREMATURE_CLOSE on an early close, or json's
+        // SyntaxError on malformed text, Node's own rejection set.
+        // arrayBuffer/blob return null here: neither value has a
+        // representation, so the module-qualified fence (with the pointed
+        // hints in BUILTIN_MODULE_FENCE_HINTS) speaks.
+        if (bi.member === "text" || bi.member === "json" || bi.member === "buffer") {
+            if (args.length !== 1) {
+                L.noLowering(`stream/consumers.${bi.member} with ${args.length} arguments`, call, `the supported form is ${bi.member}(stream)`);
+            }
+            // A provably-non-stream argument: Node's consumers reject the
+            // returned promise asynchronously with the plain "stream is not
+            // async iterable" TypeError — no sync ladder exists to borrow
+            // (finished/pipeline throw synchronously; consumers do not). A
+            // sync throw here would be observably wrong timing, so the
+            // provable case takes the named fence instead.
+            const argV = L.lowerExpr(args[0]);
+            const argInfo = argV.type.kind === "object" ? L.classes.get(argV.type.className) : undefined;
+            if (argV.type.kind !== "dyn" && argV.type.kind !== "jsval" && !streamSidesOf(L, argInfo)) {
+                L.noLowering(`stream/consumers.${bi.member} over a value that is not a stream`, call, "Node rejects the promise with 'stream is not async iterable' — pass a readable stream");
+            }
+            const recv = argV;
+            const inner = bi.member === "text" ? STRING : bi.member === "json" ? DYN : BYTES;
+            return {
+                kind: "libCall",
+                fn: `sc.${bi.member}`,
+                args: [recv],
+                type: { kind: "promise", inner },
+                loc,
+            };
+        }
+        return null;
+    }
     if (bi.module !== "stream")
         return null;
     const args = call.arguments;
@@ -1147,7 +1267,15 @@ export function lowerStreamModuleCall(L, call, bi, loc) {
         if (args.length < 3) {
             L.noLowering(`pipeline with ${args.length} arguments`, call, "the supported form is pipeline(source, ...streams, callback)");
         }
-        const streams = args.slice(0, -1).map((a) => lowerStreamArg(L, a, "pipeline"));
+        let streams;
+        try {
+            streams = args.slice(0, -1).map((a) => lowerStreamArg(L, a, "pipeline"));
+        }
+        catch (e) {
+            if (e instanceof StreamArgTypeThrow)
+                return e.expr;
+            throw e;
+        }
         const last = streams[streams.length - 1];
         const { cb, dyn } = lowerEosCallback(L, "pipeline", args[args.length - 1], last.type);
         return {
@@ -1204,7 +1332,7 @@ export function lowerStreamMethodCall(L, call, access, info) {
         if (t?.kind === "nullT")
             return "null";
         if (t?.kind === "dyn") {
-            // The JS lane's any-typed chunk: the runtime dispatches by DOM tag
+            // The JS lane's any-typed chunk: the runtime dispatches by dyn tag
             // (bytes / string / null; anything else is the write TypeError).
             return "dyn";
         }
@@ -1235,6 +1363,29 @@ export function lowerStreamMethodCall(L, call, access, info) {
         if (args.length === 0 || args.length > 2) {
             L.noLowering(`${member} with ${args.length} arguments`, call, "the supported forms are (chunk) and (chunk, \"utf8\")");
         }
+        // push(chunk, enc) with a LITERAL encoding: the per-call decode
+        // (Buffer.from(chunk, enc)) — an explicit encoding (utf8 included)
+        // overrides the stream's defaultEncoding; unknown literals throw
+        // Node's ERR_UNKNOWN_ENCODING when the push evaluates. unshift keeps
+        // the utf8-only fence below.
+        if (member === "push" && args[1] !== undefined && chunkKind(args[0]) === "string") {
+            const t = L.typeOf(args[1]);
+            if (t.isStringLiteralType()) {
+                const canonical = knownBufEncoding(t.value);
+                if (canonical === undefined) {
+                    return nodeThrowExpr(1, "ERR_UNKNOWN_ENCODING", `Unknown encoding: ${t.value}`, BOOL, loc);
+                }
+                const receiver = L.lowerExpr(access.expression);
+                const chunk = L.lowerExprExpecting(args[0], STRING);
+                return {
+                    kind: "libCall",
+                    fn: "readable.pushStrEnc",
+                    args: [receiver, chunk, strLit(canonical, loc)],
+                    type: BOOL,
+                    loc,
+                };
+            }
+        }
         checkUtf8Encoding(L, member, args[1]);
         const kind = chunkKind(args[0]);
         if ((kind === "null" || kind === "union" || kind === "dyn") && member === "unshift") {