@scriptc/compiler 0.2.6 → 0.2.8

package/dist/frontend/lowering/containers/array-methods.js

@@ -1,9 +1,13 @@
+import { lowerArrayIteratorValue } from "../iterator-adapters.js";
+import { identityPreservingWidening } from "../coercions/identity.js";
+import { arrayConcatHelper } from "./array-concat.js";
 import { boolLit, countedFor, numLit, strLit, varRef } from "../../../ir/build.js";
 import { InternalCompilerError } from "../../../errors.js";
 import * as ts from "../../ts7/adapter.js";
 import { BOOL, DYN, F64, JSVAL, STRING, UNDEFINED_T, arrayOf, isRefCounted, isUnitType, typeEquals, } from "../../../ir/ir.js";
 import { ARRAY_METHODS } from "../surfaces.js";
 import { tryLowerExpression } from "../expressions/try-lower-expression.js";
+import { isSafeToRepeat } from "../expressions/evaluation-safety.js";
 import { isJsSourceFile, locOf } from "../../program.js";
 import { islandPrimitiveExit, lowerDynDispatchMethodCall } from "../lower-calls.js";
 import { arrayIndexPresent, arrayValueRead, arrayValueStore, arrayValueType, } from "../array-values.js";
@@ -11,9 +15,124 @@ import { typeKey } from "../../type-mapper.js";
 import { defaultAfterUndefined, lowerPositionArgument, lowerStaticallyUndefinedArgument, positionNumber, } from "../optional-arguments.js";
 import { lowerArrayCopyWithin, lowerArrayFill } from "../array-indexed-mutation.js";
 import { lowerArrayUnionHofCall, lowerArraySortCall, lowerArrayHofCall, lowerArrayFindLikeCall, lowerArrayFlatMapCall, lowerArrayReduceCall, } from "./array-callbacks.js";
-import { lowerArraySpreadItems, lowerArrayValueItems } from "./array-construction.js";
+import { lowerArraySpreadItems, lowerArrayValueItems, widenArraySpread, } from "./array-construction.js";
 import { arrayLengthDeclaration } from "./array-iteration.js";
 import { lowerArrayCallback, callbackArrayElement, requireProducedArrayElement, } from "./callback-arguments.js";
