@typesol/cli 0.16.0 → 0.17.0

package/dist/compiler/emit/expressions.js

@@ -1,6 +1,7 @@
 import ts from "typescript";
+import { calleeName, resolveValueType } from "../analyze.js";
 import { INT_INFO, unsignedC, sameType, typeName } from "../model.js";
-import { U64, U8, I64, BOOL, PUBKEY, STRING, HASH, cString, intLiteral, scalarStorageC, optC, valueC } from "./shared.js";
+import { U64, U8, I64, BOOL, PUBKEY, STRING, HASH, cString, intLiteral, scalarStorageC, optC, valueC, vecCount } from "./shared.js";
 import { StorageEmitter } from "./storage.js";
 /**
  * Expressions: literals, operators with checked arithmetic, property reads, conditionals, text and casts.
@@ -62,6 +63,20 @@ export class ExpressionEmitter extends StorageEmitter {
     expr(node, hint) {
         if (ts.isParenthesizedExpression(node))
             return this.expr(node.expression, hint);
+        // `x as T`: an annotation the value must already match (no conversion: use u8(x) etc. for that). Inside a
+        // generic helper it names the instance's type: `return (a + b) as T`.
+        if (ts.isAsExpression(node) || ts.isSatisfiesExpression(node)) {
+            if (ts.isAsExpression(node) && ts.isTypeReferenceNode(node.type) && ts.isIdentifier(node.type.typeName) && node.type.typeName.text === "const")
+                return this.expr(node.expression, hint);
+            const t = resolveValueType(node.type, this.scope);
+            if (!t || t.kind === "vecArg" || t.kind === "dataEnumArg")
+                this.fail(node.type, "`as` names an integer, boolean, Pubkey, enum, option or string type the value already has");
+            const v = this.expr(node.expression, t);
+            // Not a conversion: `x as u64 | null` does not make an Option of a u64.
+            if (v.literal === undefined && !v.isNull && !sameType(v.type, t))
+                this.fail(node, `this is a ${typeName(v.type)}, not a ${typeName(t)}: \`as\` does not convert (use u64(x) and the like for integers)`);
+            return this.expect(v, t, node.expression);
+        }
         // `x!` on an Option: its value, aborting with 5108 when it is empty (JS would carry the null on).
         if (ts.isNonNullExpression(node)) {
             const v = this.expr(node.expression, hint && hint.kind !== "option" ? { kind: "option", inner: hint } : hint);
@@ -140,6 +155,8 @@ export class ExpressionEmitter extends StorageEmitter {
             }
             if (this.accounts.has(node.text))
                 this.fail(node, `"${node.text}" is an account; use ${node.text}.key for its address`);
+            if (calleeName(node, this.model.helperDecls, this.checker) || this.model.helpers.has(node.text))
+                this.fail(node, `"${node.text}" is a function: TypeSOL functions are called (${node.text}(…)), not passed around or stored`);
             this.fail(node, `unknown name "${node.text}"`);
         }
         if (ts.isPropertyAccessExpression(node))
@@ -202,7 +219,7 @@ export class ExpressionEmitter extends StorageEmitter {
             if (arr?.type.kind === "array")
                 return { c: `${arr.type.len}ULL`, type: U64 };
             if (arr?.type.kind === "vec")
-                return { c: `((uint64_t)${arr.vec.len})`, type: U64 };
+                return { c: vecCount(arr.vec), type: U64 };
             if (ts.isIdentifier(node.expression)) {
                 const l = this.lookup(node.expression.text);
                 if (l?.type.kind === "vecArg")

package/dist/compiler/emit/function.js

@@ -1,7 +1,8 @@
 import ts from "typescript";
 import { snakeCase } from "../analyze.js";
 import { decodeAddress } from "../../keys.js";
-import { INT_INFO, isScalar, isWritable, scalarSize, typeName } from "../model.js";
+import { INT_INFO, isScalar, isWritable, scalarSize, typeName, } from "../model.js";
+import { borshMinSize } from "./borsh.js";
 import { MAX_ACCOUNTS, ATA_PROGRAM_BYTES, cBytes, cString, optC, fieldC, storageDecl, helperSignature } from "./shared.js";
 import { StatementEmitter } from "./statements.js";
 /**
@@ -14,12 +15,12 @@ export class FunctionEmitter extends StatementEmitter {
         this.scopes = [new Map()];
         this.line(`(void)params;`);
         for (const p of h.params)
-            if (p.account && p.account.kind === "account")
+            if (p.account && p.account.kind === "account" && p.account.struct.layout !== "borsh")
                 this.line(`TSS_${p.account.struct.name} *d_${p.name} = (TSS_${p.account.struct.name} *)(a_${p.name}->data + 8);`);
-        for (const stmt of h.node.body.statements)
+        for (const stmt of h.statements)
             this.reporter.guard(() => this.statement(stmt));
         // A helper with a result must return one; falling off the end would leave it unset.
-        const end = h.returns ? `  TS_FAIL(TS_ERR_NO_RETURN, "TypeSOL: ${h.name} ended without returning a value");` : `  return SUCCESS;`;
+        const end = h.returns ? `  TS_FAIL(TS_ERR_NO_RETURN, "TypeSOL: ${h.display} ended without returning a value");` : `  return SUCCESS;`;
         return [`${helperSignature(h)} {`, ...this.hoisted, ...this.lines, end, `}`].join("\n");
     }
     emitInstruction() {
@@ -39,8 +40,9 @@ export class FunctionEmitter extends StatementEmitter {
                 head.push(`  TS_TRY(ts_check_signer(${v}));`);
             if (isWritable(k))
                 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}, 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) : `sizeof(TSS_${k.struct.name})`}));`);
             // 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}));`);
@@ -87,7 +89,16 @@ export class FunctionEmitter extends StatementEmitter {
                 head.push(`  TS_TRY(ts_init_zeroed(${v}, params->program_id, TS_DISC_${k.struct.name}, sizeof(TSS_${k.struct.name})));`);
             if (k.kind === "initIfNeeded" && k.struct.vec)
                 this.reporter.fail(a.node, "InitIfNeeded accounts cannot end in a Vec yet");
-            if (k.kind === "account" || k.kind === "init" || k.kind === "zeroed" || k.kind === "initIfNeeded") {
+            if ((k.kind === "account" || k.kind === "init" || k.kind === "initIfNeeded") && k.struct.layout === "borsh") {
+                // Worked on as its fixed-layout struct on the heap, packed back when the instruction returns. The heap is zero at
+                // entry and these are its first allocations (before the body uses it), so a string's padding and a list's
+                // unused slots start as zero: ts_unpack_* only writes what the Borsh bytes hold.
+                const S = k.struct.name;
+                head.push(`  TSS_${S} *d_${a.name} = NULL;`, `  TS_TRY(ts_alloc(sizeof(TSS_${S}), (uint8_t **)&d_${a.name}));`);
+                if (k.kind === "account")
+                    head.push(`  TS_TRY(ts_unpack_${S}(${v}->data + 8, ${v}->data_len - 8, d_${a.name}));`);
+            }
+            else if (k.kind === "account" || k.kind === "init" || k.kind === "zeroed" || k.kind === "initIfNeeded") {
                 head.push(`  TSS_${k.struct.name} *d_${a.name} = (TSS_${k.struct.name} *)(${v}->data + 8);`);
                 if (k.struct.vec) {
                     head.push(`  uint64_t entry_${a.name} = ${v}->data_len;`, `  (void)entry_${a.name};`);
@@ -285,13 +296,25 @@ export class FunctionEmitter extends StatementEmitter {
     epilogue() {
         if (!this.ix)
             return [];
-        return this.ix.accounts
-            .filter((a) => a.constraints.closeTo)
+        // @layout borsh accounts go back to their Borsh bytes (unless closed, or never created).
+        const packs = this.ix.accounts
+            .filter((a) => (a.kind.kind === "account" ? a.kind.mut : a.kind.kind === "init" || a.kind.kind === "initIfNeeded"))
+            .filter((a) => a.kind.struct.layout === "borsh")
             .map((a) => {
-            const line = `TS_TRY(ts_close(a_${a.name}, a_${a.constraints.closeTo}));`;
-            const optional = this.optionalIn(line);
-            return optional.length ? `if (${optional.map((n) => `a_${n} != NULL`).join(" && ")}) ${line}` : line;
+            const v = `a_${a.name}`;
+            const S = a.kind.struct.name;
+            return `if (${a.optional ? `${v} != NULL && ` : ""}${v}->data_len >= 8 && ts_key_eq(&${v}->owner, params->program_id)) TS_TRY(ts_pack_${S}(d_${a.name}, ${v}->data + 8, ${v}->data_len - 8));`;
         });
+        return [
+            ...packs,
+            ...this.ix.accounts
+                .filter((a) => a.constraints.closeTo)
+                .map((a) => {
+                const line = `TS_TRY(ts_close(a_${a.name}, a_${a.constraints.closeTo}));`;
+                const optional = this.optionalIn(line);
+                return optional.length ? `if (${optional.map((n) => `a_${n} != NULL`).join(" && ")}) ${line}` : line;
+            }),
+        ];
     }
     constraintChecks(ix) {
         const out = [];

package/dist/compiler/emit/program.js

@@ -1,5 +1,6 @@
-import { MAX_ACCOUNTS, cBytes, scalarStorageC, optC, storageDecl, helperSignature } from "./shared.js";
+import { MAX_ACCOUNTS, cBytes, scalarStorageC, optC, storageDecl, helperSignature, fixedVecC } from "./shared.js";
 import { FunctionEmitter } from "./function.js";
+import { emitBorshCodecs } from "./borsh.js";
 /**
  * The whole C translation unit: type declarations (structs, options, enums, events), every helper and instruction
  * (lowered by FunctionEmitter), and the entry point that dispatches on the instruction discriminator.
@@ -8,17 +9,26 @@ export function emitProgram(analysis, opts = {}) {
     const { model, reporter } = analysis;
     // Bodies first: they register events, string-literal errors and PDA descriptions.
     const helperBodies = [];
-    for (const h of model.helpers.values()) {
-        const body = reporter.guard(() => new FunctionEmitter(analysis, h, opts).emitHelper());
-        if (body)
-            helperBodies.push(body, "");
-    }
+    const emittedHelpers = new Set();
+    // Generic helpers' instances appear while bodies are lowered: emit until none is left.
+    const emitHelpers = () => {
+        for (const h of model.helpers.values()) {
+            if (emittedHelpers.has(h.name))
+                continue;
+            emittedHelpers.add(h.name);
+            const body = reporter.guard(() => new FunctionEmitter(analysis, h, opts).emitHelper());
+            if (body)
+                helperBodies.push(body, "");
+        }
+    };
+    emitHelpers();
     const ixBodies = [];
     for (const ix of model.instructions) {
         const body = reporter.guard(() => new FunctionEmitter(analysis, ix, opts).emitInstruction());
         if (body)
             ixBodies.push(body, "");
     }
+    emitHelpers();
     const out = [];
     out.push(`/* Generated by TypeSOL from ${analysis.sourceFile.fileName.split("/").pop()}. Do not edit. */`);
     // `const HEAP_SIZE_KIB = 64n`: a larger heap, which clients request with ComputeBudget requestHeapFrame.
@@ -43,6 +53,13 @@ export function emitProgram(analysis, opts = {}) {
             emitStruct(model.structs.get(t.name));
         if (t.kind === "array" || t.kind === "vec")
             deps(t.elem);
+        if (t.kind === "vec" && t.cap !== undefined) {
+            const name = fixedVecC(t);
+            if (emitted.has(name))
+                return;
+            emitted.add(name);
+            out.push(`typedef struct __attribute__((packed)) {`, `  uint32_t len;`, `  ${storageDecl(t.elem, `items[${t.cap}]`)};`, `} ${name};`, "");
+        }
         if (t.kind === "option" && t.inner.kind === "struct") {
             const key = `opt:${t.inner.name}`;
             if (emitted.has(key))
@@ -99,6 +116,7 @@ export function emitProgram(analysis, opts = {}) {
     for (const k of model.constants.values())
         if (typeof k.value === "object")
             out.push(`static const SolPubkey TSK_${k.name} = {${cBytes(k.value.pubkey)}};`);
+    out.push(...emitBorshCodecs(model));
     const helpers = [...model.helpers.values()];
     for (const h of helpers)
         out.push(helperSignature(h) + ";");

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

@@ -39,11 +39,17 @@ export interface Ref {
     /** Field path from the account root, when it is a plain chain of fields. */
     path?: string[];
     /** For a Vec: the u32 length lvalue, the fixed-part size expression, and whether it may be resized here. */
+    /**
+     * A Vec place: `len` the u32 length (an lvalue), `items` the element array. A trailing Vec grows the account
+     * (`fixed` bytes before it); a FixedVec (`cap`) has room for `cap` elements and never resizes.
+     */
     vec?: {
         len: string;
+        items: string;
         fixed: string;
         elemSize: number;
         resizable: boolean;
+        cap?: number;
     };
 }
 export interface Local {
@@ -88,3 +94,9 @@ export interface EmitOptions {
     /** Log a marker and the remaining compute units before every statement (`typesol build --profile`). */
     profile?: boolean;
 }
+/** C typedef name of a FixedVec<T, N>: `{ uint32_t len; T items[N]; }`. */
+export declare function fixedVecC(t: FieldType & {
+    kind: "vec";
+}): string;
+/** The element count of a Vec place to read: a FixedVec's stored length is clamped to its capacity. */
+export declare function vecCount(v: NonNullable<Ref["vec"]>): string;

package/dist/compiler/emit/shared.js

@@ -1,4 +1,4 @@
-import { INT_INFO, isWritable, optionKey, } from "../model.js";
+import { INT_INFO, fixedVecName, isWritable, optionKey, } from "../model.js";
 // Types, limits and C type helpers shared by the emitter modules.
 /** Maximum accounts the generated entrypoint deserializes. */
 export const MAX_ACCOUNTS = 32;
@@ -89,6 +89,10 @@ export function fieldC(t) {
         case "pubkey":
         case "enum":
             return scalarStorageC(t);
+        case "vec":
+            if (t.cap !== undefined)
+                return fixedVecC(t);
+            throw new Error("unreachable: a Vec is never an element");
         default:
             throw new Error(`unreachable: no element C type for ${t.kind}`);
     }
@@ -115,6 +119,8 @@ export function storageDecl(t, name) {
         case "array":
             return storageDecl(t.elem, `${name}[${t.len}]`);
         case "vec":
+            if (t.cap !== undefined)
+                return `${fixedVecC(t)} ${name}`;
             // Borsh Vec as a trailing flexible array: u32 length, then the elements.
             return `uint32_t ${name}__len;
   ${storageDecl(t.elem, `${name}[]`)}`;
@@ -175,8 +181,11 @@ export function accountMismatch(have, want) {
 export function helperSignature(h) {
     const params = ["TsParams *params"];
     for (const p of h.params) {
-        if (p.account)
+        if (p.account) {
             params.push(`TsAccount *a_${p.name}`);
+            if (p.account.kind === "account" && p.account.struct.layout === "borsh")
+                params.push(`TSS_${p.account.struct.name} *d_${p.name}`);
+        }
         else if (p.type.kind === "signerSeeds")
             params.push(`const SolSignerSeed *p_${p.name}`, `int p_${p.name}__n`);
         else if (p.type.kind === "pubkey")
@@ -190,3 +199,11 @@ export function helperSignature(h) {
         params.push(h.returns.kind === "struct" ? `TSS_${h.returns.name} *ret` : `${scalarC(h.returns)} *ret`);
     return `static uint64_t fn_${h.name}(${params.join(", ")})`;
 }
+/** C typedef name of a FixedVec<T, N>: `{ uint32_t len; T items[N]; }`. */
+export function fixedVecC(t) {
+    return `TSF_${fixedVecName(t)}`;
+}
+/** The element count of a Vec place to read: a FixedVec's stored length is clamped to its capacity. */
+export function vecCount(v) {
+    return v.cap === undefined ? `((uint64_t)${v.len})` : `((uint64_t)(${v.len} < ${v.cap} ? ${v.len} : ${v.cap}))`;
+}

package/dist/compiler/emit/statements.js

@@ -290,6 +290,12 @@ export class StatementEmitter extends CpiEmitter {
             }
             if (!ts.isIdentifier(d.name) || !d.initializer)
                 this.fail(d, "declare one plain name with an initializer");
+            // A local function is a helper of its own (lifted when the program was analyzed): nothing to run here.
+            if (ts.isArrowFunction(d.initializer) || ts.isFunctionExpression(d.initializer)) {
+                if (!this.model.helperDecls.has(d))
+                    this.fail(d, "declare local functions with const: const f = (…) => …");
+                continue;
+            }
             const name = d.name.text;
             if (this.scopes.at(-1).has(name))
                 this.fail(d.name, `"${name}" is already declared`);
@@ -498,14 +504,15 @@ export class StatementEmitter extends CpiEmitter {
         }
         // JS evaluates the target (`a.get(i).x`: which element) before the right side. The exception is
         // `acct.field = acct.create(...)`, which must create the account before the field can be touched.
-        const isCall = ts.isCallExpression(valueNode) && !this.isStorageCall(valueNode);
+        // `fixedVec([…])` is a value written in place, not a call.
+        const isCall = ts.isCallExpression(valueNode) && !this.isStorageCall(valueNode) && this.exportName(valueNode.expression) !== "fixedVec";
         const createsFirst = isCall && ts.isPropertyAccessExpression(valueNode.expression) && ["create", "createIfNeeded"].includes(valueNode.expression.name.text);
         let raw = createsFirst ? this.call(valueNode, topLevel) : undefined;
         if (createsFirst && !raw)
             this.fail(valueNode, "this call does not produce a value");
         // A helper's struct result is copied like any struct (the target first, as JS evaluates it first).
         const structCall = isCall && ts.isIdentifier(valueNode.expression)
-            ? this.model.helpers.get(valueNode.expression.text)?.returns?.kind === "struct"
+            ? this.helperOf(valueNode)?.returns?.kind === "struct"
             : false;
         if (structCall && this.writesThroughVec(target) && this.helperTakesMutAccounts(valueNode))
             this.fail(target, "the right side calls a helper that may change this Vec; store its result in a local first");
@@ -515,6 +522,7 @@ export class StatementEmitter extends CpiEmitter {
             (targetRef.type.kind === "array" ||
                 targetRef.type.kind === "struct" ||
                 targetRef.type.kind === "dataEnum" ||
+                (targetRef.type.kind === "vec" && targetRef.type.cap !== undefined) ||
                 (targetRef.type.kind === "option" && targetRef.type.inner.kind === "struct"))) {
             if (!targetRef.writable)
                 this.fail(target, this.readOnly(targetRef));
@@ -554,7 +562,7 @@ export class StatementEmitter extends CpiEmitter {
         }
     }
     helperTakesMutAccounts(node) {
-        const h = ts.isIdentifier(node.expression) ? this.model.helpers.get(node.expression.text) : undefined;
+        const h = this.helperOf(node);
         return !!h?.params.some((p) => p.account && isWritable(p.account));
     }
 }

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

@@ -67,6 +67,10 @@ export declare abstract class StorageEmitter extends EmitterBase {
      * required) or by copying another location of the same type.
      */
     protected writeAggregate(target: Ref, valueNode: ts.Expression): void;
+    /** The Vec view of a FixedVec stored at `lv` (`{ len, items[cap] }`). */
+    protected fixedVec(lv: string, elem: FieldType, cap: number): NonNullable<Ref["vec"]>;
+    /** A place whose type is a FixedVec gets its Vec view. */
+    protected withFixedVec(r: Ref): Ref;
     /** `arr.get(i)` reads storage rather than calling anything. */
     protected isStorageCall(node: ts.CallExpression): boolean;
     /** Whether an expression names an array, without emitting code or failing. */

package/dist/compiler/emit/storage.js

@@ -1,7 +1,7 @@
 import ts from "typescript";
 import { resolveScalarType } from "../analyze.js";
 import { INT_INFO, isScalar, isWritable, sameType, scalarSize, typeName } from "../model.js";
-import { U64, BOOL, PUBKEY, STRING, optC, fieldC, storageDecl } from "./shared.js";
+import { U64, BOOL, PUBKEY, STRING, optC, fieldC, fixedVecC, storageDecl, vecCount } from "./shared.js";
 import { EmitterBase } from "./base.js";
 /**
  * Places in account data and locals: references, reads and writes, Vec/array indexing, aliasing rules and
@@ -245,8 +245,8 @@ export class StorageEmitter extends EmitterBase {
         this.noOptionalChain(node);
         // A helper's struct result: a local of the caller's, read and copied like any struct.
         if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
-            const h = this.model.helpers.get(node.expression.text);
-            if (h?.returns?.kind === "struct" && !this.lookup(node.expression.text)) {
+            const h = this.helperOf(node);
+            if (h?.returns?.kind === "struct") {
                 const v = this.callHelper(node, h);
                 return { lv: `(*${v.c})`, type: { kind: "struct", name: h.returns.name }, writable: true };
             }
@@ -273,10 +273,13 @@ export class StorageEmitter extends EmitterBase {
                         return undefined;
                     this.assertUsable(a, node);
                     const r = { lv: `d_${a.name}->${f.name}`, type: f.type, writable: isWritable(a.kind), account: a, path: [f.name] };
-                    if (f.type.kind === "vec")
+                    if (f.type.kind === "vec" && f.type.cap !== undefined)
+                        r.vec = this.fixedVec(r.lv, f.type.elem, f.type.cap);
+                    else if (f.type.kind === "vec")
                         // Growing needs the account's length at instruction entry: only instructions know it.
                         r.vec = {
                             len: `d_${a.name}->${f.name}__len`,
+                            items: r.lv,
                             fixed: `sizeof(TSS_${a.kind.struct.name})`,
                             elemSize: a.kind.struct.vec.elemSize,
                             resizable: isWritable(a.kind) && !!this.ix,
@@ -307,7 +310,7 @@ export class StorageEmitter extends EmitterBase {
                 // TypeScript proved the variant set; this runtime check is the backstop.
                 const cond = located.map((l) => `${base.lv}.tag != ${l.vi}`).join(" && ");
                 this.line(`if (${cond}) TS_FAIL(TS_ERR_ENUM_VARIANT, "TypeSOL: ${e.name} is not ${names.join("/")}");`);
-                return { ...base, lv: `${base.lv}.v.${first.name}.${first.f.name}`, type: first.f.type, path: undefined, vec: undefined };
+                return this.withFixedVec({ ...base, lv: `${base.lv}.v.${first.name}.${first.f.name}`, type: first.f.type, path: undefined, vec: undefined });
             }
             if (base && base.type.kind === "option" && base.type.inner.kind === "struct") {
                 const s = this.model.structs.get(base.type.inner.name);
@@ -315,7 +318,7 @@ export class StorageEmitter extends EmitterBase {
                 if (!f)
                     this.fail(node.name, `${s.name} has no field "${field}"`);
                 this.line(`if (!${base.lv}.some) TS_FAIL(TS_ERR_UNWRAP, "TypeSOL: option is empty");`);
-                return { ...base, lv: `${base.lv}.v.${f.name}`, type: f.type, path: undefined, vec: undefined };
+                return this.withFixedVec({ ...base, lv: `${base.lv}.v.${f.name}`, type: f.type, path: undefined, vec: undefined });
             }
             if (base && base.type.kind === "struct") {
                 const s = this.model.structs.get(base.type.name);
@@ -324,9 +327,9 @@ export class StorageEmitter extends EmitterBase {
                     this.fail(node.name, `${s.name} has no field "${field}"`);
                 const r = { ...base, lv: `${base.lv}.${f.name}`, type: f.type, path: base.path && [...base.path, f.name], vec: undefined };
                 // Vecs of loaded accounts can be read and updated in place but not resized (no entry length known).
-                if (f.type.kind === "vec")
-                    r.vec = { len: `${base.lv}.${f.name}__len`, fixed: `sizeof(TSS_${s.name})`, elemSize: s.vec.elemSize, resizable: false };
-                return r;
+                if (f.type.kind === "vec" && f.type.cap === undefined)
+                    r.vec = { len: `${base.lv}.${f.name}__len`, items: r.lv, fixed: `sizeof(TSS_${s.name})`, elemSize: s.vec.elemSize, resizable: false };
+                return this.withFixedVec(r);
             }
             return undefined;
         }
@@ -345,8 +348,9 @@ export class StorageEmitter extends EmitterBase {
             if (base && (base.type.kind === "array" || base.type.kind === "vec")) {
                 if (node.arguments.length !== 1)
                     this.fail(node, "get(index) takes one argument");
-                const idx = this.index(node.arguments[0], base.type.kind === "array" ? `${base.type.len}ULL` : `(uint64_t)${base.vec.len}`);
-                return { ...base, lv: `${base.lv}[${idx}]`, type: base.type.elem, path: undefined, vec: undefined };
+                const idx = this.index(node.arguments[0], base.type.kind === "array" ? `${base.type.len}ULL` : vecCount(base.vec));
+                const lv = base.type.kind === "array" ? `${base.lv}[${idx}]` : `${base.vec.items}[${idx}]`;
+                return this.withFixedVec({ ...base, lv, type: base.type.elem, path: undefined, vec: undefined });
             }
         }
         return undefined;
@@ -475,6 +479,8 @@ export class StorageEmitter extends EmitterBase {
      * required) or by copying another location of the same type.
      */
     writeAggregate(target, valueNode) {
+        if (ts.isParenthesizedExpression(valueNode))
+            return this.writeAggregate(target, valueNode.expression);
         if (target.type.kind === "option" && target.type.inner.kind === "struct") {
             if (valueNode.kind === ts.SyntaxKind.NullKeyword) {
                 this.line(`${target.lv}.some = 0;`);
@@ -534,6 +540,35 @@ export class StorageEmitter extends EmitterBase {
             this.line(`ts_memcpy(&${target.lv}, &${tmp}, sizeof(${tmp}));`);
             return;
         }
+        if (target.type.kind === "vec" && target.type.cap !== undefined && ts.isCallExpression(valueNode) && this.exportName(valueNode.expression) === "fixedVec") {
+            const list = valueNode.arguments[0];
+            if (valueNode.arguments.length !== 1 || !ts.isArrayLiteralExpression(list))
+                this.fail(valueNode, "fixedVec([…]) takes an array literal");
+            return this.writeAggregate(target, list);
+        }
+        if (target.type.kind === "vec" && target.type.cap !== undefined && ts.isArrayLiteralExpression(valueNode)) {
+            // `list = [a, b]`: built in a temporary (the elements may read the old list), the unused slots zeroed.
+            const t = target.type;
+            const els = valueNode.elements;
+            if (els.length > t.cap)
+                this.fail(valueNode, `${els.length} elements do not fit in ${typeName(t)}`);
+            const tmp = this.tmp("fv");
+            this.line(`${fixedVecC(t)} ${tmp};`);
+            this.line(`ts_memzero(&${tmp}, sizeof(${tmp}));`);
+            this.line(`${tmp}.len = ${els.length};`);
+            els.forEach((e, i) => {
+                if (ts.isSpreadElement(e))
+                    this.fail(e, "list the elements one by one");
+                const sub = { lv: `${tmp}.items[${i}]`, type: t.elem, writable: true };
+                const vt = this.storageValueType(t.elem);
+                if (vt)
+                    this.line(this.writeStorage(sub, this.ownedString(this.expect(this.expr(e, vt), vt, e)).c) + ";");
+                else
+                    this.writeAggregate(sub, e);
+            });
+            this.line(`ts_memcpy(&${target.lv}, &${tmp}, sizeof(${tmp}));`);
+            return;
+        }
         if (ts.isObjectLiteralExpression(valueNode)) {
             if (target.type.kind !== "struct")
                 this.fail(valueNode, `expected a ${typeName(target.type)}, not an object literal`);
@@ -575,6 +610,16 @@ export class StorageEmitter extends EmitterBase {
         // Same-typed places are either distinct or identical (`a.p = a.p`); ts_copy skips the latter.
         this.line(`ts_copy(&${target.lv}, &${src.lv}, sizeof(${target.lv}));`);
     }
+    /** The Vec view of a FixedVec stored at `lv` (`{ len, items[cap] }`). */
+    fixedVec(lv, elem, cap) {
+        return { len: `${lv}.len`, items: `${lv}.items`, fixed: "", elemSize: this.fieldBytes(elem), resizable: false, cap };
+    }
+    /** A place whose type is a FixedVec gets its Vec view. */
+    withFixedVec(r) {
+        if (r.type.kind === "vec" && r.type.cap !== undefined)
+            r.vec = this.fixedVec(r.lv, r.type.elem, r.type.cap);
+        return r;
+    }
     /** `arr.get(i)` reads storage rather than calling anything. */
     isStorageCall(node) {
         return ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "get" && !!this.peekArray(node.expression.expression);
@@ -658,8 +703,11 @@ export class StorageEmitter extends EmitterBase {
                 return this.fieldBytes(t.elem) * t.len;
             case "struct":
                 return this.model.structs.get(t.name).size;
-            case "string":
             case "vec":
+                if (t.cap !== undefined)
+                    return 4 + this.fieldBytes(t.elem) * t.cap;
+                throw new Error("unreachable: variable-size field has no fixed size");
+            case "string":
                 throw new Error("unreachable: variable-size field has no fixed size");
         }
     }

package/dist/compiler/idl.js

@@ -1,7 +1,7 @@
 import ts from "typescript";
 import { snakeCase } from "./analyze.js";
 import { decodeAddress } from "../keys.js";
-import { isWritable, optionKey } from "./model.js";
+import { fixedVecName, isWritable, optionKey, typeName, } from "./model.js";
 const SYSTEM_PROGRAM = "11111111111111111111111111111111";
 const TOKEN_PROGRAM = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
 const TOKEN_2022_PROGRAM = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
@@ -37,6 +37,16 @@ const fixedEnumName = (name) => `FixedEnum_${name}`;
  * IDL type of a field or value. `borshOption` picks the encoding of Option: Borsh `option` for
  * instruction arguments and events, the fixed { is_some, value } struct for account data.
  */
+/** IDL type of a @layout borsh account's field: Anchor's own (`string`, `{ vec }`, `{ option }`). */
+function borshIdlType(t) {
+    if (t.kind === "fstring")
+        return "string";
+    if (t.kind === "vec")
+        return { vec: borshIdlType(t.elem) };
+    if (t.kind === "option")
+        return { option: idlType(t.inner) };
+    return idlType(t);
+}
 function idlType(t, borshOption = false) {
     switch (t.kind) {
         case "int":
@@ -62,7 +72,7 @@ function idlType(t, borshOption = false) {
             // Borsh enum in arguments and events; fixed tag + payload in account data.
             return borshOption || t.kind === "dataEnumArg" ? { defined: { name: t.name } } : { defined: { name: fixedEnumName(t.name) } };
         case "vec":
-            return { vec: idlType(t.elem) };
+            return t.cap === undefined ? { vec: idlType(t.elem) } : { defined: { name: fixedVecName(t) } };
         case "vecArg":
             return { vec: idlType(t.elem) };
         case "arrayArg":
@@ -125,7 +135,7 @@ function accountEntry(ix, name, k, programAddress) {
 export function buildIdl(model, address, version = "0.1.0") {
     const structs = [...model.structs.values()];
     const usedStructs = structs.filter((s) => model.accountStructs.has(s.name) || model.events.has(s.name) || s.size !== undefined);
-    return {
+    const idl = {
         address,
         metadata: { name: model.name, version, spec: "0.1.0", description: "Built with TypeSOL" },
         instructions: model.instructions.map((ix) => ({
@@ -148,7 +158,7 @@ export function buildIdl(model, address, version = "0.1.0") {
                     fields: s.fields.map((f) => ({
                         name: snakeCase(f.name),
                         ...docsOf(s.node.members.find((m) => m.name && ts.isIdentifier(m.name) && m.name.text === f.name)),
-                        type: idlType(f.type, model.events.has(s.name) && !model.accountStructs.has(s.name)),
+                        type: s.layout === "borsh" ? borshIdlType(f.type) : idlType(f.type, model.events.has(s.name) && !model.accountStructs.has(s.name)),
                     })),
                 },
             })),
@@ -201,6 +211,17 @@ export function buildIdl(model, address, version = "0.1.0") {
                     ],
                 },
             })),
+            ...[...model.fixedVecs].map(([name, t]) => ({
+                name,
+                docs: [`TypeSOL FixedVec<${typeName(t.elem)}, ${t.cap}>: \`len\` elements in use, room for ${t.cap} (the rest zero or stale).`],
+                type: {
+                    kind: "struct",
+                    fields: [
+                        { name: "len", type: "u32" },
+                        { name: "items", type: { array: [idlType(t.elem), t.cap] } },
+                    ],
+                },
+            })),
             ...[...model.fstrings]
                 .sort((a, b) => a - b)
                 .map((cap) => ({
@@ -216,4 +237,12 @@ export function buildIdl(model, address, version = "0.1.0") {
             })),
         ],
     };
+    // FixedString / FixedVec / FixedOption types only @layout borsh accounts declared (they list theirs as string / vec /
+    // option) are left out.
+    // FixedVecs first: a kept one may name a FixedString.
+    for (const prefix of [/^FixedVec\d/, /^FixedOption_/, /^FixedString\d/]) {
+        const text = JSON.stringify([idl.instructions, idl.types.filter((t) => !prefix.test(t.name))]);
+        idl.types = idl.types.filter((t) => !prefix.test(t.name) || text.includes(`"name":"${t.name}"`));
+    }
+    return idl;
 }