@typesol/cli 0.22.0 → 0.24.0

package/dist/compiler/analyze.js

@@ -422,10 +422,84 @@ export function analyze(entry) {
                 });
                 return;
             }
+            // An arrow written as a helper's function argument (`apply((x: u64): u64 => x + 1n, v)`): a local function of
+            // its own, passed like a named one. Missing parameter and return types come from the helper's parameter type.
+            const found = (ts.isArrowFunction(n) || ts.isFunctionExpression(n)) && ts.isCallExpression(n.parent) ? fnParamType(n, checker) : undefined;
+            if (found) {
+                reporter.guard(() => {
+                    const { type: target, owner } = found;
+                    if (generic)
+                        reporter.fail(n, "arrow functions passed inside a generic helper are not supported; declare the function at the top level");
+                    const lit = n;
+                    // Types left out are taken from the helper's parameter type, as written in the helper's file: its names are
+                    // resolved with that file's imports (added to this function's), and its type parameters cannot be.
+                    const typeParams = new Set((owner.typeParameters ?? []).map((t) => t.name.text));
+                    const usesTypeParam = (t) => (ts.isTypeReferenceNode(t) && ts.isIdentifier(t.typeName) && typeParams.has(t.typeName.text)) ||
+                        !!ts.forEachChild(t, (c) => usesTypeParam(c) || undefined);
+                    const ownerImports = importsOf.get(owner.getSourceFile()) ?? imports;
+                    let lifted = imports;
+                    const graft = (from, at) => {
+                        if (!from)
+                            return undefined;
+                        // `T` itself, given at the call (`applyT<u64>((v) => …)`): the type written there.
+                        const call = n.parent;
+                        if (ts.isTypeReferenceNode(from) && ts.isIdentifier(from.typeName) && typeParams.has(from.typeName.text) && call.typeArguments) {
+                            const i = (owner.typeParameters ?? []).findIndex((t) => t.name.text === from.typeName.text);
+                            const given = call.typeArguments[i];
+                            if (given)
+                                return given;
+                        }
+                        if (usesTypeParam(from))
+                            reporter.fail(at, `write the types here: the parameter's type uses the helper's type parameter (${[...typeParams].join(", ")})`);
+                        if (ownerImports !== imports) {
+                            const names = new Set();
+                            const collect = (t) => {
+                                if (ts.isTypeReferenceNode(t) && ts.isIdentifier(t.typeName))
+                                    names.add(t.typeName.text);
+                                ts.forEachChild(t, collect);
+                            };
+                            collect(from);
+                            for (const nm of names) {
+                                const theirs = ownerImports.get(nm);
+                                if (theirs === undefined)
+                                    continue;
+                                const ours = lifted.get(nm);
+                                if (ours !== undefined && ours !== theirs)
+                                    reporter.fail(at, `write the types here: "${nm}" means ${theirs} in the helper's file and ${ours} here`);
+                                if (ours === undefined) {
+                                    if (lifted === imports)
+                                        lifted = new Map(imports);
+                                    lifted.set(nm, theirs);
+                                }
+                            }
+                        }
+                        return from;
+                    };
+                    lit.parameters.forEach((p, i) => {
+                        const from = graft(p.type ? undefined : target.parameters[i]?.type, p);
+                        if (from)
+                            p.type = from;
+                    });
+                    if (!lit.type)
+                        lit.type = graft(target.type, lit);
+                    let name = `${outer}__fn`;
+                    for (let i = 2; taken.has(name); i++)
+                        name = `${outer}__fn${i}`;
+                    taken.add(name);
+                    const src = { node: lit, name, display: "the function passed here", decl: lit, imports: lifted, outer: fn };
+                    locals.push(src);
+                    if (lit.body)
+                        collectLocals(lit.body, name, imports, lit);
+                });
+                return;
+            }
             ts.forEachChild(n, visit);
         };
         visit(body);
     };
+    const importsOf = new Map();
+    for (const f of [...functions, ...helperNodes])
+        importsOf.set(f.node.getSourceFile(), f.imports);
     for (const f of functions)
         if (f.node.body && f.node.name)
             collectLocals(f.node.body, f.node.name.text, f.imports, f.node);
