@typesol/cli 0.15.0 → 0.17.0

package/dist/compiler/emit/statements.js

@@ -50,6 +50,8 @@ export class StatementEmitter extends CpiEmitter {
             return this.switchStatement(stmt);
         if (ts.isForStatement(stmt))
             return this.forLoop(stmt);
+        if (ts.isForOfStatement(stmt))
+            return this.forOf(stmt);
         if (ts.isWhileStatement(stmt))
             return this.loop(stmt.expression, stmt.statement, undefined);
         if (ts.isBreakStatement(stmt) || ts.isContinueStatement(stmt)) {
@@ -63,8 +65,8 @@ export class StatementEmitter extends CpiEmitter {
             this.line(ts.isBreakStatement(stmt) ? `break;` : `goto ${this.loops.at(-1)};`);
             return;
         }
-        if (ts.isDoStatement(stmt) || ts.isForOfStatement(stmt) || ts.isForInStatement(stmt))
-            this.fail(stmt, "only for (init; cond; step) and while loops are supported");
+        if (ts.isDoStatement(stmt) || ts.isForInStatement(stmt))
+            this.fail(stmt, "only for (init; cond; step), for (const x of list) and while loops are supported");
         this.fail(stmt, `${ts.SyntaxKind[stmt.kind]} is not supported in TypeSOL`);
     }
     returnStatement(stmt) {
@@ -77,6 +79,25 @@ export class StatementEmitter extends CpiEmitter {
             this.line(`return SUCCESS;`);
             return;
         }
+        if (returns.kind === "struct") {
+            if (!stmt.expression)
+                this.fail(stmt, `return a ${returns.name}`);
+            if (this.helper) {
+                // Write the struct through the caller's out pointer (a literal, a place or another helper's result).
+                this.writeAggregate({ lv: "(*ret)", type: returns, writable: true }, stmt.expression);
+                this.line(`return SUCCESS;`);
+                return;
+            }
+            // Return data: the struct's fixed layout, which the IDL describes field by field.
+            const t = this.tmp("ret");
+            this.line(`TSS_${returns.name} ${t};`);
+            this.writeAggregate({ lv: t, type: returns, writable: true }, stmt.expression);
+            this.line(`sol_set_return_data((const uint8_t *)&${t}, sizeof(${t}));`);
+            for (const l of this.epilogue())
+                this.line(l);
+            this.line(`return SUCCESS;`);
+            return;
+        }
         if (!stmt.expression)
             this.fail(stmt, `return a ${typeName(returns)}`);
         const v = this.expect(this.expr(stmt.expression, returns), returns, stmt.expression);
@@ -170,6 +191,65 @@ export class StatementEmitter extends CpiEmitter {
         });
         this.line(`}`);
     }
