@scriptc/compiler 0.4.6 → 0.4.7

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

@@ -660,6 +660,80 @@ function pinAnyDataCompletion(lowerer, which, fnNode) {
     lowerer.stageSourceTypes.set(symbol, funcOf([declared.params[0], data, ...declared.params.slice(2)], declared.ret));
     return symbol;
 }
+/** An object-mode Transform's completion callback whose every use calls
+ * it with one record type as `data`, or with no data or undefined: the
+ * callback parameter is typed with `data` as that record or undefined
+ * while the option callback lowers, so the record reaches the stream as a
+ * typed chunk (the emitted completion thunk) instead of converting to a
+ * checked-dynamic value at the call. Returns the pinned parameter symbol
+ * (the caller unpins it), or null when another value, a callback that
+ * escapes, or no record is passed. */
+function pinTypedDataCompletion(lowerer, which, fnNode) {
+    const index = which === "transform" ? 2 : which === "flush" ? 0 : -1;
+    const param = index < 0 ? undefined : fnNode.parameters.nodes[index];
+    if (param === undefined || !ts.isIdentifier(param.name) || param.dotDotDotToken)
+        return null;
+    const symbol = lowerer.checker.getSymbolAtLocation(param.name);
+    if (!symbol || lowerer.stageSourceTypes.has(symbol))
+        return null;
+    const declared = lowerer.paramShape(param).type;
+    if (declared.kind !== "func" || declared.rest || declared.params[1]?.kind !== "dyn")
+        return null;
+    if (fnNode.body === undefined)
+        return null;
+    const record = completionDataRecord(lowerer, fnNode.body, symbol, param.name);
+    if (record === null)
+        return null;
+    const data = unionOf(lowerer, [record, { kind: "undefinedT" }]);
+    lowerer.stageSourceTypes.set(symbol, funcOf([declared.params[0], data, ...declared.params.slice(2)], declared.ret));
+    return symbol;
+}
+/** The one record type every call of the completion callback passes as
+ * `data` (records a conversion to dyn keeps by reference: declared fields,
+ * no index signature), or null when a call passes another value, the
+ * callback is used other than by a call, or no call passes a record. */
+function completionDataRecord(lowerer, body, symbol, declaration) {
+    let ok = true;
+    const found = { record: null };
+    const visit = (node) => {
+        if (!ok)
+            return;
+        if (ts.isIdentifier(node) &&
+            node !== declaration &&
+            lowerer.checker.getSymbolAtLocation(node) === symbol) {
+            const call = node.parent;
+            if (!call || !ts.isCallExpression(call) || call.expression !== node) {
+                ok = false;
+                return;
+            }
+            const data = call.arguments.nodes[1];
+            if (data !== undefined) {
+                let t;
+                try {
+                    t = lowerer.mapTypeOf(lowerer.typeOf(data));
+                }
+                catch {
+                    t = null;
+                }
+                if (t?.kind === "undefinedT")
+                    return;
+                const shape = t?.kind === "record" ? lowerer.shapes.get(t.shapeId) : undefined;
+                if (t?.kind !== "record" ||
+                    shape === undefined ||
+                    shape.fields.length === 0 ||
+                    shape.indexValue !== undefined ||
+                    (found.record !== null && found.record.shapeId !== t.shapeId)) {
+                    ok = false;
+                    return;
+                }
+                found.record = t;
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(body);
+    return ok ? found.record : null;
+}
 /** Whether every reference to the completion callback `symbol` in `body`
  * calls it with a `data` argument that is a Buffer, a string, null or
  * undefined (or with no data). */
@@ -802,7 +876,9 @@ fallbackCb) {
                 continue;
             }
             const full = tuples[name].map((t) => (t === "fn" ? null : t));
-            const pinned = out.readableObject ? null : pinAnyDataCompletion(lowerer, name, fnNode);
+            const pinned = out.readableObject
+                ? pinTypedDataCompletion(lowerer, name, fnNode)
+                : pinAnyDataCompletion(lowerer, name, fnNode);
             let anyChunk;
             try {
                 // The completion-callback tail: typed by the checker contextually;
@@ -5928,14 +6004,36 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
         if (kind === "null")
             lowerer.noLowering("write(null)", call, "end() finishes a writable");
         const lowerWriteCb = (cbArg) => {
-            const cb = callbackDeclaresParameters(cbArg)
-                ? null
-                : lowerer.lowerExprExpecting(cbArg, funcOf([], VOID));
-            if (cb === null || cb.type.kind !== "func" || cb.type.params.length > 0) {
-                lowerer.noLowering("write completion callbacks taking the error argument", cbArg, "() => void callbacks are supported (listen for 'error' to observe failures)");
+            // The stream ignores what the callback returns (`() => count++`, a
+            // stored function returning a value): the value is discarded.
+            // An untyped callback (a function a JavaScript module returned) is
+            // called unbound with the error argument, as Node calls it.
+            const raw = lowerer.lowerExpr(cbArg);
+            const cb = raw.type.kind === "dyn"
+                ? lowerer.coerceToExpected(raw, funcOf([DYN], VOID))
+                : raw.type.kind === "func" && raw.type.ret.kind !== "void" && raw.type.params.length <= 1
+                    ? lowerer.coerceToExpected(raw, funcOf(raw.type.params, VOID))
+                    : raw;
+            if (cb.type.kind !== "func" || cb.type.ret.kind !== "void" || cb.type.params.length > 1) {
+                lowerer.noLowering("write completion callbacks of this shape", cbArg, "callbacks take () or (error?: Error | null) and return nothing");
+            }
+            if (cb.type.params.length === 0)
+                return cb;
+            const param = cb.type.params[0];
+            const def = param.kind === "union" ? lowerer.unions.get(param.unionId) : undefined;
+            const ok = param.kind === "dyn" ||
+                (!!def &&
+                    def.arms.some((a) => a.kind === "nullT") &&
+                    def.arms.some((a) => a.kind === "object" && a.className === "%Error") &&
+                    def.arms.every((a) => a.kind === "nullT" ||
+                        a.kind === "undefinedT" ||
+                        (a.kind === "object" && a.className === "%Error")));
+            if (!ok) {
+                lowerer.unsupported("SC1090", cbArg, `write completion callbacks whose parameter is not 'Error | null' (got '${lowerer.fmt(param)}')`);
             }
             return cb;
         };
+        const takesError = (cb) => cb.type.kind === "func" && cb.type.params.length === 1;
         // write(chunk, encoding[, cb]), and write(value, cb): the encoding
         // argument reaches an object-mode side's _write as passed, null when
         // the callback took its place (a byte-mode side encodes a string
@@ -5946,8 +6044,19 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
             const tail = [];
             if (encArg !== undefined)
                 tail.push(lowerer.lowerExprExpecting(encArg, DYN));
-            if (cbArg !== undefined)
-                tail.push(lowerWriteCb(cbArg));
+            if (cbArg !== undefined) {
+                const cb = lowerWriteCb(cbArg);
+                if (takesError(cb)) {
+                    return {
+                        kind: "libCall",
+                        fn: "writable.writeEcb",
+                        args: [receiver, numLit(2, loc), chunk, tail[0] ?? dynUndefinedExpr(loc), cb],
+                        type: BOOL,
+                        loc,
+                    };
+                }
+                tail.push(cb);
+            }
             const flags = (encArg !== undefined ? 1 : 0) | (cbArg !== undefined ? 2 : 0);
             return {
                 kind: "libCall",
@@ -6012,6 +6121,15 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
         const fn = kind === "bytes" ? "writable.write" : "writable.writeStr";
         if (cbArg !== undefined) {
             const cb = lowerWriteCb(cbArg);
+            if (takesError(cb)) {
+                return {
+                    kind: "libCall",
+                    fn: "writable.writeEcb",
+                    args: [receiver, numLit(kind === "bytes" ? 0 : 1, loc), chunk, dynUndefinedExpr(loc), cb],
+                    type: BOOL,
+                    loc,
+                };
+            }
             return { kind: "libCall", fn, args: [receiver, chunk, cb], type: BOOL, loc };
         }
         return { kind: "libCall", fn, args: [receiver, chunk], type: BOOL, loc };