@scriptc/compiler 0.4.8 → 0.4.9

package/dist/frontend/lowering/builtins/child-process.js

@@ -1,5 +1,5 @@
 import { recordToEnvPairs } from "./environment.js";
-import { boolLit, numLit, strLit, varRef } from "../../../ir/build.js";
+import { boolLit, nodeThrowExpr, numLit, strLit, varRef } from "../../../ir/build.js";
 import { keyedHelperName } from "../stable-names.js";
 import { InternalCompilerError } from "../../../errors.js";
 import { resolve } from "node:path";
@@ -141,12 +141,12 @@ export function lowerSpawnSyncCall(lowerer, expr, loc) {
         if (!ts.isObjectLiteralExpression(optsNode)) {
             const runtime = lowerSpawnSyncRuntimeOptions(lowerer, optsNode, expr.arguments.nodes[1], loc);
             if (runtime) {
-                return {
+                const call = (fn, extra, callCmd = cmd, callArgs = argv) => ({
                     kind: "libCall",
-                    fn: "cp.spawnSyncExt",
+                    fn,
                     args: [
-                        cmd,
-                        argv,
+                        callCmd,
+                        callArgs,
                         runtime.timeout,
                         killSignal,
                         runtime.inMode,
@@ -156,12 +156,44 @@ export function lowerSpawnSyncCall(lowerer, expr, loc) {
                         runtime.input,
                         runtime.hasInput,
                         runtime.shell,
+                        ...extra,
                     ],
                     type: SPAWNRES_T,
                     loc,
-                };
+                });
+                // An absent `env` inherits our environment; a present one replaces
+                // it. The two entry points differ only in that argument, so the
+                // member's presence test picks one at the call. Node evaluates the
+                // command and its arguments before it reads the options record, so
+                // both go into hidden locals the presence test follows: a command
+                // that adds or drops `env` in the record decides the entry point,
+                // as it does under Node.
+                if (runtime.hasEnv !== null && runtime.envPairs !== null) {
+                    const cmdLocal = lowerer.declareHiddenLocal("%spawnSyncCmd", cmd.type);
+                    const argvLocal = lowerer.declareHiddenLocal("%spawnSyncArgs", argv.type);
+                    const cmdArg = varRef(cmdLocal.id, cmd.type, loc);
+                    const argvArg = varRef(argvLocal.id, argv.type, loc);
+                    return {
+                        kind: "seqExpr",
+                        stmts: [
+                            { kind: "varDecl", localId: cmdLocal.id, init: cmd, loc },
+                            { kind: "varDecl", localId: argvLocal.id, init: argv, loc },
+                        ],
+                        result: {
+                            kind: "ternary",
+                            cond: runtime.hasEnv,
+                            then: call("cp.spawnSyncExtEnv", [runtime.envPairs], cmdArg, argvArg),
+                            else_: call("cp.spawnSyncExt", [], cmdArg, argvArg),
+                            type: SPAWNRES_T,
+                            loc,
+                        },
+                        type: SPAWNRES_T,
+                        loc,
+                    };
+                }
+                return call("cp.spawnSyncExt", []);
             }
-            lowerer.noLowering("spawnSync with a non-literal options argument", optsNode, "pass the options inline so each member can be checked, or give them the SpawnSyncOptionsWithStringEncoding type (env and killSignal stay literal)");
+            lowerer.noLowering("spawnSync with a non-literal options argument", optsNode, "pass the options inline so each member can be checked, or give them the SpawnSyncOptionsWithStringEncoding type (killSignal stays literal)");
         }
         const applyStdio = (node) => {
             const modeOf = (v, fd) => {
@@ -462,7 +494,7 @@ function lowerSpawnSyncRuntimeOptions(lowerer, optsNode, argsNode, loc) {
     const shapeId = opts.type.shapeId;
     const shape = lowerer.shapes.get(shapeId);
     const names = shape?.fields.map((f) => f.name).join(",");
-    if (names !== "cwd,encoding,input,shell,stdio,timeout,windowsHide")
+    if (names !== "cwd,encoding,env,input,shell,stdio,timeout,windowsHide")
         return null;
     if (opts.kind !== "varRef" && opts.kind !== "recordGet" && opts.kind !== "fieldGet") {
         lowerer.noLowering("spawnSync with a computed options argument", optsNode, "the member reads re-read the options — bind the object to a const first");
@@ -526,6 +558,64 @@ function lowerSpawnSyncRuntimeOptions(lowerer, optsNode, argsNode, loc) {
             loc,
         }
         : boolLit(true, loc);
+    // The `env` member replaces the child's environment. Presence rides
+    // apart from the value (an absent option inherits ours): only the
+    // present branch converts the record to pairs.
+    const envField = shape.fields.find((f) => f.name === "env");
+    let hasEnv = null;
+    let envPairs = null;
+    if (envField) {
+        const ft = envField.type;
+        const readEnv = { kind: "recordGet", obj: opts, shapeId, field: "env", type: ft, loc };
+        const pairsOf = (rec, value) => {
+            if (rec.kind !== "record")
+                return null;
+            const helper = lowerer.envToPairsHelper(rec.shapeId, loc);
+            return helper === null
+                ? null
+                : { kind: "call", callee: helper, args: [value], type: arrayOf(STRING), loc };
+        };
+        if (ft.kind === "union") {
+            const arms = lowerer.unions.get(ft.unionId)?.arms ?? [];
+            let rec = null;
+            for (const arm of arms) {
+                if (arm.kind === "record") {
+                    rec = arm;
+                    break;
+                }
+            }
+            const uTag = lowerer.armTag(ft.unionId, UNDEFINED_T);
+            if (rec !== null && uTag >= 0) {
+                hasEnv = {
+                    kind: "unionIsTag",
+                    unionId: ft.unionId,
+                    tag: uTag,
+                    negated: true,
+                    value: readEnv,
+                    type: BOOL,
+                    loc,
+                };
+                envPairs = pairsOf(rec, {
+                    kind: "unionNarrow",
+                    unionId: ft.unionId,
+                    tag: lowerer.armTag(ft.unionId, rec),
+                    value: readEnv,
+                    type: rec,
+                    loc,
+                });
+            }
+        }
+        else if (ft.kind === "record") {
+            hasEnv = boolLit(true, loc);
+            envPairs = pairsOf(ft, readEnv);
+        }
+        // A member that exists but cannot convert must not fall back to the
+        // inheriting entry point: that would silently run the child WITHOUT
+        // the environment the caller asked for.
+        if (hasEnv === null || envPairs === null) {
+            lowerer.noLowering("spawnSync with an unsupported `env` record", optsNode, "every env value must be a string or `string | undefined` — the replacement environment converts to [key, value] pairs");
+        }
+    }
     return {
         cwd: readOpt("cwd", emptyStr, STRING),
         input: readOpt("input", emptyStr, STRING),
@@ -549,6 +639,8 @@ function lowerSpawnSyncRuntimeOptions(lowerer, optsNode, argsNode, loc) {
         inMode,
         outMode: modeCall(1),
         errMode: modeCall(2),
+        hasEnv,
+        envPairs,
     };
 }
 /** Interned `%cp.spawnSyncStdioMode.<fd>` — the runtime stdio-mode
@@ -716,20 +808,83 @@ function spawnSyncStdioModeHelper(lowerer, shapeId, stdioT, fd, loc) {
     });
     return name;
 }
+/** A runtime stdio SLOT expression whose TYPE is a union of the supported
+ * literals (`useStdin ? "pipe" : "ignore"`): the expression evaluates once
+ * into a hidden local, and a strEq chain maps the value to its mode (0
+ * ignore, 1 inherit, 3 pipe). The type proves the value is one of them; a
+ * lying assertion lands on the runtime TypeError Node raises for an
+ * invalid stdio value. Null for anything else — the literal and fd paths,
+ * and the fences, stay where they are. */
+function stdioModeExpr(lowerer, el, t, which) {
+    const parts = t.isUnionType() ? ts.constituentTypes(t) : [t];
+    if (parts.length < 2)
+        return null;
+    let hasPipe = false;
+    let hasInherit = false;
+    let hasIgnore = false;
+    for (const part of parts) {
+        if (!part.isStringLiteralType())
+            return null;
+        const literal = part.value;
+        if (literal === "pipe")
+            hasPipe = true;
+        else if (literal === "inherit")
+            hasInherit = true;
+        else if (literal === "ignore")
+            hasIgnore = true;
+        else
+            return null;
+    }
+    const slotLoc = locOf(el);
+    const value = lowerer.lowerExprExpecting(el, STRING);
+    const local = lowerer.declareHiddenLocal(`stdio${which}`, STRING);
+    local.mutable = true;
+    const read = () => varRef(local.id, STRING, slotLoc);
+    const withMode = (name, m, next) => ({
+        kind: "ternary",
+        cond: {
+            kind: "strEq",
+            negated: false,
+            left: read(),
+            right: strLit(name, slotLoc),
+            type: BOOL,
+            loc: slotLoc,
+        },
+        then: numLit(m, slotLoc),
+        else_: next,
+        type: F64,
+        loc: slotLoc,
+    });
+    let mode = nodeThrowExpr(1, "ERR_INVALID_ARG_VALUE", 'spawn stdio must be "pipe", "ignore", or "inherit"', F64, slotLoc);
+    if (hasPipe)
+        mode = withMode("pipe", 3, mode);
+    if (hasInherit)
+        mode = withMode("inherit", 1, mode);
+    if (hasIgnore)
+        mode = withMode("ignore", 0, mode);
+    return {
+        kind: "seqExpr",
+        stmts: [{ kind: "assign", localId: local.id, value, loc: slotLoc }],
+        result: mode,
+        type: F64,
+        loc: slotLoc,
+    };
+}
 /** `spawn(command, args?, options)` → one cp.spawn / cp.spawnOpts
  * libCall. Computed options use native runtime normalization. Inline
- * stdio accepts "ignore", "inherit", or "pipe" as the scalar,
- * or the 3-tuple whose stdin pipe becomes child.stdin, stdout/stderr
- * pipes become child.stdout/child.stderr, and output slots may also be
- * number fds. Omitting stdio uses Node's default: all three piped. The
- * other lowered
- * members: `detached` (a boolean literal, inline or carried by the
- * conditional spread `...(c ? { detached: true } : {})` in either
+ * stdio accepts "ignore", "inherit", or "pipe" as the scalar, or the
+ * 3-tuple whose stdin pipe becomes child.stdin, stdout/stderr pipes
+ * become child.stdout/child.stderr, and output slots may also be number
+ * fds; a 3-tuple slot whose type is a union of those literals
+ * (`useStdin ? "pipe" : "ignore"`) evaluates once and maps to its mode
+ * at the call. Omitting stdio uses Node's default: all three piped. The
+ * other lowered members: `detached` (a boolean literal, inline or carried
+ * by the conditional spread `...(c ? { detached: true } : {})` in either
  * orientation — POSIX_SPAWN_SETSID, the child gets its own session and
- * process group like Node's), `env` (a
- * REPLACEMENT environment, the exec-core pairs machinery), `cwd`, and
- * `windowsHide` (a POSIX no-op). The bare `{ stdio: "ignore" }` shape
- * keeps its historical cp.spawn lowering. */
+ * process group like Node's), `env` (a REPLACEMENT environment, the
+ * exec-core pairs machinery), `cwd`, and `windowsHide` (a POSIX no-op).
+ * The bare `{ stdio: "ignore" }` shape keeps its historical cp.spawn
+ * lowering. */
 export function lowerSpawnCall(lowerer, expr, loc) {
     if (expr.arguments.nodes.length > 3 || expr.arguments.nodes.some(ts.isSpreadElement)) {
         lowerer.noLowering("spawn with this argument shape", expr, 'the supported form is spawn(command, args?, { stdio: "pipe" | "ignore" | "inherit", detached?, env?, cwd? })');
@@ -770,7 +925,11 @@ export function lowerSpawnCall(lowerer, expr, loc) {
     // the out/err fd expressions for mode 2 (the daemon-log idiom:
     // stdio: ["ignore", logFd, logFd]).
     let sawStdio = false;
-    let inMode = 0, outMode = 0, errMode = 0;
+    // A slot may be a runtime expression (a union of the three literals), so
+    // each mode is an IrExpr: a literal here, the mapped expression there.
+    let inMode = numLit(0, loc);
+    let outMode = numLit(0, loc);
+    let errMode = numLit(0, loc);
     let outFd = numLit(0, loc);
     let errFd = numLit(0, loc);
     let detached = boolLit(false, loc);
@@ -780,6 +939,19 @@ export function lowerSpawnCall(lowerer, expr, loc) {
     let envPairs = { kind: "arrayLit", elems: [], type: arrayOf(STRING), loc };
     let cwd = emptyStr;
     let plain = true; // exactly { stdio: "ignore" }: the historical libCall
+    // Node evaluates the command, then the arguments, then the options
+    // object's members in source order. A member value that needs a hidden
+    // local is bound in that order, so a side effect in an earlier member (a
+    // call, an assignment) shapes a later one as it does under Node.
+    const valuePrelude = [];
+    const bindInto = (stmts, name, value) => {
+        if (value.kind === "strLit" || value.kind === "numLit" || value.kind === "boolLit")
+            return value;
+        const local = lowerer.declareHiddenLocal(name, value.type);
+        stmts.push({ kind: "varDecl", localId: local.id, init: value, loc });
+        return varRef(local.id, value.type, loc);
+    };
+    const bind = (name, value) => bindInto(valuePrelude, name, value);
     if (optsNode && ts.isObjectLiteralExpression(optsNode)) {
         for (const p of optsNode.properties.nodes) {
             // The conditional-spread idiom `...(isWindows ? {} : { detached:
@@ -802,14 +974,14 @@ export function lowerSpawnCall(lowerer, expr, loc) {
                             : null;
                     if (lit !== null) {
                         const cond = lowerer.lowerCondition(cs.cond);
-                        detached = {
+                        detached = bind("%spawnDetached", {
                             kind: "ternary",
                             cond,
                             then: boolLit(cs.whenTrue ? lit : false, loc),
                             else_: boolLit(cs.whenTrue ? false : lit, loc),
                             type: BOOL,
                             loc,
-                        };
+                        });
                         plain = false;
                         continue;
                     }
@@ -825,6 +997,9 @@ export function lowerSpawnCall(lowerer, expr, loc) {
                     // The 3-tuple form: every slot accepts a literal, including
                     // "pipe" (child.stdin/stdout/stderr); stdout/stderr also accept
                     // a number-typed fd (an openSync result — dup2'd into the child).
+                    // A slot EXPRESSION whose type is a union of the three literals
+                    // (`useStdin ? "pipe" : "ignore"`) evaluates once into a hidden
+                    // local and maps to its mode at the call.
                     if (ts.isArrayLiteralExpression(m.value) && m.value.elements.nodes.length === 3) {
                         const slot = (el, which) => {
                             const t = lowerer.typeOf(el);
@@ -832,7 +1007,7 @@ export function lowerSpawnCall(lowerer, expr, loc) {
                                 if (t.value !== "ignore" && t.value !== "inherit" && t.value !== "pipe") {
                                     lowerer.noLowering(`spawn with stdio "${t.value}"`, el, '"ignore", "inherit", "pipe", and number output fds are the supported stdio slots');
                                 }
-                                const mode = t.value === "inherit" ? 1 : t.value === "pipe" ? 3 : 0;
+                                const mode = numLit(t.value === "inherit" ? 1 : t.value === "pipe" ? 3 : 0, loc);
                                 if (which === 0)
                                     inMode = mode;
                                 else if (which === 1)
@@ -843,19 +1018,31 @@ export function lowerSpawnCall(lowerer, expr, loc) {
                                     plain = false;
                                 return;
                             }
+                            const runtimeMode = stdioModeExpr(lowerer, el, t, which);
+                            if (runtimeMode) {
+                                const mode = bind(`%spawnStdio${which}Mode`, runtimeMode);
+                                if (which === 0)
+                                    inMode = mode;
+                                else if (which === 1)
+                                    outMode = mode;
+                                else
+                                    errMode = mode;
+                                plain = false;
+                                return;
+                            }
                             if (which === 0) {
                                 lowerer.noLowering("spawn with this stdin slot", el, 'stdin takes "pipe", "ignore", or "inherit" (fd stdin has no lowering)');
                             }
                             if (lowerer.mapTypeOf(t)?.kind !== "f64") {
                                 lowerer.noLowering("spawn with this stdio option", el, 'each slot is "ignore", "inherit", or a number fd (an openSync result)');
                             }
-                            const fd = lowerer.lowerExprExpecting(el, F64);
+                            const fd = bind(which === 1 ? "%spawnStdoutFd" : "%spawnStderrFd", lowerer.lowerExprExpecting(el, F64));
                             if (which === 1) {
-                                outMode = 2;
+                                outMode = numLit(2, loc);
                                 outFd = fd;
                             }
                             else {
-                                errMode = 2;
+                                errMode = numLit(2, loc);
                                 errFd = fd;
                             }
                         };
@@ -870,7 +1057,7 @@ export function lowerSpawnCall(lowerer, expr, loc) {
                         lowerer.noLowering("spawn with this stdio option", m.value, '"pipe", "ignore", and "inherit" are the supported stdio literals ' +
                             "(or a 3-tuple of those and number output fds)");
                     }
-                    const mode = v === "inherit" ? 1 : v === "pipe" ? 3 : 0;
+                    const mode = numLit(v === "inherit" ? 1 : v === "pipe" ? 3 : 0, loc);
                     inMode = outMode = errMode = mode;
                     sawStdio = true;
                     if (v !== "ignore")
@@ -889,18 +1076,18 @@ export function lowerSpawnCall(lowerer, expr, loc) {
                         // A runtime boolean — the portable daemon idiom `detached:
                         // process.platform !== "win32"` — reaches the same
                         // POSIX_SPAWN_SETSID flag through scr_spawn_opts's bool slot.
-                        detached = lowerer.lowerExprExpecting(m.value, BOOL);
+                        detached = bind("%spawnDetached", lowerer.lowerExprExpecting(m.value, BOOL));
                         plain = false;
                     }
                     break;
                 }
                 case "env":
                     hasEnv = boolLit(true, loc);
-                    envPairs = recordToEnvPairs(lowerer, m.value);
+                    envPairs = bind("%spawnEnv", recordToEnvPairs(lowerer, m.value));
                     plain = false;
                     break;
                 case "cwd":
-                    cwd = lowerer.lowerExprExpecting(m.value, STRING);
+                    cwd = bind("%spawnCwd", lowerer.lowerExprExpecting(m.value, STRING));
                     plain = false;
                     break;
                 case "windowsHide":
@@ -925,7 +1112,7 @@ export function lowerSpawnCall(lowerer, expr, loc) {
         }
     }
     if (!sawStdio) {
-        inMode = outMode = errMode = 3;
+        inMode = outMode = errMode = numLit(3, loc);
         plain = false;
     }
     // Node joins [command, ...args] with single spaces for the shell form, and
@@ -940,15 +1127,15 @@ export function lowerSpawnCall(lowerer, expr, loc) {
     if (plain) {
         return { kind: "libCall", fn: "cp.spawn", args: [cmd, argv], type: CHILD_T, loc };
     }
-    return {
+    const callOf = (callCmd, callArgs) => ({
         kind: "libCall",
         fn: "cp.spawnOpts",
         args: [
-            cmd,
-            argv,
-            numLit(inMode, loc),
-            numLit(outMode, loc),
-            numLit(errMode, loc),
+            callCmd,
+            callArgs,
+            inMode,
+            outMode,
+            errMode,
             outFd,
             errFd,
             detached,
@@ -959,7 +1146,17 @@ export function lowerSpawnCall(lowerer, expr, loc) {
         ],
         type: CHILD_T,
         loc,
-    };
+    });
+    if (valuePrelude.length === 0)
+        return callOf(cmd, argv);
+    // The bound member values were collected in source order; the command and
+    // the arguments precede them, so an earlier value that changes a later
+    // one's input is seen as in Node.
+    const stmts = [];
+    const callCmd = bindInto(stmts, "%spawnCmd", cmd);
+    const callArgs = bindInto(stmts, "%spawnArgs", argv);
+    stmts.push(...valuePrelude);
+    return { kind: "seqExpr", stmts, result: callOf(callCmd, callArgs), type: CHILD_T, loc };
 }
 /** `fork(staticModulePath, args?, options?)` embeds the selected program
  * module and re-executes the native artifact with one private target id.