+    /**
+     * `for (const x of list)` over a Vec or FixedArray: an index loop that binds `x` as `const x = list.get(i)` would,
+     * so elements are values (scalars, strings) or references into the data (structs), with the same aliasing rules.
+     * As in JS, the length is read again before every step, so a body that pushes or pops sees the new length.
+     */
+    forOf(stmt) {
+        if (stmt.awaitModifier)
+            this.fail(stmt, "for await is not supported");
+        const list = stmt.initializer;
+        const d = ts.isVariableDeclarationList(list) && list.declarations.length === 1 ? list.declarations[0] : undefined;
+        if (!d || !(list.flags & ts.NodeFlags.Const) || !ts.isIdentifier(d.name) || d.type)
+            this.fail(stmt.initializer, "write for (const x of list): one const name, no type annotation");
+        if (this.isRemaining(stmt.expression))
+            this.fail(stmt.expression, "iterate remaining accounts with for (let i = 0n; i < rest.length; i++) and rest.get(i)");
+        // Synthetic `list.length` / `list.get(i)` nodes placed at the loop, so errors and checks point at the source.
+        const f = ts.factory;
+        const index = `__of${this.temp++}`;
+        const place = (n) => {
+            ts.setTextRange(n, stmt.expression);
+            n.parent = stmt;
+            return n;
+        };
+        const indexId = place(f.createIdentifier(index));
+        const length = place(f.createPropertyAccessExpression(stmt.expression, "length"));
+        const get = place(f.createCallExpression(place(f.createPropertyAccessExpression(stmt.expression, "get")), undefined, [indexId]));
+        // The element's declaration: the source's own name (so aliasing checks find its uses) bound to list.get(i).
+        const decl = f.createVariableDeclaration(d.name, undefined, undefined, get);
+        ts.setTextRange(decl, d);
+        decl.parent = list;
+        const declList = { ...list, flags: ts.NodeFlags.Const, declarations: [decl] };
+        const ci = this.tmp("of_i");
+        const label = this.tmp("ts_continue_");
+        this.line(`{`);
+        this.block(() => {
+            this.line(`uint64_t ${ci} = 0;`);
+            this.scopes.at(-1).set(index, { c: ci, type: U64, mutable: false });
+            this.line(`while (1) {`);
+            this.block(() => {
+                const n = this.expect(this.expr(length, U64), U64, stmt.expression);
+                this.line(`if (!(${ci} < ${n.c})) break;`);
+                this.variable(declList);
+                this.loops.push(label);
+                this.line(`{`);
+                this.block(() => this.body(stmt.statement));
+                this.line(`}`);
+                this.loops.pop();
+                this.line(`${label}:;`);
+                this.line(`${ci}++;`);
+            });
+            this.line(`}`);
+        });
+        this.line(`}`);
+    }
+    /** Whether `e` is the remaining accounts (or a const bound to them). */
+    isRemaining(e) {
+        if (ts.isCallExpression(e) && this.exportName(e.expression) === "remainingAccounts")
+            return true;
+        return ts.isIdentifier(e) && this.lookup(e.text)?.type.kind === "remaining";
+    }
     /**
      * `while (1) { cond; if (!cond) break; body; continue_label: step }`. The condition is lowered
      * inside the loop so its checked-arithmetic temporaries are recomputed every iteration.
@@ -204,8 +284,18 @@ export class StatementEmitter extends CpiEmitter {
         if (!(list.flags & (ts.NodeFlags.Const | ts.NodeFlags.Let)))
             this.fail(list, "use const or let, not var");
         for (const d of list.declarations) {
+            if (ts.isObjectBindingPattern(d.name) && d.initializer) {
+                this.destructure(list, d, d.name, d.initializer, topLevel);
+                continue;
+            }
             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`);
@@ -312,6 +402,39 @@ export class StatementEmitter extends CpiEmitter {
             this.scopes.at(-1).set(name, { c, type, mutable });
         }
     }
+    /**
+     * `const { a, b: c } = s`: one declaration per name, `const a = s.a`, in source order. The source must be a name or
+     * a field path (no calls), so reading it once per name reads the same thing JS reads once.
+     */
+    destructure(list, d, pattern, init, topLevel) {
+        if (d.type)
+            this.fail(d.type, "destructuring takes the types from the source; drop the annotation");
+        const plain = (e) => ts.isIdentifier(e) ||
+            (ts.isPropertyAccessExpression(e) && !e.questionDotToken && plain(e.expression)) ||
+            (ts.isParenthesizedExpression(e) && plain(e.expression));
+        if (!plain(init))
+            this.fail(init, "destructure a variable or a field (a.b.c); bind a call to a const first");
+        const f = ts.factory;
+        for (const el of pattern.elements) {
+            if (el.dotDotDotToken)
+                this.fail(el, "...rest is not supported in destructuring");
+            if (el.initializer)
+                this.fail(el, "default values are not supported in destructuring");
+            if (!ts.isIdentifier(el.name))
+                this.fail(el, "nested destructuring is not supported; destructure in two steps");
+            const prop = el.propertyName ?? el.name;
+            if (!ts.isIdentifier(prop))
+                this.fail(el, "use plain field names");
+            const access = f.createPropertyAccessExpression(init, prop.text);
+            ts.setTextRange(access, el);
+            access.parent = d;
+            // The element's own name node, so aliasing checks and the type checker find its uses.
+            const decl = f.createVariableDeclaration(el.name, undefined, undefined, access);
+            ts.setTextRange(decl, el);
+            decl.parent = list;
+            this.variable({ ...list, declarations: [decl] }, topLevel);
+        }
+    }
     expressionStatement(e, topLevel) {
         if (ts.isBinaryExpression(e)) {
             const op = e.operatorToken.kind;
@@ -332,6 +455,8 @@ export class StatementEmitter extends CpiEmitter {
             const base = compound[op];
             if (base !== undefined)
                 return this.assign(e.left, e.right, base);
+            if (op === ts.SyntaxKind.AsteriskAsteriskEqualsToken)
+                this.fail(e.operatorToken, "write x = x ** n instead of **=");
         }
         if ((ts.isPostfixUnaryExpression(e) || ts.isPrefixUnaryExpression(e)) &&
             (e.operator === ts.SyntaxKind.PlusPlusToken || e.operator === ts.SyntaxKind.MinusMinusToken)) {
@@ -379,17 +504,25 @@ 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.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");
         // Whole arrays / structs: copy between identical layouts.
-        const targetRef = isCall ? undefined : this.ref(target);
+        const targetRef = isCall && !structCall ? undefined : this.ref(target);
         if (targetRef &&
             (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));
@@ -407,8 +540,9 @@ export class StatementEmitter extends CpiEmitter {
                 this.fail(valueNode, "this call does not produce a value");
         }
         let value = this.expect(raw ?? this.expr(valueNode, place.type), place.type, valueNode);
-        if (ts.isIdentifier(target))
-            value = this.ownedString(value); // a local keeps its own copy of account text
+        // A local, or a string field of a variable enum (a view), keeps its own copy of account text.
+        if (ts.isIdentifier(target) || (value.type.kind === "string" && this.peekKind(target) === "string"))
+            value = this.ownedString(value);
         this.line(place.write(value.c) + ";");
     }
     /** Whether a place goes through a Vec element (`v.get(i).x`, `v.get(i)`). */
@@ -428,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

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { type FieldType, type ValueType } from "../model.js";
+import { type FieldType, type Helper, type ValueType } from "../model.js";
 import { type Value, type Ref } from "./shared.js";
 import { EmitterBase } from "./base.js";
 /**
@@ -7,6 +7,7 @@ import { EmitterBase } from "./base.js";
  * argument validation.
  */
 export declare abstract class StorageEmitter extends EmitterBase {
+    protected abstract callHelper(node: ts.CallExpression, h: Helper): Value | undefined;
     /** C lines rejecting malformed fixed-layout data at `lv`: bools, enums, option tags, string lengths, enum tags. */
     protected validation(lv: string, t: FieldType, pad: string, fail?: string): string[];
     /** The variants TypeScript has narrowed a data-enum expression to (e.g. inside `if (a.kind === "X")`). */
@@ -66,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
@@ -73,12 +73,13 @@ export class StorageEmitter extends EmitterBase {
         return r?.type.kind === "dataEnum" ? r : undefined;
     }
     looksLikeDataEnum(node) {
-        const saved = { lines: this.lines.length, temp: this.temp, diagnostics: this.reporter.diagnostics.length };
+        const saved = { lines: this.lines.length, hoisted: this.hoisted.length, temp: this.temp, diagnostics: this.reporter.diagnostics.length };
         try {
             return this.reporter.guard(() => this.ref(node))?.type.kind === "dataEnum";
         }
         finally {
             this.lines.length = saved.lines;
+            this.hoisted.length = saved.hoisted; // a probed helper call may hoist declarations
             this.temp = saved.temp;
             this.reporter.diagnostics.length = saved.diagnostics;
         }
@@ -144,7 +145,7 @@ export class StorageEmitter extends EmitterBase {
         // Loops around `at` that do not also contain the declaration run their earlier statements again later.
         let loop;
         for (let n = at.parent; n && n !== decl.parent; n = n.parent)
-            if ((ts.isForStatement(n) || ts.isWhileStatement(n) || ts.isDoStatement(n)) && !(decl.pos >= n.pos && decl.end <= n.end))
+            if ((ts.isForStatement(n) || ts.isForOfStatement(n) || ts.isWhileStatement(n) || ts.isDoStatement(n)) && !(decl.pos >= n.pos && decl.end <= n.end))
                 loop = n;
         let found = false;
         const scope = decl.parent.parent.parent; // VariableDeclaration -> List -> Statement -> enclosing block
@@ -207,13 +208,14 @@ export class StorageEmitter extends EmitterBase {
             return this.looksLikeStructPlace(node.expression);
         if (ts.isConditionalExpression(node))
             return this.looksLikeStructPlace(node.whenTrue) && this.looksLikeStructPlace(node.whenFalse);
-        const saved = { lines: this.lines.length, temp: this.temp, diagnostics: this.reporter.diagnostics.length };
+        const saved = { lines: this.lines.length, hoisted: this.hoisted.length, temp: this.temp, diagnostics: this.reporter.diagnostics.length };
         try {
             const r = this.reporter.guard(() => this.ref(node));
             return r?.type.kind === "struct";
         }
         finally {
             this.lines.length = saved.lines;
+            this.hoisted.length = saved.hoisted; // a probed helper call may hoist declarations
             this.temp = saved.temp;
             this.reporter.diagnostics.length = saved.diagnostics;
         }
@@ -241,6 +243,14 @@ export class StorageEmitter extends EmitterBase {
         if (ts.isParenthesizedExpression(node))
             return this.ref(node.expression);
         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.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 };
+            }
+        }
         if (ts.isIdentifier(node)) {
             const l = this.lookup(node.text);
             if (l && l.type.kind === "array")
@@ -263,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,
@@ -284,7 +297,9 @@ export class StorageEmitter extends EmitterBase {
                     const vi = e.variants.findIndex((v) => v.name === n);
                     const fields = e.variants[vi]?.fields ?? [];
                     const at = fields.findIndex((x) => x.name === field);
-                    const offset = fields.slice(0, Math.max(at, 0)).reduce((sum, x) => sum + this.fieldBytes(x.type), 0);
+                    // In the C payload a string is a TS_Str view (16 bytes); everything else has its stored size.
+                    const cBytes = (t) => (t.kind === "string" ? 16 : this.fieldBytes(t));
+                    const offset = fields.slice(0, Math.max(at, 0)).reduce((sum, x) => sum + cBytes(x.type), 0);
                     return { vi, name: n, f: fields[at], offset };
                 });
                 if (located.some((l) => !l.f))
@@ -295,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);
@@ -303,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);
@@ -312,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;
         }
@@ -333,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;
@@ -412,6 +428,8 @@ export class StorageEmitter extends EmitterBase {
                 return { c: `(&${r.lv})`, type: r.type };
             case "fstring":
                 return { c: `ts_fstr_view((const uint8_t *)&${r.lv}, ${r.type.cap})`, type: STRING };
+            case "string":
+                return { c: r.lv, type: STRING }; // a variable enum's text: already a view
             case "enum":
                 return { c: r.lv, type: r.type };
             case "option":
@@ -439,6 +457,7 @@ export class StorageEmitter extends EmitterBase {
                 return `${r.lv} = *(${c})`;
             case "fstring":
                 return `TS_TRY(ts_fstr_set((uint8_t *)&${r.lv}, ${r.type.cap}, ${c}))`;
+            case "string":
             case "enum":
             case "option":
                 return `${r.lv} = ${c}`;
@@ -449,7 +468,7 @@ export class StorageEmitter extends EmitterBase {
     storageValueType(t) {
         if (isScalar(t))
             return t;
-        if (t.kind === "fstring")
+        if (t.kind === "fstring" || t.kind === "string")
             return STRING;
         if (t.kind === "option" && t.inner.kind !== "struct")
             return t;
@@ -460,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;`);
@@ -510,14 +531,44 @@ export class StorageEmitter extends EmitterBase {
                 const f = variant.fields.find((x) => x.name === name);
                 const sub = { lv: `${tmp}.v.${variant.name}.${f.name}`, type: f.type, writable: true };
                 const vt = this.storageValueType(f.type);
+                // A string kept in a variable enum holds its own copy of account text (the account may change later).
                 if (vt)
-                    this.line(this.writeStorage(sub, this.expect(this.expr(ex, vt), vt, ex).c) + ";");
+                    this.line(this.writeStorage(sub, this.ownedString(this.expect(this.expr(ex, vt), vt, ex)).c) + ";");
                 else
                     this.writeAggregate(sub, ex);
             }
             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`);
@@ -559,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);
@@ -570,12 +631,13 @@ export class StorageEmitter extends EmitterBase {
     }
     /** The kind of storage an expression names (struct, array, dataEnum…), without emitting code or failing. */
     peekKind(node) {
-        const saved = { lines: this.lines.length, temp: this.temp, diagnostics: this.reporter.diagnostics.length };
+        const saved = { lines: this.lines.length, hoisted: this.hoisted.length, temp: this.temp, diagnostics: this.reporter.diagnostics.length };
         try {
             return this.reporter.guard(() => this.ref(node))?.type.kind;
         }
         finally {
             this.lines.length = saved.lines;
+            this.hoisted.length = saved.hoisted; // a probed helper call may hoist declarations
             this.temp = saved.temp;
             this.reporter.diagnostics.length = saved.diagnostics;
         }
@@ -641,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,33 +158,47 @@ 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)),
                     })),
                 },
             })),
             ...[...model.enums.values()].map((e) => ({ name: e.name, type: { kind: "enum", variants: e.variants.map((v) => ({ name: v })) } })),
