@scriptc/compiler 0.0.30 → 0.0.31

package/dist/frontend/lowering/lowerer.d.ts

@@ -1044,6 +1044,15 @@ export declare class Lowerer {
     /** formatIrType with this Lowerer's registries (records and unions expand
      * to their structure in diagnostics). */
     fmt(t: IrType): string;
+    /** Whether an IR value has JavaScript Array identity. Homogeneous arrays
+     * use the native array representation; non-empty fixed tuples use a
+     * positional record shape so their slots can keep distinct types, but
+     * Array.isArray must still answer true for both representations. */
+    isArrayValueType(t: IrType): boolean;
+    /** Runtime tags of every JavaScript-array arm in one union. Kept beside
+     * isArrayValueType so Array.isArray's predicate and its narrowing bridge
+     * cannot disagree about fixed tuple arms. */
+    arrayValueTags(unionId: string): number[];
     /** isJsonSafeType with this Lowerer's registries — the shared fence for
      * what JSON.stringify accepts and what a checked cast can validate. */
     jsonSafe(t: IrType): boolean;
@@ -1067,14 +1076,24 @@ export declare class Lowerer {
      * arm before the JSON round trip). */
     boundaryExitSafe(t: IrType): boolean;
     isIslandExpr(node: ts.Expression): boolean;
-    /** True when this node's CHECKER type is `any[]`/`unknown[]` — the type
-     * tsc's Array.isArray predicate narrows readonly arrays to (its `arg is
-     * any[]` quirk), and what a union collapses to when such an arm absorbs
-     * its siblings. The VALUE behind it can still be a real static array
-     * (maybeNarrow's isArray bridge extracts the union's array arm), so
-     * receiver-typed dispatch falls back to the LOWERED type under this
-     * test. */
+    /** True when this node's CHECKER type is proven `any[]`/`unknown[]`,
+     * directly or through the intersection tsc builds for a readonly tuple
+     * union (`(Model | readonly [Model, Command]) & any[]`; TS7 distributes
+     * this over the union arms). These are forms of the `arg is any[]`
+     * Array.isArray predicate; the VALUE behind them can still be a real
+     * static array/tuple (maybeNarrow's bridge extracts the union's one
+     * array-valued arm), so receiver-typed dispatch falls back to the LOWERED
+     * type under this test. */
     checkerAnyArray(node: ts.Expression): boolean;
+    /** Type-level half of checkerAnyArray, for narrowing sites that already
+     * queried the checker type from a general AST node. */
+    checkerAnyArrayType(t: ts.Type): boolean;
+    /** The lowered static array/tuple value behind checkerAnyArray's
+     * synthetic `any[]` spelling. Array.isArray can leave readonly tuple
+     * unions as intersections that do not map directly, while maybeNarrow
+     * still extracts the runtime-proven array arm from the original union.
+     * Receiver dispatchers use this bridge instead of the synthetic type. */
+    checkerArrayValue(node: ts.Expression): IrExpr | null;
     /** Substitutes a bound type parameter anywhere inside mapType's recursion
      * (`T`, `T[]`, `{ v: T }`, `(x: T) => T` all resolve). Inert outside
      * generic instantiation. */

package/dist/frontend/lowering/lowerer.js

@@ -2683,6 +2683,20 @@ export class Lowerer {
     fmt(t) {
         return formatIrType(t, this.shapes, this.unions);
     }
+    /** Whether an IR value has JavaScript Array identity. Homogeneous arrays
+     * use the native array representation; non-empty fixed tuples use a
+     * positional record shape so their slots can keep distinct types, but
+     * Array.isArray must still answer true for both representations. */
+    isArrayValueType(t) {
+        return t.kind === "array" || (t.kind === "record" && this.shapes.get(t.shapeId)?.tuple === true);
+    }
+    /** Runtime tags of every JavaScript-array arm in one union. Kept beside
+     * isArrayValueType so Array.isArray's predicate and its narrowing bridge
+     * cannot disagree about fixed tuple arms. */
+    arrayValueTags(unionId) {
+        const def = this.unions.get(unionId);
+        return def ? def.arms.flatMap((arm, tag) => (this.isArrayValueType(arm) ? [tag] : [])) : [];
+    }
     /** isJsonSafeType with this Lowerer's registries — the shared fence for
      * what JSON.stringify accepts and what a checked cast can validate. */
     jsonSafe(t) {
@@ -2716,18 +2730,49 @@ export class Lowerer {
     isIslandExpr(node) {
         return isIslandExpr(this, node);
     }
-    /** True when this node's CHECKER type is `any[]`/`unknown[]` — the type
-     * tsc's Array.isArray predicate narrows readonly arrays to (its `arg is
-     * any[]` quirk), and what a union collapses to when such an arm absorbs
-     * its siblings. The VALUE behind it can still be a real static array
-     * (maybeNarrow's isArray bridge extracts the union's array arm), so
-     * receiver-typed dispatch falls back to the LOWERED type under this
-     * test. */
+    /** True when this node's CHECKER type is proven `any[]`/`unknown[]`,
+     * directly or through the intersection tsc builds for a readonly tuple
+     * union (`(Model | readonly [Model, Command]) & any[]`; TS7 distributes
+     * this over the union arms). These are forms of the `arg is any[]`
+     * Array.isArray predicate; the VALUE behind them can still be a real
+     * static array/tuple (maybeNarrow's bridge extracts the union's one
+     * array-valued arm), so receiver-typed dispatch falls back to the LOWERED
+     * type under this test. */
     checkerAnyArray(node) {
-        const t = this.typeOf(node);
-        return (this.checker.isArrayType(t) &&
-            ((this.checker.getTypeArguments(t)[0]?.flags ?? 0) &
-                (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0);
+        return this.checkerAnyArrayType(this.typeOf(node));
+    }
+    /** Type-level half of checkerAnyArray, for narrowing sites that already
+     * queried the checker type from a general AST node. */
+    checkerAnyArrayType(t) {
+        const isAnyArray = (part) => this.checker.isArrayType(part) &&
+            ((this.checker.getTypeArguments(part)[0]?.flags ?? 0) &
+                (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0;
+        const visit = (part) => {
+            if (isAnyArray(part))
+                return true;
+            // 5.9 leaves `(U) & any[]` as one intersection; 7 distributes it
+            // into `(A & any[]) | (B & any[])`. An intersection is array-proven
+            // when one constituent is; a union is array-proven only when EVERY
+            // arm is, so an ordinary `any[] | string` never qualifies.
+            if ((part.flags & ts.TypeFlags.Intersection) !== 0) {
+                return part.getTypes().some(visit);
+            }
+            if (part.isUnionType())
+                return part.getTypes().every(visit);
+            return false;
+        };
+        return visit(t);
+    }
+    /** The lowered static array/tuple value behind checkerAnyArray's
+     * synthetic `any[]` spelling. Array.isArray can leave readonly tuple
+     * unions as intersections that do not map directly, while maybeNarrow
+     * still extracts the runtime-proven array arm from the original union.
+     * Receiver dispatchers use this bridge instead of the synthetic type. */
+    checkerArrayValue(node) {
+        if (!this.checkerAnyArray(node))
+            return null;
+        const value = this.lowerExpr(node);
+        return this.isArrayValueType(value.type) ? value : null;
     }
     /** Substitutes a bound type parameter anywhere inside mapType's recursion
      * (`T`, `T[]`, `{ v: T }`, `(x: T) => T` all resolve). Inert outside