@scriptc/compiler 0.4.1 → 0.4.3

package/dist/frontend/lowering/iterable-values.js

@@ -0,0 +1,297 @@
+/* `Iterable<T>` values. The type maps to the iterable union
+ * (type-mapper.ts iterableUnionType): an array, Set, Map or string keeps
+ * its own arm, so the value stays the same multi-pass object (identity,
+ * inspection and typeof are the source's own), and every iterator — a
+ * generator, an array, Map or Set iterator, a checked-dynamic iterator —
+ * enters the generator arm, single-pass as in JavaScript.
+ *
+ * Consumers open an iterator over the current arm the way for-of's
+ * GetIterator does: an array, Set, Map or string arm starts a fresh live
+ * walk (the sources' own iterator helpers), the generator arm is itself.
+ * for-of gives the array arm its own array loop, so iterating an Iterable
+ * that holds an array runs at array-loop speed. */
+import * as ts from "../ts7/adapter.js";
+import { locOf } from "../program.js";
+import { varRef, numLit } from "../../ir/build.js";
+import { BOOL, F64, iterableArmsElem, typeEquals, } from "../../ir/ir.js";
+import { typeKey } from "../type-mapper.js";
+import { keyedHelperName } from "./stable-names.js";
+import { PoisonError } from "./lowerer.js";
+import { noLoweringDiag, unsupportedDiag } from "../../diagnostics/diagnostic.js";
+import { generatorLoopBinding, lowerForOfGenerator } from "./lower-generators.js";
+import { iteratorSlotAdapter, lowerArrayIteratorValue, lowerCollectionIteratorValue, lowerStringIteratorValue, } from "./iterator-adapters.js";
+import { arrayValueRead, arrayValueType } from "./array-values.js";
+/** The iterable union `t` names, or null. */
+export function iterableUnionOf(lowerer, t) {
+    const info = iterableSlotUnionOf(lowerer, t);
+    // An optional Iterable (`Iterable<T> | undefined`) is consumed only once
+    // narrowed to the iterable union itself.
+    if (info === null || info.arms.some((arm) => arm.kind === "undefinedT" || arm.kind === "nullT"))
+        return null;
+    return info;
+}
+/** The iterable union `t` names, also an optional or nullable one
+ * (`Iterable<T> | undefined`, whose unit arms sit beside the iterable
+ * arms), or null. */
+function iterableSlotUnionOf(lowerer, t) {
+    if (t.kind !== "union")
+        return null;
+    const arms = lowerer.unions.get(t.unionId)?.arms;
+    if (!arms)
+        return null;
+    const elem = iterableArmsElem(arms);
+    if (elem === null)
+        return null;
+    const gen = arms.find((arm) => arm.kind === "generator");
+    return { unionId: t.unionId, type: t, elem, arms, gen };
+}
+/** The generator arm of an iterable union (what a generator function
+ * declared to return Iterable<T> returns), or `t` itself. */
+export function iterableGeneratorArm(lowerer, t) {
+    return iterableUnionOf(lowerer, t)?.gen ?? t;
+}
+/** A value flowing into an iterable-typed slot, optional or nullable
+ * ones included: a source arm wraps as itself; a generator over other
+ * channel types or a checked-dynamic iterator (a Map or Set iterator)
+ * adapts into the generator arm. Null when neither applies, leaving the
+ * ordinary conversion fences to refuse other sources (class iterables,
+ * typed arrays, other element types). */
+export function iterableSlotValue(lowerer, expr, expected) {
+    const info = iterableSlotUnionOf(lowerer, expected);
+    if (info === null || expr.type.kind === "union")
+        return null;
+    const wrap = (value) => ({
+        kind: "unionWrap",
+        unionId: info.unionId,
+        tag: lowerer.armTag(info.unionId, value.type),
+        value,
+        type: info.type,
+        loc: expr.loc,
+    });
+    if (lowerer.armTag(info.unionId, expr.type) >= 0)
+        return wrap(expr);
+    if (expr.type.kind === "generator" || expr.type.kind === "dyn") {
+        const adapted = iteratorSlotAdapter(lowerer, expr, info.gen);
+        if (adapted && typeEquals(adapted.type, info.gen))
+            return wrap(adapted);
+    }
+    // Class instances (their own [Symbol.iterator]) and typed arrays have no
+    // arm: refuse them here, by name.
+    if (expr.type.kind === "object" || expr.type.kind === "bytes") {
+        lowerer.pushDiag(unsupportedDiag("SC1090", expr.loc, `an Iterable<${lowerer.fmt(info.elem)}> holding a '${lowerer.fmt(expr.type)}' (an Iterable value holds an array, Set, Map, string, or iterator)`));
+        throw new PoisonError();
+    }
+    return null;
+}
+/** GetIterator on an iterable union value: an interned helper answering a
+ * generator over the current arm — a fresh live walk of an array, Set, Map
+ * or string, or the generator arm itself. */
+export function iterableGenerator(lowerer, value, info) {
+    const loc = value.loc;
+    const key = `iterableOf:${typeKey(info.type)}`;
+    let name = lowerer.valueHelpers.get(key);
+    if (!name) {
+        const u = varRef("u.0", info.type, loc);
+        const body = [];
+        let genTag = -1;
+        info.arms.forEach((arm, tag) => {
+            if (arm.kind === "generator") {
+                genTag = tag;
+                return;
+            }
+            const narrowed = {
+                kind: "unionNarrow",
+                unionId: info.unionId,
+                tag,
+                value: u,
+                type: arm,
+                loc,
+            };
+            const walk = arm.kind === "array"
+                ? lowerArrayIteratorValue(lowerer, narrowed, "values", info.gen, loc)
+                : arm.kind === "set"
+                    ? lowerCollectionIteratorValue(lowerer, narrowed, "values", info.gen, loc)
+                    : arm.kind === "map"
+                        ? lowerCollectionIteratorValue(lowerer, narrowed, "entries", info.gen, loc)
+                        : arm.kind === "string"
+                            ? lowerStringIteratorValue(lowerer, narrowed, info.gen, loc)
+                            : null;
+            if (walk === null || !typeEquals(walk.type, info.gen)) {
+                lowerer.pushDiag(noLoweringDiag(`iterating an Iterable<${lowerer.fmt(info.elem)}> that holds a ${arm.kind}`, loc));
+                throw new PoisonError();
+            }
+            body.push({
+                kind: "if",
+                cond: {
+                    kind: "unionIsTag",
+                    unionId: info.unionId,
+                    tag,
+                    negated: false,
+                    value: u,
+                    type: BOOL,
+                    loc,
+                },
+                then: [{ kind: "return", value: walk, loc }],
+                else_: null,
+                loc,
+            });
+        });
+        body.push({
+            kind: "return",
+            value: {
+                kind: "unionNarrow",
+                unionId: info.unionId,
+                tag: genTag,
+                value: u,
+                type: info.gen,
+                loc,
+            },
+            loc,
+        });
+        name = keyedHelperName(lowerer, "%iterable.of", key);
+        lowerer.valueHelpers.set(key, name);
+        lowerer.liftedFns.push({
+            name,
+            params: [{ localId: "u.0", name: "u", type: info.type }],
+            returnType: info.gen,
+            locals: [{ id: "u.0", name: "u", type: info.type, mutable: false }],
+            body,
+            loc,
+        });
+    }
+    return { kind: "call", callee: name, args: [value], type: info.gen, loc };
+}
+/** Whether a loop body declares a class (a class has one lowering per
+ * declaration, so its body cannot lower twice). */
+function declaresClass(body) {
+    let found = false;
+    ts.walkPreorder(body, (node) => {
+        if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) {
+            found = true;
+            return "stop";
+        }
+        return undefined;
+    });
+    return found;
+}
+/** `for (x of iterable)` over an iterable union:
+ *
+ *   { const %src = <iterable>;
+ *     if (%src is the array arm) {
+ *       const %arr = <array arm>;
+ *       for (let %cur = 0; %cur < %arr.length; %cur++) { const x = %arr[%cur]; <body> }
+ *     } else {
+ *       for (const x of GetIterator(%src)) <body>     // the generator for-of
+ *     }
+ *   }
+ *
+ * The array arm walks exactly like an array for-of (live length, the
+ * backend's dense-array loop forms), so an Iterable holding an array
+ * iterates at array speed; every other arm drives its iterator with the
+ * generator for-of's IteratorClose rules. The body lowers once for each
+ * loop; a body that declares a class lowers only once, in the generator
+ * for-of over every arm. */
+export function lowerForOfIterable(lowerer, stmt, iterable, info, labels) {
+    const loc = locOf(stmt);
+    const generatorLoop = (source) => lowerForOfGenerator(lowerer, stmt, iterableGenerator(lowerer, source, info), labels);
+    const arrayTag = info.arms.findIndex((arm) => arm.kind === "array");
+    // A union without an array arm (`Set<T> | Generator<T>`) has only the
+    // generator loop.
+    if (stmt.awaitModifier || declaresClass(stmt.statement) || arrayTag < 0)
+        return generatorLoop(iterable);
+    const arrT = info.arms[arrayTag];
+    lowerer.scopes.push(new Map());
+    try {
+        const src = lowerer.declareHiddenLocal("%iterableSource", info.type);
+        const srcRef = () => varRef(src.id, info.type, loc);
+        const arr = lowerer.declareHiddenLocal("%arrayIterator", arrT);
+        const cursor = lowerer.declareHiddenLocal("%arrayCursor", F64);
+        cursor.mutable = true;
+        const arrRef = varRef(arr.id, arrT, loc);
+        const curRef = varRef(cursor.id, F64, loc);
+        // The element: a hole reads undefined, which an undefined-armed T
+        // holds; for other element types the read traps, as typed reads do.
+        const element = typeEquals(arrayValueType(lowerer, info.elem), info.elem)
+            ? arrayValueRead(lowerer, arrRef, curRef, info.elem, loc)
+            : { kind: "arrayGet", arr: arrRef, index: curRef, type: info.elem, loc };
+        const arrayLoop = (() => {
+            lowerer.scopes.push(new Map());
+            try {
+                const binding = generatorLoopBinding(lowerer, stmt, element, info.elem);
+                const body = lowerer.inCtl("loop", () => lowerer.lowerScopedBlock(stmt.statement), labels);
+                return {
+                    kind: "for",
+                    init: { kind: "varDecl", localId: cursor.id, init: numLit(0, loc), loc },
+                    cond: {
+                        kind: "bin",
+                        op: "<",
+                        left: curRef,
+                        right: {
+                            kind: "arrIntrinsic",
+                            method: "length",
+                            receiver: arrRef,
+                            args: [],
+                            type: F64,
+                            loc,
+                        },
+                        type: BOOL,
+                        loc,
+                    },
+                    update: {
+                        kind: "assign",
+                        localId: cursor.id,
+                        value: { kind: "bin", op: "+", left: curRef, right: numLit(1, loc), type: F64, loc },
+                        loc,
+                    },
+                    body: [...binding, ...body],
+                    ...(labels && { labels }),
+                    loc,
+                };
+            }
+            finally {
+                lowerer.scopes.pop();
+            }
+        })();
+        return {
+            kind: "block",
+            body: [
+                { kind: "varDecl", localId: src.id, init: iterable, loc },
+                {
+                    kind: "if",
+                    cond: {
+                        kind: "unionIsTag",
+                        unionId: info.unionId,
+                        tag: arrayTag,
+                        negated: false,
+                        value: srcRef(),
+                        type: BOOL,
+                        loc,
+                    },
+                    then: [
+                        {
+                            kind: "varDecl",
+                            localId: arr.id,
+                            init: {
+                                kind: "unionNarrow",
+                                unionId: info.unionId,
+                                tag: arrayTag,
+                                value: srcRef(),
+                                type: arrT,
+                                loc,
+                            },
+                            loc,
+                        },
+                        arrayLoop,
+                    ],
+                    else_: [generatorLoop(srcRef())],
+                    loc,
+                },
+            ],
+            loc,
+        };
+    }
+    finally {
+        lowerer.scopes.pop();
+    }
+}
+//# sourceMappingURL=iterable-values.js.map

