@scriptc/compiler 0.2.7 → 0.2.9

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

@@ -7,6 +7,7 @@ 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";
@@ -17,6 +18,121 @@ import { lowerArrayUnionHofCall, lowerArraySortCall, lowerArrayHofCall, lowerArr
 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)) ??
@@ -510,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,
@@ -536,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.
@@ -634,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
@@ -722,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) {
@@ -760,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,