@scriptc/compiler 0.4.5 → 0.4.6

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

@@ -6,7 +6,7 @@ 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, STRING, UNDEFINED_T, arrayOf, isRefCounted, isUnitType, typeEquals, } from "../../../ir/ir.js";
+import { BOOL, DYN, F64, STRING, UNDEFINED_T, arrayOf, canDynCheckTo, 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";
@@ -16,6 +16,8 @@ import { arrayIndexPresent, arrayValueRead, arrayValueStore, arrayValueType, ele
 import { typeKey } from "../../type-mapper.js";
 import { defaultAfterUndefined, lowerPositionArgument, lowerStaticallyUndefinedArgument, positionNumber, } from "../optional-arguments.js";
 import { lowerArrayCopyWithin, lowerArrayFill } from "../array-indexed-mutation.js";
+import { checkedIteratorPack, widenedIterableType } from "../expressions/array-literals.js";
+import { notIterableSpelling } from "../iterable-spelling.js";
 import { lowerArrayUnionHofCall, lowerArraySortCall, lowerArrayHofCall, lowerArrayFindLikeCall, lowerArrayFlatMapCall, lowerArrayReduceCall, lowerTuplePredicateCall, } from "./array-callbacks.js";
 import { lowerArraySpreadItems, lowerArrayValueItems, widenArraySpread, } from "./array-construction.js";
 import { arrayLengthDeclaration } from "./array-iteration.js";
@@ -171,49 +173,167 @@ function lowerArrayPosition(lowerer, node, defaultValue, subject) {
         loc,
     };
 }
-function lowerArrayJoinSeparator(lowerer, node, loc) {
+/** `receiver.join(node)`: the separator defaults to "," for an absent or
+ * undefined argument and is ToString of anything else. */
+function lowerArrayJoin(lowerer, receiver, node, loc) {
+    const join = (sep) => arrayJoin(receiver, sep, loc);
     const comma = strLit(",", loc);
     if (!node)
-        return comma;
+        return join(comma);
     const undefinedValue = lowerStaticallyUndefinedArgument(lowerer, node);
     if (undefinedValue)
-        return defaultAfterUndefined(undefinedValue, comma);
+        return join(defaultAfterUndefined(undefinedValue, comma));
     const value = lowerer.lowerExpr(node);
     if (value.type.kind === "nullT")
-        return defaultAfterUndefined(value, strLit("null", loc));
+        return join(defaultAfterUndefined(value, strLit("null", loc)));
+    const ternary = (cond, else_) => ({
+        kind: "ternary",
+        cond,
+        then: comma,
+        else_,
+        type: STRING,
+        loc,
+    });
+    // The separator from its value: "," for the undefined value, ToString of
+    // anything else (null prints "null", a symbol throws the catchable
+    // TypeError).
+    let separatorOf = (ref) => lowerer.ensureString(ref, node);
+    let held = false;
     if (value.type.kind === "union") {
-        const undefinedTag = lowerer.armTag(value.type.unionId, UNDEFINED_T);
+        const unionId = value.type.unionId;
+        const undefinedTag = lowerer.armTag(unionId, UNDEFINED_T);
         if (undefinedTag >= 0) {
-            const local = lowerer.declareHiddenLocal("%joinSeparator", value.type);
-            const ref = varRef(local.id, value.type, loc);
-            return {
-                kind: "seqExpr",
-                stmts: [{ kind: "varDecl", localId: local.id, init: value, loc }],
-                result: {
-                    kind: "ternary",
-                    cond: {
-                        kind: "unionIsTag",
-                        unionId: value.type.unionId,
-                        tag: undefinedTag,
-                        value: ref,
-                        negated: false,
-                        type: BOOL,
-                        loc,
-                    },
-                    then: comma,
-                    else_: lowerer.ensureString(ref, node),
-                    type: STRING,
-                    loc,
-                },
-                type: STRING,
+            held = true;
+            separatorOf = (ref) => ternary({
+                kind: "unionIsTag",
+                unionId,
+                tag: undefinedTag,
+                value: ref,
+                negated: false,
+                type: BOOL,
                 loc,
-            };
+            }, lowerer.ensureString(ref, node));
         }
     }
-    if (value.type.kind === "dyn") {
-        lowerer.noLowering(".join separator with a runtime-dependent undefined value", node);
+    else if (value.type.kind === "dyn") {
+        held = true;
+        separatorOf = (ref) => ternary({ kind: "dynTest", test: "undefined", value: ref, type: BOOL, loc }, { kind: "libCall", fn: "dyn.toStringCoerce", args: [ref], type: STRING, loc });
     }
-    return lowerer.ensureString(value, node);
+    if (!convertsWithoutCode(lowerer, value.type))
+        return orderedSeparatorJoin(lowerer, receiver, value, separatorOf, loc);
+    if (!held)
+        return join(separatorOf(value));
+    const local = lowerer.declareHiddenLocal("%joinSeparator", value.type);
+    return join({
+        kind: "seqExpr",
+        stmts: [{ kind: "varDecl", localId: local.id, init: value, loc }],
+        result: separatorOf(varRef(local.id, value.type, loc)),
+        type: STRING,
+        loc,
+    });
+}
+/** Whether ToString of a `type` value runs no code of the program: primitives
+ * and unions of them. */
+function convertsWithoutCode(lowerer, type) {
+    if (type.kind === "union")
+        return (lowerer.unions.get(type.unionId)?.arms.every((arm) => convertsWithoutCode(lowerer, arm)) ??
+            false);
+    return (type.kind === "string" ||
+        type.kind === "f64" ||
+        type.kind === "bool" ||
+        type.kind === "nullT" ||
+        type.kind === "undefinedT");
+}
+function arrayJoin(receiver, sep, loc) {
+    return { kind: "arrIntrinsic", method: "join", receiver, args: [sep], type: STRING, loc };
+}
+/** `receiver.join(value)` where ToString of the separator value can run code
+ * of the program (an object's toString, a checked-dynamic value).
+ * Array.prototype.join reads the length before it converts the separator,
+ * and that code can change the array, so the join covers exactly the
+ * elements below that length: a longer array joins its first ones, and the
+ * missing elements of a shorter one join as empty strings. */
+function orderedSeparatorJoin(lowerer, receiver, value, separatorOf, loc) {
+    const array = lowerer.declareHiddenLocal("%joinArray", receiver.type);
+    const separatorValue = lowerer.declareHiddenLocal("%joinSeparatorValue", value.type);
+    const length = lowerer.declareHiddenLocal("%joinLength", F64);
+    const separator = lowerer.declareHiddenLocal("%joinSeparator", STRING);
+    const arrayRef = varRef(array.id, receiver.type, loc);
+    const separatorValueRef = varRef(separatorValue.id, value.type, loc);
+    const lengthRef = varRef(length.id, F64, loc);
+    const separatorRef = varRef(separator.id, STRING, loc);
+    const currentLength = () => ({
+        kind: "arrIntrinsic",
+        method: "length",
+        receiver: arrayRef,
+        args: [],
+        type: F64,
+        loc,
+    });
+    const compare = (op, left, right) => ({
+        kind: "bin",
+        op,
+        left,
+        right,
+        type: BOOL,
+        loc,
+    });
+    const minus = (left, right) => ({
+        kind: "bin",
+        op: "-",
+        left,
+        right,
+        type: F64,
+        loc,
+    });
+    const repeat = (count) => ({
+        kind: "strIntrinsic",
+        method: "repeat",
+        receiver: separatorRef,
+        args: [count],
+        type: STRING,
+        loc,
+    });
+    const ternary = (cond, then, else_) => ({
+        kind: "ternary",
+        cond,
+        then,
+        else_,
+        type: STRING,
+        loc,
+    });
+    const first = {
+        kind: "arrIntrinsic",
+        method: "slice",
+        receiver: arrayRef,
+        args: [numLit(0, loc), lengthRef],
+        type: receiver.type,
+        loc,
+    };
+    const changed = ternary(compare(">", currentLength(), lengthRef), arrayJoin(first, separatorRef, loc), ternary(compare("===", currentLength(), numLit(0, loc)), repeat(minus(lengthRef, numLit(1, loc))), {
+        kind: "strConcat",
+        left: arrayJoin(arrayRef, separatorRef, loc),
+        right: repeat(minus(lengthRef, currentLength())),
+        type: STRING,
+        loc,
+    }));
+    return {
+        kind: "seqExpr",
+        stmts: [
+            { kind: "varDecl", localId: array.id, init: receiver, loc },
+            { kind: "varDecl", localId: separatorValue.id, init: value, loc },
+            { kind: "varDecl", localId: length.id, init: currentLength(), loc },
+            {
+                kind: "varDecl",
+                localId: separator.id,
+                init: separatorOf(separatorValueRef),
+                loc,
+            },
+        ],
+        result: ternary(compare("===", currentLength(), lengthRef), arrayJoin(arrayRef, separatorRef, loc), changed),
+        type: STRING,
+        loc,
+    };
 }
 /** Ambient array method calls. `push`/`unshift`/`pop`/`reverse`/
  * `indexOf`/`includes`/`join`
@@ -642,6 +762,17 @@ export function lowerArrayMethodCall(lowerer, call, access) {
                 // Fresh elements (an array literal) convert into the element layout.
                 src = liftedFreshSpread(lowerer, spreadArg.expression, src, receiverIr, loc) ?? src;
             }
+            // A source the checker typed WIDER than the iterable it holds at run
+            // time (an untyped value, a `T | undefined` local): Node iterates
+            // whatever the value is and throws the not-iterable TypeError for
+            // null/undefined. Drain through the checked iterator walk and
+            // validate each element into the receiver's slot.
+            if (!typeEquals(src.type, receiverIr) &&
+                (src.type.kind === "dyn" || widenedIterableType(lowerer, src.type)) &&
+                canDynCheckTo(receiverIr, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
+                const dynSrc = lowerer.coerceInto(spreadArg.expression, src, DYN);
+                src = lowerer.coerceInto(spreadArg.expression, checkedIteratorPack(lowerer, dynSrc, notIterableSpelling(spreadArg.expression), loc), receiverIr);
+            }
             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)`);
             }
@@ -808,6 +939,14 @@ export function lowerArrayMethodCall(lowerer, call, access) {
                 args.push(arg);
                 continue;
             }
+            // A checked-dynamic value: whether JS spreads it is decided at run
+            // time (an array spreads one level, anything else is one element).
+            if ((argIr === null || argIr.kind === "dyn") &&
+                (probedArg ?? tryLowerExpression(lowerer, argNode))?.type.kind === "dyn") {
+                shape.push("dyn");
+                args.push(lowerer.lowerExpr(argNode));
+                continue;
+            }
             // An element value — union elements wrap exactly like a push.
             shape.push(null);
             args.push(lowerer.lowerExprExpecting(argNode, elem));
@@ -916,8 +1055,7 @@ export function lowerArrayMethodCall(lowerer, call, access) {
             lowerer.unsupported("SC1090", call, "'.join()' on arrays of this element type (number, string, boolean and Date arrays join — unions of those with undefined/null arms too, the units printing empty like JS)");
         }
         const receiver = lowerer.lowerExpr(access.expression);
-        const sep = lowerArrayJoinSeparator(lowerer, call.arguments.nodes[0], loc);
-        return { kind: "arrIntrinsic", method: "join", receiver, args: [sep], type: STRING, loc };
+        return lowerArrayJoin(lowerer, receiver, call.arguments.nodes[0], loc);
     }
     if (name === "map" || name === "filter" || name === "forEach") {
         return lowerArrayHofCall(lowerer, call, access, name, elem);
@@ -1537,17 +1675,27 @@ function arraySearchHelper(lowerer, method, elem, valueT, needleT, directNeedle,
         },
         loc,
     };
-    const visitPresent = [
-        { kind: "varDecl", localId: "value.0", init: value, loc },
-        {
-            kind: "if",
-            cond: match,
-            then: [{ kind: "return", value: method === "includes" ? boolLit(true, loc) : indexRef, loc }],
-            else_: null,
-            loc,
-        },
-        advance,
-    ];
+    const found = {
+        kind: "if",
+        cond: directNeedle ? equal : match,
+        then: [{ kind: "return", value: method === "includes" ? boolLit(true, loc) : indexRef, loc }],
+        else_: null,
+        loc,
+    };
+    // A direct needle reads only value slots: an undefined or foreign
+    // element written through a dynamic view has no element-typed payload.
+    const visitPresent = directNeedle
+        ? [
+            {
+                kind: "if",
+                cond: { kind: "bin", op: "===", left: stateRef, right: numLit(1, loc), type: BOOL, loc },
+                then: [{ kind: "varDecl", localId: "value.0", init: value, loc }, found],
+                else_: null,
+                loc,
+            },
+            advance,
+        ]
+        : [{ kind: "varDecl", localId: "value.0", init: value, loc }, found, advance];
     const skipHole = method === "lastIndexOf"
         ? [advance]
         : [