+/** `a.push(v, ...)` where some argument is a runtime-optional read of the
+ * element type (an unchecked array read or a hole-observing iteration
+ * binding). Every argument evaluates before the first append; a present
+ * value takes the ordinary push (and its inline dense fast path), while a
+ * missing one appends a present-undefined slot at the current length,
+ * exactly what Node stores. The result is the final length. Pure
+ * receivers and arguments are repeated instead of copied into temporaries:
+ * appends run no user code, so repeated reads observe the same values. */
+function lowerOptionalArrayPush(lowerer, receiver, values, elem, loc) {
+    const stmts = [];
+    const pure = isSafeToRepeat(receiver) && values.every(isSafeToRepeat);
+    const stable = (value, name) => {
+        if (pure)
+            return value;
+        const temp = lowerer.declareHiddenLocal(name, value.type);
+        stmts.push({ kind: "varDecl", localId: temp.id, init: value, loc });
+        return varRef(temp.id, value.type, loc);
+    };
+    const target = stable(receiver, "%pushTarget");
+    const args = values.map((value) => stable(value, "%pushValue"));
+    const length = () => ({
+        kind: "arrIntrinsic",
+        method: "length",
+        receiver: target,
+        args: [],
+        type: F64,
+        loc,
+    });
+    const push = (value) => ({
+        kind: "exprStmt",
+        expr: { kind: "arrIntrinsic", method: "push", receiver: target, args: [value], type: F64, loc },
+        loc,
+    });
+    for (const value of args) {
+        if (value.type.kind === "union" && lowerer.runtimeOptionalWidening(value.type, elem) !== null) {
+            const unionId = value.type.unionId;
+            stmts.push({
+                kind: "if",
+                cond: {
+                    kind: "unionIsTag",
+                    unionId,
+                    tag: lowerer.armTag(unionId, UNDEFINED_T),
+                    negated: false,
+                    value,
+                    type: BOOL,
+                    loc,
+                },
+                then: [{ kind: "arraySetUndefined", arr: target, index: length(), loc }],
+                else_: [push(lowerer.coerceToExpected(value, elem))],
+                loc,
+            });
+        }
+        else {
+            stmts.push(push(lowerer.coerceToExpected(value, elem)));
+        }
+    }
+    return { kind: "seqExpr", stmts, result: length(), type: F64, loc };
+}
+/** `a.splice(start, count, v)` where v may hold undefined at run time.
+ * Receiver, start, count, and v evaluate once, in order; a present v is
+ * inserted as a plain element literal (which a statement-position splice
+ * then inserts without any temporary array), a missing one through the
+ * present-undefined item array. Both arms return the removed elements. */
+function lowerOptionalSpliceItem(lowerer, receiver, positions, value, elem, arrType, loc) {
+    const stmts = [];
+    const repeatable = (e) => e.kind === "numLit" || isSafeToRepeat(e);
+    const pure = repeatable(receiver) && positions.every(repeatable) && repeatable(value);
+    const stable = (e, name) => {
+        if (pure)
+            return e;
+        const temp = lowerer.declareHiddenLocal(name, e.type);
+        stmts.push({ kind: "varDecl", localId: temp.id, init: e, loc });
+        return varRef(temp.id, e.type, loc);
+    };
+    const target = stable(receiver, "%spliceTarget");
+    const bounds = positions.map((position) => stable(position, "%splicePosition"));
+    const item = stable(value, "%spliceValue");
+    if (item.type.kind !== "union")
+        throw new InternalCompilerError("runtime-optional splice item is not a union");
+    const splice = (items) => ({
+        kind: "arrIntrinsic",
+        method: "spliceInsert",
+        receiver: target,
+        args: [...bounds, items],
+        type: arrType,
+        loc,
+    });
+    return {
+        kind: "seqExpr",
+        stmts,
+        result: {
+            kind: "ternary",
+            cond: {
+                kind: "unionIsTag",
+                unionId: item.type.unionId,
+                tag: lowerer.armTag(item.type.unionId, UNDEFINED_T),
+                negated: false,
+                value: item,
+                type: BOOL,
+                loc,
+            },
+            then: splice(lowerArrayValueItems(lowerer, [item], elem, arrType, loc)),
+            else_: splice({
+                kind: "arrayLit",
+                elems: [lowerer.coerceToExpected(item, elem)],
+                type: arrType,
+                loc,
+            }),
+            type: arrType,
+            loc,
+        },
+        type: arrType,
+        loc,
+    };
+}
 function primitivePositionType(lowerer, type) {
     if (type.kind === "union") {
         return (lowerer.unions.get(type.unionId)?.arms.every((arm) => primitivePositionType(lowerer, arm)) ??
@@ -100,7 +219,12 @@ export function lowerArrayMethodCall(lowerer, call, access) {
     if (lowerer.chainBlocked(access, call))
         return null;
     const name = access.name.text;
-    if (!ARRAY_METHODS.has(name) && name !== "sort" && name !== "shift" && name !== "splice")
+    const iteratorMethod = (name === "values" || name === "keys" || name === "entries") && call.arguments.length === 0;
+    if (!ARRAY_METHODS.has(name) &&
+        name !== "sort" &&
+        name !== "shift" &&
+        name !== "splice" &&
+        !iteratorMethod)
         return null;
     let receiverIr = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
     const checkerReceiver = lowerer.checker.getTypeAtLocation(access.expression);
@@ -144,6 +268,19 @@ export function lowerArrayMethodCall(lowerer, call, access) {
         return null;
     let elem = receiverIr.elem;
     const loc = locOf(call);
+    if (iteratorMethod) {
+        const type = lowerer.mapTypeOf(lowerer.typeOf(call));
+        const receiver = lowerer.lowerExpr(access.expression);
+        // Only a static array resolves to a generator here; other lowered
+        // receivers (island arrays, narrowed unions, checked dynamic values)
+        // continue to their dedicated handling below.
+        if (receiver.type.kind === "array") {
+            const value = type ? lowerArrayIteratorValue(lowerer, receiver, name, type, loc) : null;
+            if (value)
+                return value;
+            lowerer.unsupported("SC1090", call, `'${name}()' iterators over this array element type`);
+        }
+    }
     // An island handle behind an array-typed .d.ts surface
     // (`parts().join("-")` — arrays never exit eagerly, so the value
     // stays jsval): the ENGINE's own Array.prototype method runs on the
@@ -436,9 +573,9 @@ export function lowerArrayMethodCall(lowerer, call, access) {
             : null;
         if ((name === "push" || name === "unshift") && spreadArg && ts.isSpreadElement(spreadArg)) {
             let src = lowerer.lowerExpr(spreadArg.expression);
-            // `a.push(...someSet)` / `a.unshift(...someSet)`: a same-element Set drains first
+            // `a.push(...someSet)` / `a.unshift(...someSet)`: a compatible Set drains first
             // (setIntrinsic toArray — insertion order), then appends.
-            if (src.type.kind === "set" && typeEquals(src.type.elem, elem)) {
+            if (src.type.kind === "set" && identityPreservingWidening(lowerer, src.type.elem, elem)) {
                 src = {
                     kind: "setIntrinsic",
                     method: "toArray",
@@ -448,6 +585,19 @@ export function lowerArrayMethodCall(lowerer, call, access) {
                     loc,
                 };
             }
+            if (src.type.kind === "array" &&
+                !typeEquals(src.type, receiverIr) &&
+                identityPreservingWidening(lowerer, src.type.elem, elem)) {
+                const items = widenArraySpread(lowerer, src, elem, loc);
+                return {
+                    kind: "arrIntrinsic",
+                    method: name === "push" ? "pushSpread" : "unshiftSpread",
+                    receiver,
+                    args: [items],
+                    type: F64,
+                    loc,
+                };
+            }
             if (!typeEquals(src.type, receiverIr)) {
                 lowerer.unsupported("SC1090", spreadArg, `${name === "push" ? "pushing" : "unshifting"} a spread of '${lowerer.fmt(src.type)}' onto a '${lowerer.fmt(receiverIr)}' array (only a same-element-type array spreads)`);
             }
@@ -476,10 +626,13 @@ export function lowerArrayMethodCall(lowerer, call, access) {
         }
         const valueProbes = call.arguments.map((arg) => tryLowerExpression(lowerer, arg));
         if (valueProbes.some((probe) => probe !== null && lowerer.runtimeOptionalWidening(probe.type, elem) !== null)) {
+            if (name === "push") {
+                return lowerOptionalArrayPush(lowerer, receiver, call.arguments.map((arg) => lowerer.lowerExpr(arg)), elem, loc);
+            }
             const items = lowerArrayValueItems(lowerer, call.arguments.map((arg) => lowerer.lowerExpr(arg)), elem, receiverIr, loc);
             return {
                 kind: "arrIntrinsic",
-                method: name === "push" ? "pushSpread" : "unshiftSpread",
+                method: "unshiftSpread",
                 receiver,
                 args: [items],
                 type: F64,
@@ -502,6 +655,9 @@ export function lowerArrayMethodCall(lowerer, call, access) {
         };
     }
     if (name === "pop") {
+        // An unused result needs no value at all: drop the last slot.
+        if (resultDiscarded(call))
+            return lowerDiscardedPop(lowerer, access.expression, loc);
         // Widen a union payload through the normal array-read machinery
         // before removing it. Reinterpreting the stored union's tag as the
         // result union would confuse arms when undefined changes their order.
@@ -540,7 +696,7 @@ export function lowerArrayMethodCall(lowerer, call, access) {
             const argIr = lowerer.mapTypeOf(lowerer.typeOf(argNode));
             const probedArg = probedUntyped ? tryLowerExpression(lowerer, argNode) : null;
             const argArrayType = probedArg?.type.kind === "array" ? probedArg.type : argIr?.kind === "array" ? argIr : null;
-            if (argArrayType !== null && typeEquals(argArrayType.elem, elem)) {
+            if (argArrayType !== null) {
                 if (elem.kind === "array" && typeEquals(argArrayType, elem)) {
                     // number[][].concat(inner: number[]) — TS says element, JS's
                     // IsArray says spread; no honest static answer exists.
@@ -554,7 +710,7 @@ export function lowerArrayMethodCall(lowerer, call, access) {
                     arg = lowerer.coerceInto(argNode, arg, argArrayType);
                 if (arg.type.kind !== "array")
                     lowerer.badType(argNode, lowerer.typeOf(argNode));
-                shape.push("a");
+                shape.push(arg.type.elem);
                 args.push(arg);
                 continue;
             }
@@ -567,16 +723,16 @@ export function lowerArrayMethodCall(lowerer, call, access) {
             if (elem.kind === "jsval") {
                 const arg = lowerer.lowerExpr(argNode);
                 if (arg.type.kind === "array" && arg.type.elem.kind === "jsval") {
-                    shape.push("a");
+                    shape.push(arg.type.elem);
                     args.push(arg);
                     continue;
                 }
             }
             // An element value — union elements wrap exactly like a push.
-            shape.push("e");
+            shape.push(null);
             args.push(lowerer.lowerExprExpecting(argNode, elem));
         }
-        const helper = arrayConcatHelper(lowerer, elem, shape, loc);
+        const helper = arrayConcatHelper(lowerer, elem, shape, call, loc);
         return { kind: "call", callee: helper, args: [receiver, ...args], type: receiverIr, loc };
     }
     if (name === "slice") {
@@ -600,6 +756,9 @@ export function lowerArrayMethodCall(lowerer, call, access) {
         const hasSpread = itemNodes.some(ts.isSpreadElement);
         const itemProbes = hasSpread ? [] : itemNodes.map((arg) => tryLowerExpression(lowerer, arg));
         const statefulItems = itemProbes.some((probe) => probe !== null && lowerer.runtimeOptionalWidening(probe.type, elem) !== null);
+        if (statefulItems && itemNodes.length === 1) {
+            return lowerOptionalSpliceItem(lowerer, receiver, args, lowerer.lowerExpr(itemNodes[0]), elem, receiverIr, loc);
+        }
         const items = hasSpread
             ? lowerArraySpreadItems(lowerer, itemNodes, elem, receiverIr, loc)
             : statefulItems
@@ -688,7 +847,80 @@ export function lowerArrayMethodCall(lowerer, call, access) {
     // reduce / reduceRight
     return lowerArrayReduceCall(lowerer, call, access, name, elem);
 }
-/** Read before splice so removal cannot destroy the result's owned payload.
+/** The call's value is never read: an expression statement, a `void`
+ * operand, the left of a comma, or a for-loop initializer or update. */
+function resultDiscarded(call) {
+    let child = call;
+    let parent = call.parent;
+    while (parent && ts.isParenthesizedExpression(parent)) {
+        child = parent;
+        parent = parent.parent;
+    }
+    if (!parent)
+        return false;
+    if (ts.isExpressionStatement(parent) || ts.isVoidExpression(parent))
+        return true;
+    if (ts.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.CommaToken)
+        return parent.left === child || resultDiscarded(parent);
+    return (ts.isForStatement(parent) && (parent.initializer === child || parent.incrementor === child));
+}
+/** `xs.pop()` whose result is unused: truncate a non-empty array by one
+ * slot. Truncation releases the removed element and leaves the length of
+ * an empty array at zero, as pop does (pop's own `length = 0` store, a
+ * no-op unless the array is frozen). */
+function lowerDiscardedPop(lowerer, source, loc) {
+    const receiver = lowerer.lowerExpr(source);
+    const arr = lowerer.declareHiddenLocal("%popArray", receiver.type);
+    const arrRef = varRef(arr.id, arr.type, loc);
+    const length = lowerer.declareHiddenLocal("%popLength", F64);
+    const lengthRef = varRef(length.id, F64, loc);
+    return {
+        kind: "seqExpr",
+        stmts: [
+            { kind: "varDecl", localId: arr.id, init: receiver, loc },
+            {
+                kind: "varDecl",
+                localId: length.id,
+                init: {
+                    kind: "arrIntrinsic",
+                    method: "length",
+                    receiver: arrRef,
+                    args: [],
+                    type: F64,
+                    loc,
+                },
+                loc,
+            },
+            {
+                kind: "if",
+                cond: { kind: "bin", op: ">", left: lengthRef, right: numLit(0, loc), type: BOOL, loc },
+                then: [
+                    {
+                        kind: "arraySetLength",
+                        arr: arrRef,
+                        length: {
+                            kind: "bin",
+                            op: "-",
+                            left: lengthRef,
+                            right: numLit(1, loc),
+                            type: F64,
+                            loc,
+                        },
+                        loc,
+                        pop: true,
+                    },
+                ],
+                else_: [{ kind: "arraySetLength", arr: arrRef, length: numLit(0, loc), loc, pop: true }],
+                loc,
+            },
+        ],
+        // The value is never read; any placeholder scalar keeps it unboxed.
+        result: numLit(0, loc),
+        type: F64,
+        loc,
+    };
+}
+/** Read before removal so it cannot destroy the result's owned payload.
  * The source is evaluated once and empty/sparse arrays yield undefined using
  * the same slot-state checks as an indexed read. */
 function lowerUnionArrayRemoval(lowerer, source, elem, first, loc) {
@@ -726,18 +958,39 @@ function lowerUnionArrayRemoval(lowerer, source, elem, first, loc) {
                 loc,
             },
             { kind: "varDecl", localId: result.id, init: value, loc },
-            {
-                kind: "exprStmt",
-                expr: {
-                    kind: "arrIntrinsic",
-                    method: "splice",
-                    receiver: arrRef,
-                    args: [indexRef, numLit(1, loc)],
-                    type: arr.type,
+            first
+                ? {
+                    kind: "exprStmt",
+                    expr: {
+                        kind: "arrIntrinsic",
+                        method: "splice",
+                        receiver: arrRef,
+                        args: [indexRef, numLit(1, loc)],
+                        type: arr.type,
+                        loc,
+                    },
+                    loc,
+                }
+                : {
+                    // Removing the last slot is a truncation: no removed-element
+                    // array, and an empty array keeps length zero.
+                    kind: "if",
+                    cond: {
+                        kind: "bin",
+                        op: ">=",
+                        left: indexRef,
+                        right: numLit(0, loc),
+                        type: BOOL,
+                        loc,
+                    },
+                    then: [{ kind: "arraySetLength", arr: arrRef, length: indexRef, loc, pop: true }],
+                    // Pop's `length = 0` store on an empty array (a no-op unless the
+                    // array is frozen).
+                    else_: [
+                        { kind: "arraySetLength", arr: arrRef, length: numLit(0, loc), loc, pop: true },
+                    ],
                     loc,
                 },
-                loc,
-            },
         ],
         result: varRef(result.id, result.type, loc),
         type: result.type,
@@ -1576,129 +1829,6 @@ export function lowerTupleReadMethodCall(lowerer, call, access, tupleReceiver) {
     }
     return { kind: "call", callee: helper, args: [receiver, fnArg], type: outType, loc };
 }
-/** An ordinary indexed read: values retain their element type, while
- * holes, missing properties, and present undefined yield undefined. */
-export function lowerSafeIndexRead(lowerer, arr, index, loc) {
-    if (arr.type.kind !== "array")
-        throw new InternalCompilerError("indexed read requires an array");
-    const elem = arr.type.elem;
-    if (elem.kind === "void")
-        return null;
-    const resultT = arrayValueType(lowerer, elem);
-    const key = `idxOr:${typeKey(elem)}`;
-    let name = lowerer.arrHofHelpers.get(key);
-    if (!name) {
-        name = `%arr.idxOr.${lowerer.arrHofHelpers.size}`;
-        lowerer.arrHofHelpers.set(key, name);
-        const arrT = arr.type;
-        lowerer.liftedFns.push({
-            name,
-            params: [
-                { localId: "a.0", name: "a", type: arrT },
-                { localId: "i.0", name: "i", type: F64 },
-            ],
-            returnType: resultT,
-            locals: [
-                { id: "a.0", name: "a", type: arrT, mutable: false },
-                { id: "i.0", name: "i", type: F64, mutable: false },
-            ],
-            body: [
-                {
-                    kind: "return",
-                    value: arrayValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, loc),
-                    loc,
-                },
-            ],
-            loc,
-        });
-    }
-    return { kind: "call", callee: name, args: [arr, index], type: resultT, loc };
-}
-/** Fuse only our own f64-array read helper with immediate ToNumber.
- * Reuse its arguments verbatim so the receiver and index still evaluate
- * exactly once, in order, before the read. Do not specialize user calls,
- * union-element arrays, or optional values stored in locals. */
-export function tryLowerNumericIndexRead(lowerer, operand, loc) {
-    if (operand.kind !== "call" ||
-        operand.callee !== lowerer.arrHofHelpers.get(`idxOr:${typeKey(F64)}`))
-        return null;
-    const [arr, index] = operand.args;
-    if (operand.args.length !== 2 ||
-        arr?.type.kind !== "array" ||
-        arr.type.elem.kind !== "f64" ||
-        index?.type.kind !== "f64")
-        return null;
-    // The intrinsic owns the evaluated receiver through index evaluation,
-    // then borrows it for one slot lookup. No extra helper parameter or
-    // separate state/getter expressions need to retain the array again.
-    return {
-        kind: "arrIntrinsic",
-        method: "getNumber",
-        receiver: arr,
-        args: [index],
-        type: F64,
-        loc,
-    };
-}
-/** Backward-compatible name for the npm-static probe path. */
-export const lowerNpmStaticSafeIndexRead = lowerSafeIndexRead;
-/** Interned synthetic function for one (elem, argument-shape) concat —
- * `%arr.concat.<n>(a, x0, x1, ...)`: a fresh array takes a's elements
- * (pushSpread), then each argument pushes (element) or spreads (array)
- * in order; the receiver and array arguments are only READ. Rides
- * liftedFns like the HOF helpers (a plain function — no captures). */
-function arrayConcatHelper(lowerer, elem, shape, loc) {
-    const key = `concat:${typeKey(elem)}:${shape.join("")}`;
-    const existing = lowerer.arrHofHelpers.get(key);
-    if (existing)
-        return existing;
-    const name = `%arr.concat.${lowerer.arrHofHelpers.size}`;
-    lowerer.arrHofHelpers.set(key, name);
-    const arrT = arrayOf(elem);
-    const locals = [
-        { id: "a.0", name: "a", type: arrT, mutable: false },
-        ...shape.map((s, i) => ({
-            id: `x.${i}`,
-            name: `x${i}`,
-            type: s === "a" ? arrT : elem,
-            mutable: false,
-        })),
-        { id: "out.0", name: "out", type: arrT, mutable: false },
-    ];
-    const params = [
-        { localId: "a.0", name: "a", type: arrT },
-        ...shape.map((s, i) => ({
-            localId: `x.${i}`,
-            name: `x${i}`,
-            type: s === "a" ? arrT : elem,
-        })),
-    ];
-    const append = (s, src) => ({
-        kind: "exprStmt",
-        expr: {
-            kind: "arrIntrinsic",
-            method: s === "a" ? "concatSpread" : "push",
-            receiver: varRef("out.0", arrT, loc),
-            args: [src],
-            type: F64,
-            loc,
-        },
-        loc,
-    });
-    const body = [
-        {
-            kind: "varDecl",
-            localId: "out.0",
-            init: { kind: "arrayLit", elems: [], type: arrT, loc },
-            loc,
-        },
-        append("a", varRef("a.0", arrT, loc)),
-        ...shape.map((s, i) => append(s, varRef(`x.${i}`, s === "a" ? arrT : elem, loc))),
-        { kind: "return", value: varRef("out.0", arrT, loc), loc },
-    ];
-    lowerer.liftedFns.push({ name, params, returnType: arrT, locals, body, loc });
-    return name;
-}
 /** `a.at(i)` — the es2022 relative-index read. Desugars to an interned
  * helper over existing IR nodes, ToIntegerOrInfinity-exact: the index
  * truncates toward zero (floor for non-negatives, mirrored floor for