+            // A variable enum (it holds strings) only exists in Borsh: no fixed account-data form to describe.
             ...[...model.dataEnums.values()].flatMap((e) => [
                 {
                     name: e.name,
                     ...docsOf(e.node),
                     type: {
                         kind: "enum",
-                        variants: e.variants.map((v) => v.fields.length ? { name: v.name, fields: v.fields.map((f) => ({ name: snakeCase(f.name), type: idlType(f.type) })) } : { name: v.name }),
-                    },
-                },
-                {
-                    name: fixedEnumName(e.name),
-                    docs: [
-                        `TypeSOL ${e.name} in account data: \`tag\` is the variant index, \`payload\` the variant's fields (Borsh layout) padded to the largest variant.`,
-                    ],
-                    type: {
-                        kind: "struct",
-                        fields: [
-                            { name: "tag", type: "u8" },
-                            { name: "payload", type: { array: ["u8", e.payload] } },
-                        ],
+                        variants: e.variants.map((v) => v.fields.length
+                            ? {
+                                name: v.name,
+                                // A nested variable enum only exists in Borsh; fixed fields keep the fixed forms the bytes use.
+                                fields: v.fields.map((f) => ({
+                                    name: snakeCase(f.name),
+                                    type: f.type.kind === "dataEnum" && model.dataEnums.get(f.type.name)?.variable ? { defined: { name: f.type.name } } : idlType(f.type),
+                                })),
+                            }
+                            : { name: v.name }),
                     },
                 },
+                ...(e.variable
+                    ? []
+                    : [
+                        {
+                            name: fixedEnumName(e.name),
+                            docs: [
+                                `TypeSOL ${e.name} in account data: \`tag\` is the variant index, \`payload\` the variant's fields (Borsh layout) padded to the largest variant.`,
+                            ],
+                            type: {
+                                kind: "struct",
+                                fields: [
+                                    { name: "tag", type: "u8" },
+                                    { name: "payload", type: { array: ["u8", e.payload] } },
+                                ],
+                            },
+                        },
+                    ]),
             ]),
             ...[...model.options.values()].map((inner) => ({
                 name: fixedOptionName(inner),
@@ -187,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) => ({
@@ -202,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;
 }