@scriptc/compiler 0.0.23 → 0.0.25

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

@@ -1,7 +1,8 @@
 import * as ts from "../ts7/adapter.js";
 import type { Lowerer } from "./lowerer.js";
 import { IrExpr, IrFunction, IrRecordShape, IrStmt, IrType, SrcLoc } from "../../ir/nodes.js";
-/** Ambient array method calls. `push`/`pop`/`indexOf`/`includes`/`join`
+/** Ambient array method calls. `push`/`unshift`/`pop`/`reverse`/
+ * `indexOf`/`includes`/`join`
    * lower to arrIntrinsic; the HOF family — `map`/`filter`/`forEach`/
    * `find`/`some`/`every`/`flatMap`/`reduce`/`reduceRight` — desugars to a
    * direct call of a synthetic loop function (see lowerArrayHofCall and

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

@@ -70,11 +70,29 @@ function defaultAfterUndefined(value, defaultValue) {
 }
 function lowerOptionalDefaultArg(L, node, expected, defaultValue) {
     const undefinedArg = lowerStaticallyUndefinedArg(L, node);
-    return undefinedArg
-        ? defaultAfterUndefined(undefinedArg, defaultValue)
-        : L.lowerExprExpecting(node, expected);
+    if (undefinedArg)
+        return defaultAfterUndefined(undefinedArg, defaultValue);
+    const value = L.lowerExpr(node);
+    if (value.type.kind === "union") {
+        const def = L.unions.get(value.type.unionId);
+        if (def?.arms.length === 2 &&
+            def.arms.some((arm) => arm.kind === "undefinedT") &&
+            def.arms.some((arm) => typeEquals(arm, expected))) {
+            // A runtime optional argument uses its API default only on the
+            // undefined arm. The exact two-arm gate deliberately excludes null:
+            // optional parameters do not admit it, and an asserted null must keep
+            // the ordinary checked-narrow failure instead of defaulting.
+            return { kind: "nullish", left: value, right: defaultValue, type: expected, loc: value.loc };
+        }
+    }
+    return L.coerceInto(node, value, expected);
 }
-/** Ambient array method calls. `push`/`pop`/`indexOf`/`includes`/`join`
+function lowerSplitLimitArg(L, node, loc) {
+    const defaultValue = { kind: "numLit", value: 4294967295, type: F64, loc };
+    return node ? lowerOptionalDefaultArg(L, node, F64, defaultValue) : defaultValue;
+}
+/** Ambient array method calls. `push`/`unshift`/`pop`/`reverse`/
+ * `indexOf`/`includes`/`join`
    * lower to arrIntrinsic; the HOF family — `map`/`filter`/`forEach`/
    * `find`/`some`/`every`/`flatMap`/`reduce`/`reduceRight` — desugars to a
    * direct call of a synthetic loop function (see lowerArrayHofCall and
@@ -184,6 +202,19 @@ export function lowerArrayMethodCall(L, call, access) {
             loc,
         };
     }
+    if (name === "reverse") {
+        if (call.arguments.length !== 0) {
+            L.noLowering(`.reverse with ${call.arguments.length} arguments`, call);
+        }
+        return {
+            kind: "arrIntrinsic",
+            method: "reverse",
+            receiver: L.lowerExpr(access.expression),
+            args: [],
+            type: receiverIr,
+            loc,
+        };
+    }
     if (name === "with") {
         if (call.arguments.length !== 2 || call.arguments.some(ts.isSpreadElement)) {
             L.noLowering(`.with with ${call.arguments.length} arguments`, call);
@@ -238,11 +269,11 @@ export function lowerArrayMethodCall(L, call, access) {
     // indexOf/includes take a fromIndex, join's separator is optional, the
     // predicate/mapping HOFs take a thisArg. Each unlowered form is fenced
     // per site (SC2020), never silently truncated to the supported
-    // arguments. push lowers every declared form (variadic, 0 args
+    // arguments. push/unshift lower every declared form (variadic, 0 args
     // included — Node returns the unchanged length); reduce/reduceRight
     // lower both declared forms (with and without an initial value).
     const arity = {
-        push: [0, Number.MAX_SAFE_INTEGER], pop: [0, 0], indexOf: [1, 1], includes: [1, 1], join: [1, 1],
+        push: [0, Number.MAX_SAFE_INTEGER], unshift: [0, Number.MAX_SAFE_INTEGER], pop: [0, 0], indexOf: [1, 1], includes: [1, 1], join: [1, 1],
         concat: [0, Number.MAX_SAFE_INTEGER],
         slice: [0, 2], shift: [0, 0], splice: [1, 2], at: [1, 1],
         map: [1, 1], filter: [1, 1], forEach: [1, 1], find: [1, 1], findIndex: [1, 1], some: [1, 1],
@@ -262,36 +293,43 @@ export function lowerArrayMethodCall(L, call, access) {
                         : undefined;
         L.noLowering(`.${name} with ${call.arguments.length} argument${call.arguments.length === 1 ? "" : "s"}`, call, hint);
     }
-    if (name === "push" || name === "pop") {
+    if (name === "push" || name === "unshift" || name === "pop") {
         const receiver = L.lowerExpr(access.expression);
-        // `a.push(...src)`: append src's elements in order (count
-        // snapshotted first, so `a.push(...a)` duplicates like JS) and
-        // return the new length.
+        // `a.push(...src)` / `a.unshift(...src)`: copy src's elements in
+        // order (count snapshotted first, so the self-spread forms duplicate
+        // like JS) and return the new length.
         const spreadArg = call.arguments.length === 1 && ts.isSpreadElement(call.arguments[0])
             ? call.arguments[0]
             : null;
-        if (name === "push" && spreadArg && ts.isSpreadElement(spreadArg)) {
+        if ((name === "push" || name === "unshift") && spreadArg && ts.isSpreadElement(spreadArg)) {
             let src = L.lowerExpr(spreadArg.expression);
-            // `a.push(...someSet)`: a same-element Set drains first
+            // `a.push(...someSet)` / `a.unshift(...someSet)`: a same-element Set drains first
             // (setIntrinsic toArray — insertion order), then appends.
             if (src.type.kind === "set" && typeEquals(src.type.elem, elem)) {
                 src = { kind: "setIntrinsic", method: "toArray", receiver: src, args: [], type: arrayOf(src.type.elem), loc };
             }
             if (!typeEquals(src.type, receiverIr)) {
-                L.unsupported("SC1090", spreadArg, `pushing a spread of '${L.fmt(src.type)}' onto a '${L.fmt(receiverIr)}' array (only a same-element-type array spreads)`);
+                L.unsupported("SC1090", spreadArg, `${name === "push" ? "pushing" : "unshifting"} a spread of '${L.fmt(src.type)}' onto a '${L.fmt(receiverIr)}' array (only a same-element-type array spreads)`);
             }
-            return { kind: "arrIntrinsic", method: "pushSpread", receiver, args: [src], type: F64, loc };
+            return {
+                kind: "arrIntrinsic",
+                method: name === "push" ? "pushSpread" : "unshiftSpread",
+                receiver,
+                args: [src],
+                type: F64,
+                loc,
+            };
         }
-        // Pushed values flow into the element slot like an assignment would:
+        // Inserted values flow into the element slot like an assignment would:
         // union-element arrays wrap plain arm values (coerceInto is inert
         // when the types already agree).
-        const args = call.arguments.map((a) => name === "push" ? L.lowerExprExpecting(a, elem) : L.lowerExpr(a));
+        const args = call.arguments.map((a) => name === "push" || name === "unshift" ? L.lowerExprExpecting(a, elem) : L.lowerExpr(a));
         return {
             kind: "arrIntrinsic",
             method: name,
             receiver,
             args,
-            type: name === "push" ? F64 : elem,
+            type: name === "push" || name === "unshift" ? F64 : elem,
             loc,
         };
     }
@@ -539,7 +577,7 @@ export function lowerArrayHofCall(L, call, access, method, elem) {
     if (method === "map" &&
         (fnRet.kind === "map" || fnRet.kind === "set" || fnRet.kind === "url" ||
             fnRet.kind === "searchParams" || fnRet.kind === "generator" || fnRet.kind === "caught" ||
-            fnRet.kind === "stats" || fnRet.kind === "spawnRes" || fnRet.kind === "netSocket" ||
+            fnRet.kind === "stats" || fnRet.kind === "fileHandle" || fnRet.kind === "spawnRes" || fnRet.kind === "netSocket" ||
             fnRet.kind === "dgramSocket" || fnRet.kind === "testCtx" || fnRet.kind === "httpReq" ||
             fnRet.kind === "httpRes" || fnRet.kind === "httpClientReq" || fnRet.kind === "secureCtx" ||
             fnRet.kind === "fsWatcher" || fnRet.kind === "childStream" || fnRet.kind === "procStream" ||
@@ -4618,14 +4656,13 @@ export function lowerRegexMethodCall(L, call, access, dynReceiver) {
         const arg0 = call.arguments[0];
         if (!arg0 || L.mapTypeOf(L.typeOf(arg0))?.kind !== "regex")
             return null;
-        // The lib declares forms beyond the lowered slice: split's limit
-        // parameter and function replacement values both typecheck now —
-        // fenced with the regex-surface code (its hint lists what works).
-        if (name === "split" && call.arguments.length !== 1) {
-            L.unsupported("SC1120", call, "'.split()' with a limit argument");
-        }
         const receiver = lowerReceiver();
-        const args = call.arguments.map((a) => L.lowerExpr(a));
+        // Split's omitted or undefined limit is 2^32-1. Complete it here so
+        // both IR backends and the runtime have one required (regex, limit)
+        // shape; an optional-number value selects the default at runtime.
+        const args = name === "split"
+            ? [L.lowerExpr(arg0), lowerSplitLimitArg(L, call.arguments[1], loc)]
+            : call.arguments.map((a) => L.lowerExpr(a));
         if (name !== "split" && args[1]?.type.kind !== "string") {
             L.unsupported("SC1120", call.arguments[1] ?? call, "function replacement values (replacements must be string templates)");
         }
@@ -4677,7 +4714,9 @@ export function lowerStringMethodCall(L, call, access, dynReceiver) {
         L.noLowering(`.${access.name.text} with ${call.arguments.length} argument${call.arguments.length === 1 ? "" : "s"} on strings`, call);
     }
     const receiver = dynReceiver ? dynReceiver() : L.lowerExpr(access.expression);
-    const args = call.arguments.map((a) => L.lowerExpr(a));
+    const args = entry.method === "split"
+        ? [L.lowerExpr(call.arguments[0]), lowerSplitLimitArg(L, call.arguments[1], locOf(call))]
+        : call.arguments.map((a) => L.lowerExpr(a));
     // split's separator must BE a string here (a regex argument was
     // claimed by lowerRegexMethodCall before this path) — the lib's
     // `string | RegExp` union has no lowering as a VALUE.
@@ -5041,10 +5080,38 @@ export function lowerBytesMethodCall(L, call, access) {
         }
         if (nArgs > 3)
             L.noLowering(`.toString with ${nArgs} arguments on Buffers`, call);
-        const encNode = call.arguments[0];
-        const encName = encNode ? bufEncoding(L, "Buffer.toString", encNode) : "utf8";
         const receiver = L.lowerExpr(access.expression);
-        const enc = { kind: "strLit", value: encName, type: STRING, loc };
+        const encNode = call.arguments[0];
+        let method = "toString";
+        let enc = { kind: "strLit", value: "utf8", type: STRING, loc };
+        if (encNode) {
+            const encType = L.typeOf(encNode);
+            const encName = encType.isStringLiteralType()
+                ? knownBufEncoding(encType.value)
+                : undefined;
+            if (encName !== undefined) {
+                // Keep literals on the canonical, non-throwing fast path.
+                enc = { kind: "strLit", value: encName, type: STRING, loc };
+            }
+            else {
+                const undefinedArg = lowerStaticallyUndefinedArg(L, encNode);
+                if (undefinedArg) {
+                    // An explicit undefined is the omitted-encoding default. Keep
+                    // the canonical, non-throwing path while preserving effects
+                    // from equivalent spellings such as `void sideEffect()`.
+                    enc = defaultAfterUndefined(undefinedArg, enc);
+                }
+                else {
+                    // A BufferEncoding-typed variable selects its decoder at
+                    // runtime. Optional variables default their undefined arm to
+                    // utf8; the checked intrinsic canonicalizes every present
+                    // alias/case and raises Node's ERR_UNKNOWN_ENCODING when a cast
+                    // lets a bad value through.
+                    enc = lowerOptionalDefaultArg(L, encNode, STRING, enc);
+                    method = "toStringVar";
+                }
+            }
+        }
         // The range form toString(enc, start[, end]) decodes the clamped
         // [start, end) byte window (Node's slice-then-decode). An omitted
         // end stays omitted (2 intrinsic args) — the emitter supplies the
@@ -5054,11 +5121,11 @@ export function lowerBytesMethodCall(L, call, access) {
             const start = L.lowerExprExpecting(call.arguments[1], F64);
             if (nArgs === 3) {
                 const end = L.lowerExprExpecting(call.arguments[2], F64);
-                return { kind: "bytesIntrinsic", method: "toString", receiver, args: [enc, start, end], type: STRING, loc };
+                return { kind: "bytesIntrinsic", method, receiver, args: [enc, start, end], type: STRING, loc };
             }
-            return { kind: "bytesIntrinsic", method: "toString", receiver, args: [enc, start], type: STRING, loc };
+            return { kind: "bytesIntrinsic", method, receiver, args: [enc, start], type: STRING, loc };
         }
-        return { kind: "bytesIntrinsic", method: "toString", receiver, args: [enc], type: STRING, loc };
+        return { kind: "bytesIntrinsic", method, receiver, args: [enc], type: STRING, loc };
     }
     // The Buffer-declared comparison/search/mutation surface. All of
     // these resolve against the Buffer interface (the checker keeps most