@scriptc/compiler 0.0.9 → 0.0.10

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

@@ -274,6 +274,23 @@ export type ForOfIterProjection = "keys" | "values" | "entries";
    * enter/exit bracketing: the pair list compacts immediately (no
    * tombstones), so there is no iteration depth to keep exact. */
 export declare function lowerForOfSearchParams(L: Lowerer, stmt: ts.ForOfStatement, iterable: IrExpr, proj?: ForOfIterProjection): IrStmt;
+/** for-of over an ARRAY's keys()/entries() projections consumed directly
+   * by the head (`for (const [index, line] of lines.entries())` — the
+   * dominant formatter idiom): the LIVE index walk — the length re-reads
+   * every pass, exactly the array iterator's contract (elements appended
+   * mid-walk are visited; a shrink ends the loop early) — yielding the
+   * index (`keys`, a number) or the [index, element] pair (`entries`).
+   * `values` never lands here: lowerForOf's receiver unwrap owns it. A
+   * `[i, v]` head of plain identifiers binds straight from the reads (the
+   * tuple never materializes); identifier heads and the remaining
+   * patterns bind through the checker's own element type — the interned
+   * [number, T] tuple record. Stored iterator OBJECTS keep their fence
+   * (only the direct for-of position unwraps). */
+export declare function lowerForOfArrayIter(L: Lowerer, stmt: ts.ForOfStatement, iterable: IrExpr & {
+    type: IrType & {
+        kind: "array";
+    };
+}, proj: "keys" | "entries"): IrStmt;
 export declare function lowerForOfMap(L: Lowerer, stmt: ts.ForOfStatement, iterable: IrExpr, mapT: IrType & {
     kind: "map";
 }, proj?: ForOfIterProjection): IrStmt;

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

