@typesol/cli 0.15.0 → 0.17.0

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

@@ -23,6 +23,17 @@ export declare abstract class ExpressionEmitter extends StorageEmitter {
     protected textOfInt(name: IntName, c: string, out: string): string;
     /** `c ? a : b` on values: only the chosen branch runs (its checks and side effects included). */
     protected conditional(node: ts.ConditionalExpression, hint?: ValueType): Value;
+    /**
+     * `a ?? b` on an Option: a's value when it has one, else b, which runs only then (as in JS). The result is an
+     * Option itself when b can be null.
+     */
+    protected nullish(node: ts.BinaryExpression, hint?: ValueType): Value;
+    /**
+     * `a ** b` on integers, every multiplication checked (5100 on overflow, like `*`). A literal exponent unrolls by
+     * squaring at compile time; otherwise a square-and-multiply loop runs, squaring only while bits remain (a square
+     * that overflows then would make the result overflow too). A negative exponent aborts, as JS throws a RangeError.
+     */
+    protected power(node: ts.BinaryExpression, hint?: ValueType): Value;
     protected binary(node: ts.BinaryExpression, hint?: ValueType): Value;
     /** Checked integer arithmetic into a fresh temporary. */
     protected arith(op: ts.BinaryOperator, left: Value, right: Value, node: ts.Node): Value;

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,27 @@ 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);
+            if (v.type.kind !== "option")
+                this.fail(node, "! works on Option values; check optional accounts with `x !== null`");
+            return this.unwrap(v, node);
+        }
         this.noOptionalChain(node);
         if (ts.isBigIntLiteral(node)) {
             const value = BigInt(node.text.slice(0, -1).replace(/_/g, ""));
@@ -133,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))
@@ -195,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")
@@ -406,9 +430,10 @@ export class ExpressionEmitter extends StorageEmitter {
             (ts.isBigIntLiteral(node.whenFalse) || ts.isPrefixUnaryExpression(node.whenFalse));
         if (!type && !bothLiteral && (ts.isBigIntLiteral(node.whenTrue) || node.whenTrue.kind === ts.SyntaxKind.NullKeyword)) {
             // Type the non-literal branch first, without emitting it, to give the literal its type.
-            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 };
             const probe = this.reporter.guard(() => this.expr(node.whenFalse));
             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;
             if (probe && probe.literal === undefined && !probe.isNull)
@@ -434,11 +459,108 @@ export class ExpressionEmitter extends StorageEmitter {
         this.lines[declAt] = this.lines[declAt].replace(`/* ${t} */`, `${vt.kind === "pubkey" ? "SolPubkey" : valueC(vt)} ${t};`);
         return vt.kind === "pubkey" ? { c: `(&${t})`, type: vt } : { c: t, type: vt };
     }
+    /**
+     * `a ?? b` on an Option: a's value when it has one, else b, which runs only then (as in JS). The result is an
+     * Option itself when b can be null.
+     */
+    nullish(node, hint) {
+        const left = this.expr(node.left, hint?.kind === "option" ? hint : hint ? { kind: "option", inner: hint } : undefined);
+        if (left.isNull)
+            return this.expect(this.expr(node.right, hint), hint, node.right);
+        if (left.type.kind !== "option")
+            return left; // never null: JS never evaluates b
+        const inner = left.type.inner;
+        if (inner.kind === "struct")
+            this.fail(node, "?? works on Options of integers, booleans and Pubkeys");
+        const nullable = (t) => !!(t.flags & ts.TypeFlags.Null) || (t.isUnion() && t.types.some(nullable));
+        const type = hint ?? (nullable(this.checker.getTypeAtLocation(node)) ? left.type : inner);
+        const lo = this.tmp("opt");
+        this.line(`${optC(inner)} ${lo} = ${left.c};`);
+        const t = this.tmp("nn");
+        this.line(`${type.kind === "pubkey" ? "SolPubkey" : valueC(type)} ${t};`);
+        const set = (v) => this.line(v.type.kind === "pubkey" ? `${t} = *(${v.c});` : `${t} = ${v.c};`);
+        this.line(`if (${lo}.some) {`);
+        this.block(() => {
+            const some = inner.kind === "pubkey"
+                ? { c: `(&${lo}.v)`, type: inner }
+                : inner.kind === "bool"
+                    ? { c: `(${lo}.v != 0)`, type: inner }
+                    : { c: `${lo}.v`, type: inner };
+            set(this.expect(some, type, node.left));
+        });
+        this.line(`} else {`);
+        this.block(() => set(this.expect(this.expr(node.right, type), type, node.right)));
+        this.line(`}`);
+        return type.kind === "pubkey" ? { c: `(&${t})`, type } : { c: t, type };
+    }
+    /**
+     * `a ** b` on integers, every multiplication checked (5100 on overflow, like `*`). A literal exponent unrolls by
+     * squaring at compile time; otherwise a square-and-multiply loop runs, squaring only while bits remain (a square
+     * that overflows then would make the result overflow too). A negative exponent aborts, as JS throws a RangeError.
+     */
+    power(node, hint) {
+        let base = this.expr(node.left, hint?.kind === "int" ? hint : undefined);
+        const mark = this.lines.length;
+        const exp = this.expr(node.right);
+        // JS reads the base first: if the exponent ran statements (a helper that changes it), use the value read before.
+        base = this.settle(base, mark);
+        if (base.literal !== undefined)
+            base = this.literal(base.literal, hint?.kind === "int" ? hint : U64, node.left);
+        if (base.type.kind !== "int")
+            this.fail(node.left, "** needs an integer base");
+        const type = base.type;
+        const ct = INT_INFO[type.name].c;
+        const K = ts.SyntaxKind;
+        if (exp.literal !== undefined) {
+            if (exp.literal < 0n)
+                this.fail(node.right, "the exponent of ** cannot be negative");
+            if (exp.literal > 255n)
+                this.fail(node.right, "the exponent of ** must be at most 255 when it is a literal (larger ones always overflow unless the base is 0 or 1)");
+            const n = exp.literal;
+            if (n === 0n)
+                return this.literal(1n, type, node);
+            // Bits from high to low: square, then multiply by the base when the bit is set.
+            const b = this.tmp("pb");
+            this.line(`${ct} ${b} = ${base.c};`);
+            let acc = { c: b, type };
+            const bits = n.toString(2);
+            for (const bit of bits.slice(1)) {
+                acc = this.arith(K.AsteriskToken, acc, acc, node);
+                if (bit === "1")
+                    acc = this.arith(K.AsteriskToken, acc, { c: b, type }, node);
+            }
+            return acc;
+        }
+        if (exp.type.kind !== "int")
+            this.fail(node.right, "the exponent of ** must be an integer");
+        const r = this.tmp("pr");
+        const sq = this.tmp("ps");
+        const e = this.tmp("pe");
+        this.line(`${ct} ${r} = 1;`);
+        this.line(`${ct} ${sq} = ${base.c};`);
+        if (INT_INFO[exp.type.name].signed)
+            this.line(`if (${exp.c} < 0) TS_FAIL(TS_ERR_OVERFLOW, "TypeSOL: negative exponent");`);
+        this.line(`${INT_INFO[exp.type.name].bytes === 16 ? "unsigned __int128" : "uint64_t"} ${e} = (${INT_INFO[exp.type.name].bytes === 16 ? "unsigned __int128" : "uint64_t"})(${exp.c});`);
+        this.line(`while (${e}) {`);
+        this.block(() => {
+            this.line(`if (${e} & 1) {`);
+            this.block(() => this.line(`${r} = ${this.arith(K.AsteriskToken, { c: r, type }, { c: sq, type }, node).c};`));
+            this.line(`}`);
+            this.line(`${e} >>= 1;`);
+            this.line(`if (${e}) {`);
+            this.block(() => this.line(`${sq} = ${this.arith(K.AsteriskToken, { c: sq, type }, { c: sq, type }, node).c};`));
+            this.line(`}`);
+        });
+        this.line(`}`);
+        return { c: r, type };
+    }
     binary(node, hint) {
         const op = node.operatorToken.kind;
         const K = ts.SyntaxKind;
         if (op === K.AsteriskAsteriskToken)
-            this.fail(node.operatorToken, "** is not supported; multiply, or use mulDiv/isqrt");
+            return this.power(node, hint);
+        if (op === K.QuestionQuestionToken)
+            return this.nullish(node, hint);
         if (op === K.AmpersandAmpersandToken || op === K.BarBarToken) {
             const left = this.expect(this.expr(node.left, BOOL), BOOL, node.left);
             const t = this.tmp();

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};`);
@@ -224,8 +235,18 @@ export class FunctionEmitter extends StatementEmitter {
                 e.variants.forEach((variant, i) => {
                     head.push(`  case ${i}: {`);
                     for (const f of variant.fields) {
+                        if (f.type.kind === "string") {
+                            // Borsh String: u32 length, then UTF-8 bytes, kept as a view of the instruction data.
+                            const lv = `${v}.v.${variant.name}.${f.name}`;
+                            head.push(`    if (params->data_len < off + 4) TS_FAIL(TS_ERR_INSTRUCTION_DATA, "TypeSOL: instruction data too short");`);
+                            head.push(`    { uint32_t n = (uint32_t)ts_read_le(params->data + off, 4); off += 4;`);
+                            head.push(`      if (params->data_len < off + n) TS_FAIL(TS_ERR_INSTRUCTION_DATA, "TypeSOL: instruction data too short");`);
+                            head.push(`      ${lv} = ts_str(params->data + off, n); off += n; }`);
+                            head.push(`    if (!ts_utf8_valid(${lv}.ptr, ${lv}.len)) TS_FAIL(TS_ERR_INSTRUCTION_DATA, "TypeSOL: invalid UTF-8 in a string argument");`);
+                            continue;
+                        }
                         if (!isScalar(f.type))
-                            this.reporter.fail(a.node, `${e.name}.${variant.name}.${f.name}: enum arguments carry integers, booleans, Pubkeys and enums`);
+                            this.reporter.fail(a.node, `${e.name}.${variant.name}.${f.name}: enum arguments carry integers, booleans, Pubkeys, enums and strings`);
                         const size = scalarSize(f.type);
                         head.push(`    if (params->data_len < off + ${size}) TS_FAIL(TS_ERR_INSTRUCTION_DATA, "TypeSOL: instruction data too short");`);
                         head.push(`    ts_memcpy(&${v}.v.${variant.name}.${f.name}, params->data + off, ${size});`, `    off += ${size};`);
@@ -275,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,11 +119,14 @@ 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}[]`)}`;
         case "string":
-            throw new Error("unreachable: variable strings are not stored");
+            // Only in a variable data enum's payload (arguments, events, locals): a view of the text.
+            return `TS_Str ${name}`;
     }
 }
 /** Why an account of kind `have` cannot be passed where a helper takes `want`, or undefined when it can. */
@@ -174,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")
@@ -186,6 +196,14 @@ export function helperSignature(h) {
             params.push(`${valueC(p.type)} p_${p.name}`);
     }
     if (h.returns)
-        params.push(`${scalarC(h.returns)} *ret`);
+        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.d.ts

@@ -10,6 +10,14 @@ export declare abstract class StatementEmitter extends CpiEmitter {
     /** `switch` on integers, enums and `.kind` of data enums: a C switch, with JS fallthrough/break semantics. */
     protected switchStatement(stmt: ts.SwitchStatement): void;
     protected forLoop(stmt: ts.ForStatement): void;
+    /**
+     * `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.
+     */
+    protected forOf(stmt: ts.ForOfStatement): void;
+    /** Whether `e` is the remaining accounts (or a const bound to them). */
+    protected isRemaining(e: ts.Expression): boolean;
     /**
      * `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.
@@ -17,6 +25,11 @@ export declare abstract class StatementEmitter extends CpiEmitter {
     protected loop(cond: ts.Expression | undefined, body: ts.Statement, step: ts.Expression | undefined): void;
     protected body(stmt: ts.Statement): void;
     protected variable(list: ts.VariableDeclarationList, topLevel?: boolean): void;
+    /**
+     * `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.
+     */
+    protected destructure(list: ts.VariableDeclarationList, d: ts.VariableDeclaration, pattern: ts.ObjectBindingPattern, init: ts.Expression, topLevel: boolean): void;
     protected expressionStatement(e: ts.Expression, topLevel: boolean): void;
     protected assign(target: ts.Expression, valueNode: ts.Expression, op?: ts.BinaryOperator, topLevel?: boolean): void;
     /** Whether a place goes through a Vec element (`v.get(i).x`, `v.get(i)`). */