@scriptc/compiler 0.0.17 → 0.0.19

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

@@ -930,12 +930,13 @@ export function lowerVarStatement(L, stmt) {
                 return [];
             return L.lowerDestructuringDecl(decl, isLet);
         }
-        // A STORED matchAll drain (`const rows = s.matchAll(re)`): the drain
-        // runs through matchAllInto with a hidden companion index array so a
-        // later for-of over `rows` in the same function can serve `m.index`.
-        // Plain local consts only — module globals, TDZ-predeclared consts,
-        // and annotated non-drain types keep the ordinary path (and stored-
-        // row .index keeps its fence).
+        // STORED protocol values with statically closed representations:
+        // numeric value iterators retain source/cursor/done hidden locals; a
+        // matchAll drain retains its companion index array so a later
+        // for-of can serve `m.index`. Both are const-only interceptions.
+        const numericIterator = lowerNumericIteratorDecl(L, decl, isConst);
+        if (numericIterator)
+            return numericIterator;
         const drained = lowerMatchAllDrainDecl(L, decl, isConst);
         if (drained)
             return drained;
@@ -943,6 +944,88 @@ export function lowerVarStatement(L, stmt) {
         return lowered ? [lowered] : [];
     });
 }
+/** The numeric indexed source of a built-in value-iterator expression:
+   * `numbers.values()` or the equivalent
+   * `numbers[Symbol.iterator]()`, where numbers is number[] or one of the
+   * represented typed arrays (including Uint8Array). This is deliberately
+   * a syntax + provenance test rather than a mapping for the iterator
+   * object: it has observable mutable protocol state, represented by
+   * hidden locals only while a stored binding stays in one function. */
+export function numericIteratorSourceOf(L, expr) {
+    if (expr === undefined)
+        return null;
+    let init = expr;
+    while (ts.isParenthesizedExpression(init))
+        init = init.expression;
+    if (!ts.isCallExpression(init) || init.questionDotToken || init.arguments.length !== 0)
+        return null;
+    let receiver = null;
+    if (ts.isPropertyAccessExpression(init.expression) &&
+        !init.expression.questionDotToken &&
+        init.expression.name.text === "values" &&
+        L.isStdlibMember(init.expression)) {
+        receiver = init.expression.expression;
+    }
+    else if (ts.isElementAccessExpression(init.expression) &&
+        !init.expression.questionDotToken &&
+        init.expression.argumentExpression !== undefined) {
+        let key = init.expression.argumentExpression;
+        while (ts.isParenthesizedExpression(key))
+            key = key.expression;
+        if (ts.isPropertyAccessExpression(key) &&
+            L.stdlibGlobalMember(key, "Symbol") === "iterator") {
+            receiver = init.expression.expression;
+        }
+    }
+    if (receiver === null)
+        return null;
+    const sourceT = L.mapTypeOf(L.typeOf(receiver));
+    return ((sourceT?.kind === "array" && sourceT.elem.kind === "f64") ||
+        sourceT?.kind === "bytes") ? receiver : null;
+}
+/** A stored numeric value iterator does not become a first-class IR
+   * value. Its standard-library provenance proves the built-in iterator
+   * shape, so the declaration snapshots the indexed source and initializes
+   * the exact mutable protocol state:
+   *
+   *   const %source = numbers; let %index = 0; let %done = false;
+   *
+   * A same-function for-of resolves the binding symbol through
+   * numericIterators and drives these locals. Other value uses retain the
+   * iterator-object fence. */
+function lowerNumericIteratorDecl(L, decl, isConst) {
+    if (!isConst || !ts.isIdentifier(decl.name))
+        return null;
+    const sourceNode = numericIteratorSourceOf(L, decl.initializer);
+    if (sourceNode === null)
+        return null;
+    const sym = L.checker.getSymbolAtLocation(decl.name);
+    if (!sym || L.tdzPredeclared.has(sym))
+        return null;
+    const source = L.lowerExpr(sourceNode);
+    if (!((source.type.kind === "array" && source.type.elem.kind === "f64") ||
+        source.type.kind === "bytes")) {
+        L.badType(sourceNode, L.typeOf(sourceNode));
+    }
+    const loc = locOf(decl);
+    const indexedSource = L.declareHiddenLocal("%numiterSource", source.type);
+    const index = L.declareHiddenLocal("%numiterIndex", F64);
+    const done = L.declareHiddenLocal("%numiterDone", BOOL);
+    index.mutable = true;
+    done.mutable = true;
+    L.numericIterators.set(sym, {
+        sourceLocalId: indexedSource.id,
+        sourceType: source.type,
+        indexLocalId: index.id,
+        doneLocalId: done.id,
+        ctx: L.ctx,
+    });
+    return [
+        { kind: "varDecl", localId: indexedSource.id, init: source, loc },
+        { kind: "varDecl", localId: index.id, init: { kind: "numLit", value: 0, type: F64, loc }, loc },
+        { kind: "varDecl", localId: done.id, init: { kind: "boolLit", value: false, type: BOOL, loc }, loc },
+    ];
+}
 /** The stored-drain interception behind lowerVarStatement: lowers
    * `const rows = s.matchAll(re)` (a direct stdlib matchAll initializer on
    * a plain const identifier local) as the companion-index drain and
@@ -1338,6 +1421,53 @@ export function lowerBindingPattern(L, pattern, srcRef, srcType, isLet, out, dyn
             });
             return;
         }
+        // Represented typed arrays are dense numeric iterables. Destructuring
+        // reads their elements in index order; a rest binding drains to a
+        // fresh number[] (never another typed array), exactly the iterator
+        // protocol's Array accumulation.
+        if (srcType.kind === "bytes") {
+            pattern.elements.forEach((el, i) => {
+                if (ts.isOmittedExpression(el) || el.name === undefined)
+                    return;
+                const loc = locOf(el);
+                if (el.dotDotDotToken) {
+                    if (el.initializer) {
+                        L.unsupported("SC1031", el, "defaults on rest elements");
+                    }
+                    const all = {
+                        kind: "bytesIntrinsic",
+                        method: "toArray",
+                        receiver: srcRef(),
+                        args: [],
+                        type: arrayOf(F64),
+                        loc,
+                    };
+                    const value = {
+                        kind: "arrIntrinsic",
+                        method: "slice",
+                        receiver: all,
+                        args: [{ kind: "numLit", value: i, type: F64, loc }],
+                        type: arrayOf(F64),
+                        loc,
+                    };
+                    L.bindPatternTarget(el.name, value, isLet, out);
+                    return;
+                }
+                let value = {
+                    kind: "bytesIntrinsic",
+                    method: "get",
+                    receiver: srcRef(),
+                    args: [{ kind: "numLit", value: i, type: F64, loc }],
+                    type: F64,
+                    loc,
+                };
+                if (el.initializer) {
+                    value = arrayPositionDefault(L, el, value, srcRef, i, F64, out);
+                }
+                L.bindPatternTarget(el.name, value, isLet, out);
+            });
+            return;
+        }
         if (srcType.kind !== "array") {
             L.unsupported("SC1031", pattern, `array destructuring of non-array values (the source is ${srcType.kind}-typed)`);
         }
@@ -1979,11 +2109,29 @@ function arrayPositionDefaultValue(L, blame, init, read, srcRef, index, elemT, b
     if (isUnitType(elemT)) {
         return L.lowerExprExpecting(init, bodyT);
     }
+    const source = srcRef();
+    const length = source.type.kind === "bytes"
+        ? {
+            kind: "bytesIntrinsic",
+            method: "length",
+            receiver: source,
+            args: [],
+            type: F64,
+            loc,
+        }
+        : {
+            kind: "arrIntrinsic",
+            method: "length",
+            receiver: source,
+            args: [],
+            type: F64,
+            loc,
+        };
     const inRange = {
         kind: "bin",
         op: "<",
         left: { kind: "numLit", value: index, type: F64, loc },
-        right: { kind: "arrIntrinsic", method: "length", receiver: srcRef(), args: [], type: F64, loc },
+        right: length,
         type: BOOL,
         loc,
     };
@@ -5195,8 +5343,8 @@ function lowerArrayAssignInto(L, out, target, tmpRef, blame, loc) {
         });
         elemsRef = () => ({ kind: "varRef", localId: iterTmp.id, type: srcType, loc });
     }
-    else if (srcType.kind !== "array" && !isTuple) {
-        if (elements.length === 0 && (srcType.kind === "string" || srcType.kind === "bytes" || srcType.kind === "map" || srcType.kind === "set")) {
+    else if (srcType.kind !== "array" && srcType.kind !== "bytes" && !isTuple) {
+        if (elements.length === 0 && (srcType.kind === "string" || srcType.kind === "map" || srcType.kind === "set")) {
             // `[] = e` over a statically-iterable source: GetIterator +
             // immediate close — no user code can observe it, so evaluating
             // the RHS is the whole statement.
@@ -5220,6 +5368,16 @@ function lowerArrayAssignInto(L, out, target, tmpRef, blame, loc) {
             }
             return { kind: "recordGet", obj: tmpRef(), shapeId: srcType.shapeId, field: String(i), type: fieldType, loc: locOf(at) };
         }
+        if (srcType.kind === "bytes") {
+            return {
+                kind: "bytesIntrinsic",
+                method: "get",
+                receiver: tmpRef(),
+                args: [{ kind: "numLit", value: i, type: F64, loc: locOf(at) }],
+                type: F64,
+                loc: locOf(at),
+            };
+        }
         // Plain arrays read by index — a pattern wider than the runtime
         // array traps (the arrayGet discipline, divergence 4's policy; JS
         // would answer undefined).
@@ -5257,6 +5415,24 @@ function lowerArrayAssignInto(L, out, target, tmpRef, blame, loc) {
         // defaults on nested targets fence in the shared machinery).
         const readOf = (targetT) => {
             if (isRest) {
+                if (srcType.kind === "bytes") {
+                    const all = {
+                        kind: "bytesIntrinsic",
+                        method: "toArray",
+                        receiver: tmpRef(),
+                        args: [],
+                        type: arrayOf(F64),
+                        loc: locOf(el),
+                    };
+                    return {
+                        kind: "arrIntrinsic",
+                        method: "slice",
+                        receiver: all,
+                        args: [{ kind: "numLit", value: i, type: F64, loc: locOf(el) }],
+                        type: arrayOf(F64),
+                        loc: locOf(el),
+                    };
+                }
                 return isTuple
                     ? tupleTailValue(L, el, tmpRef, srcType, shape, i, targetT)
                     : { kind: "arrIntrinsic", method: "slice", receiver: tmpRef(), args: [{ kind: "numLit", value: i, type: F64, loc: locOf(el) }], type: srcType, loc: locOf(el) };
@@ -5295,7 +5471,9 @@ function lowerArrayAssignInto(L, out, target, tmpRef, blame, loc) {
                 else if (targetT !== null) {
                     read = isTuple
                         ? undefArmDefault(L, el, defaultNode, read, targetT)
-                        : arrayPositionDefaultValue(L, el, defaultNode, read, tmpRef, i, srcType.elem, targetT, out);
+                        : arrayPositionDefaultValue(L, el, defaultNode, read, tmpRef, i, srcType.kind === "bytes"
+                            ? F64
+                            : srcType.elem, targetT, out);
                 }
             }
             return read;
@@ -5351,6 +5529,22 @@ export function lowerForOf(L, stmt) {
         }
         L.unsupported("SC1070", stmt, "'for await' (async iteration over anything but process.stdin and readable streams)");
     }
+    // A stored numeric value iterator declared in this function keeps its
+    // built-in protocol state in hidden locals (lowerVarStatement). The
+    // iterator's own [Symbol.iterator]() returns itself, so for-of resumes
+    // that cursor rather than starting another indexed-source walk.
+    {
+        let src = stmt.expression;
+        while (ts.isParenthesizedExpression(src))
+            src = src.expression;
+        if (ts.isIdentifier(src)) {
+            const sym = L.resolveValueSymbol(src);
+            const state = sym ? L.numericIterators.get(sym) : undefined;
+            if (state?.ctx === L.ctx) {
+                return lowerForOfStoredNumericIterator(L, stmt, state, labels);
+            }
+        }
+    }
     // `for (const k of m.keys())` / `.values()` / `.entries()`: the
     // iterator methods consumed DIRECTLY by a for-of head ride the
     // container's live walk — exactly `for..of m` with the projection
@@ -5396,6 +5590,15 @@ export function lowerForOf(L, stmt) {
                     return lowerForOfArrayIter(L, stmt, container, proj);
                 }
             }
+            // Typed arrays expose the same live indexed iterator projections.
+            // Their fixed length makes the walk simpler, but the yielded keys
+            // and [key, numeric value] pairs are identical to Array's.
+            if (recv?.kind === "bytes" && (proj === "keys" || proj === "entries")) {
+                const container = L.lowerExpr(src.expression.expression);
+                if (container.type.kind === "bytes") {
+                    return lowerForOfArrayIter(L, stmt, container, proj);
+                }
+            }
         }
     }
     // `for (const m of s.matchAll(re))` — direct call or a stored-const
@@ -5429,25 +5632,32 @@ export function lowerForOf(L, stmt) {
             }
         }
     }
-    // `for (v of xs.values())` over an ARRAY receiver: Array.prototype
-    // .values() iterates the array's elements exactly — the iterator
-    // object never needs to exist, so the loop runs over the receiver
-    // itself (matchAll's eager-drain stance). Only the DIRECT for-of
-    // position unwraps; a stored iterator value keeps its fence.
-    let iterSrc = stmt.expression;
-    {
+    // A DIRECT built-in value-iterator expression needs no first-class
+    // iterator object. The numeric recognizer covers number[] / typed
+    // arrays and both values/default spellings; retain the established
+    // generic Array.prototype.values() unwrap for every other T[] too.
+    // Stored numeric values took the retained-state path above.
+    let iterSrc = numericIteratorSourceOf(L, stmt.expression);
+    if (iterSrc === null) {
         let e = stmt.expression;
         while (ts.isParenthesizedExpression(e))
             e = e.expression;
-        if (ts.isCallExpression(e) && !e.questionDotToken && e.arguments.length === 0 &&
-            ts.isPropertyAccessExpression(e.expression) && !e.expression.questionDotToken &&
+        if (ts.isCallExpression(e) &&
+            !e.questionDotToken &&
+            e.arguments.length === 0 &&
+            ts.isPropertyAccessExpression(e.expression) &&
+            !e.expression.questionDotToken &&
             e.expression.name.text === "values" &&
             L.isStdlibMember(e.expression) &&
             L.mapTypeOf(L.typeOf(e.expression.expression))?.kind === "array") {
             iterSrc = e.expression.expression;
         }
     }
+    iterSrc ??= stmt.expression;
     let iterable = L.lowerExpr(iterSrc);
+    if (iterable.type.kind === "bytes") {
+        return lowerForOfBytes(L, stmt, iterable, labels);
+    }
     if (iterable.type.kind !== "array") {
         // The lib types strings as iterable too, so those for-ofs typecheck;
         // only arrays, Maps, and Sets have a lowering. Named specifically —
@@ -5665,6 +5875,182 @@ export function lowerForOf(L, stmt) {
         L.scopes.pop();
     }
 }
+/** Direct for-of over a represented typed array. The implicit iterator is
+   * unobservable, so instantiate its source/cursor/done state as ordinary
+   * hidden locals and share the retained numeric-iterator driver. */
+function lowerForOfBytes(L, stmt, iterable, labels) {
+    const loc = locOf(stmt);
+    const source = L.declareHiddenLocal("%numiterSource", iterable.type);
+    const index = L.declareHiddenLocal("%numiterIndex", F64);
+    const done = L.declareHiddenLocal("%numiterDone", BOOL);
+    index.mutable = true;
+    done.mutable = true;
+    const loop = lowerForOfStoredNumericIterator(L, stmt, {
+        sourceLocalId: source.id,
+        sourceType: iterable.type,
+        indexLocalId: index.id,
+        doneLocalId: done.id,
+    }, labels);
+    return {
+        kind: "block",
+        body: [
+            { kind: "varDecl", localId: source.id, init: iterable, loc },
+            { kind: "varDecl", localId: index.id, init: { kind: "numLit", value: 0, type: F64, loc }, loc },
+            { kind: "varDecl", localId: done.id, init: { kind: "boolLit", value: false, type: BOOL, loc }, loc },
+            loop,
+        ],
+        loc,
+    };
+}
+/** Drive a stored built-in numeric value iterator through its retained
+   * protocol state. Unlike the ordinary array for-of IR, the cursor
+   * advances BEFORE the source body: breaking or returning from the body
+   * leaves the iterator positioned at the next element. Natural
+   * exhaustion sets the sticky done bit; breaking early does not.
+   *
+   *   while (true) {
+   *     if (%done) break;
+   *     if (%index >= %source.length) { %done = true; break; }
+   *     const value = %source[%index];
+   *     %index += 1;
+   *     <assign/bind head>; <body>
+   *   }
+   */
+function lowerForOfStoredNumericIterator(L, stmt, state, labels) {
+    let exprTarget = null;
+    let exprTargetNode = null;
+    if (!ts.isVariableDeclarationList(stmt.initializer)) {
+        let target = stmt.initializer;
+        while (ts.isParenthesizedExpression(target))
+            target = target.expression;
+        if (ts.isIdentifier(target)) {
+            exprTarget = L.resolveWritable(target);
+            exprTargetNode = target;
+        }
+        if (!exprTarget) {
+            L.unsupported("SC1090", stmt.initializer, "for-of over a stored numeric iterator assigning anything but a pre-declared identifier");
+        }
+    }
+    const list = ts.isVariableDeclarationList(stmt.initializer) ? stmt.initializer : null;
+    if (list && (list.flags & ts.NodeFlags.Using) !== 0) {
+        L.unsupported("SC1090", list, "'using' declarations (dispose-at-scope-exit semantics)");
+    }
+    const isLet = list !== null && (list.flags & ts.NodeFlags.Let) !== 0;
+    const decl = list ? list.declarations[0] : null;
+    if (decl && !ts.isIdentifier(decl.name))
+        L.unsupported("SC1031", decl.name);
+    const loc = locOf(stmt);
+    const sourceT = state.sourceType;
+    if (!((sourceT.kind === "array" && sourceT.elem.kind === "f64") ||
+        sourceT.kind === "bytes")) {
+        throw new Error("internal: retained numeric iterator has a non-numeric source");
+    }
+    const ref = (localId, type) => ({ kind: "varRef", localId, type, loc });
+    const indexRef = () => ref(state.indexLocalId, F64);
+    const doneRef = () => ref(state.doneLocalId, BOOL);
+    const sourceRef = () => ref(state.sourceLocalId, sourceT);
+    const sourceLength = () => sourceT.kind === "array"
+        ? {
+            kind: "arrIntrinsic",
+            method: "length",
+            receiver: sourceRef(),
+            args: [],
+            type: F64,
+            loc,
+        }
+        : {
+            kind: "bytesIntrinsic",
+            method: "length",
+            receiver: sourceRef(),
+            args: [],
+            type: F64,
+            loc,
+        };
+    const sourceValue = () => sourceT.kind === "array"
+        ? { kind: "arrayGet", arr: sourceRef(), index: indexRef(), type: F64, loc }
+        : {
+            kind: "bytesIntrinsic",
+            method: "get",
+            receiver: sourceRef(),
+            args: [indexRef()],
+            type: F64,
+            loc,
+        };
+    const one = { kind: "numLit", value: 1, type: F64, loc };
+    L.scopes.push(new Map());
+    try {
+        const varTarget = exprTarget ?? (decl ? forOfVarTarget(L, decl) : null);
+        const value = varTarget
+            ? L.declareHiddenLocal("%numiterValue", F64)
+            : L.declareLocal(decl.name, decl.name.text, F64, isLet);
+        const valueRef = ref(value.id, F64);
+        const blame = decl?.name ?? exprTargetNode ?? stmt.initializer;
+        const head = [
+            {
+                kind: "if",
+                cond: doneRef(),
+                then: [{ kind: "break", loc }],
+                else_: null,
+                loc,
+            },
+            {
+                kind: "if",
+                cond: {
+                    kind: "bin",
+                    op: ">=",
+                    left: indexRef(),
+                    right: sourceLength(),
+                    type: BOOL,
+                    loc,
+                },
+                then: [
+                    {
+                        kind: "assign",
+                        localId: state.doneLocalId,
+                        value: { kind: "boolLit", value: true, type: BOOL, loc },
+                        loc,
+                    },
+                    { kind: "break", loc },
+                ],
+                else_: null,
+                loc,
+            },
+            {
+                kind: "varDecl",
+                localId: value.id,
+                init: sourceValue(),
+                loc,
+            },
+            {
+                kind: "assign",
+                localId: state.indexLocalId,
+                value: { kind: "bin", op: "+", left: indexRef(), right: one, type: F64, loc },
+                loc,
+            },
+            ...(varTarget
+                ? [
+                    {
+                        kind: "assign",
+                        localId: varTarget.id,
+                        value: L.coerceInto(blame, valueRef, varTarget.type),
+                        loc,
+                    },
+                ]
+                : []),
+        ];
+        const body = L.inCtl("loop", () => L.lowerScopedBlock(stmt.statement), labels);
+        return {
+            kind: "while",
+            cond: { kind: "boolLit", value: true, type: BOOL, loc },
+            body: [...head, ...body],
+            ...(labels && { labels }),
+            loc,
+        };
+    }
+    finally {
+        L.scopes.pop();
+    }
+}
 /** A DIRECT `s.matchAll(re)` call: a stdlib matchAll property call on a
    * string-typed receiver with one regex-typed argument (parens stripped).
    * The shape the companion-index machinery serves. */
@@ -6561,8 +6947,9 @@ function lowerForInArray(L, stmt, labels) {
    * POSIX read never yields an empty data chunk, so EOF is the only way
    * to see one. Awaiting parks the fiber like any await, so timers and
    * other fibers interleave with the reads exactly as in Node; the loop
-   * variable is a fresh const Uint8Array binding per iteration. Only
-   * async-function bodies can host it (the await parks a fiber). */
+   * variable is a fresh const Uint8Array binding per iteration. Async
+   * function bodies and async module initializers can host it (the await
+   * parks their fiber). */
 function lowerForAwaitStdin(L, stmt) {
     if (!L.ctx.isAsync) {
         L.unsupported("SC1090", stmt, "top-level 'for await' (await outside async functions)");