@typesol/cli 0.23.0 → 0.24.1

package/dist/compiler/analyze.js

@@ -424,24 +424,69 @@ export function analyze(entry) {
             }
             // 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 target = (ts.isArrowFunction(n) || ts.isFunctionExpression(n)) && ts.isCallExpression(n.parent) ? fnParamType(n, checker) : undefined;
-            if (target) {
+            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 = target.parameters[i]?.type;
-                        if (!p.type && from)
+                        const from = graft(p.type ? undefined : target.parameters[i]?.type, p);
+                        if (from)
                             p.type = from;
                     });
                     if (!lit.type)
-                        lit.type = target.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, outer: fn };
+                    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);
@@ -452,6 +497,9 @@ export function analyze(entry) {
         };
         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);
@@ -474,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(() => {
@@ -545,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; make ${s} @layout borsh, or pass the list as its own FixedVec<T, N> argument`);
-        }
         // 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);
@@ -563,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"))) {
@@ -595,13 +673,14 @@ export function analyze(entry) {
             generics,
             helperDecls,
             closureDecls,
+            factories,
             errors,
             errorEnums,
             enums,
             dataEnums,
             options,
             constants,
-            events: new Set(),
+            events: collectEvents([...functions, ...helperNodes], structs),
             accountStructs,
             argStructs,
             fstrings,
@@ -842,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);
@@ -1012,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;
             }
         }
@@ -1080,11 +1159,44 @@ function fnParamType(arrow, checker) {
                 ? d.initializer
                 : undefined;
         const t = fn?.parameters[i]?.type;
-        if (t && ts.isFunctionTypeNode(t))
-            return t;
+        if (fn && t && ts.isFunctionTypeNode(t))
+            return { type: t, owner: fn };
     }
     return undefined;
 }
+/**
+ * The structs a program emits (`emit<T>(…)` / `emitCpi<T>(…)` anywhere in its functions and helpers), known before
+ * any code is emitted, so the IDL and the event checks do not depend on the order code is emitted in.
+ */
+function collectEvents(sources, structs) {
+    const events = new Set();
+    for (const { node, imports } of sources) {
+        const visit = (n) => {
+            if (ts.isCallExpression(n) && ts.isIdentifier(n.expression)) {
+                const name = imports.get(n.expression.text);
+                const t = n.typeArguments?.[0];
+                if ((name === "emit" || name === "emitCpi") && t && ts.isTypeReferenceNode(t) && ts.isIdentifier(t.typeName) && structs.has(t.typeName.text))
+                    events.add(t.typeName.text);
+            }
+            ts.forEachChild(n, visit);
+        };
+        visit(node);
+    }
+    return events;
+}
+/** 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;
@@ -1652,7 +1764,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,5 +1,5 @@
 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 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";
@@ -24,6 +24,16 @@ export declare abstract class EmitterBase {
     protected readonly pendingInit: Set<string>;
     /** Bump temporaries from create()/createIfNeeded(), for `acct.pdaBump`. */
     protected readonly bumps: Map<string, string>;
+    /**
+     * Seed arrays already declared (no spare slot, every seed read in place): the C entries, and where the array is.
+     * An identical list in the same or an inner block reuses it (see seeds()).
+     */
+    protected readonly seedArrays: Map<string, {
+        name: string;
+        scope: Map<string, Local>;
+        at: number;
+        text: string;
+    }>;
     /** Closures being expanded, innermost last: a `return` inside one assigns `result` and jumps to `label`. */
     protected inlineFrames: {
         label: string;
@@ -32,6 +42,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 +51,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). */
@@ -61,7 +74,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;
@@ -78,11 +91,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;
@@ -120,6 +138,11 @@ export declare abstract class EmitterBase {
     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;

package/dist/compiler/emit/base.js

@@ -23,6 +23,11 @@ export class EmitterBase {
     pendingInit = new Set();
     /** Bump temporaries from create()/createIfNeeded(), for `acct.pdaBump`. */
     bumps = new Map();
+    /**
+     * Seed arrays already declared (no spare slot, every seed read in place): the C entries, and where the array is.
+     * An identical list in the same or an inner block reuses it (see seeds()).
+     */
+    seedArrays = new Map();
     /** Closures being expanded, innermost last: a `return` inside one assigns `result` and jumps to `label`. */
     inlineFrames = [];
     /** Closures being expanded (a closure calling itself cannot be expanded). */
@@ -31,6 +36,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;
@@ -172,21 +178,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);
                 }
@@ -283,9 +280,57 @@ 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),
+            seedArrays: new Map(this.seedArrays),
+        };
+        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));
+            this.seedArrays.clear();
+            saved.seedArrays.forEach((v, k) => this.seedArrays.set(k, v));
+        }
     }
     fail(node, message) {
         return this.reporter.fail(node, message);
@@ -295,7 +340,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))
@@ -336,4 +381,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

@@ -39,6 +39,13 @@ export declare abstract class CallEmitter extends ExpressionEmitter {
     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;

package/dist/compiler/emit/calls.js

@@ -195,7 +195,7 @@ export class CallEmitter extends ExpressionEmitter {
                 if (!isWritable(acct.kind) || !struct)
                     this.fail(args[0], "realloc needs a Mut<Struct> account of this program");
                 if (struct?.vec)
-                    this.fail(args[0], `${struct.name} ends in a Vec, which sizes the account itself (push/pop/clear)`);
+                    this.fail(args[0], `${struct.name} has a growable Vec, which sizes the account itself (push/pop/clear)`);
                 const size = this.expect(this.expr(args[1], U64), U64, args[1]);
                 const payer = this.accountParam(args[2], "the payer");
                 if (payer.kind.kind !== "signer" || !payer.kind.mut)
@@ -460,10 +460,21 @@ export class CallEmitter extends ExpressionEmitter {
         }
         if (builtin)
             this.fail(callee, `${builtin} cannot be called here`);
+        // `adder(5n)(1n)`: the function a function returns, called right away.
+        if (ts.isCallExpression(callee)) {
+            const made = this.madeFunction(callee);
+            if (made)
+                return this.expandClosure(made, node.arguments, node);
+        }
         if (ts.isIdentifier(callee)) {
             const local = this.lookup(callee.text);
+            if (local?.closure && this.returnedFunction(local.closure.node))
+                this.fail(node, `${callee.text} returns a function: bind it (const f = ${callee.text}(…)) or call it right away (${callee.text}(…)(…))`);
             if (local?.closure)
                 return this.expandClosure(local.closure, node.arguments, node);
+            const name = calleeName(callee, this.model.helperDecls, this.checker) ?? callee.text;
+            if (!local && this.model.factories.has(name))
+                this.fail(node, `${callee.text} returns a function: bind it (const f = ${callee.text}(…)) or call it right away (${callee.text}(…)(…))`);
         }
         const inlined = this.helperWithClosure(node);
         if (inlined)
@@ -1007,17 +1018,96 @@ export class CallEmitter extends ExpressionEmitter {
         const g = this.givenClosure(node);
         if (!g)
             return undefined;
-        if (g.typeParams.length)
-            this.fail(node, `${g.display} has type parameters, so it takes only functions that read nothing around them; pass the values the function needs instead`);
-        for (const p of g.node.parameters)
-            if (p.type && !ts.isFunctionTypeNode(p.type) && !resolveValueType(p.type, this.scope))
-                this.fail(node, `${g.display} takes accounts or lists, so it cannot be expanded here for the function that reads the variables around it; pass the values it needs instead`);
-        return { value: this.expandClosure({ node: g.node, name: g.display, scopes: [] }, node.arguments, node) };
+        // Type parameters: bound from the call (as an instance would be) while the body is expanded.
+        const saved = this.scope;
+        if (g.typeParams.length) {
+            const typeArgs = this.typeArgsOf(node, g);
+            const bound = new Map();
+            const structs = new Map();
+            g.typeParams.forEach((n, i) => {
+                const t = typeArgs[i];
+                if (t.kind === "struct")
+                    structs.set(n, t.name);
+                else
+                    bound.set(n, t);
+            });
+            this.scope = { ...this.scope, typeArgs: bound, structArgs: structs };
+        }
+        try {
+            return { value: this.expandClosure({ node: g.node, name: g.display, scopes: [], env: this.noEnv(), imports: g.imports }, node.arguments, node) };
+        }
+        finally {
+            this.scope = saved;
+        }
+    }
+    /** The function a function returns (`return (x) => x + n`, or an arrow body `(n) => (x) => x + n`), if it returns one. */
+    returnedFunction(fn) {
+        const strip = (e) => (e && ts.isParenthesizedExpression(e) ? strip(e.expression) : e);
+        const body = fn.body;
+        let ret;
+        if (body && !ts.isBlock(body))
+            ret = strip(body);
+        else if (body && body.statements.length === 1 && ts.isReturnStatement(body.statements[0]))
+            ret = strip(body.statements[0].expression);
+        if (ret && (ts.isArrowFunction(ret) || ts.isFunctionExpression(ret)))
+            return ret;
+        if (fn.type && ts.isFunctionTypeNode(fn.type))
+            this.fail(fn, "a function that returns a function has one statement: return (x) => … (the function it makes)");
+        return 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).
+     */
+    madeFunction(call) {
+        if (!ts.isIdentifier(call.expression))
+            return undefined;
+        const local = this.lookup(call.expression.text);
+        let maker = local?.closure;
+        if (!maker && !local) {
+            const name = calleeName(call.expression, this.model.helperDecls, this.checker) ?? call.expression.text;
+            const f = this.model.factories.get(name);
+            if (f)
+                maker = { node: f.node, name: call.expression.text, scopes: [], env: this.noEnv(), imports: f.imports };
+        }
+        if (!maker)
+            return undefined;
+        const made = this.returnedFunction(maker.node);
+        if (!made)
+            return undefined;
+        const fn = maker.node;
+        if (call.arguments.length !== fn.parameters.length)
+            this.fail(call, `${maker.name}() takes ${fn.parameters.length} argument(s)`);
+        const params = new Map();
+        fn.parameters.forEach((p, i) => {
+            if (!ts.isIdentifier(p.name) || p.initializer || p.dotDotDotToken)
+                this.fail(p, "parameters are plain names");
+            const arg = call.arguments[i];
+            if (p.type && ts.isFunctionTypeNode(p.type)) {
+                params.set(p.name.text, { c: "", type: BOOL, mutable: false, closure: this.closureOf(arg) });
+                return;
+            }
+            const annotated = p.type ? resolveValueType(p.type, this.scope) : undefined;
+            let v = this.expr(arg, annotated);
+            if (v.literal !== undefined && !annotated)
+                v = this.literal(v.literal, U64, arg);
+            const type = annotated ?? v.type;
+            if (!["int", "bool", "pubkey", "string", "enum", "option"].includes(type.kind))
+                this.fail(arg, `the function made keeps integers, booleans, Pubkeys, strings, enums or Options, not ${typeName(type)}`);
+            v = this.expect(v, type, arg);
+            const c = `l_${p.name.text}_${this.temp++}`;
+            if (type.kind === "pubkey")
+                this.line(`SolPubkey ${c} = *(${v.c});`);
+            else
+                this.line(`${valueC(type)} ${c} = ${this.ownedString(v).c};`);
+            params.set(p.name.text, { c, type, mutable: true });
+        });
+        return { node: made, name: `the function ${maker.name}() made`, scopes: [...maker.scopes, params], env: maker.env, imports: maker.imports };
     }
     /** A function given for a function parameter of an expanded helper or closure, as something to expand. */
     closureOf(arg) {
         if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg))
-            return { node: arg, name: "the function passed", scopes: [...this.scopes] };
+            return { node: arg, name: "the function passed", scopes: [...this.scopes], env: this.envNow(), imports: this.scope.imports };
         if (ts.isIdentifier(arg)) {
             const l = this.lookup(arg.text);
             if (l?.closure)
@@ -1025,7 +1115,7 @@ export class CallEmitter extends ExpressionEmitter {
             const name = calleeName(arg, this.model.helperDecls, this.checker) ?? arg.text;
             const h = this.model.helpers.get(name) ?? this.model.generics.get(name);
             if (h)
-                return { node: h.node, name: h.display, scopes: [] };
+                return { node: h.node, name: h.display, scopes: [], env: this.noEnv(), imports: h.imports };
         }
         this.fail(arg, "pass a function: its name, or an arrow written here");
     }

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

@@ -8,6 +8,9 @@ type MplField = {
 } | {
     value: ts.Expression;
     type: ValueType;
+} | {
+    c: string;
+    n: string;
 };
 /**
  * Other programs: PDAs and seeds, account creation, System/Token/ATA/Metaplex CPIs, generic invoke, Borsh
@@ -100,8 +103,37 @@ export declare abstract class CpiEmitter extends CallEmitter {
     protected corePlugin(n: ts.Expression, withAuthority: boolean): MplField[];
     /** CreateV1 / CreateCollectionV1 plugins: Option<Vec<PluginAuthorityPair>>. */
     protected corePluginList(n: ts.Expression | undefined): MplField[];
-    /** Metaplex Core: assets and collections (with plugins), plugins added, updated and removed, transfer and burn. */
+    /**
+     * Metaplex Core: assets and collections (with plugins), plugins and external plugin adapters added, updated, written
+     * and removed, transfer and burn. Each method is a row of CORE_OPS below: its accounts in order, its data.
+     */
     protected coreOp(node: ts.CallExpression, core: AccountParam, method: string): undefined;
+    /**
+     * Core instructions: `args` fixed arguments (then an optional plugin list when `plugins`, then optional signer
+     * seeds), accounts in order (`[argument, label, writable, signer]`, or "self": the Core program, Core's "none" for an
+     * optional account), at most `max` bytes of data.
+     */
+    private coreOps;
+    /** The fields of a Core object literal (`{ kind: "AppData", … }`) by name. */
+    private coreProps;
+    /** PluginAuthority: "none" | "owner" | "updateAuthority" (literals), or an address. */
+    private coreAuthority;
+    private coreOption;
+    private coreSchema;
+    /** Vec<(HookableLifecycleEvent, ExternalCheckResult)>: `[{ event: "transfer", canReject: true }, …]`. */
+    private coreChecks;
+    /** ExtraAccount: `{ kind: "address", address, isSigner?, isWritable? }` or a preconfigured one (`{ kind: "owner" }`, …). */
+    private coreExtraAccount;
+    /**
+     * ExternalPluginAdapterInitInfo from a literal: `{ kind: "AppData", dataAuthority, schema? }`, `{ kind: "Oracle",
+     * baseAddress, checks, resultsOffset?, baseAddressConfig? }`, `{ kind: "LifecycleHook", hookedProgram, checks,
+     * extraAccounts?, dataAuthority?, schema? }` and the Linked forms (collections); `authority?` is the plugin's own.
+     */
+    protected coreExternalPlugin(n: ts.Expression): MplField[];
+    /** ExternalPluginAdapterKey: `{ kind: "AppData", dataAuthority }`, `{ kind: "Oracle", address }`, `{ kind: "LifecycleHook", address }`, … */
+    protected coreExternalKey(n: ts.Expression): MplField[];
+    /** The data written: Option<Vec<u8>> from a string, a Vec<u8> argument, or null (clears it). */
+    protected coreExternalData(n: ts.Expression): MplField[];
     /** PluginType (u8) from a kind string literal: removePlugin(…, "FreezeDelegate"). */
     protected corePluginType(n: ts.Expression): MplField;
     /** Bubblegum (compressed NFTs on SPL account compression): createTree, mint (MintV1, no collection, no creators). */