@typesol/cli 0.22.0 → 0.24.0

package/dist/compiler/emit/statements.js

@@ -1,7 +1,7 @@
 import ts from "typescript";
-import { MAX_RETURN_DATA, resolveValueType, structNameOf } from "../analyze.js";
-import { INT_INFO, isWritable, optionKey, scalarSize, typeName } from "../model.js";
-import { U64, BOOL, cString, optC, scalarC, scalarStorageC, valueC } from "./shared.js";
+import { MAX_RETURN_DATA, calleeName, resolveScalarType, resolveValueType, structNameOf, typesolName } from "../analyze.js";
+import { INT_INFO, isScalar, isWritable, optionKey, scalarSize, typeName, } from "../model.js";
+import { U64, BOOL, cString, fixedVecC, optC, scalarC, scalarStorageC, valueC } from "./shared.js";
 import { CpiEmitter } from "./cpi.js";
 /**
  * Statements: variables, assignment, control flow and return.
@@ -259,37 +259,234 @@ export class StatementEmitter extends CpiEmitter {
             n.parent = stmt;
             return n;
         };
-        const indexId = place(f.createIdentifier(index));
-        const length = place(f.createPropertyAccessExpression(stmt.expression, "length"));
-        const get = place(f.createCallExpression(place(f.createPropertyAccessExpression(stmt.expression, "get")), undefined, [indexId]));
-        // The element's declaration: the source's own name (so aliasing checks find its uses) bound to list.get(i).
-        const decl = f.createVariableDeclaration(d.name, undefined, undefined, get);
-        ts.setTextRange(decl, d);
-        decl.parent = list;
-        const declList = { ...list, flags: ts.NodeFlags.Const, declarations: [decl] };
+        void place;
         const ci = this.tmp("of_i");
         const label = this.tmp("ts_continue_");
+        this.eachElement(stmt.expression, stmt, { index, ci, next: label, alwaysNext: true }, (element) => {
+            // The element's declaration: the source's own name (so aliasing checks find its uses) bound to the element.
+            const decl = f.createVariableDeclaration(d.name, undefined, undefined, element);
+            ts.setTextRange(decl, d);
+            decl.parent = list;
+            const declList = { ...list, flags: ts.NodeFlags.Const, declarations: [decl] };
+            this.variable(declList);
+            this.loops.push(label);
+            this.line(`{`);
+            this.block(() => this.body(stmt.statement));
+            this.line(`}`);
+            this.loops.pop();
+        });
+    }
+    /** The function an identifier names (a closure, a local function or a helper), as something to expand; else undefined. */
+    functionNamed(id) {
+        const l = this.lookup(id.text);
+        if (l)
+            return l.closure;
+        const name = calleeName(id, this.model.helperDecls, this.checker);
+        const h = name ? (this.model.helpers.get(name) ?? this.model.generics.get(name)) : undefined;
+        return h ? { node: h.node, name: h.display, scopes: [], env: this.noEnv(), imports: h.imports } : undefined;
+    }
+    /** `xs.map(…)` / `xs.filter(…)` (or a chain of them): a list built element by element, not stored anywhere yet. */
+    isPipeline(e) {
+        return ts.isCallExpression(e) && ts.isPropertyAccessExpression(e.expression) && (e.expression.name.text === "map" || e.expression.name.text === "filter");
+    }
+    /** The list under a chain of map / filter calls, and the calls in the order they run. */
+    pipelineStages(e) {
+        const stages = [];
+        let base = e;
+        while (this.isPipeline(base)) {
+            const access = base.expression;
+            const kind = access.name.text;
+            if (base.arguments.length !== 1)
+                this.fail(base, `${kind}() takes one argument: the callback`);
+            const fn = base.arguments[0];
+            if (!ts.isArrowFunction(fn) && !ts.isFunctionExpression(fn))
+                this.fail(fn, `pass ${kind} an arrow function written here: xs.${kind}((x) => …)`);
+            if (fn.parameters.length > 2)
+                this.fail(fn.parameters[2], `${kind}'s callback takes the element and its index`);
+            stages.unshift({ kind, fn });
+            base = access.expression;
+        }
+        if (stages.length) {
+            const l = ts.isIdentifier(base) ? this.lookup(base.text) : undefined;
+            if (!(l?.type.kind === "vecArg" || l?.type.kind === "array" || this.peekArray(base)))
+                this.fail(base, "map and filter work on a Vec, FixedArray or FixedVec");
+        }
+        return { base, stages };
+    }
+    /**
+     * Run `body` for each element of a list, or of a chain of `map` / `filter` calls on one (`xs.filter(f).map(g)`):
+     * one index loop over the list (its length read every step, as `for … of`), each callback expanded in it. A
+     * filter skips to the next element, a map binds its result, so a chain builds no list. `body` gets the element (as
+     * `list.get(i)` gives it, structs by reference, or the mapped value) and its index in the chain's output (after a
+     * filter, the count of elements it let through, as JS gives callbacks).
+     */
+    eachElement(list, at, names, body) {
+        const f = ts.factory;
+        const place = (n) => {
+            ts.setTextRange(n, at);
+            n.parent = at;
+            return n;
+        };
+        const { base, stages } = this.pipelineStages(list);
+        const { index, ci } = names;
+        const indexId = place(f.createIdentifier(index));
+        const length = place(f.createPropertyAccessExpression(base, "length"));
+        const get = place(f.createCallExpression(place(f.createPropertyAccessExpression(base, "get")), undefined, [indexId]));
+        const next = names.next ?? (stages.some((s) => s.kind === "filter") ? this.tmp("ts_next_") : undefined);
         this.line(`{`);
         this.block(() => {
             this.line(`uint64_t ${ci} = 0;`);
             this.scopes.at(-1).set(index, { c: ci, type: U64, mutable: false });
+            const counters = stages
+                .filter((st) => st.kind === "filter")
+                .map(() => {
+                const k = this.tmp("lm_k");
+                this.line(`uint64_t ${k} = 0;`);
+                return k;
+            });
             this.line(`while (1) {`);
             this.block(() => {
-                const n = this.expect(this.expr(length, U64), U64, stmt.expression);
+                const n = this.expect(this.expr(length, U64), U64, base);
                 this.line(`if (!(${ci} < ${n.c})) break;`);
-                this.variable(declList);
-                this.loops.push(label);
-                this.line(`{`);
-                this.block(() => this.body(stmt.statement));
-                this.line(`}`);
-                this.loops.pop();
-                this.line(`${label}:;`);
+                let element = get;
+                let idx = indexId;
+                let k = 0;
+                for (const st of stages) {
+                    if (st.kind === "map") {
+                        const ret = st.fn.body && !ts.isBlock(st.fn.body) ? st.fn.body : undefined;
+                        const bare = ret && ts.isParenthesizedExpression(ret) ? ret.expression : ret;
+                        if (bare && ts.isObjectLiteralExpression(bare))
+                            this.fail(st.fn, "a map to structs is stored, with the struct type: const ys: FixedVec<MyStruct, N> = xs.map((x) => ({ … }))");
+                    }
+                    const closure = { node: st.fn, name: `${st.kind}'s callback`, scopes: [...this.scopes], env: this.envNow(), imports: this.scope.imports };
+                    const v = this.expandClosure(closure, [element, idx].slice(0, st.fn.parameters.length), st.fn);
+                    if (st.kind === "filter") {
+                        if (!v)
+                            this.fail(st.fn, "filter's callback returns a boolean");
+                        const b = this.expect(v, BOOL, st.fn);
+                        this.line(`if (!(${b.c})) goto ${next};`);
+                        const id = `__lk${this.temp++}`;
+                        const ic = this.tmp("lm_ki");
+                        this.line(`uint64_t ${ic} = ${counters[k++]}++;`);
+                        this.scopes.at(-1).set(id, { c: ic, type: U64, mutable: false });
+                        idx = place(f.createIdentifier(id));
+                    }
+                    else {
+                        if (!v)
+                            this.fail(st.fn, "map's callback returns the new element");
+                        const mv = v.literal !== undefined ? this.literal(v.literal, U64, st.fn) : v;
+                        if (!["int", "bool", "pubkey", "enum"].includes(mv.type.kind))
+                            this.fail(st.fn, `map's callback returns integers, booleans, Pubkeys or enums (the new list's elements), not ${typeName(mv.type)}`);
+                        const id = `__lv${this.temp++}`;
+                        const mc = this.tmp("lm_v");
+                        this.line(mv.type.kind === "pubkey" ? `SolPubkey ${mc} = *(${mv.c});` : `${valueC(mv.type)} ${mc} = ${mv.c};`);
+                        this.scopes.at(-1).set(id, { c: mc, type: mv.type, mutable: false });
+                        element = place(f.createIdentifier(id));
+                    }
+                }
+                body(element, idx);
+                if (next && (names.alwaysNext || counters.length))
+                    this.line(`${next}:;`);
                 this.line(`${ci}++;`);
             });
             this.line(`}`);
         });
         this.line(`}`);
     }