@@ -2649,23 +2649,27 @@ export function lowerIteratorHelperCall(L, call, access) {
     const terminal = access.name.text;
     if (!ITER_TERMINALS.has(terminal))
         return null;
-    // Walk receiver: stage* ← values() ← array-typed source.
+    // Walk receiver: stage* ← values()/entries() ← array-typed source
+    // (entries seeds the chain with [index, element] pairs — the
+    // checker's own tuple type).
     const stages = [];
     let cur = access.expression;
     let source = null;
+    let srcProj = "values";
     for (;;) {
         if (!ts.isCallExpression(cur) || !ts.isPropertyAccessExpression(cur.expression))
             return null;
         if (cur.questionDotToken || cur.expression.questionDotToken)
             return null;
         const name = cur.expression.name.text;
-        if (name === "values" && cur.arguments.length === 0) {
+        if ((name === "values" || name === "entries") && cur.arguments.length === 0) {
             const recvIr = L.mapTypeOf(L.typeOf(cur.expression.expression));
             if (recvIr?.kind !== "array")
                 return null;
             if (!L.isStdlibMember(cur.expression))
                 return null;
             source = cur.expression.expression;
+            srcProj = name;
             break;
         }
         if (!ITER_STAGES.has(name) || cur.arguments.length !== 1 || ts.isSpreadElement(cur.arguments[0]))
@@ -2687,7 +2691,12 @@ export function lowerIteratorHelperCall(L, call, access) {
     const items = L.lowerExpr(source);
     if (items.type.kind !== "array")
         return null;
-    let elem = items.type.elem;
+    // The entries() seed: the interned [number, T] tuple — the same shape
+    // the checker's own [number, T] maps to, so stage callbacks typed
+    // against the lib's pairs intern equal.
+    let elem = srcProj === "entries"
+        ? { kind: "record", shapeId: L.shapes.intern([{ name: "0", type: F64 }, { name: "1", type: items.type.elem }], true) }
+        : items.type.elem;
     const stageIrs = [];
     for (const s of stages) {
         if (s.name === "take" || s.name === "drop") {
@@ -2774,12 +2783,12 @@ export function lowerIteratorHelperCall(L, call, access) {
         L.noLowering(`.${terminal} at this result type`, call, "the chain's element and result types must be representable — annotate the callbacks' types");
     }
     const stageKeys = stageIrs.map((s) => (s.kind === "take" || s.kind === "drop" ? s.kind : `${s.kind}:${typeKey(s.fn.type)}`));
-    const key = `iter:${typeKey(items.type)}:${stageKeys.join(",")}:${terminal}:${termArgs.map((a) => typeKey(a.type)).join(",")}`;
+    const key = `iter:${srcProj}:${typeKey(items.type)}:${stageKeys.join(",")}:${terminal}:${termArgs.map((a) => typeKey(a.type)).join(",")}`;
     let helper = L.arrHofHelpers.get(key);
     if (!helper) {
         helper = `%iter.${terminal}.${L.arrHofHelpers.size}`;
         L.arrHofHelpers.set(key, helper);
-        L.liftedFns.push(buildIterChainFn(L, helper, items.type, stageIrs, terminal, termArgs.map((a) => a.type), resultT, loc));
+        L.liftedFns.push(buildIterChainFn(L, helper, items.type, srcProj, stageIrs, terminal, termArgs.map((a) => a.type), resultT, loc));
     }
     const budgetOrFn = stageIrs.map((s) => (s.kind === "take" || s.kind === "drop" ? s.budget : s.fn));
     return { kind: "call", callee: helper, args: [items, ...budgetOrFn, ...termArgs], type: resultT, loc };
@@ -2862,7 +2871,7 @@ function internBudgetChecker(L, loc) {
    * source order, flatMap as an inner loop over its returned array.
    * Pre-loop, a zero take budget marks done immediately — Node pulls
    * nothing at all through a take(0). */
-function buildIterChainFn(L, name, itemsT, stages, terminal, termArgTs, resultT, loc) {
+function buildIterChainFn(L, name, itemsT, srcProj, stages, terminal, termArgTs, resultT, loc) {
     const ref = (localId, type) => ({ kind: "varRef", localId, type, loc });
     const num = (value) => ({ kind: "numLit", value, type: F64, loc });
     const boolLit = (value) => ({ kind: "boolLit", value, type: BOOL, loc });
@@ -2883,7 +2892,12 @@ function buildIterChainFn(L, name, itemsT, stages, terminal, termArgTs, resultT,
     const doneId = addLocal("done", BOOL, true);
     const done = () => ref(doneId, BOOL);
     const setDone = { kind: "assign", localId: doneId, value: boolLit(true), loc };
-    let elem = itemsT.elem;
+    // The entries() seed builds each pass's [index, element] pair — the
+    // same interned tuple the caller computed its stage types against.
+    const seedT = srcProj === "entries"
+        ? { kind: "record", shapeId: L.shapes.intern([{ name: "0", type: F64 }, { name: "1", type: itemsT.elem }], true) }
+        : itemsT.elem;
+    let elem = seedT;
     const slots = [];
     for (const s of stages) {
         if (s.kind === "take" || s.kind === "drop") {
@@ -3128,7 +3142,19 @@ function buildIterChainFn(L, name, itemsT, stages, terminal, termArgTs, resultT,
         }
     }
     const iId = addLocal("i", F64, true);
-    const vId = addLocal("v", itemsT.elem, false);
+    const vId = addLocal("v", seedT, false);
+    const elemRead = () => ({ kind: "arrayGet", arr: ref("items.0", itemsT), index: ref(iId, F64), type: itemsT.elem, loc });
+    const seedInit = srcProj === "entries"
+        ? {
+            kind: "recordLit",
+            fields: [
+                { name: "0", value: ref(iId, F64) },
+                { name: "1", value: elemRead() },
+            ],
+            type: seedT,
+            loc,
+        }
+        : elemRead();
     const loop = {
         kind: "for",
         init: { kind: "varDecl", localId: iId, init: num(0), loc },
@@ -3142,8 +3168,8 @@ function buildIterChainFn(L, name, itemsT, stages, terminal, termArgTs, resultT,
         },
         update: { kind: "assign", localId: iId, value: { kind: "bin", op: "+", left: ref(iId, F64), right: num(1), type: F64, loc }, loc },
         body: [
-            { kind: "varDecl", localId: vId, init: { kind: "arrayGet", arr: ref("items.0", itemsT), index: ref(iId, F64), type: itemsT.elem, loc }, loc },
-            ...emit(ref(vId, itemsT.elem)),
+            { kind: "varDecl", localId: vId, init: seedInit, loc },
+            ...emit(ref(vId, seedT)),
         ],
         loc,
     };
@@ -3436,6 +3462,143 @@ export function lowerForOfSearchParams(L, stmt, iterable, proj) {
         L.scopes.pop();
     }
 }
+/** for-of over an ARRAY's keys()/entries() projections consumed directly
+   * by the head (`for (const [index, line] of lines.entries())` — the
+   * dominant formatter idiom): the LIVE index walk — the length re-reads
+   * every pass, exactly the array iterator's contract (elements appended
+   * mid-walk are visited; a shrink ends the loop early) — yielding the
+   * index (`keys`, a number) or the [index, element] pair (`entries`).
+   * `values` never lands here: lowerForOf's receiver unwrap owns it. A
+   * `[i, v]` head of plain identifiers binds straight from the reads (the
+   * tuple never materializes); identifier heads and the remaining
+   * patterns bind through the checker's own element type — the interned
+   * [number, T] tuple record. Stored iterator OBJECTS keep their fence
+   * (only the direct for-of position unwraps). */
+export function lowerForOfArrayIter(L, stmt, iterable, proj) {
+    const loc = locOf(stmt);
+    const arrT = iterable.type;
+    const elemT = arrT.elem;
+    const yieldsPair = proj === "entries";
+    if (!ts.isVariableDeclarationList(stmt.initializer)) {
+        L.unsupported("SC1090", stmt.initializer, "for-of over a pre-declared variable (declare the loop variable in the loop: for (const x of ...))");
+    }
+    const list = stmt.initializer;
+    if ((list.flags & ts.NodeFlags.Using) !== 0) {
+        L.unsupported("SC1090", list, "'using' declarations (dispose-at-scope-exit semantics)");
+    }
+    const isVar = (list.flags & ts.NodeFlags.BlockScoped) === 0;
+    const isLet = (list.flags & ts.NodeFlags.Let) !== 0 || isVar;
+    const decl = list.declarations[0]; // the grammar allows exactly one
+    L.scopes.push(new Map());
+    try {
+        const arr = L.declareHiddenLocal("%arof", arrT);
+        const i = L.declareHiddenLocal("%iterof", F64);
+        i.mutable = true;
+        const ref = (localId, type) => ({ kind: "varRef", localId, type, loc });
+        const num = (value) => ({ kind: "numLit", value, type: F64, loc });
+        const keyRead = () => ref(i.id, F64);
+        const valRead = () => ({ kind: "arrayGet", arr: ref(arr.id, arrT), index: ref(i.id, F64), type: elemT, loc });
+        const binds = [];
+        const isPlainIdent = (el) => ts.isBindingElement(el) && el.name !== undefined && ts.isIdentifier(el.name) && !el.initializer && !el.dotDotDotToken;
+        if (yieldsPair &&
+            !isVar && // var pattern names assign hoisted slots — the generic desugar below owns them
+            ts.isArrayBindingPattern(decl.name) &&
+            decl.name.elements.length >= 1 && decl.name.elements.length <= 2 &&
+            decl.name.elements.every(isPlainIdent)) {
+            // `for (const [i, v] of xs.entries())` — bind straight from the
+            // reads; the tuple never exists. `[i]` alone reads only the index.
+            const els = decl.name.elements;
+            const kLocal = L.declareLocal(els[0].name, els[0].name.text, F64, isLet);
+            binds.push({ kind: "varDecl", localId: kLocal.id, init: keyRead(), loc });
+            if (els[1]) {
+                const vLocal = L.declareLocal(els[1].name, els[1].name.text, elemT, isLet);
+                binds.push({ kind: "varDecl", localId: vLocal.id, init: valRead(), loc });
+            }
+        }
+        else {
+            // Identifier heads and the remaining patterns bind through the
+            // checker's own element type — [number, T] for pair yields,
+            // number otherwise — the Map desugar's exact shape.
+            const declT = L.mapTypeOf(L.checker.getTypeAtLocation(decl.name));
+            if (yieldsPair) {
+                const shape = declT?.kind === "record" ? L.shapes.get(declT.shapeId) : null;
+                if (declT?.kind !== "record" || !shape?.tuple || shape.fields.length !== 2 ||
+                    shape.fields.find((f) => f.name === "0")?.type.kind !== "f64" ||
+                    !typeEquals(shape.fields.find((f) => f.name === "1")?.type ?? F64, elemT)) {
+                    L.badType(decl.name, L.checker.getTypeAtLocation(decl.name)); // defensive: the lib declares [number, T]
+                }
+            }
+            else if (declT?.kind !== "f64") {
+                L.badType(decl.name, L.checker.getTypeAtLocation(decl.name)); // defensive: the lib declares number
+            }
+            const elemInit = yieldsPair
+                ? {
+                    kind: "recordLit",
+                    fields: [
+                        { name: "0", value: keyRead() },
+                        { name: "1", value: valRead() },
+                    ],
+                    type: declT,
+                    loc,
+                }
+                : keyRead();
+            if (ts.isIdentifier(decl.name)) {
+                const varTarget = forOfVarTarget(L, decl);
+                if (varTarget) {
+                    // `for (var x of ...)`: one function-scoped binding, assigned
+                    // per pass — closures made in the loop share it, and the value
+                    // persists after the loop (both Node-exact for var).
+                    const tmp = L.declareHiddenLocal("%vof", declT);
+                    binds.push({ kind: "varDecl", localId: tmp.id, init: elemInit, loc });
+                    binds.push({
+                        kind: "assign",
+                        localId: varTarget.id,
+                        value: L.coerceInto(decl.name, { kind: "varRef", localId: tmp.id, type: declT, loc }, varTarget.type),
+                        loc,
+                    });
+                }
+                else {
+                    const local = L.declareLocal(decl.name, decl.name.text, declT, isLet);
+                    binds.push({ kind: "varDecl", localId: local.id, init: elemInit, loc });
+                }
+            }
+            else {
+                const tmp = L.declareHiddenLocal("%destr", declT);
+                binds.push({ kind: "varDecl", localId: tmp.id, init: elemInit, loc });
+                L.lowerBindingPattern(decl.name, () => ({ kind: "varRef", localId: tmp.id, type: declT, loc }), declT, isLet, binds);
+            }
+        }
+        const body = L.inCtl("loop", () => L.lowerScopedBlock(stmt.statement));
+        const loop = {
+            kind: "for",
+            init: { kind: "varDecl", localId: i.id, init: num(0), loc },
+            cond: {
+                kind: "bin",
+                op: "<",
+                left: ref(i.id, F64),
+                right: { kind: "arrIntrinsic", method: "length", receiver: ref(arr.id, arrT), args: [], type: F64, loc },
+                type: BOOL,
+                loc,
+            },
+            update: {
+                kind: "assign",
+                localId: i.id,
+                value: { kind: "bin", op: "+", left: ref(i.id, F64), right: num(1), type: F64, loc },
+                loc,
+            },
+            body: [...binds, ...body],
+            loc,
+        };
+        return {
+            kind: "block",
+            body: [{ kind: "varDecl", localId: arr.id, init: iterable, loc }, loop],
+            loc,
+        };
+    }
+    finally {
+        L.scopes.pop();
+    }
+}
 export function lowerForOfMap(L, stmt, iterable, mapT, proj) {
     return lowerForOfMapOrSet(L, stmt, iterable, mapT, proj);
 }
@@ -6305,6 +6468,26 @@ export function lowerDynArrayFlatMapCall(L, call, access, recv) {
     const { fnArg, arity } = hofCallbackArg(L, argNode, [DYN], DYN);
     const ret = fnArg.type.ret;
     if (ret.kind !== "array") {
+        // A DYNAMIC-returning callback (`plugins.flatMap((plugin) =>
+        // plugin.languages ?? [])` — the getSupportInfo shape, where the
+        // callback's members ride the DOM): the call dispatches on the
+        // RECEIVER's runtime kind (dynInvoke) with the callback boxed —
+        // a wrapped ISLAND receiver runs the ENGINE's own JS-exact
+        // Array.prototype.flatMap (the routed-ops lane), a native DOM
+        // array runs the runtime's flatMap, and non-arrays throw Node's
+        // TypeError. The result stays dyn, checked per use.
+        if (ret.kind === "dyn" || ret.kind === "jsval") {
+            const boxed = { kind: "dynFrom", value: fnArg, type: DYN, loc };
+            return {
+                kind: "dynInvoke",
+                recv,
+                method: "flatMap",
+                calleeName: access.getText(),
+                args: [boxed],
+                type: DYN,
+                loc,
+            };
+        }
         L.unsupported("SC1090", call, `'.flatMap' on 'unknown' receivers whose callback returns '${L.fmt(ret)}' ` +
             `(only callbacks returning a typed ARRAY compile — the results concatenate ` +
             `without validation; return one-element/empty arrays instead of bare values)`);