package/dist/frontend/lowering/iterable-values.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterable-values.js","sourceRoot":"","sources":["../../../src/frontend/lowering/iterable-values.ts"],"names":[],"mappings":"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"}

package/dist/frontend/lowering/iterator-adapters.js

@@ -1,3 +1,4 @@
+import { keyedHelperName } from "./stable-names.js";
 import { dynUndefinedExpr, varRef } from "../../ir/build.js";
 import { BOOL, DYN, F64, STRING, typeEquals, UNDEFINED_T, VOID, } from "../../ir/ir.js";
 import { streamTypedRefEligible } from "../../ir/analysis.js";
@@ -9,11 +10,196 @@ import { lowerSafeIndexRead } from "./array-values.js";
  * through an interned adapter generator. Null when neither applies. */
 export function iteratorSlotAdapter(lowerer, expr, expected) {
     if (expr.type.kind === "dyn")
-        return dynIteratorAdapter(lowerer, expr, expected);
+        return (collectionIteratorSlotValue(lowerer, expr, expected) ??
+            dynIteratorAdapter(lowerer, expr, expected));
     if (expr.type.kind === "generator")
         return generatorRetypeAdapter(lowerer, expr, expected);
     return null;
 }
+/** `m.values()` (or keys/entries, or a Set's) on a typed Map or Set, which
+ * lowers to a dynamic invocation on the boxed collection, flowing into an
+ * iterator-typed slot (`values(): IterableIterator<T> { return
+ * this.rows.values(); }`): an interned generator over the collection that
+ * reads each entry typed, instead of the checked adapter over the boxed
+ * native iterator (dynIteratorAdapter), which boxes every value and checks
+ * it back. It keeps that adapter's protocol: the walk is lazy and live, and
+ * since the native iterator has no return(), an early exit from a
+ * consumer's loop parks it on the current entry instead of completing it,
+ * so a later loop continues with the next entry. Null for any other source
+ * or a slot whose yield type is not the collection's entry type. */
+function collectionIteratorSlotValue(lowerer, expr, expected) {
+    if (expr.kind !== "dynInvoke" || expr.args.length > 0 || expr.calleeNameValue)
+        return null;
+    const method = expr.method;
+    if (method !== "values" && method !== "keys" && method !== "entries")
+        return null;
+    if (expr.recv.kind !== "dynFrom")
+        return null;
+    const receiver = expr.recv.value;
+    const collT = receiver.type;
+    if (collT.kind !== "map" && collT.kind !== "set")
+        return null;
+    if (expected.async || expected.yieldT.kind === "void")
+        return null;
+    if (expected.retT.kind !== "void" && expected.retT.kind !== "dyn")
+        return null;
+    if (expected.nextT.kind !== "undefinedT" && expected.nextT.kind !== "dyn")
+        return null;
+    const resultType = genResultRecord(expected.yieldT, expected.retT, lowerer.shapes, lowerer.unions);
+    if (!resultType)
+        return null;
+    const loc = expr.loc;
+    const key = `collIterSlot:${method}:${typeKey(collT)}:${typeKey(expected)}`;
+    let name = lowerer.valueHelpers.get(key);
+    if (!name) {
+        const coll = varRef("coll.0", collT, loc);
+        const index = varRef("index.0", F64, loc);
+        const native = varRef("native.0", DYN, loc);
+        const resumedFlag = varRef("resumed.0", BOOL, loc);
+        const keyT = collT.kind === "map" ? collT.key : collT.elem;
+        const valueT = collT.kind === "map" ? collT.value : collT.elem;
+        const read = (m, t) => collT.kind === "map"
+            ? { kind: "mapIntrinsic", method: m, receiver: coll, args: [index], type: t, loc }
+            : { kind: "setIntrinsic", method: "iterKey", receiver: coll, args: [index], type: t, loc };
+        // entries() answers [key, value] pairs: only a slot whose yield type is
+        // that pair as a record of the two fields takes the typed walk; a tuple
+        // or other pair type keeps the checked adapter.
+        if (method === "entries") {
+            const pair = expected.yieldT.kind === "record" ? lowerer.shapes.get(expected.yieldT.shapeId) : undefined;
+            const field = (name) => pair?.fields.find((f) => f.name === name)?.type;
+            const first = field("0");
+            const second = field("1");
+            if (pair === undefined ||
+                pair.fields.length !== 2 ||
+                first === undefined ||
+                second === undefined ||
+                !typeEquals(first, keyT) ||
+                !typeEquals(second, valueT))
+                return null;
+        }
+        const entry = () => method === "keys" || (collT.kind === "set" && method === "values")
+            ? read("iterKey", keyT)
+            : method === "values"
+                ? read("iterValue", valueT)
+                : {
+                    kind: "recordLit",
+                    fields: [
+                        { name: "0", value: read("iterKey", keyT) },
+                        { name: "1", value: read("iterValue", valueT) },
+                    ],
+                    type: expected.yieldT,
+                    loc,
+                };
+        if (!typeEquals(entry().type, expected.yieldT))
+            return null;
+        // The entry is read once per step and kept: the parking yield of an
+        // early exit answers it again rather than rereading a slot the loop may
+        // have deleted.
+        const current = varRef("current.0", expected.yieldT, loc);
+        const suspend = () => ({
+            kind: "exprStmt",
+            expr: { kind: "yieldExpr", value: current, type: resumeType(expected.nextT), loc },
+            loc,
+        });
+        const finish = {
+            kind: "return",
+            value: expected.retT.kind === "dyn" ? dynUndefinedExpr(loc) : null,
+            loc,
+        };
+        name = keyedHelperName(lowerer, "%coll.iterSlot", key);
+        lowerer.valueHelpers.set(key, name);
+        lowerer.liftedFns.push({
+            name,
+            params: [{ localId: "coll.0", name: "coll", type: collT }],
+            returnType: expected.retT,
+            locals: [
+                { id: "coll.0", name: "coll", type: collT, mutable: false },
+                { id: "native.0", name: "native", type: DYN, mutable: false },
+                { id: "index.0", name: "index", type: F64, mutable: true },
+                { id: "resumed.0", name: "resumed", type: BOOL, mutable: true },
+                { id: "current.0", name: "current", type: expected.yieldT, mutable: false },
+            ],
+            body: [
+                {
+                    kind: "varDecl",
+                    localId: "native.0",
+                    init: {
+                        kind: "dynInvoke",
+                        recv: lowerer.coerceToExpected(coll, DYN),
+                        method: "values",
+                        calleeName: collT.kind === "map" ? "map.values" : "set.values",
+                        args: [],
+                        type: DYN,
+                        loc,
+                    },
+                    loc,
+                },
+                {
+                    kind: "varDecl",
+                    localId: "resumed.0",
+                    init: { kind: "boolLit", value: false, type: BOOL, loc },
+                    loc,
+                },
+                {
+                    kind: "while",
+                    cond: { kind: "boolLit", value: true, type: BOOL, loc },
+                    body: [
+                        {
+                            kind: "assign",
+                            localId: "index.0",
+                            value: {
+                                kind: "libCall",
+                                fn: "dyn.collectionIteratorIndex",
+                                args: [native],
+                                type: F64,
+                                loc,
+                            },
+                            loc,
+                        },
+                        {
+                            kind: "if",
+                            cond: {
+                                kind: "bin",
+                                op: "<",
+                                left: index,
+                                right: { kind: "numLit", value: 0, type: F64, loc },
+                                type: BOOL,
+                                loc,
+                            },
+                            then: [finish],
+                            else_: null,
+                            loc,
+                        },
+                        setResumed(false, loc),
+                        { kind: "varDecl", localId: "current.0", init: entry(), loc },
+                        {
+                            kind: "tryCatch",
+                            tryBody: [suspend(), setResumed(true, loc)],
+                            catchBody: null,
+                            catchLocalId: null,
+                            // An early exit parks on the current entry; the next step
+                            // resumes the walk after it.
+                            finallyBody: [
+                                {
+                                    kind: "if",
+                                    cond: { kind: "unary", op: "!", operand: resumedFlag, type: BOOL, loc },
+                                    then: [suspend(), { kind: "continue", loc }],
+                                    else_: null,
+                                    loc,
+                                },
+                            ],
+                            loc,
+                        },
+                    ],
+                    loc,
+                },
+            ],
+            generator: { yieldT: expected.yieldT, nextT: expected.nextT, resultType, tag: "!" },
+            loc,
+        });
+    }
+    return { kind: "call", callee: name, args: [receiver], type: expected, loc };
+}
 /** `resumed.0 = value` — the adapters' early-exit marker around a yield. */
 function setResumed(value, loc) {
     return {
@@ -57,7 +243,7 @@ function dynIteratorAdapter(lowerer, expr, expected) {
     const key = `iterAdapt:${typeKey(expected)}`;
     let name = lowerer.valueHelpers.get(key);
     if (!name) {
-        name = `%iter.adapt.${lowerer.valueHelpers.size}`;
+        name = keyedHelperName(lowerer, "%iter.adapt", key);
         lowerer.valueHelpers.set(key, name);
         const locals = [];
         const local = (id, type, mutable = false) => {
@@ -280,7 +466,7 @@ export function lowerCollectionIteratorValue(lowerer, receiver, method, type, lo
             };
         if (!typeEquals(yielded.type, type.yieldT))
             return null;
-        name = `%coll.iter.${lowerer.valueHelpers.size}`;
+        name = keyedHelperName(lowerer, "%coll.iter", key);
         lowerer.valueHelpers.set(key, name);
         lowerer.liftedFns.push({
             name,
@@ -374,7 +560,7 @@ export function lowerBytesIteratorValue(lowerer, receiver, method, type, loc) {
     const key = `bytesIter:${method}:${typeKey(bytesT)}:${typeKey(type)}`;
     let name = lowerer.valueHelpers.get(key);
     if (!name) {
-        name = `%bytes.iter.${lowerer.valueHelpers.size}`;
+        name = keyedHelperName(lowerer, "%bytes.iter", key);
         lowerer.valueHelpers.set(key, name);
         const list = varRef("list.0", bytesT, loc);
         const index = varRef("index.0", F64, loc);
@@ -473,7 +659,7 @@ export function lowerStringIteratorValue(lowerer, receiver, type, loc) {
     const key = `strIter:${typeKey(type)}`;
     let name = lowerer.valueHelpers.get(key);
     if (!name) {
-        name = `%str.iter.${lowerer.valueHelpers.size}`;
+        name = keyedHelperName(lowerer, "%str.iter", key);
         lowerer.valueHelpers.set(key, name);
         const text = varRef("text.0", STRING, loc);
         const index = varRef("index.0", F64, loc);
@@ -625,7 +811,7 @@ function generatorRetypeAdapter(lowerer, expr, expected) {
             type: resumeType(expected.nextT),
             loc,
         };
-        name = `%gen.retype.${lowerer.valueHelpers.size}`;
+        name = keyedHelperName(lowerer, "%gen.retype", key);
         lowerer.valueHelpers.set(key, name);
         lowerer.liftedFns.push({
             name,
@@ -739,7 +925,7 @@ export function generatorDrain(lowerer, source, elem, loc) {
         const value = lowerer.coerceToExpected(genValue(genRef, loc), elem);
         if (!typeEquals(value.type, elem))
             return null;
-        name = `%gen.drain.${lowerer.valueHelpers.size}`;
+        name = keyedHelperName(lowerer, "%gen.drain", key);
         lowerer.valueHelpers.set(key, name);
         lowerer.liftedFns.push({
             name,
@@ -797,7 +983,7 @@ export function generatorDrain(lowerer, source, elem, loc) {
         const value = lowerer.coerceToExpected(raw, elem);
         if (!typeEquals(value.type, elem))
             return null;
-        name = `%gen.drain.${lowerer.valueHelpers.size}`;
+        name = keyedHelperName(lowerer, "%gen.drain", key);
         lowerer.valueHelpers.set(key, name);
         lowerer.liftedFns.push({
             name,
@@ -918,7 +1104,7 @@ export function lowerArrayIteratorValue(lowerer, receiver, method, type, loc) {
         }
         if (!yielded || !typeEquals(yielded.type, type.yieldT))
             return null;
-        name = `%arr.iter.${lowerer.valueHelpers.size}`;
+        name = keyedHelperName(lowerer, "%arr.iter", key);
         lowerer.valueHelpers.set(key, name);
         lowerer.liftedFns.push({
             name,