@typesol/cli 0.21.0 → 0.23.0

package/dist/compiler/analyze.js

@@ -422,6 +422,32 @@ 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 target = (ts.isArrowFunction(n) || ts.isFunctionExpression(n)) && ts.isCallExpression(n.parent) ? fnParamType(n, checker) : undefined;
+            if (target) {
+                reporter.guard(() => {
+                    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;
+                    lit.parameters.forEach((p, i) => {
+                        const from = target.parameters[i]?.type;
+                        if (!p.type && from)
+                            p.type = from;
+                    });
+                    if (!lit.type)
+                        lit.type = target.type;
+                    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 };
+                    locals.push(src);
+                    if (lit.body)
+                        collectLocals(lit.body, name, imports, lit);
+                });
+                return;
+            }
             ts.forEachChild(n, visit);
         };
         visit(body);
@@ -525,7 +551,7 @@ export function analyze(entry) {
             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`);
+                    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")
@@ -580,6 +606,7 @@ export function analyze(entry) {
             argStructs,
             fstrings,
             fixedVecs,
+            localVecs: new Map(),
         },
         sourceFile,
         files: programFiles(program, entryPath).map((f) => f.fileName),
@@ -642,11 +669,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 +745,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) {
@@ -824,9 +863,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 +872,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}`),
@@ -987,13 +1035,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 +1061,30 @@ 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 (t && ts.isFunctionTypeNode(t))
+            return t;
+    }
+    return undefined;
+}
 function captures(l, localDecls, checker) {
     const fn = l.node;
     let found = false;

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 { 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,
@@ -50,6 +50,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.
@@ -116,4 +118,12 @@ 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;
+    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

@@ -87,6 +87,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 +106,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 +125,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);

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,16 @@ 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;
+    /** 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;

package/dist/compiler/emit/calls.js

@@ -1,9 +1,9 @@
 import ts from "typescript";
-import { calleeName, resolveScalarType } from "../analyze.js";
+import { calleeName, resolveScalarType, resolveValueType } from "../analyze.js";
 import { ANCHOR_ERRORS } from "../anchor-errors.js";
 import { decodeAddress } from "../../keys.js";
 import { INT_INFO, INT_NAMES, isScalar, isWritable, sameType, scalarSize, typeName, } from "../model.js";
-import { U64, U8, I64, BOOL, PUBKEY, STRING, HASH, cBytes, cString, scalarC, scalarStorageC, optC, valueC, fieldC, storageDecl, accountMismatch, vecCount, } from "./shared.js";
+import { U64, U8, I64, BOOL, PUBKEY, STRING, HASH, cBytes, cString, scalarC, scalarStorageC, optC, valueC, fieldC, storageDecl, accountMismatch, vecCount, emptySizeC, vecLenCheck, } from "./shared.js";
 import { ExpressionEmitter } from "./expressions.js";
 /**
  * Calls: built-in functions, Vec methods, helpers, remaining accounts, foreign account reads and return data.
@@ -465,6 +465,9 @@ export class CallEmitter extends ExpressionEmitter {
             if (local?.closure)
                 return this.expandClosure(local.closure, node.arguments, node);
         }
+        const inlined = this.helperWithClosure(node);
+        if (inlined)
+            return inlined.value;
         const helper = this.helperOf(node);
         if (helper)
             return this.callHelper(node, helper);
@@ -473,9 +476,12 @@ export class CallEmitter extends ExpressionEmitter {
             // xs.some(…) and friends on a Vec, FixedArray, FixedVec or Vec argument: a loop with the callback expanded in it.
             if (LIST_METHODS.has(method)) {
                 const l = ts.isIdentifier(callee.expression) ? this.lookup(callee.expression.text) : undefined;
-                if (l?.type.kind === "vecArg" || l?.type.kind === "array" || this.peekArray(callee.expression))
+                if (l?.type.kind === "vecArg" || l?.type.kind === "array" || this.isPipeline(callee.expression) || this.peekArray(callee.expression))
                     return this.listMethod(node, method);
             }
+            // A map / filter chain is consumed by a list method, `.length` or for…of, or stored: const ys = xs.map(…).
+            if (this.isPipeline(node))
+                this.fail(node, `${method} builds a new list: store it (const ys = xs.${method}(…)), or use it right away with a list method, .length or for…of`);
             // Vec<T> instruction arguments are read-only views.
             if (ts.isIdentifier(callee.expression)) {
                 const l = this.lookup(callee.expression.text);
@@ -620,6 +626,21 @@ export class CallEmitter extends ExpressionEmitter {
                 this.fail(node, "only Vecs of Mut<...> / Init<...> accounts can grow or shrink");
             this.line(`TS_TRY(ts_resize(params, ${payer}, a_${v.account.name}, 8 + ${info.fixed} + (${newLen}) * ${info.elemSize}, entry_${v.account.name}));`);
         };
+        /**
+         * The growable Vecs stored after this one move by `by` bytes (+ grows, - shrinks): where they start and how many
+         * bytes they take, read before the resize; references into them cannot outlive this call.
+         */
+        const tail = info.tail;
+        const tailStart = () => {
+            if (!tail)
+                return undefined;
+            this.assertNotAliased(tail.paths, node);
+            const at = this.tmp("tail");
+            const n = this.tmp("tail_n");
+            this.line(`uint8_t *${at} = ${tail.end};`);
+            this.line(`uint64_t ${n} = (uint64_t)(${tail.dataEnd} - ${at});`);
+            return { at, n };
+        };
         switch (method) {
             case "set": {
                 if (args.length !== 2)
@@ -655,8 +676,11 @@ export class CallEmitter extends ExpressionEmitter {
                 const write = stageElem(args[0]);
                 const n = this.tmp("n");
                 this.line(`uint64_t ${n} = (uint64_t)${info.len};`);
-                // Resizing does not move the data, so element pointers stay valid.
+                const t = tailStart();
+                // Resizing does not move the data, so element pointers stay valid; the Vecs after this one shift up.
                 resize(`${n} + 1`, `a_${payer.name}`);
+                if (t)
+                    this.line(`ts_memmove(${t.at} + ${info.elemSize}, ${t.at}, ${t.n});`);
                 this.line(`${info.len} = (uint32_t)(${n} + 1);`);
                 write(elemRef(n));
                 return undefined;
@@ -686,6 +710,9 @@ export class CallEmitter extends ExpressionEmitter {
                         this.line(`${valueC(st)} ${out} = ${val.c};`);
                     result = st.kind === "pubkey" ? { c: `(&${out})`, type: st } : { c: out, type: st };
                 }
+                const t = info.cap === undefined ? tailStart() : undefined;
+                if (t)
+                    this.line(`ts_memmove(${t.at} - ${info.elemSize}, ${t.at}, ${t.n});`);
                 this.line(`${info.len} = (uint32_t)(${n} - 1);`);
                 resize(`${n} - 1`, "NULL");
                 return result;
@@ -695,6 +722,9 @@ export class CallEmitter extends ExpressionEmitter {
                     this.fail(node, "clear() takes no arguments");
                 needWritable();
                 this.assertNotAliased(elemPaths(), node);
+                const t = info.cap === undefined ? tailStart() : undefined;
+                if (t)
+                    this.line(`ts_memmove((uint8_t *)${info.items}, ${t.at}, ${t.n});`);
                 this.line(`${info.len} = 0;`);
                 resize("0", "NULL");
                 return undefined;
@@ -933,9 +963,10 @@ export class CallEmitter extends ExpressionEmitter {
         if (this.model.events.has(s.name) && s.fields.some((f) => f.type.kind === "option" || f.type.kind === "dataEnum"))
             this.fail(node, `${s.name} is emitted as an event and has Option or enum fields; declare a separate event struct`);
         this.model.accountStructs.add(s.name);
-        this.line(`TS_TRY(ts_check_program_account(${h}, params->program_id, TS_DISC_${s.name}, sizeof(TSS_${s.name})));`);
+        this.line(`TS_TRY(ts_check_program_account(${h}, params->program_id, TS_DISC_${s.name}, ${emptySizeC(s)}));`);
         if (s.vec)
-            this.line(`TS_TRY(ts_check_vec_len(${h}, sizeof(TSS_${s.name}), ((TSS_${s.name} *)(${h}->data + 8))->${s.vec.name}__len, TS_ELEM_${s.name}));`);
+            for (const l of vecLenCheck(s, h, `((TSS_${s.name} *)(${h}->data + 8))`, ""))
+                this.line(l);
         if (mut) {
             this.line(`TS_TRY(ts_check_writable(${h}));`);
             this.line(`TS_TRY(ts_check_unaliased(params, ${h}));`);
@@ -967,6 +998,37 @@ export class CallEmitter extends ExpressionEmitter {
         visit(body);
         return found;
     }
+    /**
+     * 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.
+     */
+    helperWithClosure(node) {
+        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) };
+    }
+    /** 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] };
+        if (ts.isIdentifier(arg)) {
+            const l = this.lookup(arg.text);
+            if (l?.closure)
+                return l.closure;
+            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: [] };
+        }
+        this.fail(arg, "pass a function: its name, or an arrow written here");
+    }
     callHelper(node, h) {
         if (this.ix && !this.ix.accounts.some((a) => a.kind.kind === "system" && !a.optional) && h.params.some((p) => p.account) && this.helperGrows(h.node))
             this.fail(node, `${h.display}() grows a Vec (push): the instruction needs a SystemProgram parameter to top up rent`);

package/dist/compiler/emit/cpi.js

@@ -2,7 +2,7 @@ import ts from "typescript";
 import { discriminator, snakeCase } from "../analyze.js";
 import { borshMinSize } from "./borsh.js";
 import { INT_INFO, isScalar, isWritable, optionKey, sameType, scalarSize, typeName, } from "../model.js";
-import { MAX_ACCOUNTS, MAX_SEEDS, MAX_CPI_DATA, MAX_EVENT, U64, U8, BOOL, PUBKEY, STRING, cBytes, isStable, cString, scalarStorageC, optC, valueC, } from "./shared.js";
+import { MAX_ACCOUNTS, MAX_SEEDS, MAX_CPI_DATA, MAX_EVENT, U64, U8, BOOL, PUBKEY, STRING, cBytes, isStable, cString, scalarStorageC, optC, valueC, emptySizeC, fixedVecC, vecCount, } from "./shared.js";
 import { CallEmitter } from "./calls.js";
 /**
  * Bubblegum instructions that replace a leaf: discriminator, accounts in order ([label, writable, signer, optional,
@@ -321,7 +321,7 @@ export class CpiEmitter extends CallEmitter {
         const b = this.tmp("bump");
         // The account's size: the struct's (8 + its fixed size, Anchor's InitSpace for @layout borsh), or Anchor's
         // `space = …` when given, which must hold the struct.
-        const need = `8 + sizeof(TSS_${s.name})`;
+        const need = s.layout === "borsh" ? `8 + sizeof(TSS_${s.name})` : `8 + ${emptySizeC(s)}`;
         let space = need;
         const spaceArg = node.arguments[2];
         if (spaceArg) {
@@ -2642,8 +2642,46 @@ export class CpiEmitter extends CallEmitter {
                 this.fail(obj, `missing field "${f.name}" of ${s.name}`);
         for (const [name, e] of given) {
             const f = s.fields.find((x) => x.name === name);
-            if (f.type.kind === "vec")
-                this.fail(obj, "Vec fields are not supported in events yet");
+            if (f.type.kind === "vec" && f.type.cap !== undefined) {
+                // A FixedVec keeps its fixed layout, as in account data: u32 length, then room for N elements.
+                const ft = f.type;
+                const t = this.tmp("evv");
+                this.line(`${fixedVecC(ft)} ${t};`);
+                this.line(`ts_memzero(&${t}, sizeof(${t}));`);
+                this.writeAggregate({ lv: t, type: ft, writable: true }, e);
+                const n = this.fieldBytes(ft);
+                staged.set(name, (put) => put(`&${t}`, String(n), n));
+                continue;
+            }
+            if (f.type.kind === "vec") {
+                // A Vec is Borsh: u32 length, then the elements, read from a Vec argument or account data when emitted.
+                const l = ts.isIdentifier(e) ? this.lookup(e.text) : undefined;
+                const r = l?.type.kind === "vecArg" ? undefined : this.ref(e);
+                const elemSize = this.fieldBytes(f.type.elem);
+                if (l?.type.kind === "vecArg") {
+                    if (!sameType(l.type.elem, f.type.elem))
+                        this.fail(e, `expected a ${typeName(f.type)}`);
+                    const c = l.c;
+                    staged.set(name, (put) => {
+                        const n = this.tmp("vl");
+                        this.line(`uint32_t ${n} = (uint32_t)${c}.len;`);
+                        put(`&${n}`, "4");
+                        put(`(const uint8_t *)${c}.ptr`, `(uint64_t)${n} * ${elemSize}`);
+                    });
+                }
+                else if (r?.vec && r.type.kind === "vec" && sameType(r.type.elem, f.type.elem)) {
+                    const info = r.vec;
+                    staged.set(name, (put) => {
+                        const n = this.tmp("vl");
+                        this.line(`uint32_t ${n} = (uint32_t)${vecCount(info)};`);
+                        put(`&${n}`, "4");
+                        put(`(const uint8_t *)${info.items}`, `(uint64_t)${n} * ${elemSize}`);
+                    });
+                }
+                else
+                    this.fail(e, `expected a ${typeName(f.type)}: a Vec argument or a list in account data`);
+                continue;
+            }
             if (f.type.kind === "option" && f.type.inner.kind === "struct")
                 this.fail(obj, "Option<struct> fields are not supported in events yet");
             const vt = f.type.kind === "string" ? STRING : f.type.kind === "option" || isScalar(f.type) ? f.type : undefined;

package/dist/compiler/emit/expressions.js

@@ -174,6 +174,8 @@ export class ExpressionEmitter extends StorageEmitter {
                     this.fail(node, `"${node.text}" is a function: TypeSOL functions are called (${node.text}(…)), not passed around or stored`);
                 if (l.type.kind === "array")
                     this.fail(node, `"${node.text}" is an array; use .get(i)`);
+                if (l.type.kind === "vec")
+                    this.fail(node, `"${node.text}" is a list; use .get(i) and .length`);
                 if (l.type.kind === "remaining")
                     return { c: "", type: l.type };
                 return l.type.kind === "pubkey" && !l.ptr ? { c: `(&${l.c})`, type: l.type } : { c: l.c, type: l.type };
@@ -261,6 +263,13 @@ export class ExpressionEmitter extends StorageEmitter {
         if (field === "length") {
             if (this.isRemaining(node.expression))
                 return { c: `((uint64_t)(params->ka_num - ${this.ix.accounts.length}))`, type: U64 };
+            // The number of elements a map / filter chain gives: counted, nothing stored.
+            if (this.isPipeline(node.expression)) {
+                const n = this.tmp("count");
+                this.line(`uint64_t ${n} = 0;`);
+                this.eachElement(node.expression, node, { index: `__ln${this.temp++}`, ci: this.tmp("ln_i") }, () => this.line(`${n}++;`));
+                return { c: n, type: U64 };
+            }
             const arr = this.ref(node.expression);
             if (arr?.type.kind === "array")
                 return { c: `${arr.type.len}ULL`, type: U64 };

package/dist/compiler/emit/function.js

@@ -3,7 +3,7 @@ import { snakeCase } from "../analyze.js";
 import { decodeAddress } from "../../keys.js";
 import { INT_INFO, isScalar, isWritable, scalarSize, typeName, } from "../model.js";
 import { borshIdentical, borshMinSize } from "./borsh.js";
-import { MAX_ACCOUNTS, ATA_PROGRAM_BYTES, cBytes, cString, optC, fieldC, storageDecl, helperSignature } from "./shared.js";
+import { MAX_ACCOUNTS, ATA_PROGRAM_BYTES, cBytes, cString, optC, fieldC, storageDecl, helperSignature, emptySizeC, vecLenCheck } from "./shared.js";
 import { StatementEmitter } from "./statements.js";
 /**
  * One instruction or helper as a C function: the instruction prologue (account checks, constraints and
@@ -42,7 +42,7 @@ export class FunctionEmitter extends StatementEmitter {
                 head.push(`  TS_TRY(ts_check_writable(${v}));`);
             // A @layout borsh account only has to hold its smallest Borsh form (unpacking checks the rest).
             if (k.kind === "account")
-                head.push(`  TS_TRY(ts_check_program_account(${v}, params->program_id, TS_DISC_${k.struct.name}, ${k.struct.layout === "borsh" ? borshMinSize(k.struct, this.model) : `sizeof(TSS_${k.struct.name})`}));`);
+                head.push(`  TS_TRY(ts_check_program_account(${v}, params->program_id, TS_DISC_${k.struct.name}, ${k.struct.layout === "borsh" ? borshMinSize(k.struct, this.model) : emptySizeC(k.struct)}));`);
             // A token account created by this instruction is checked where it is created (create/createIfNeeded).
             if (k.kind === "token" && !k.init)
                 head.push(`  TS_TRY(ts_check_token_account(${v}));`);
@@ -106,7 +106,7 @@ export class FunctionEmitter extends StatementEmitter {
                 if (k.struct.vec) {
                     head.push(`  uint64_t entry_${a.name} = ${v}->data_len;`, `  (void)entry_${a.name};`);
                     if (k.kind === "account")
-                        head.push(`  TS_TRY(ts_check_vec_len(${v}, sizeof(TSS_${k.struct.name}), d_${a.name}->${k.struct.vec.name}__len, TS_ELEM_${k.struct.name}));`);
+                        head.push(...vecLenCheck(k.struct, v, `d_${a.name}`));
                 }
             }
             // realloc(x, …) needs the size the account had when the instruction started (the 10 KiB growth limit).
@@ -219,6 +219,8 @@ export class FunctionEmitter extends StatementEmitter {
                 const size = this.fieldBytes(elem);
                 need("4");
                 head.push(`  TS_VecArg arg_${a.name};`, `  arg_${a.name}.len = (uint32_t)ts_read_le(${at}, 4);`, `  off += 4;`);
+                if (a.type.cap !== undefined)
+                    head.push(`  if (arg_${a.name}.len > ${a.type.cap}) TS_FAIL(TS_ERR_INSTRUCTION_DATA, "TypeSOL: more elements than the FixedVec argument holds");`);
                 need(`(uint64_t)arg_${a.name}.len * ${size}`);
                 head.push(`  arg_${a.name}.ptr = ${at};`, `  off += (uint64_t)arg_${a.name}.len * ${size};`);
                 // Struct elements are read in place, so check them all now; scalars are checked when read.

package/dist/compiler/emit/program.js

@@ -1,4 +1,4 @@
-import { MAX_ACCOUNTS, cBytes, scalarStorageC, optC, storageDecl, helperSignature, fixedVecC } from "./shared.js";
+import { MAX_ACCOUNTS, cBytes, scalarStorageC, optC, storageDecl, helperSignature, fixedVecC, laterVecC } from "./shared.js";
 import { FunctionEmitter } from "./function.js";
 import { emitBorshCodecs } from "./borsh.js";
 /**
@@ -96,9 +96,14 @@ export function emitProgram(analysis, opts = {}) {
             return;
         emitted.add(s.name);
         s.fields.forEach((f) => deps(f.type));
+        // Growable Vecs after the first live past the C struct (see StructDef.vecs): a header type each.
+        const later = new Set((s.vecs ?? []).slice(1).map((v) => v.name));
+        for (const v of (s.vecs ?? []).slice(1))
+            out.push(`typedef struct __attribute__((packed)) {`, `  uint32_t len;`, `  ${storageDecl(v.elem, "items[]")};`, `} ${laterVecC(s.name, v.name)};`);
         out.push(`typedef struct __attribute__((packed)) {`);
         for (const f of s.fields)
-            out.push(`  ${storageDecl(f.type, f.name)};`);
+            if (!later.has(f.name))
+                out.push(`  ${storageDecl(f.type, f.name)};`);
         if (!s.fields.length)
             out.push(`  uint8_t __empty[0];`); // a marker account (Anchor `pub struct NftAuthority {}`): discriminator only
         out.push(`} TSS_${s.name};`);
@@ -113,6 +118,8 @@ export function emitProgram(analysis, opts = {}) {
         emitStruct(s);
     for (const e of model.dataEnums.values())
         deps({ kind: "dataEnum", name: e.name });
+    for (const t of model.localVecs.values())
+        deps(t);
     for (const k of model.constants.values())
         if (typeof k.value === "object")
             out.push(`static const SolPubkey TSK_${k.name} = {${cBytes(k.value.pubkey)}};`);

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

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { type AccountParam, type FieldType, type Helper, type IntName, type ParamKind, type ScalarType, type ValueType } from "../model.js";
+import { type AccountParam, type FieldType, type Helper, type IntName, type ParamKind, type ScalarType, type StructDef, type ValueType } from "../model.js";
 /** Maximum accounts the generated entrypoint deserializes. */
 export declare const MAX_ACCOUNTS = 32;
 export declare const MAX_SEEDS = 15;
@@ -46,16 +46,27 @@ export interface Ref {
     vec?: {
         len: string;
         items: string;
+        /** The account's size without this Vec's elements (so with `n` of them: 8 + fixed + n × elemSize). */
         fixed: string;
         elemSize: number;
         resizable: boolean;
         cap?: number;
+        /** Growable Vecs stored after this one move when it grows or shrinks: where its elements end, and their paths. */
+        tail?: {
+            end: string;
+            dataEnd: string;
+            paths: string[];
+        };
     };
 }
 export interface Local {
     c: string;
+    /** A value, or a local FixedArray / FixedVec (`fixedArray<T, N>(…)`, `const ys = xs.map(…)`) held in place. */
     type: ValueType | (FieldType & {
         kind: "array";
+    }) | (FieldType & {
+        kind: "vec";
+        cap: number;
     });
     mutable: boolean;
     /** Pubkey held as a `const SolPubkey *` (helper parameters) rather than a value. */
@@ -70,7 +81,8 @@ export interface Local {
 }
 /** A closure and the scopes it was declared in (its free names resolve there, wherever it is called). */
 export interface Closure {
-    node: ts.ArrowFunction | ts.FunctionExpression;
+    /** The function expanded: a closure, or a helper expanded where it is called because it was given one. */
+    node: ts.ArrowFunction | ts.FunctionExpression | ts.FunctionDeclaration;
     name: string;
     scopes: Map<string, Local>[];
 }
@@ -102,6 +114,24 @@ export interface EmitOptions {
     /** Log a marker and the remaining compute units before every statement (`typesol build --profile`). */
     profile?: boolean;
 }
+/** C type of a growable Vec stored after the first one of struct `s`: `{ uint32_t len; T items[]; }`. */
+export declare function laterVecC(s: string, field: string): string;
+/** The account size of struct `s` with every growable Vec empty, as C (8-byte discriminator not included). */
+export declare function emptySizeC(s: StructDef): string;
+/**
+ * Where growable Vec `k` of a struct at `base` (a C lvalue of type TSS_<S>) starts, as C: its length and elements.
+ * The first is a member of the struct; each further one starts right after the previous one's elements.
+ */
+export declare function vecPlace(s: StructDef, base: string, k: number): {
+    len: string;
+    items: string;
+    end: string;
+};
+/**
+ * C lines checking that an account's size matches its growable Vecs' lengths (`d`: its TSS_<S> pointer, `a`: its
+ * TsAccount). One Vec: ts_check_vec_len; more: each length read only once the bytes before it are known to exist.
+ */
+export declare function vecLenCheck(s: StructDef, a: string, d: string, pad?: string): string[];
 /** C typedef name of a FixedVec<T, N>: `{ uint32_t len; T items[N]; }`. */
 export declare function fixedVecC(t: FieldType & {
     kind: "vec";