@scriptc/compiler 0.4.3 → 0.4.5

package/dist/frontend/lowering/containers/array-pipelines.js

@@ -1,7 +1,11 @@
+import * as ts from "../../ts7/adapter.js";
+import { CONTRACT_TYPES_MODULE } from "../../contract-types.js";
 import { keyedHelperName } from "../stable-names.js";
+import { writtenLocals } from "../../../ir/callback-specialization.js";
+import { AmbientReceiverReaders } from "../../../ir/receiver-readers.js";
 import { boolLit, countedFor, numLit, varRef } from "../../../ir/build.js";
 import { BOOL, F64, VOID, typeEquals, typeKey, } from "../../../ir/ir.js";
-import { everyExprChild, everyStmtChild, everyStmtList, transformStmtList, } from "../../../ir/traverse.js";
+import { everyExpr, everyExprChild, everyStmt, everyStmtChild, everyStmtList, transformExpr, transformStmtList, } from "../../../ir/traverse.js";
 import { arrayIndexPresent, arrayValueRead, arrayValueStore, arrayValueType, } from "../array-values.js";
 const PRODUCERS = new Set(["map", "filter", "flatMap", "flatMapArray"]);
 const TERMINALS = new Set([
@@ -454,6 +458,70 @@ function matchChain(lowerer, e) {
         loc: e.loc,
     };
 }
+/** The outermost array-HOF call of `e` on its own, over its receiver. */
+function loneChain(lowerer, e) {
+    const top = stageOf(lowerer, e);
+    if (!top)
+        return null;
+    const { stage, receiver } = top;
+    if (receiver.type.kind !== "array")
+        return null;
+    const stages = [];
+    let terminal;
+    if (TERMINALS.has(stage.info.method)) {
+        const init = stage.info.method === "reduce" && stage.info.hasInit && e.kind === "call" ? e.args[2] : null;
+        terminal = { kind: "call", stage, init };
+    }
+    else if (PRODUCERS.has(stage.info.method)) {
+        terminal = { kind: "collect" };
+        stages.push(stage);
+    }
+    else
+        return null;
+    return {
+        source: receiver,
+        sourceType: receiver.type,
+        slice: null,
+        stages,
+        terminal,
+        type: e.type,
+        loc: e.loc,
+    };
+}
+/** The callbacks of `chain` in order, or null when its stages cannot run
+ * in one loop: element types that do not line up, an array argument past
+ * the first stage, reduce without a seed, or findIndex over holes. */
+function chainCallbacks(chain) {
+    const { stages, terminal } = chain;
+    const terminalStage = terminal.kind === "call" ? terminal.stage : null;
+    const callbacks = terminalStage ? [...stages, terminalStage] : stages;
+    // Element types must line up stage to stage.
+    let elem = chain.sourceType.elem;
+    for (const stage of callbacks) {
+        if (!typeEquals(stage.info.elem, elem))
+            return null;
+        if (stage.info.method === "filter" && !typeEquals(stage.info.outElem, stage.info.elem))
+            return null;
+        if ((stage.info.method === "map" || stage.info.method === "flatMap") &&
+            !typeEquals(stage.info.outElem, stage.info.fnRet))
+            return null;
+        elem = stage.info.outElem;
+    }
+    // Index arguments are reproduced; an array argument only names the source.
+    for (let k = 0; k < callbacks.length; k++) {
+        const stage = callbacks[k];
+        const lead = stage.info.method === "reduce" ? 1 : 0;
+        if (stage.info.arity > lead + 3)
+            return null;
+        if (stage.info.arity === lead + 3 && (k !== 0 || chain.slice))
+            return null;
+    }
+    if (terminalStage?.info.method === "reduce" && !terminalStage.info.hasInit)
+        return null;
+    if (terminalStage?.info.method === "findIndex" && holeCarrying(chain))
+        return null;
+    return callbacks;
+}
 /** Fuse chains of array-HOF helper calls into one loop.
  *
  * `xs.filter(f).map(g).reduce(h, z)` lowers to nested helper calls, each
@@ -500,9 +568,27 @@ class PipelineFusion {
     added = [];
     effects;
     helpers = new Map();
+    /** Bindings each function, or a closure it creates, writes after their
+     * declaration. */
+    written;
+    /** classCaptured's answers by function name. */
+    classCaptures = new Map();
+    /** Whether a module imports or re-exports the contract types. */
+    contractTypes;
+    /** Bindings of the function being fused that inlined callbacks captured. */
+    inlinedCaptures = new Set();
+    /** The helper calls each callback with an undefined receiver; a copied
+     * body runs under the receiver around the array call instead. */
+    receivers;
     constructor(lowerer, functions) {
         this.lowerer = lowerer;
         this.effects = new CallbackEffects(functions, lowerer.globalsList);
+        this.written = writtenLocals({ functions });
+        this.receivers = new AmbientReceiverReaders(new Map(functions.map((fn) => [fn.name, fn])));
+        this.contractTypes = lowerer.moduleOrder.some((sf) => sf.statements.nodes.some((st) => (ts.isImportDeclaration(st) || ts.isExportDeclaration(st)) &&
+            st.moduleSpecifier !== undefined &&
+            ts.isStringLiteral(st.moduleSpecifier) &&
+            st.moduleSpecifier.text === CONTRACT_TYPES_MODULE));
     }
     run(fn) {
         const infos = this.lowerer.arrHofInfo;
@@ -513,6 +599,7 @@ class PipelineFusion {
         if (!candidate)
             return;
         const removed = new Set();
+        this.inlinedCaptures = new Set();
         let body = this.lists(fn.body, fn, removed);
         body = transformStmtList(body, {
             stmt: (s) => s,
@@ -521,6 +608,8 @@ class PipelineFusion {
         fn.body = body;
         if (removed.size > 0)
             fn.locals = fn.locals.filter((l) => !removed.has(l.id));
+        if (this.inlinedCaptures.size > 0)
+            unboxUncaptured(fn, this.inlinedCaptures);
     }
     /* ── statement lists: fold single-use chain bindings ── */
     lists(list, fn, removed) {
@@ -645,43 +734,55 @@ class PipelineFusion {
     }
     /* ── expressions ── */
     fuse(e, fn) {
-        const plan = this.plan(e, fn);
+        const plan = this.plan(e, fn) ?? this.lonePlan(e, fn);
         return plan ? this.emit(plan) : null;
     }
+    /** One array-HOF call on its own (or the last call of a chain that does
+     * not fuse), when every callback is a closure literal whose body can be
+     * copied into the loop. A single stage reorders nothing, so the
+     * callbacks' effects need no model; their captured bindings must keep
+     * one value while the loop runs (stableTarget), since the loop reads
+     * them once, when it starts. The loop keeps the helper's order: the
+     * length read once, each element read when it is visited, holes
+     * skipped (and kept by map). */
+    lonePlan(e, fn) {
+        const chain = loneChain(this.lowerer, e);
+        if (!chain)
+            return null;
+        const callbacks = chainCallbacks(chain);
+        if (!callbacks)
+            return null;
+        const inline = this.stableTarget(fn);
+        let frame;
+        for (const stage of callbacks) {
+            for (const arg of [stage.slow, stage.fast]) {
+                if (!arg)
+                    continue;
+                const target = inline(arg);
+                if (!target)
+                    return null;
+                frame ??= target.sourceName;
+            }
+        }
+        return {
+            chain,
+            callbacks,
+            writes: new Set(),
+            risky: true,
+            inline,
+            ...(frame === undefined ? {} : { frame }),
+        };
+    }
     /** Decide whether `e` is a fusable chain; null when it is not. */
     plan(e, fn) {
         const chain = matchChain(this.lowerer, e);
         if (!chain)
             return null;
+        const callbacks = chainCallbacks(chain);
+        if (!callbacks)
+            return null;
         const { stages, terminal } = chain;
         const terminalStage = terminal.kind === "call" ? terminal.stage : null;
-        const callbacks = terminalStage ? [...stages, terminalStage] : stages;
-        // Element types must line up stage to stage.
-        let elem = chain.sourceType.elem;
-        for (const stage of callbacks) {
-            if (!typeEquals(stage.info.elem, elem))
-                return null;
-            if (stage.info.method === "filter" && !typeEquals(stage.info.outElem, stage.info.elem))
-                return null;
-            if ((stage.info.method === "map" || stage.info.method === "flatMap") &&
-                !typeEquals(stage.info.outElem, stage.info.fnRet))
-                return null;
-            elem = stage.info.outElem;
-        }
-        // Index arguments are reproduced; an array argument only names the source.
-        for (let k = 0; k < callbacks.length; k++) {
-            const stage = callbacks[k];
-            const lead = stage.info.method === "reduce" ? 1 : 0;
-            if (stage.info.arity > lead + 3)
-                return null;
-            if (stage.info.arity === lead + 3 && (k !== 0 || chain.slice))
-                return null;
-        }
-        if (terminalStage?.info.method === "reduce" && !terminalStage.info.hasInit)
-            return null;
-        const holes = holeCarrying(chain);
-        if (terminalStage?.info.method === "findIndex" && holes)
-            return null;
         // Effects of each callback, in chain order.
         const scope = this.effects.scope(fn, true);
         const summaries = [];
@@ -758,35 +859,90 @@ class PipelineFusion {
      * are passed in by value, read when the fused call starts; no callback
      * in the chain assigns a binding another one reads). */
     inlineTarget = (arg) => {
-        if (arg.kind !== "closure" || arg.adapts)
-            return null;
-        const fn = this.effects.fn(arg.fnName);
-        if (!fn || fn.async || fn.generator || fn.classCaptures?.length)
+        const fn = this.closureTarget(arg);
+        if (!fn)
             return null;
         const captures = new Set((fn.captures ?? []).map((c) => c.localId));
-        if (captures.size !== arg.captures.length)
-            return null;
         const effects = this.effects.ofFunction(fn);
         if (!effects || intersects(effects.writes, captures))
             return null;
-        if (fn.locals.some((l) => l.tdz || (l.boxed && !captures.has(l.id))))
-            return null;
-        let size = 0;
-        const small = everyStmtList(fn.body, {
-            expr: (e) => ++size <= MAX_INLINE_NODES && e.kind !== "closure" && e.kind !== "selfRef",
-            stmt: (s) => ++size <= MAX_INLINE_NODES && s.kind !== "tryCatch",
-        });
-        return small ? fn : null;
+        return inlinableBody(fn, captures) ? fn : null;
     };
+    /** inlineTarget for a callback created in `fn` whose captured bindings
+     * nothing assigns after their declaration: `fn`'s own locals and
+     * parameters, written neither by `fn` nor by any closure that shares
+     * them, and not by the callback body. A binding a local class captures
+     * counts as written, since its methods may assign it; so does a binding
+     * a method reads through its class's captures. The callback must
+     * not observe the ambient receiver (AmbientReceiverReaders). */
+    stableTarget(fn) {
+        const locals = new Map(fn.locals.map((l) => [l.id, l]));
+        const inherited = new Set([...(fn.captures ?? []), ...(fn.classCaptures ?? [])].map((c) => c.localId));
+        const written = this.written.get(fn.name);
+        const classCaptured = this.classCaptured(fn);
+        return (arg) => {
+            const target = this.closureTarget(arg);
+            if (!target || !written || arg.kind !== "closure")
+                return null;
+            if (!this.receivers.ignores(target))
+                return null;
+            for (const id of arg.captures) {
+                const local = locals.get(id);
+                if (!local || local.tdz || inherited.has(id) || written.has(id) || classCaptured.has(id))
+                    return null;
+            }
+            const captures = new Set((target.captures ?? []).map((c) => c.localId));
+            const assigns = !everyStmtList(target.body, {
+                stmt: (st) => !((st.kind === "assign" || st.kind === "forOf") && captures.has(st.localId)),
+                expr: (ex) => !((ex.kind === "assignExpr" || ex.kind === "incDec") && captures.has(ex.localId)),
+            });
+            return !assigns && inlinableBody(target, captures) ? target : null;
+        };
+    }
+    /** The bindings of `fn` that a local class it creates captures. */
+    classCaptured(fn) {
+        const known = this.classCaptures.get(fn.name);
+        if (known)
+            return known;
+        const ids = new Set();
+        everyStmtList(fn.body, {
+            expr: (e) => {
+                if (e.kind === "classRef")
+                    for (const id of e.captures ?? [])
+                        ids.add(id);
+                return true;
+            },
+            stmt: () => true,
+        });
+        this.classCaptures.set(fn.name, ids);
+        return ids;
+    }
+    /** The function behind a closure-literal callback the loop can inline. */
+    closureTarget(arg) {
+        if (arg.kind !== "closure" || arg.adapts)
+            return null;
+        const fn = this.effects.fn(arg.fnName);
+        if (!fn || fn.async || fn.generator || fn.classCaptures?.length)
+            return null;
+        if ((fn.captures ?? []).length !== arg.captures.length)
+            return null;
+        return fn;
+    }
     emit(plan) {
-        const built = new FusedLoop(this.lowerer, plan.chain, this.inlineTarget).build();
+        const built = new FusedLoop(this.lowerer, plan.chain, plan.inline ?? this.inlineTarget, this.contractTypes).build();
         if (!built)
             return null;
+        for (const id of built.inlinedCaptures)
+            this.inlinedCaptures.add(id);
         let name = this.helpers.get(built.key);
         if (!name) {
-            name = keyedHelperName(this.lowerer, "%arr.fused", built.key);
+            name = keyedHelperName(this.lowerer, plan.inline ? "%arr.loop" : "%arr.fused", built.key);
             this.helpers.set(built.key, name);
-            this.added.push({ ...built.fn, name });
+            const helper = { ...built.fn, name };
+            // A lone call's loop stands in the inlined callback's stack frame.
+            if (plan.frame !== undefined)
+                helper.sourceName = plan.frame;
+            this.added.push(helper);
         }
         return {
             kind: "call",
@@ -797,6 +953,47 @@ class PipelineFusion {
         };
     }
 }
+/** Whether a statement inside `e` (a sequence expression's) returns. */
+function returns(e) {
+    return !everyExpr(e, { expr: () => true, stmt: (s) => s.kind !== "return" });
+}
+/** Drops the box of each binding in `inlined` that no closure or class
+ * created in `fn` captures any more: the callbacks that captured it were
+ * copied into loops, which receive its value. A dead-zone binding keeps the
+ * box that represents its uninitialized state, and bindings `fn` itself
+ * captures keep theirs. */
+function unboxUncaptured(fn, inlined) {
+    const captured = new Set();
+    everyStmtList(fn.body, {
+        expr: (e) => {
+            if (e.kind === "closure" || e.kind === "classRef")
+                for (const id of e.captures ?? [])
+                    captured.add(id);
+            return true;
+        },
+        stmt: () => true,
+    });
+    const inherited = new Set([...(fn.captures ?? []), ...(fn.classCaptures ?? [])].map((c) => c.localId));
+    fn.locals = fn.locals.map((local) => {
+        if (local.boxed !== true || local.tdz === true || !inlined.has(local.id))
+            return local;
+        if (captured.has(local.id) || inherited.has(local.id))
+            return local;
+        const { boxed: _boxed, ...plain } = local;
+        return plain;
+    });
+}
+/** A callback body the loop can copy: small, no nested closures, recursion
+ * or try statements, and no boxed locals besides its captures. */
+function inlinableBody(fn, captures) {
+    if (fn.locals.some((l) => l.tdz || (l.boxed && !captures.has(l.id))))
+        return false;
+    let size = 0;
+    return everyStmtList(fn.body, {
+        expr: (e) => ++size <= MAX_INLINE_NODES && e.kind !== "closure" && e.kind !== "selfRef",
+        stmt: (s) => ++size <= MAX_INLINE_NODES && s.kind !== "tryCatch",
+    });
+}
 function intersects(a, b) {
     for (const id of a)
         if (b.has(id))
@@ -889,6 +1086,7 @@ class FusedLoop {
     lowerer;
     chain;
     inlineTarget;
+    contractTypes;
     params = [];
     locals = [];
     args = [];
@@ -897,18 +1095,21 @@ class FusedLoop {
     loc;
     next = 0;
     failed = false;
-    constructor(lowerer, chain, inlineTarget) {
+    /** `contractTypes`: the program writes contract types, which the
+     * contract checker binds to source bindings. */
+    constructor(lowerer, chain, inlineTarget, contractTypes) {
         this.lowerer = lowerer;
         this.chain = chain;
         this.inlineTarget = inlineTarget;
+        this.contractTypes = contractTypes;
         this.loc = chain.loc;
     }
     fresh(name) {
         return `${name}.${this.next++}`;
     }
-    local(name, type, mutable = false) {
+    local(name, type, mutable = false, source) {
         const id = this.fresh(name);
-        this.locals.push({ id, name, type, mutable });
+        this.locals.push(source ? { id, name, type, mutable, source } : { id, name, type, mutable });
         return id;
     }
     param(name, value, key) {
@@ -924,7 +1125,9 @@ class FusedLoop {
         const known = this.callees.find((c) => c.arg === arg);
         if (known)
             return known;
-        const target = this.inlineTarget(arg);
+        // Called as a plain function: the loop is not the target's receiver.
+        const inlineTarget = this.inlineTarget;
+        const target = inlineTarget(arg);
         let callee;
         if (target && arg.kind === "closure") {
             const captures = new Map();
@@ -974,10 +1177,18 @@ class FusedLoop {
                 return true;
             },
         });
+        // Copies keep their source bindings, so contract types written on
+        // them are checked against what the loop stores. In a program that
+        // writes contract types, a parameter with a source binding keeps its
+        // own local for the same reason.
+        const sources = new Map(fn.locals.map((l) => [l.id, l.source]));
         const aliased = new Set();
         fn.params.forEach((p, index) => {
             const arg = args[index];
-            if (arg.kind === "varRef" && !assigned.has(p.localId) && typeEquals(arg.type, p.type)) {
+            if (arg.kind === "varRef" &&
+                !assigned.has(p.localId) &&
+                typeEquals(arg.type, p.type) &&
+                !(this.contractTypes && sources.get(p.localId) !== undefined)) {
                 renamed.set(p.localId, arg.localId);
                 aliased.add(p.localId);
             }
@@ -985,11 +1196,31 @@ class FusedLoop {
         for (const l of fn.locals) {
             if (renamed.has(l.id))
                 continue;
-            const id = this.local(l.name, l.type, true);
+            const id = this.local(l.name, l.type, true, l.source);
             renamed.set(l.id, id);
         }
+        const rename = (id) => renamed.get(id) ?? id;
+        const renameExpr = (e) => {
+            switch (e.kind) {
+                case "varRef":
+                case "incDec":
+                case "assignExpr":
+                    return { ...e, localId: rename(e.localId) };
+                default:
+                    return e;
+            }
+        };
+        // A bound parameter's value is an element or index with no source text
+        // of its own; it is located at the parameter, without a span.
+        const bind = fn.params.flatMap((p, index) => {
+            if (aliased.has(p.localId))
+                return [];
+            const source = sources.get(p.localId);
+            const arg = args[index];
+            const init = source ? { ...arg, loc: { ...source.loc, end: source.loc.start } } : arg;
+            return [{ kind: "varDecl", localId: rename(p.localId), init, loc }];
+        });
         const labels = new Map();
-        const exit = this.fresh("%fused.exit");
         const label = (name) => {
             let id = labels.get(name);
             if (!id) {
@@ -998,19 +1229,51 @@ class FusedLoop {
             }
             return id;
         };
+        /** Locals and labels of a copied statement; returns are the caller's. */
+        const renameStmt = (st) => {
+            switch (st.kind) {
+                case "varDecl":
+                case "assign":
+                    return { ...st, localId: rename(st.localId) };
+                case "break":
+                case "continue":
+                    return st.label ? { ...st, label: label(st.label) } : st;
+                case "forOf": {
+                    const renamedFor = { ...st, localId: rename(st.localId) };
+                    return st.labels ? { ...renamedFor, labels: st.labels.map(label) } : renamedFor;
+                }
+                case "while":
+                case "doWhile":
+                case "for":
+                case "switch":
+                case "block":
+                    return st.labels ? { ...st, labels: st.labels.map(label) } : st;
+                default:
+                    return st;
+            }
+        };
+        // A body whose only return is its last statement (`(x) => x * k`,
+        // `{ const y = x * 2; return y > 4; }`) needs no exit block: its other
+        // statements run after the bindings, and the call's value is the
+        // returned expression.
+        const last = fn.body[fn.body.length - 1];
+        const prefix = fn.body.slice(0, -1);
+        if (last !== undefined &&
+            last.kind === "return" &&
+            last.value !== null &&
+            typeEquals(last.value.type, fn.returnType) &&
+            !returns(last.value) &&
+            prefix.every((st) => everyStmt(st, { expr: () => true, stmt: (x) => x.kind !== "return" }))) {
+            const copy = { expr: renameExpr, stmt: renameStmt };
+            return {
+                pre: [...bind, ...transformStmtList(prefix, copy)],
+                value: transformExpr(last.value, copy),
+            };
+        }
+        const exit = this.fresh("%fused.exit");
         const result = fn.returnType.kind === "void" ? null : this.local("ret", fn.returnType, true);
-        const rename = (id) => renamed.get(id) ?? id;
         const body = transformStmtList(fn.body, {
-            expr: (e) => {
-                switch (e.kind) {
-                    case "varRef":
-                    case "incDec":
-                    case "assignExpr":
-                        return { ...e, localId: rename(e.localId) };
-                    default:
-                        return e;
-                }
-            },
+            expr: renameExpr,
             stmt: (s) => {
                 switch (s.kind) {
                     case "return": {
@@ -1030,25 +1293,14 @@ class FusedLoop {
                             loc: s.loc,
                         };
                     }
-                    case "varDecl":
-                    case "assign":
-                        return { ...s, localId: rename(s.localId) };
                     case "break":
                     case "continue":
                         return s.label && s.label !== exit ? { ...s, label: label(s.label) } : s;
-                    case "while":
-                    case "doWhile":
-                    case "for":
-                    case "block":
-                        return s.labels ? { ...s, labels: s.labels.map(label) } : s;
                     default:
-                        return s;
+                        return renameStmt(s);
                 }
             },
         });
-        const bind = fn.params.flatMap((p, index) => aliased.has(p.localId)
-            ? []
-            : [{ kind: "varDecl", localId: rename(p.localId), init: args[index], loc }]);
         const pre = [];
         if (result !== null)
             pre.push({ kind: "varDecl", localId: result, init: null, loc });
@@ -1523,7 +1775,8 @@ class FusedLoop {
         };
         foldKnownUnions(fn);
         scalarizeRecordTemporaries(this.lowerer, fn);
-        return { fn, args: this.args, key: this.keyParts.join("|") };
+        const inlinedCaptures = this.callees.flatMap((c) => c.inline && c.arg.kind === "closure" ? c.arg.captures : []);
+        return { fn, args: this.args, key: this.keyParts.join("|"), inlinedCaptures };
     }
 }
 function increment(id, loc) {
@@ -1623,8 +1876,11 @@ function foldKnownUnions(fn) {
                 case "for":
                 case "while":
                 case "doWhile":
+                case "forOf":
                 case "block":
                     return { ...s, body: prune(s.body) };
+                case "switch":
+                    return { ...s, cases: s.cases.map((c) => ({ ...c, body: prune(c.body) })) };
                 default:
                     return s;
             }
@@ -1816,6 +2072,19 @@ function scalarizeRecordTemporaries(lowerer, fn) {
                         body: rewriteList(s.body),
                     },
                 ];
+            case "forOf":
+                return [{ ...s, iterable: rewriteExpr(s.iterable), body: rewriteList(s.body) }];
+            case "switch":
+                return [
+                    {
+                        ...s,
+                        disc: rewriteExpr(s.disc),
+                        cases: s.cases.map((c) => ({
+                            test: c.test === null ? null : rewriteExpr(c.test),
+                            body: rewriteList(c.body),
+                        })),
+                    },
+                ];
             case "block":
                 return [{ ...s, body: rewriteList(s.body) }];
             default: {