@scriptc/compiler 0.0.29 → 0.0.31

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

@@ -35,21 +35,22 @@ export declare function arrayHofHelper(L: Lowerer, method: "map" | "filter" | "f
    * parameter type). Null when this isn't a tuple slice/map — writers and
    * the rest of the surface keep their fences. */
 export declare function lowerTupleReadMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** The OOB-SAFE indexed read for --npm-static package files: `xs[i]`
+/** An OOB-SAFE indexed read: `xs[i]`
    * answers the interned `elem | undefined` union — the element when `i`
    * is an integer in [0, len), JS's property-miss undefined otherwise —
    * instead of the trap divergence 4 documents for program code.
    * Package JS is inference-typed, guard-style code (`registeredArguments
    * .slice(-1)[0]`, commander's last-element probe), and the trap would
    * fire on working Node idioms; program files keep the documented trap
-   * (their annotations can prove bounds). Null when the element is
-   * union-typed (the re-tag has no story here) — the caller keeps the
-   * ordinary read. */
-export declare function lowerNpmStaticSafeIndexRead(L: Lowerer, arr: IrExpr & {
+   * (their annotations can prove bounds). Existing element unions retag
+   * into the canonical union with an added undefined arm. */
+export declare function lowerSafeIndexRead(L: Lowerer, arr: IrExpr & {
     type: {
         kind: "array";
     };
 }, index: IrExpr, loc: SrcLoc): IrExpr | null;
+/** Backward-compatible name for the npm-static probe path. */
+export declare const lowerNpmStaticSafeIndexRead: typeof 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)

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

@@ -633,13 +633,23 @@ export function lowerTupleReadMethodCall(L, call, access) {
         return null;
     if (!L.isStdlibMember(access))
         return null;
-    const receiverIr = L.mapTypeOf(L.typeOf(access.expression));
+    let receiverIr = L.mapTypeOf(L.typeOf(access.expression));
+    let receiver = null;
+    // A readonly tuple union under Array.isArray is checker-typed as an
+    // unmappable intersection with any[], while maybeNarrow still extracts
+    // its one tuple arm. Dispatch the supported tuple read methods from
+    // that lowered representation, like tuple indexing and `.length`.
+    const checkerArray = L.checkerArrayValue(access.expression);
+    if (checkerArray?.type.kind === "record") {
+        receiverIr = checkerArray.type;
+        receiver = checkerArray;
+    }
     if (receiverIr?.kind !== "record")
         return null;
     const shape = L.shapes.get(receiverIr.shapeId);
     if (!shape?.tuple)
         return null;
-    const receiver = L.lowerExpr(access.expression);
+    receiver ??= L.lowerExpr(access.expression);
     if (receiver.type.kind !== "record")
         return null;
     if (!pureReemittable(receiver)) {
@@ -702,26 +712,25 @@ export function lowerTupleReadMethodCall(L, call, access) {
     const helper = arrayHofHelper(L, "map", snapshotElem, fnRet, arity, loc);
     return { kind: "call", callee: helper, args: [snapshot, fnArg], type: arrayOf(fnRet), loc };
 }
-/** The OOB-SAFE indexed read for --npm-static package files: `xs[i]`
+/** An OOB-SAFE indexed read: `xs[i]`
    * answers the interned `elem | undefined` union — the element when `i`
    * is an integer in [0, len), JS's property-miss undefined otherwise —
    * instead of the trap divergence 4 documents for program code.
    * Package JS is inference-typed, guard-style code (`registeredArguments
    * .slice(-1)[0]`, commander's last-element probe), and the trap would
    * fire on working Node idioms; program files keep the documented trap
-   * (their annotations can prove bounds). Null when the element is
-   * union-typed (the re-tag has no story here) — the caller keeps the
-   * ordinary read. */
-export function lowerNpmStaticSafeIndexRead(L, arr, index, loc) {
+   * (their annotations can prove bounds). Existing element unions retag
+   * into the canonical union with an added undefined arm. */
+export function lowerSafeIndexRead(L, arr, index, loc) {
     const elem = arr.type.elem;
-    if (elem.kind === "union" || elem.kind === "void" || elem.kind === "dyn")
+    if (elem.kind === "void" || elem.kind === "dyn")
         return null;
-    const resultT = L.withUndefinedArm(elem);
-    if (resultT.kind !== "union")
+    const resultT = elem.kind === "union" ? L.withUndefinedArmOf(elem) : L.withUndefinedArm(elem);
+    if (!resultT || resultT.kind !== "union")
         return null;
     const undefTag = L.armTag(resultT.unionId, UNDEFINED_T);
-    const foundTag = L.armTag(resultT.unionId, elem);
-    if (undefTag < 0 || foundTag < 0)
+    const foundTag = elem.kind === "union" ? -1 : L.armTag(resultT.unionId, elem);
+    if (undefTag < 0 || (elem.kind !== "union" && foundTag < 0))
         return null;
     const arrT = arr.type;
     const key = `idxOr:${typeKey(elem)}`;
@@ -745,6 +754,7 @@ export function lowerNpmStaticSafeIndexRead(L, arr, index, loc) {
         };
         const body = [
             readLenStmt(arrT, loc),
+            { kind: "if", cond: { kind: "bin", op: "!==", left: i, right: i, type: BOOL, loc }, then: [{ kind: "return", value: miss, loc }], else_: null, loc },
             { kind: "if", cond: lt(i, num(0)), then: [{ kind: "return", value: miss, loc }], else_: null, loc },
             { kind: "if", cond: { kind: "bin", op: ">=", left: i, right: n, type: BOOL, loc }, then: [{ kind: "return", value: miss, loc }], else_: null, loc },
             // A fractional index is a property miss too (floor(i) < i exactly
@@ -759,7 +769,9 @@ export function lowerNpmStaticSafeIndexRead(L, arr, index, loc) {
             { kind: "varDecl", localId: "v.0", init: { kind: "arrayGet", arr: ref("a.0", arrT), index: i, type: elem, loc }, loc },
             {
                 kind: "return",
-                value: { kind: "unionWrap", unionId: resultT.unionId, tag: foundTag, value: v, type: resultT, loc },
+                value: elem.kind === "union"
+                    ? L.coerceToExpected(v, resultT)
+                    : { kind: "unionWrap", unionId: resultT.unionId, tag: foundTag, value: v, type: resultT, loc },
                 loc,
             },
         ];
@@ -782,6 +794,8 @@ export function lowerNpmStaticSafeIndexRead(L, arr, index, loc) {
     }
     return { kind: "call", callee: name, args: [arr, index], type: resultT, 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)