+    /**
+     * `const ys = xs.map(…)` / `xs.filter(…)`: the chain's elements in a local FixedVec, as big as the list it starts
+     * from (a FixedArray's length, a FixedVec's capacity) or as annotated (`const ys: FixedVec<u64, 16> = …`, needed
+     * when it starts from a Vec). It lives on the stack, so it holds at most 2 KiB; one more element than it holds aborts.
+     */
+    localList(d, init, c) {
+        const { base, stages } = this.pipelineStages(init);
+        let cap;
+        let annotatedElem;
+        if (d.type) {
+            const t = d.type;
+            const args = ts.isTypeReferenceNode(t) ? (t.typeArguments ?? []) : [];
+            const n = args[1] && ts.isLiteralTypeNode(args[1]) && ts.isNumericLiteral(args[1].literal) ? Number(args[1].literal.text) : NaN;
+            const elemNode = args[0];
+            const sn = elemNode && structNameOf(elemNode, this.scope);
+            const fs = elemNode && typesolName(elemNode, this.scope.imports) === "FixedString" ? elemNode.typeArguments?.[0] : undefined;
+            const fcap = fs && ts.isLiteralTypeNode(fs) && ts.isNumericLiteral(fs.literal) ? Number(fs.literal.text) : NaN;
+            if (Number.isInteger(fcap) && fcap >= 1)
+                this.model.fstrings.add(fcap);
+            annotatedElem = elemNode
+                ? (resolveScalarType(elemNode, this.scope) ??
+                    (sn && this.model.structs.has(sn) ? { kind: "struct", name: sn } : Number.isInteger(fcap) && fcap >= 1 ? { kind: "fstring", cap: fcap } : undefined))
+                : undefined;
+            if (!ts.isTypeReferenceNode(t) || typesolName(t, this.scope.imports) !== "FixedVec" || !annotatedElem || !Number.isInteger(n) || n < 1)
+                this.fail(t, "annotate the new list as FixedVec<T, N> (N a literal)");
+            cap = n;
+        }
+        else {
+            const r = this.reporter.guard(() => this.ref(base));
+            const l = ts.isIdentifier(base) ? this.lookup(base.text) : undefined;
+            if (r?.type.kind === "array")
+                cap = r.type.len;
+            else if (r?.type.kind === "vec" && r.type.cap !== undefined)
+                cap = r.type.cap;
+            if (cap === undefined || l?.type.kind === "vecArg")
+                this.fail(init, "this list has no fixed size: annotate the new one with its capacity, const ys: FixedVec<T, N> = …");
+        }
+        // The element type: the last map's result, else the list's own elements (known once the loop is emitted).
+        const declAt = this.lines.length;
+        this.line(`/* ${c} */`);
+        let elem = stages.some((st) => st.kind === "map") ? undefined : this.listElem(base);
+        const cap0 = cap;
+        // A last map to structs or FixedStrings (annotated) writes each result straight into its slot.
+        const last = stages.at(-1);
+        if (last?.kind === "map" && annotatedElem && !isScalar(annotatedElem)) {
+            const target = annotatedElem;
+            const inner = init.expression.expression;
+            this.eachElement(inner, init, { index: `__ml${this.temp++}`, ci: this.tmp("ml_i") }, (element, index) => {
+                this.line(`if (${c}.len >= ${cap0}) TS_FAIL(TS_ERR_INDEX, "TypeSOL: the new list is full");`);
+                const closure = { node: last.fn, name: "map's callback", scopes: [...this.scopes], env: this.envNow(), imports: this.scope.imports };
+                this.expandClosure(closure, [element, index].slice(0, last.fn.parameters.length), last.fn, {
+                    lv: `${c}.items[${c}.len]`,
+                    type: target,
+                    writable: true,
+                });
+                this.line(`${c}.len++;`);
+            });
+            elem = target;
+        }
+        else
+            this.eachElement(init, init, { index: `__ml${this.temp++}`, ci: this.tmp("ml_i") }, (element) => {
+                if (!elem) {
+                    const v = this.expr(element);
+                    elem = v.type;
+                }
+                const target = annotatedElem ?? elem;
+                const sub = { lv: `${c}.items[${c}.len]`, type: target, writable: true };
+                this.line(`if (${c}.len >= ${cap0}) TS_FAIL(TS_ERR_INDEX, "TypeSOL: the new list is full");`);
+                const vt = this.storageValueType(target);
+                if (vt)
+                    this.line(this.writeStorage(sub, this.ownedString(this.expect(this.expr(element, vt), vt, element)).c) + ";");
+                else
+                    this.writeAggregate(sub, element);
+                this.line(`${c}.len++;`);
+            });
+        const t = { kind: "vec", elem: annotatedElem ?? elem, cap: cap0 };
+        const bytes = 4 + this.fieldBytes(t.elem) * cap0;
+        if (bytes > 2048)
+            this.fail(init, `the new list takes ${bytes} bytes; locals live on the 4 KiB stack, so keep it under 2 KiB (a smaller FixedVec<T, N>)`);
+        this.model.localVecs.set(fixedVecC(t), t);
+        const pad = "  ".repeat(this.indent);
+        this.lines[declAt] = `${pad}${fixedVecC(t)} ${c};\n${pad}ts_memzero(&${c}, sizeof(${c}));`;
+        return t;
+    }
+    /** The element type of a Vec, FixedArray, FixedVec or Vec argument. */
+    listElem(list) {
+        const l = ts.isIdentifier(list) ? this.lookup(list.text) : undefined;
+        if (l?.type.kind === "vecArg")
+            return l.type.elem;
+        const r = this.ref(list);
+        if (r && (r.type.kind === "array" || r.type.kind === "vec"))
+            return r.type.elem;
+        this.fail(list, "expected a Vec, FixedArray or FixedVec");
+    }
     /** Whether `e` is the remaining accounts (or a const bound to them). */
     isRemaining(e) {
         if (ts.isCallExpression(e) && this.exportName(e.expression) === "remainingAccounts")
@@ -325,24 +522,43 @@ export class StatementEmitter extends CpiEmitter {
      * was declared with, so a block around the call that declares the same name does not change what it reads, and
      * writes to captured `let`s are seen by the enclosing function. Returns the result (undefined for no value).
      */
-    expandClosure(c, args, node) {
+    expandClosure(c, args, node, into) {
         const fn = c.node;
         if (this.inlining.has(fn))
             this.fail(node, `${c.name} calls itself: closures cannot be recursive`);
+        // Its types are written in its own file: they mean what that file's imports say (the arguments are the caller's).
+        const calleeScope = c.imports === this.scope.imports ? this.scope : { ...this.scope, imports: c.imports };
         if (args.length !== fn.parameters.length)
             this.fail(node, `${c.name}() takes ${fn.parameters.length} argument(s)`);
         const params = new Map();
+        // Account parameters (of a helper expanded here) name the caller's accounts while the body runs.
+        const aliases = new Map();
         fn.parameters.forEach((p, i) => {
             if (!ts.isIdentifier(p.name) || p.initializer || p.dotDotDotToken)
                 this.fail(p, "closure parameters are plain names");
             const arg = args[i];
             const name = p.name.text;
+            // A function parameter (of a helper expanded here): the function given, expanded where the body calls it.
+            if (p.type && ts.isFunctionTypeNode(p.type)) {
+                params.set(name, { c: "", type: BOOL, mutable: false, closure: this.closureOf(arg) });
+                return;
+            }
+            if (p.type && ts.isIdentifier(arg) && !this.lookup(arg.text) && this.accounts.has(arg.text) && !resolveValueType(p.type, calleeScope)) {
+                aliases.set(name, this.accounts.get(arg.text));
+                return;
+            }
             const c2 = `l_${name}_${this.temp++}`;
-            const annotated = p.type ? resolveValueType(p.type, this.scope) : undefined;
+            const annotated = p.type ? resolveValueType(p.type, calleeScope) : undefined;
             if (!annotated && this.looksLikeStructPlace(arg)) {
                 const place = this.structPlace(arg);
                 this.line(`TSS_${place.struct} *${c2} = ${place.ptr};`);
-                params.set(name, { c: c2, type: { kind: "structRef", struct: place.struct, writable: place.writable }, mutable: false, paths: this.pathsOf(arg) });
+                params.set(name, {
+                    c: c2,
+                    type: { kind: "structRef", struct: place.struct, writable: place.writable },
+                    mutable: false,
+                    paths: this.pathsOf(arg),
+                    decl: p,
+                });
                 return;
             }
             let v = this.expr(arg, annotated);
@@ -358,7 +574,7 @@ export class StatementEmitter extends CpiEmitter {
                 this.line(`${valueC(type)}${type.kind === "account" ? "" : " "}${c2} = ${this.ownedString(v).c};`);
             params.set(name, { c: c2, type, mutable: true });
         });
-        const declared = fn.type && fn.type.kind !== ts.SyntaxKind.VoidKeyword ? resolveValueType(fn.type, this.scope) : undefined;
+        const declared = fn.type && fn.type.kind !== ts.SyntaxKind.VoidKeyword ? resolveValueType(fn.type, calleeScope) : undefined;
         if (fn.type && fn.type.kind !== ts.SyntaxKind.VoidKeyword && !declared)
             this.fail(fn.type, "closures return integers, booleans, Pubkeys, strings, enums or Options");
         const frame = {
@@ -368,16 +584,42 @@ export class StatementEmitter extends CpiEmitter {
             declAt: this.lines.length,
             pad: "  ".repeat(this.indent),
             node: fn,
+            into,
         };
         this.line(declared ? `${declared.kind === "pubkey" ? "SolPubkey" : valueC(declared)} ${frame.result};` : `/* ${frame.result} */`);
-        const saved = { scopes: this.scopes, loops: this.loops.splice(0) };
+        // The body names what it could where it was written: a closure the caller's arguments and accounts, a helper
+        // only its own parameters (its account parameters name the caller's accounts) and the module.
+        const swap = (m, to) => {
+            const before = new Map(m);
+            m.clear();
+            for (const [k, v] of to)
+                m.set(k, v);
+            return before;
+        };
+        const bodyAccounts = new Map(c.env.accounts);
+        for (const [n, a] of aliases)
+            bodyAccounts.set(n, a);
+        // Accounts are found by name before locals: a parameter named like one the body can see would read the account.
+        for (const n of params.keys())
+            if (bodyAccounts.has(n))
+                this.fail(fn.parameters.find((p) => ts.isIdentifier(p.name) && p.name.text === n) ?? node, `"${n}" shadows the account "${n}"; use another name`);
+        const saved = {
+            scope: this.scope,
+            scopes: this.scopes,
+            loops: this.loops.splice(0),
+            args: swap(this.args, c.env.args),
+            accounts: swap(this.accounts, bodyAccounts),
+        };
         this.scopes = [...c.scopes, params];
+        this.scope = calleeScope;
         this.inlining.add(fn);
         this.inlineFrames.push(frame);
         try {
             this.line(`{`);
             this.block(() => {
                 const body = fn.body;
+                if (!body)
+                    this.fail(fn, `${c.name} has no body`);
                 if (ts.isBlock(body))
                     body.statements.forEach((s) => this.reporter.guard(() => this.statement(s)));
                 else {
@@ -385,7 +627,7 @@ export class StatementEmitter extends CpiEmitter {
                     const ret = ts.factory.createReturnStatement(body);
                     ts.setTextRange(ret, body);
                     ret.parent = fn;
-                    if (ts.isCallExpression(body) && !frame.type) {
+                    if (ts.isCallExpression(body) && !frame.type && !into) {
                         const v = this.call(body, false);
                         if (v)
                             this.closureResult(v, body, frame);
@@ -400,7 +642,10 @@ export class StatementEmitter extends CpiEmitter {
         finally {
             this.inlineFrames.pop();
             this.inlining.delete(fn);
+            swap(this.args, saved.args);
+            swap(this.accounts, saved.accounts);
             this.scopes = saved.scopes;
+            this.scope = saved.scope;
             this.loops.push(...saved.loops);
         }
         if (!frame.type) {
@@ -434,9 +679,7 @@ export class StatementEmitter extends CpiEmitter {
             this.fail(cb, `pass ${method} an arrow function written here: xs.${method}((x) => …)`);
         const fn = cb;
         const index = `__lm${this.temp++}`;
-        const indexId = place(f.createIdentifier(index));
-        const length = place(f.createPropertyAccessExpression(list, "length"));
-        const element = place(f.createCallExpression(place(f.createPropertyAccessExpression(list, "get")), undefined, [indexId]));
+        void place;
         const I64 = { kind: "int", name: "i64" };
         // The result, declared before the loop.
         const res = this.tmp("lm");
@@ -482,69 +725,58 @@ export class StatementEmitter extends CpiEmitter {
         }
         const findDecl = method === "find" ? this.lines.length - 1 : -1;
         const ci = this.tmp("lm_i");
-        this.line(`{`);
-        this.block(() => {
-            this.line(`uint64_t ${ci} = 0;`);
-            this.scopes.at(-1).set(index, { c: ci, type: U64, mutable: false });
-            this.line(`while (1) {`);
-            this.block(() => {
-                const n = this.expect(this.expr(length, U64), U64, list);
-                this.line(`if (!(${ci} < ${n.c})) break;`);
-                if (valueForm) {
-                    const eq = place(f.createBinaryExpression(element, ts.SyntaxKind.EqualsEqualsEqualsToken, place(f.createIdentifier(needle))));
-                    const hit = this.expect(this.expr(eq, BOOL), BOOL, node);
-                    this.line(`if (${hit.c}) {`);
-                    this.line(method === "includes" ? `  ${res} = true;` : `  ${res} = (int64_t)${ci};`);
-                    this.line(`  break;`);
-                    this.line(`}`);
+        this.eachElement(list, node, { index, ci }, (element, indexId) => {
+            if (valueForm) {
+                const eq = place(f.createBinaryExpression(element, ts.SyntaxKind.EqualsEqualsEqualsToken, place(f.createIdentifier(needle))));
+                const hit = this.expect(this.expr(eq, BOOL), BOOL, node);
+                this.line(`if (${hit.c}) {`);
+                this.line(method === "includes" ? `  ${res} = true;` : `  ${res} = (int64_t)${this.expr(indexId, U64).c};`);
+                this.line(`  break;`);
+                this.line(`}`);
+            }
+            else {
+                const closure = { node: fn, name: `${method}'s callback`, scopes: [...this.scopes], env: this.envNow(), imports: this.scope.imports };
+                const accId = method === "reduce" ? place(f.createIdentifier(`__acc${this.temp++}`)) : undefined;
+                if (accId)
+                    this.scopes.at(-1).set(accId.text, { c: res, type: accType, mutable: true });
+                const all = method === "reduce" ? [accId, element, indexId] : [element, indexId];
+                const v = this.expandClosure(closure, all.slice(0, fn.parameters.length), cb);
+                if (method === "forEach") {
+                    if (v)
+                        this.fail(cb, "forEach's callback returns nothing");
+                }
+                else if (method === "reduce") {
+                    if (!v)
+                        this.fail(cb, "reduce's callback returns the new accumulator");
+                    const nv = this.expect(v, accType, cb);
+                    this.line(accType.kind === "pubkey" ? `${res} = *(${nv.c});` : `${res} = ${nv.c};`);
                 }
                 else {
-                    const closure = { node: fn, name: `${method}'s callback`, scopes: [...this.scopes] };
-                    const accId = method === "reduce" ? place(f.createIdentifier(`__acc${this.temp++}`)) : undefined;
-                    if (accId)
-                        this.scopes.at(-1).set(accId.text, { c: res, type: accType, mutable: true });
-                    const all = method === "reduce" ? [accId, element, indexId] : [element, indexId];
-                    const v = this.expandClosure(closure, all.slice(0, fn.parameters.length), cb);
-                    if (method === "forEach") {
-                        if (v)
-                            this.fail(cb, "forEach's callback returns nothing");
-                    }
-                    else if (method === "reduce") {
-                        if (!v)
-                            this.fail(cb, "reduce's callback returns the new accumulator");
-                        const nv = this.expect(v, accType, cb);
-                        this.line(accType.kind === "pubkey" ? `${res} = *(${nv.c});` : `${res} = ${nv.c};`);
-                    }
-                    else {
-                        if (!v)
-                            this.fail(cb, `${method}'s callback returns a boolean`);
-                        const b = this.expect(v, BOOL, cb);
-                        if (method === "some")
-                            this.line(`if (${b.c}) { ${res} = true; break; }`);
-                        if (method === "every")
-                            this.line(`if (!(${b.c})) { ${res} = false; break; }`);
-                        if (method === "findIndex")
-                            this.line(`if (${b.c}) { ${res} = (int64_t)${ci}; break; }`);
-                        if (method === "find") {
-                            this.line(`if (${b.c}) {`);
-                            this.block(() => {
-                                const e = this.expr(element);
-                                elemType = e.type;
-                                if (!["int", "bool", "pubkey", "enum"].includes(e.type.kind))
-                                    this.fail(node, "find returns an Option of the element, so the elements must be integers, booleans, Pubkeys or enums; use findIndex");
-                                this.line(`${res}.some = 1;`);
-                                this.line(e.type.kind === "pubkey" ? `${res}.v = *(${e.c});` : `${res}.v = ${e.c};`);
-                                this.line(`break;`);
-                            });
-                            this.line(`}`);
-                        }
+                    if (!v)
+                        this.fail(cb, `${method}'s callback returns a boolean`);
+                    const b = this.expect(v, BOOL, cb);
+                    if (method === "some")
+                        this.line(`if (${b.c}) { ${res} = true; break; }`);
+                    if (method === "every")
+                        this.line(`if (!(${b.c})) { ${res} = false; break; }`);
+                    if (method === "findIndex")
+                        this.line(`if (${b.c}) { ${res} = (int64_t)${this.expr(indexId, U64).c}; break; }`);
+                    if (method === "find") {
+                        this.line(`if (${b.c}) {`);
+                        this.block(() => {
+                            const e = this.expr(element);
+                            elemType = e.type;
+                            if (!["int", "bool", "pubkey", "enum"].includes(e.type.kind))
+                                this.fail(node, "find returns an Option of the element, so the elements must be integers, booleans, Pubkeys or enums; use findIndex");
+                            this.line(`${res}.some = 1;`);
+                            this.line(e.type.kind === "pubkey" ? `${res}.v = *(${e.c});` : `${res}.v = ${e.c};`);
+                            this.line(`break;`);
+                        });
+                        this.line(`}`);
                     }
                 }
-                this.line(`${ci}++;`);
-            });
-            this.line(`}`);
+            }
         });
-        this.line(`}`);
         if (method === "find") {
             const inner = elemType;
             this.model.options.set(optionKey(inner), inner);
@@ -555,6 +787,17 @@ export class StatementEmitter extends CpiEmitter {
     }
     /** `return` inside an expanded closure: the value goes to the closure's result, then past its body. */
     closureReturn(stmt, frame) {
+        if (frame.into && stmt.expression) {
+            // Written straight into its place (an object literal for a struct, text for a FixedString, or a value).
+            const target = frame.into;
+            const vt = this.storageValueType(target.type);
+            if (vt)
+                this.line(this.writeStorage(target, this.ownedString(this.expect(this.expr(stmt.expression, vt), vt, stmt.expression)).c) + ";");
+            else
+                this.writeAggregate(target, stmt.expression);
+            this.line(`goto ${frame.label};`);
+            return;
+        }
         if (!stmt.expression) {
             if (frame.type)
                 this.fail(stmt, "this function returns a value");
@@ -628,7 +871,7 @@ export class StatementEmitter extends CpiEmitter {
                         c: "",
                         type: BOOL,
                         mutable: false,
-                        closure: { node: d.initializer, name: d.name.text, scopes: [...this.scopes] },
+                        closure: { node: d.initializer, name: d.name.text, scopes: [...this.scopes], env: this.envNow(), imports: this.scope.imports },
                     });
                     continue;
                 }
@@ -644,12 +887,26 @@ export class StatementEmitter extends CpiEmitter {
                 this.fail(d.name, `"${name}" shadows the parameter "${name}"; use another name`);
             const c = `l_${name}_${this.temp++}`;
             const init = d.initializer;
+            // A function as a value: another name for one (`const h = g`), or the one a function returns (`adder(5n)`).
+            const made = ts.isCallExpression(init) ? this.madeFunction(init) : undefined;
+            const alias = ts.isIdentifier(init) ? this.functionNamed(init) : undefined;
+            if (made || alias) {
+                if (mutable)
+                    this.fail(d, "bind functions with const");
+                this.scopes.at(-1).set(name, { c: "", type: BOOL, mutable: false, closure: (made ?? alias) });
+                continue;
+            }
             const fn = ts.isCallExpression(init) ? this.exportName(init.expression) : undefined;
             if (fn === "fixedArray") {
                 const t = this.localArray(init, c);
                 this.scopes.at(-1).set(name, { c, type: t, mutable });
                 continue;
             }
+            if (this.isPipeline(init)) {
+                const t = this.localList(d, init, c);
+                this.scopes.at(-1).set(name, { c, type: t, mutable });
+                continue;
+            }
             if (fn === "loadAccount" || fn === "loadAccountMut" || fn === "loadForeign") {
                 if (mutable)
                     this.fail(d, "bind loaded accounts with const");
@@ -851,6 +1108,8 @@ export class StatementEmitter extends CpiEmitter {
                     const pieces = this.templatePieces(rhsNode);
                     if (pieces.text !== undefined)
                         this.line(`TS_TRY(ts_str_append(&${cur}, ts_str((const uint8_t *)${cString(pieces.text)}, ${Buffer.byteLength(pieces.text, "utf8")})));`);
+                    else if (pieces.only !== undefined)
+                        this.line(`TS_TRY(ts_str_append(&${cur}, ${pieces.only}));`);
                     else
                         this.line(`TS_TRY(ts_str_append_parts(&${cur}, ${pieces.arr}, ${pieces.n}));`);
                     return;

package/dist/compiler/emit/storage.d.ts

@@ -27,8 +27,12 @@ export declare abstract class StorageEmitter extends EmitterBase {
      * value. Refuse when a live reference into the replaced place is still used afterwards.
      */
     protected assertNotAliased(replaced: string[] | undefined, at: ts.Node, helper?: string): void;
-    /** Whether the variable declared by `decl` is read after `at` (later in its block, or anywhere in a loop around `at`). */
-    protected usedAfter(decl: ts.VariableDeclaration, at: ts.Node): boolean;
+    /**
+     * Whether the variable declared by `decl` is read after `at` (later in its block, or anywhere in a loop around `at`).
+     * A parameter (of a closure or helper expanded here) is read after `at` when its function reads it after `at`; when
+     * `at` is in another function (a closure or helper it calls), any read of it in its own function counts.
+     */
+    protected usedAfter(decl: ts.VariableDeclaration | ts.ParameterDeclaration, at: ts.Node): boolean;
     /**
      * A pointer to a struct in storage, from `place` or `cond ? placeA : placeB` (same struct type).
      * Returns undefined when the expression is not such a place.