@@ -448,8 +522,13 @@ export function analyze(entry) {
     const helpers = new Map();
     const generics = new Map();
     const helperDecls = new Map();
+    const factories = new Map();
     for (const fn of [...helperNodes, ...locals.filter((l) => !inline.has(l.decl))]) {
         helperDecls.set(fn.decl, fn.name);
+        if (returnsFunction(fn.node)) {
+            factories.set(fn.name, { node: fn.node, imports: fn.imports });
+            continue;
+        }
         const fnParams = fn.node.parameters.map((p, i) => (p.type && ts.isFunctionTypeNode(p.type) ? i : -1)).filter((i) => i >= 0);
         if (fn.node.typeParameters?.length || fnParams.length) {
             reporter.guard(() => {
@@ -519,14 +598,6 @@ export function analyze(entry) {
                 if (structs.get(s).layout === "borsh" && s !== whole)
                     reporter.error(fn.node.name ?? fn.node, `argument ${a.name}: ${s} is @layout borsh; pass it as a whole argument, not inside a list or enum`);
         }
-        // Arguments are Borsh: a FixedVec's padded layout is account data only (a @layout borsh struct's FixedVec is a Borsh Vec).
-        for (const a of ix.args) {
-            const seen = new Set();
-            collectStructs(a.type, structs, dataEnums, seen);
-            for (const s of seen)
-                if (structs.get(s).layout !== "borsh" && structs.get(s).fields.some((f) => f.type.kind === "vec" && f.type.cap !== undefined))
-                    reporter.error(fn.node.name ?? fn.node, `argument ${a.name}: ${s} holds a FixedVec, which only account data can; pass a Vec<T> argument instead`);
-        }
         // A returned struct goes out in its fixed layout, like an argument comes in: it cannot also be a Borsh event.
         if (ix.returns?.kind === "struct")
             collectStructs(ix.returns, structs, dataEnums, argStructs);
@@ -537,6 +608,39 @@ export function analyze(entry) {
                     reporter.error(a.node, `${a.kind.struct.name} holds a string (or an enum carrying one), so it is an argument, return value or event; account data uses FixedString<N>`);
             }
     }
+    // Arguments are Borsh, where a FixedVec is a Vec (only what it holds). A struct passed as a whole argument and used
+    // nowhere else (not account data, not nested, not returned) is read as Anchor sends it: @layout borsh, implied.
+    // Anywhere else its FixedVec keeps the padded layout of account data, which an argument cannot have.
+    const hasFixedVec = (n) => structs.get(n).fields.some((f) => f.type.kind === "vec" && f.type.cap !== undefined);
+    const holds = (f, n) => {
+        const inner = f.type.kind === "array" || f.type.kind === "vec" ? f.type.elem : f.type.kind === "option" ? f.type.inner : f.type;
+        return inner.kind === "struct" && inner.name === n;
+    };
+    // In another struct, or in a data enum's variant (stored in its fixed layout in account data).
+    const nestedSomewhere = (n) => [...structs.values()].some((o) => o.fields.some((f) => holds(f, n))) ||
+        [...dataEnums.values()].some((e) => e.variants.some((v) => v.fields.some((f) => holds(f, n))));
+    for (const ix of instructions)
+        for (const a of ix.args) {
+            const seen = new Set();
+            collectStructs(a.type, structs, dataEnums, seen);
+            const whole = a.type.kind === "structRef" ? a.type.struct : undefined;
+            for (const n of seen) {
+                const sd = structs.get(n);
+                if (sd.layout === "borsh" || !hasFixedVec(n))
+                    continue;
+                const onlyArgument = n === whole &&
+                    !accountStructs.has(n) &&
+                    !nestedSomewhere(n) &&
+                    !instructions.some((i) => i.returns?.kind === "struct" && i.returns.name === n) &&
+                    !instructions.some((i) => i.args.some((x) => x !== a && x.type.kind !== "structRef" && JSON.stringify(x.type).includes(`"${n}"`)));
+                if (onlyArgument) {
+                    sd.layout = "borsh";
+                    reporter.guard(() => checkBorshLayout(sd, structs, dataEnums, reporter));
+                    continue;
+                }
+                reporter.error(ix.node.name ?? ix.node, `argument ${a.name}: ${n} holds a FixedVec and is also account data, nested or returned (a fixed layout there, Borsh in arguments); declare a separate struct for the argument, or pass the list as its own FixedVec<T, N> argument`);
+            }
+        }
     checkSnakeDuplicates(instructions.map((ix) => ({ name: ix.node.name.text, node: ix.node.name })), "instructions", reporter);
     // emitCpi's event instruction (Anchor's EVENT_IX_TAG) is dispatched before every other instruction.
     if (instructions.some((ix) => ix.accounts.some((a) => a.kind.kind === "eventAuthority"))) {
@@ -569,6 +673,7 @@ export function analyze(entry) {
             generics,
             helperDecls,
             closureDecls,
+            factories,
             errors,
             errorEnums,
             enums,
@@ -580,6 +685,7 @@ export function analyze(entry) {
             argStructs,
             fstrings,
             fixedVecs,
+            localVecs: new Map(),
         },
         sourceFile,
         files: programFiles(program, entryPath).map((f) => f.fileName),
@@ -642,11 +748,15 @@ export function resolveArgAggregate(node, scope, structs) {
         return { kind: "structRef", struct: top.name, writable: false };
     if (top?.kind === "array")
         return { kind: "arrayArg", array: top };
-    if (typesolName(node, scope.imports) === "Vec") {
-        const e = node.typeArguments?.[0];
+    const list = typesolName(node, scope.imports);
+    if (list === "Vec" || list === "FixedVec") {
+        const [e, n] = node.typeArguments ?? [];
         const elem = e && fixed(e);
+        const cap = list === "FixedVec" ? numericLiteralArg(n) : undefined;
+        if (list === "FixedVec" && !(cap !== undefined && Number.isInteger(cap) && cap >= 1))
+            return undefined;
         if (elem && (elem.kind === "struct" || elem.kind === "array"))
-            return { kind: "vecArg", elem };
+            return { kind: "vecArg", elem, ...(cap ? { cap } : {}) };
     }
     return undefined;
 }
@@ -714,6 +824,14 @@ export function resolveValueType(node, scope, allowVec = false) {
         if (elem)
             return { kind: "vecArg", elem };
     }
+    // FixedVec<T, N> as an argument: a Borsh Vec of at most N elements (more fail to deserialize), read like a Vec argument.
+    if (allowVec && typesolName(node, scope.imports) === "FixedVec") {
+        const [elemNode, n] = node.typeArguments ?? [];
+        const elem = elemNode && resolveScalarType(elemNode, scope);
+        const cap = numericLiteralArg(n);
+        if (elem && cap !== undefined && Number.isInteger(cap) && cap >= 1)
+            return { kind: "vecArg", elem, cap };
+    }
     return resolveScalarType(node, scope);
 }
 function numericLiteralArg(node) {
@@ -803,7 +921,7 @@ function analyzeStructs(items, aliases, dataEnums, reporter, scopeFor, fstrings,
         }
         if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) && names.has(node.typeName.text) && !targs.length)
             return { kind: "struct", name: node.typeName.text };
-        reporter.fail(node, "field type must be an integer, boolean, Pubkey, FixedArray<T, N>, FixedString<N>, FixedVec<T, N>, Vec<T> (last), string (events only) or another struct");
+        reporter.fail(node, "field type must be an integer, boolean, Pubkey, FixedArray<T, N>, FixedString<N>, FixedVec<T, N>, Vec<T>, string (events only) or another struct");
     };
     for (const { decl, imports: fileImports } of items) {
         scope = scopeFor(fileImports);
@@ -824,9 +942,7 @@ function analyzeStructs(items, aliases, dataEnums, reporter, scopeFor, fstrings,
                 if (problem)
                     reporter.fail(m.name, problem);
                 const type = fieldType(m.type);
-                if (type.kind === "vec" && type.cap === undefined && m !== decl.members[decl.members.length - 1])
-                    reporter.fail(m, "a Vec<T> field must be the last field of the struct (its length changes the account size); use FixedVec<T, N> for a list of at most N elsewhere");
-                fields.push({ name, type });
+                fields.push({ name, type, node: m });
             }
             checkSnakeDuplicates(decl.members.map((m) => ({ name: m.name.text, node: m })), "fields", reporter);
             const name = decl.name.text;
@@ -835,9 +951,20 @@ function analyzeStructs(items, aliases, dataEnums, reporter, scopeFor, fstrings,
             const layoutText = typeof layoutTag?.comment === "string" ? layoutTag.comment.trim() : undefined;
             if (layoutTag && layoutText !== "borsh" && layoutText !== "fixed")
                 reporter.fail(layoutTag, "@layout is borsh (Anchor's account bytes) or fixed (the default)");
+            const growable = (f) => f.type.kind === "vec" && f.type.cap === undefined;
+            // Anchor's bytes keep the declared order, so there a growable Vec has to be last (the fields after it would move).
+            if (layoutText === "borsh")
+                for (const f of fields.slice(0, -1))
+                    if (growable(f))
+                        reporter.fail(f.node ?? decl, "in a @layout borsh struct a Vec<T> field must be the last field (Anchor's bytes keep the declared order); use FixedVec<T, N> for a list of at most N elsewhere");
+            // The fixed layout stores the growable Vecs after the fixed-size fields, in the order declared, so every other
+            // field keeps a fixed offset; the IDL lists the fields in this stored order.
+            const stored = layoutText === "borsh" ? fields : [...fields.filter((f) => !growable(f)), ...fields.filter(growable)];
+            for (const f of stored)
+                delete f.node;
             structs.set(name, {
                 name,
-                fields,
+                fields: stored,
                 size: undefined,
                 accountDiscriminator: discriminator(`account:${name}`),
                 eventDiscriminator: discriminator(`event:${name}`),
@@ -964,7 +1091,7 @@ function analyzeStructs(items, aliases, dataEnums, reporter, scopeFor, fstrings,
                 if (s.size === undefined)
                     reporter.fail(at, `${t.name} has a string field and cannot be nested; use FixedString<N>`);
                 if (s.vec)
-                    reporter.fail(at, `${t.name} ends in a Vec and can only be account data, not nested`);
+                    reporter.fail(at, `${t.name} has a growable Vec and can only be account data, not nested`);
                 return s.size;
             }
         }
@@ -987,13 +1114,19 @@ function analyzeStructs(items, aliases, dataEnums, reporter, scopeFor, fstrings,
         s.size = total;
         if (total !== undefined && total + 8 > MAX_ACCOUNT_SIZE)
             reporter.fail(s.node.name, `${s.name} is ${total + 8} bytes with its discriminator; Solana accounts are at most ${MAX_ACCOUNT_SIZE} bytes`);
-        const last = s.fields.at(-1);
-        if (last?.type.kind === "vec" && last.type.cap === undefined) {
-            const elemSize = sizeOf(last.type.elem, s.node);
-            if (elemSize === undefined)
-                reporter.fail(s.node, "Vec elements must have a fixed size");
-            s.vec = { name: last.name, elem: last.type.elem, elemSize };
-        }
+        // Growable Vecs (stored last, see above): the first one's length and elements end the C struct; the others follow
+        // it in the account, each a u32 length and its elements.
+        for (const f of s.fields)
+            if (f.type.kind === "vec" && f.type.cap === undefined) {
+                const elemSize = sizeOf(f.type.elem, s.node);
+                if (elemSize === undefined)
+                    reporter.fail(s.node, "Vec elements must have a fixed size");
+                (s.vecs ??= []).push({ name: f.name, elem: f.type.elem, elemSize });
+            }
+        s.vec = s.vecs?.[0];
+        // The C struct holds the first Vec's length; each further one adds its own when the account is created.
+        if (s.vecs && s.size !== undefined)
+            s.size -= 4 * (s.vecs.length - 1);
         state.set(s.name, "done");
     };
     for (const s of structs.values())
@@ -1007,6 +1140,43 @@ function analyzeStructs(items, aliases, dataEnums, reporter, scopeFor, fstrings,
 }
 const isFunctionNode = (n) => ts.isFunctionDeclaration(n) || ts.isArrowFunction(n) || ts.isFunctionExpression(n) || ts.isMethodDeclaration(n);
 /** Whether a local function reads a variable or parameter of a function around it (a closure). */
+/**
+ * The function type of the helper parameter an arrow is passed for (`f` in `function apply(f: (x: u64) => u64, …)`),
+ * when the arrow is an argument of a call to a declared function or const arrow; undefined otherwise.
+ */
+function fnParamType(arrow, checker) {
+    const call = arrow.parent;
+    const i = call.arguments.indexOf(arrow);
+    if (i < 0 || !ts.isIdentifier(call.expression))
+        return undefined;
+    let sym = checker.getSymbolAtLocation(call.expression);
+    if (sym && sym.flags & ts.SymbolFlags.Alias)
+        sym = checker.getAliasedSymbol(sym);
+    for (const d of sym?.declarations ?? []) {
+        const fn = ts.isFunctionDeclaration(d)
+            ? d
+            : ts.isVariableDeclaration(d) && d.initializer && (ts.isArrowFunction(d.initializer) || ts.isFunctionExpression(d.initializer))
+                ? d.initializer
+                : undefined;
+        const t = fn?.parameters[i]?.type;
+        if (fn && t && ts.isFunctionTypeNode(t))
+            return { type: t, owner: fn };
+    }
+    return undefined;
+}
+/** Whether a function returns a function: typed so, or its body is (or only returns) an arrow. */
+function returnsFunction(fn) {
+    if (fn.type)
+        return ts.isFunctionTypeNode(fn.type);
+    const strip = (e) => (e && ts.isParenthesizedExpression(e) ? strip(e.expression) : e);
+    const body = fn.body;
+    const ret = body && !ts.isBlock(body)
+        ? strip(body)
+        : body?.statements.length === 1 && ts.isReturnStatement(body.statements[0])
+            ? strip(body.statements[0].expression)
+            : undefined;
+    return !!ret && (ts.isArrowFunction(ret) || ts.isFunctionExpression(ret));
+}
 function captures(l, localDecls, checker) {
     const fn = l.node;
     let found = false;
@@ -1574,7 +1744,7 @@ function resolveAccountKind(node, reporter, imports, structs) {
             if (!s)
                 reporter.fail(node, "Zeroed<T> needs a struct declared in this program");
             if (s.vec)
-                reporter.fail(node, `${s.name} ends in a Vec; Zeroed<T> is for fixed-size (large) accounts`);
+                reporter.fail(node, `${s.name} has a growable Vec; Zeroed<T> is for fixed-size (large) accounts`);
             if (s.layout === "borsh")
                 reporter.fail(node, `${s.name} is @layout borsh; Zeroed<T> reads large accounts in place, so it takes fixed layouts only`);
             return { kind: "zeroed", struct: s };

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

@@ -1,7 +1,7 @@
 import ts from "typescript";
-import { type Analysis, type TypeScope } from "../analyze.js";
+import { type Analysis, type TypeArg, type TypeScope } from "../analyze.js";
 import type { Reporter } from "../diagnostics.js";
-import { type AccountParam, type Helper, type IdlSeed, type Instruction, type ProgramModel, type ValueType } from "../model.js";
+import { type AccountParam, type GenericHelper, type Helper, type IdlSeed, type Instruction, type ProgramModel, type ValueType } from "../model.js";
 import { type Value, type Ref, type Local, type Closure, type EmitOptions } from "./shared.js";
 /**
  * State of one function being lowered, and the primitives every layer uses: emitting lines, temporaries,
@@ -32,6 +32,8 @@ export declare abstract class EmitterBase {
         declAt: number;
         pad: string;
         node: ts.Node;
+        /** A place the result is written to (a stored `map` element), instead of a value. */
+        into?: Ref;
     }[];
     /** Closures being expanded (a closure calling itself cannot be expanded). */
     protected readonly inlining: Set<ts.Node>;
@@ -39,7 +41,8 @@ export declare abstract class EmitterBase {
     protected readonly loops: string[];
     protected readonly ix: Instruction | undefined;
     protected readonly helper: Helper | undefined;
-    protected readonly scope: TypeScope;
+    /** Type names in effect (a generic helper expanded where it is called binds its type parameters here). */
+    protected scope: TypeScope;
     protected readonly checker: ts.TypeChecker;
     protected readonly analysis: Analysis;
     /** Calls already resolved to a helper (a generic one's instance is found by probing its arguments). */
@@ -50,6 +53,8 @@ export declare abstract class EmitterBase {
     constructor(analysis: Analysis, target: Instruction | Helper, opts?: EmitOptions);
     /** The helper a call runs: a function, a const arrow function (top-level or local), or a generic one's instance. */
     protected helperOf(node: ts.CallExpression): Helper | undefined;
+    /** The helper a call runs, when it is given a closure for a function parameter (so it is expanded there). */
+    protected givenClosure(node: ts.CallExpression): GenericHelper | undefined;
     /**
      * The functions passed for a helper's function parameters: named functions only (a helper, or a local function that
      * captures nothing). A closure can only run where it is declared, so it cannot be passed.
@@ -59,7 +64,7 @@ export declare abstract class EmitterBase {
     private structArg;
     private fixedStruct;
     /** A generic call's type arguments: written out (`max<u64>(a, b)`), or the types of the arguments in `T` positions. */
-    private typeArgsOf;
+    protected typeArgsOf(node: ts.CallExpression, g: GenericHelper): TypeArg[];
     protected line(s: string): void;
     /** `file.ts:line` of a node, for messages. */
     protected location(node: ts.Node): string;
@@ -76,11 +81,16 @@ export declare abstract class EmitterBase {
     protected noOptionalChain(node: ts.Node): void;
     protected lookup(name: string): Local | undefined;
     protected block(fn: () => void): void;
+    /**
+     * Run `fn` to learn something (a type, a storage kind) without keeping anything it did: the emitted and hoisted
+     * lines, temporaries, diagnostics and emitter state are put back. Undefined when `fn` fails.
+     */
+    protected probe<T>(fn: () => T): T | undefined;
     protected fail(node: ts.Node, message: string): never;
     protected exportName(node: ts.Expression): string | undefined;
     /**
      * `acct!.field` on an optional account: the same access without `!` (using the account checks that it was passed,
-     * failing with 3020 otherwise). Returns undefined for anything else.
+     * failing with 5115 otherwise). Returns undefined for anything else.
      */
     protected withoutBang(node: ts.Expression): ts.PropertyAccessExpression | undefined;
     protected accountParam(node: ts.Expression, what: string): AccountParam;
@@ -116,4 +126,17 @@ export declare abstract class EmitterBase {
     protected abstract epilogue(): string[];
     protected abstract expandClosure(c: Closure, args: readonly ts.Expression[], node: ts.Node): Value | undefined;
     protected abstract listMethod(node: ts.CallExpression, method: string): Value | undefined;
+    protected abstract isPipeline(e: ts.Expression): e is ts.CallExpression;
+    protected abstract closureOf(arg: ts.Expression): Closure;
+    /** The arguments and accounts code written here can name (what a closure written here keeps). */
+    protected envNow(): Closure["env"];
+    /** None: a helper's or factory's body sees its own parameters and the module only. */
+    protected noEnv(): Closure["env"];
+    protected abstract madeFunction(call: ts.CallExpression): Closure | undefined;
+    protected abstract eachElement(list: ts.Expression, at: ts.Node, names: {
+        index: string;
+        ci: string;
+        next?: string;
+        alwaysNext?: boolean;
+    }, body: (element: ts.Expression, index: ts.Expression) => void): void;
 }

package/dist/compiler/emit/base.js

@@ -31,6 +31,7 @@ export class EmitterBase {
     loops = [];
     ix;
     helper;
+    /** Type names in effect (a generic helper expanded where it is called binds its type parameters here). */
     scope;
     checker;
     analysis;
@@ -87,6 +88,9 @@ export class EmitterBase {
     helperOf(node) {
         if (!ts.isIdentifier(node.expression))
             return undefined;
+        // Given a closure, the helper is expanded where it is called (helperWithClosure), not called.
+        if (this.givenClosure(node))
+            return undefined;
         const cached = this.calleeCache.get(node);
         if (cached !== undefined)
             return cached ?? undefined;
@@ -103,6 +107,17 @@ export class EmitterBase {
         this.calleeCache.set(node, h ?? null);
         return h;
     }
+    /** The helper a call runs, when it is given a closure for a function parameter (so it is expanded there). */
+    givenClosure(node) {
+        if (!ts.isIdentifier(node.expression))
+            return undefined;
+        const name = calleeName(node.expression, this.model.helperDecls, this.checker) ?? (this.lookup(node.expression.text) ? undefined : node.expression.text);
+        const g = name ? this.model.generics.get(name) : undefined;
+        if (!g?.fnParams.length)
+            return undefined;
+        const closureArg = (a) => !!a && (ts.isArrowFunction(a) || ts.isFunctionExpression(a) ? !this.model.helperDecls.has(a) : ts.isIdentifier(a) && !!this.lookup(a.text)?.closure);
+        return g.fnParams.some((i) => closureArg(node.arguments[i])) ? g : undefined;
+    }
     /**
      * The functions passed for a helper's function parameters: named functions only (a helper, or a local function that
      * captures nothing). A closure can only run where it is declared, so it cannot be passed.
@@ -111,6 +126,13 @@ export class EmitterBase {
         return g.fnParams.map((i) => {
             const arg = node.arguments[i];
             const pname = g.node.parameters[i].name.text;
+            // An arrow written here: lifted to a local function when it reads nothing around it.
+            if (arg && (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg))) {
+                const lifted = this.model.helperDecls.get(arg);
+                if (lifted)
+                    return lifted;
+                this.fail(arg, `this function reads the variables of the function around it, so it can only run there, not be passed to ${g.display}; pass the values it needs as arguments`);
+            }
             if (!arg || !ts.isIdentifier(arg))
                 this.fail(arg ?? node, `pass ${g.display}'s ${pname} a named function (declare it: const f = (…) => …)`);
             const passed = this.helper?.fnArgs?.get(arg.text);
@@ -151,21 +173,12 @@ export class EmitterBase {
                 if (!arg || !p.type || !ts.isTypeReferenceNode(p.type) || !ts.isIdentifier(p.type.typeName) || p.type.typeName.text !== tp || p.type.typeArguments)
                     continue;
                 // Type the argument without emitting it: it is lowered again, once, by the call.
-                const saved = { lines: this.lines.length, hoisted: this.hoisted.length, temp: this.temp, diagnostics: this.reporter.diagnostics.length };
-                const probe = this.reporter.guard(() => this.expr(arg));
-                this.lines.length = saved.lines;
-                this.hoisted.length = saved.hoisted;
-                this.temp = saved.temp;
-                this.reporter.diagnostics.length = saved.diagnostics;
+                const probe = this.probe(() => this.expr(arg));
                 if (probe?.type.kind === "structRef")
                     return this.fixedStruct(probe.type.struct, arg);
                 if (!probe) {
                     // A struct place (`p.a`) is not a value: type it as a reference, again without emitting anything.
-                    const r = this.reporter.guard(() => this.ref(arg));
-                    this.lines.length = saved.lines;
-                    this.hoisted.length = saved.hoisted;
-                    this.temp = saved.temp;
-                    this.reporter.diagnostics.length = saved.diagnostics;
+                    const r = this.probe(() => this.ref(arg));
                     if (r?.type.kind === "struct")
                         return this.fixedStruct(r.type.name, arg);
                 }
@@ -262,9 +275,54 @@ export class EmitterBase {
     block(fn) {
         this.scopes.push(new Map());
         this.indent++;
-        fn();
-        this.indent--;
-        this.scopes.pop();
+        try {
+            fn();
+        }
+        finally {
+            this.indent--;
+            this.scopes.pop();
+        }
+    }
+    /**
+     * Run `fn` to learn something (a type, a storage kind) without keeping anything it did: the emitted and hoisted
+     * lines, temporaries, diagnostics and emitter state are put back. Undefined when `fn` fails.
+     */
+    probe(fn) {
+        const saved = {
+            lines: this.lines.length,
+            hoisted: this.hoisted.length, // a probed helper call may hoist declarations
+            temp: this.temp,
+            diagnostics: this.reporter.diagnostics.length,
+            scopes: this.scopes.length,
+            indent: this.indent,
+            loops: this.loops.length,
+            frames: this.inlineFrames.length,
+            created: new Set(this.created),
+            pendingInit: new Set(this.pendingInit),
+            bumps: new Map(this.bumps),
+        };
+        try {
+            return this.reporter.guard(fn);
+        }
+        finally {
+            this.lines.length = saved.lines;
+            this.hoisted.length = saved.hoisted;
+            this.temp = saved.temp;
+            this.reporter.diagnostics.length = saved.diagnostics;
+            this.scopes.length = saved.scopes;
+            this.indent = saved.indent;
+            this.loops.length = saved.loops;
+            this.inlineFrames.length = saved.frames;
+            for (const [set, from] of [
+                [this.created, saved.created],
+                [this.pendingInit, saved.pendingInit],
+            ]) {
+                set.clear();
+                from.forEach((x) => set.add(x));
+            }
+            this.bumps.clear();
+            saved.bumps.forEach((v, k) => this.bumps.set(k, v));
+        }
     }
     fail(node, message) {
         return this.reporter.fail(node, message);
@@ -274,7 +332,7 @@ export class EmitterBase {
     }
     /**
      * `acct!.field` on an optional account: the same access without `!` (using the account checks that it was passed,
-     * failing with 3020 otherwise). Returns undefined for anything else.
+     * failing with 5115 otherwise). Returns undefined for anything else.
      */
     withoutBang(node) {
         if (!ts.isPropertyAccessExpression(node) || !ts.isNonNullExpression(node.expression))
@@ -315,4 +373,12 @@ export class EmitterBase {
         if (createdBy && !this.created.has(a.name))
             this.fail(node, `"${a.name}" is used before ${a.name}.${createdBy}(...) runs`);
     }
+    /** The arguments and accounts code written here can name (what a closure written here keeps). */
+    envNow() {
+        return { args: new Map(this.args), accounts: new Map(this.accounts) };
+    }
+    /** None: a helper's or factory's body sees its own parameters and the module only. */
+    noEnv() {
+        return { args: new Map(), accounts: new Map() };
+    }
 }

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

@@ -1,6 +1,6 @@
 import ts from "typescript";
 import { type ErrorDef, type FieldType, type Helper } from "../model.js";
-import { type Value, type Ref } from "./shared.js";
+import { type Value, type Ref, type Closure } from "./shared.js";
 import { ExpressionEmitter } from "./expressions.js";
 export declare abstract class CallEmitter extends ExpressionEmitter {
     protected call(node: ts.CallExpression, topLevel: boolean): Value | undefined;
@@ -31,6 +31,23 @@ export declare abstract class CallEmitter extends ExpressionEmitter {
     protected loadAccount(node: ts.CallExpression, mut: boolean): Value;
     /** Whether a helper (or one it calls) grows a Vec, which needs the instruction's SystemProgram for rent. */
     private helperGrows;
+    /**
+     * A helper given a closure (a function that reads the caller's variables) for a function parameter: a closure only
+     * runs where it is declared, so the helper is expanded here, like a closure, with the closure bound to the
+     * parameter. Helpers expanded so take values (not accounts) and have no type parameters.
+     */
+    protected helperWithClosure(node: ts.CallExpression): {
+        value: Value | undefined;
+    } | undefined;
+    /** The function a function returns (`return (x) => x + n`, or an arrow body `(n) => (x) => x + n`), if it returns one. */
+    protected returnedFunction(fn: Closure["node"]): ts.ArrowFunction | ts.FunctionExpression | undefined;
+    /**
+     * `adder(5n)`, where `adder` returns a function: the arguments are evaluated here into locals of the current block,
+     * and the function it returns is bound to them as a closure (expanded where it is called, like any closure).
+     */
+    protected madeFunction(call: ts.CallExpression): Closure | undefined;
+    /** A function given for a function parameter of an expanded helper or closure, as something to expand. */
+    protected closureOf(arg: ts.Expression): Closure;
     protected callHelper(node: ts.CallExpression, h: Helper): Value | undefined;
     /** One helper argument: a C argument list fragment (accounts, seeds, references) or a value to settle. */
     protected helperArg(h: Helper, p: Helper["params"][number], n: ts.Expression): Value | string;