@typesol/cli 0.16.0 → 0.18.0

package/dist/compiler/emit/statements.js

@@ -1,7 +1,7 @@
 import ts from "typescript";
-import { resolveValueType } from "../analyze.js";
-import { INT_INFO, isWritable, scalarSize, typeName } from "../model.js";
-import { U64, BOOL, cString, scalarC, scalarStorageC, valueC } from "./shared.js";
+import { MAX_RETURN_DATA, resolveValueType, structNameOf } from "../analyze.js";
+import { INT_INFO, isWritable, optionKey, scalarSize, typeName } from "../model.js";
+import { U64, BOOL, cString, optC, scalarC, scalarStorageC, valueC } from "./shared.js";
 import { CpiEmitter } from "./cpi.js";
 /**
  * Statements: variables, assignment, control flow and return.
@@ -65,11 +65,16 @@ export class StatementEmitter extends CpiEmitter {
             this.line(ts.isBreakStatement(stmt) ? `break;` : `goto ${this.loops.at(-1)};`);
             return;
         }
-        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");
+        if (ts.isDoStatement(stmt))
+            return this.doLoop(stmt);
+        if (ts.isForInStatement(stmt))
+            this.fail(stmt, "for … in is not supported: use for (init; cond; step), for (const x of list), while or do … while");
         this.fail(stmt, `${ts.SyntaxKind[stmt.kind]} is not supported in TypeSOL`);
     }
     returnStatement(stmt) {
+        const frame = this.inlineFrames.at(-1);
+        if (frame)
+            return this.closureReturn(stmt, frame);
         const returns = this.helper ? this.helper.returns : this.ix.returns;
         if (!returns) {
             if (stmt.expression)
@@ -92,7 +97,18 @@ export class StatementEmitter extends CpiEmitter {
             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}));`);
+            if (this.model.structs.get(returns.name).layout === "borsh") {
+                // A @layout borsh struct returns its Borsh bytes, as Anchor's return data does.
+                const b = this.tmp("retb");
+                const w = this.tmp("retw");
+                this.line(`uint8_t *${b};`);
+                this.line(`TS_TRY(ts_alloc(sizeof(${t}), &${b}));`);
+                this.line(`uint64_t ${w} = 0;`);
+                this.line(`TS_TRY(ts_pack_${returns.name}(&${t}, ${b}, sizeof(${t}), &${w}));`);
+                this.line(`sol_set_return_data(${b}, ${w});`);
+            }
+            else
+                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;`);
@@ -101,8 +117,24 @@ export class StatementEmitter extends CpiEmitter {
         if (!stmt.expression)
             this.fail(stmt, `return a ${typeName(returns)}`);
         const v = this.expect(this.expr(stmt.expression, returns), returns, stmt.expression);
-        if (this.helper)
+        if (this.helper && returns.kind === "string") {
+            // The caller gets its own copy: the text may be account data the caller then changes.
+            this.line(`TS_TRY(ts_str_copy(${v.c}, ret));`);
+        }
+        else if (this.helper)
             this.line(returns.kind === "pubkey" ? `*ret = *(${v.c});` : `*ret = ${v.c};`);
+        else if (returns.kind === "string") {
+            // Return data is the Borsh String: u32 length, then the bytes (at most 1024 in all).
+            const s = this.tmp("rets");
+            const b = this.tmp("retb");
+            this.line(`TS_Str ${s} = ${v.c};`);
+            this.line(`if (${s}.len > ${MAX_RETURN_DATA - 4}) TS_FAIL(TS_ERR_INSTRUCTION_DATA, "TypeSOL: returned string longer than ${MAX_RETURN_DATA - 4} bytes");`);
+            this.line(`uint8_t *${b};`);
+            this.line(`TS_TRY(ts_alloc(4 + ${s}.len, &${b}));`);
+            this.line(`ts_write_le(${b}, ${s}.len, 4);`);
+            this.line(`ts_memcpy(${b} + 4, ${s}.ptr, ${s}.len);`);
+            this.line(`sol_set_return_data(${b}, 4 + ${s}.len);`);
+        }
         else if (returns.kind === "pubkey")
             this.line(`sol_set_return_data((const uint8_t *)(${v.c}), 32);`);
         else {
@@ -146,11 +178,16 @@ export class StatementEmitter extends CpiEmitter {
         const typed = subject.literal !== undefined ? this.literal(subject.literal, U64, stmt.expression) : subject;
         if (typed.type.kind !== "int" && typed.type.kind !== "enum")
             this.fail(stmt.expression, "switch works on integers and enums");
-        if (typed.type.kind === "int" && INT_INFO[typed.type.name].bytes === 16)
-            this.fail(stmt.expression, "switch on 128-bit integers is not supported; use if/else");
+        // C cannot switch on 128-bit values: pick the case's index with comparisons, then switch on that.
+        const wide = typed.type.kind === "int" && INT_INFO[typed.type.name].bytes === 16;
         const t = this.tmp("sw");
         this.line(`${scalarC(typed.type)} ${t} = ${typed.c};`);
-        this.line(`switch (${t}) {`);
+        const pick = wide ? this.tmp("swi") : undefined;
+        const pickAt = this.lines.length;
+        const cases = [];
+        if (pick)
+            this.line(`int ${pick} = -1;`);
+        this.line(`switch (${pick ?? t}) {`);
         const seen = new Set();
         for (const clause of stmt.caseBlock.clauses) {
             if (ts.isCaseClause(clause)) {
@@ -166,7 +203,12 @@ export class StatementEmitter extends CpiEmitter {
                 if (seen.has(label.c))
                     this.fail(clause.expression, "duplicate case");
                 seen.add(label.c);
-                this.line(`case ${label.c}: {`);
+                if (pick) {
+                    cases.push(label.c);
+                    this.line(`case ${cases.length - 1}: {`);
+                }
+                else
+                    this.line(`case ${label.c}: {`);
             }
             else
                 this.line(`default: {`);
@@ -176,6 +218,10 @@ export class StatementEmitter extends CpiEmitter {
             this.line(`}`);
         }
         this.line(`}`);
+        if (pick && cases.length) {
+            const pad = "  ".repeat(this.indent);
+            this.lines.splice(pickAt + 1, 0, ...cases.map((c, i) => `${pad}${i ? "else " : ""}if (${t} == ${c}) ${pick} = ${i};`));
+        }
     }
     forLoop(stmt) {
         this.line(`{`);
@@ -273,6 +319,290 @@ export class StatementEmitter extends CpiEmitter {
         });
         this.line(`}`);
     }
+    /**
+     * Expand a closure where it is called: the arguments are evaluated here, in order, into the parameters (scalars,
+     * Pubkeys and strings by value, structs by reference, as JS passes objects); the body then runs with the names it
+     * was declared with, so a block around the call that declares the same name does not change what it reads, and
+     * writes to captured `let`s are seen by the enclosing function. Returns the result (undefined for no value).
+     */
+    expandClosure(c, args, node) {
+        const fn = c.node;
+        if (this.inlining.has(fn))
+            this.fail(node, `${c.name} calls itself: closures cannot be recursive`);
+        if (args.length !== fn.parameters.length)
+            this.fail(node, `${c.name}() takes ${fn.parameters.length} argument(s)`);
+        const params = new Map();
+        fn.parameters.forEach((p, i) => {
+            if (!ts.isIdentifier(p.name) || p.initializer || p.dotDotDotToken)
+                this.fail(p, "closure parameters are plain names");
+            const arg = args[i];
+            const name = p.name.text;
+            const c2 = `l_${name}_${this.temp++}`;
+            const annotated = p.type ? resolveValueType(p.type, this.scope) : undefined;
+            if (!annotated && this.looksLikeStructPlace(arg)) {
+                const place = this.structPlace(arg);
+                this.line(`TSS_${place.struct} *${c2} = ${place.ptr};`);
+                params.set(name, { c: c2, type: { kind: "structRef", struct: place.struct, writable: place.writable }, mutable: false, paths: this.pathsOf(arg) });
+                return;
+            }
+            let v = this.expr(arg, annotated);
+            if (v.isNull && !annotated)
+                this.fail(arg, "give the parameter a type to pass null");
+            if (v.literal !== undefined && !annotated)
+                v = this.literal(v.literal, U64, arg);
+            const type = annotated ?? v.type;
+            v = this.expect(v, type, arg);
+            if (type.kind === "pubkey")
+                this.line(`SolPubkey ${c2} = *(${v.c});`);
+            else
+                this.line(`${valueC(type)}${type.kind === "account" ? "" : " "}${c2} = ${this.ownedString(v).c};`);
+            params.set(name, { c: c2, type, mutable: true });
+        });
+        const declared = fn.type && fn.type.kind !== ts.SyntaxKind.VoidKeyword ? resolveValueType(fn.type, this.scope) : undefined;
+        if (fn.type && fn.type.kind !== ts.SyntaxKind.VoidKeyword && !declared)
+            this.fail(fn.type, "closures return integers, booleans, Pubkeys, strings, enums or Options");
+        const frame = {
+            label: this.tmp("ts_ret_"),
+            result: this.tmp("ret"),
+            type: declared,
+            declAt: this.lines.length,
+            pad: "  ".repeat(this.indent),
+            node: fn,
+        };
+        this.line(declared ? `${declared.kind === "pubkey" ? "SolPubkey" : valueC(declared)} ${frame.result};` : `/* ${frame.result} */`);
+        const saved = { scopes: this.scopes, loops: this.loops.splice(0) };
+        this.scopes = [...c.scopes, params];
+        this.inlining.add(fn);
+        this.inlineFrames.push(frame);
+        try {
+            this.line(`{`);
+            this.block(() => {
+                const body = fn.body;
+                if (ts.isBlock(body))
+                    body.statements.forEach((s) => this.reporter.guard(() => this.statement(s)));
+                else {
+                    // An expression body: its value is the result (a call may have none).
+                    const ret = ts.factory.createReturnStatement(body);
+                    ts.setTextRange(ret, body);
+                    ret.parent = fn;
+                    if (ts.isCallExpression(body) && !frame.type) {
+                        const v = this.call(body, false);
+                        if (v)
+                            this.closureResult(v, body, frame);
+                    }
+                    else
+                        this.closureReturn(ret, frame);
+                }
+            });
+            this.line(`}`);
+            this.line(`${frame.label}:;`);
+        }
+        finally {
+            this.inlineFrames.pop();
+            this.inlining.delete(fn);
+            this.scopes = saved.scopes;
+            this.loops.push(...saved.loops);
+        }
+        if (!frame.type) {
+            if (this.lines[frame.declAt].includes(`/* ${frame.result} */`))
+                this.lines[frame.declAt] = "";
+            return undefined;
+        }
+        return frame.type.kind === "pubkey" ? { c: `(&${frame.result})`, type: frame.type } : { c: frame.result, type: frame.type };
+    }
+    /**
+     * `xs.forEach / some / every / find / findIndex / reduce / includes / indexOf` on a Vec, FixedArray, FixedVec or Vec
+     * argument: an index loop (the length read each step, as `for … of`), the callback (an arrow written at the call)
+     * expanded with each element as `xs.get(i)` gives it (structs by reference) and, if it takes one, the index.
+     * `find` gives an Option of the element (scalar elements), `findIndex` / `indexOf` an i64 (-1 when absent).
+     */
+    listMethod(node, method) {
+        const access = node.expression;
+        const list = access.expression;
+        const args = node.arguments;
+        const f = ts.factory;
+        const place = (n) => {
+            ts.setTextRange(n, node);
+            n.parent = node;
+            return n;
+        };
+        const valueForm = method === "includes" || method === "indexOf";
+        if (args.length !== (method === "reduce" ? 2 : 1))
+            this.fail(node, method === "reduce" ? "reduce(callback, initial) takes two arguments" : `${method}() takes one argument`);
+        const cb = args[0];
+        if (!valueForm && !ts.isArrowFunction(cb) && !ts.isFunctionExpression(cb))
+            this.fail(cb, `pass ${method} an arrow function written here: xs.${method}((x) => …)`);
+        const fn = cb;
+        const index = `__lm${this.temp++}`;
+        const indexId = place(f.createIdentifier(index));
+        const length = place(f.createPropertyAccessExpression(list, "length"));
+        const element = place(f.createCallExpression(place(f.createPropertyAccessExpression(list, "get")), undefined, [indexId]));
+        const I64 = { kind: "int", name: "i64" };
+        // The result, declared before the loop.
+        const res = this.tmp("lm");
+        let result;
+        let elemType;
+        let accType;
+        let needle;
+        if (method === "some" || method === "includes")
+            (this.line(`bool ${res} = false;`), (result = { c: res, type: BOOL }));
+        if (method === "every")
+            (this.line(`bool ${res} = true;`), (result = { c: res, type: BOOL }));
+        if (method === "findIndex" || method === "indexOf")
+            (this.line(`int64_t ${res} = -1;`), (result = { c: res, type: I64 }));
+        if (method === "reduce") {
+            const accParam = fn.parameters[0];
+            const annotated = accParam?.type ? resolveValueType(accParam.type, this.scope) : undefined;
+            let init = this.expr(args[1], annotated);
+            if (init.literal !== undefined && !annotated)
+                init = this.literal(init.literal, U64, args[1]);
+            accType = annotated ?? init.type;
+            init = this.expect(init, accType, args[1]);
+            if (!["int", "bool", "pubkey", "string", "enum", "option"].includes(accType.kind))
+                this.fail(args[1], `reduce accumulates integers, booleans, Pubkeys, strings, enums or Options, not ${typeName(accType)}`);
+            this.line(accType.kind === "pubkey" ? `SolPubkey ${res} = *(${init.c});` : `${valueC(accType)} ${res} = ${this.ownedString(init).c};`);
+            result = accType.kind === "pubkey" ? { c: `(&${res})`, type: accType } : { c: res, type: accType };
+        }
+        if (valueForm) {
+            // The value looked for, read once, compared with === (scalars and strings).
+            const v = this.expr(cb);
+            needle = `__lv${this.temp++}`;
+            const t = this.tmp("needle");
+            const vt = v.literal !== undefined ? U64 : v.type;
+            if (!["int", "bool", "pubkey", "string", "enum"].includes(vt.kind))
+                this.fail(cb, `${method} compares integers, booleans, Pubkeys, strings or enums`);
+            const typed = v.literal !== undefined ? v : this.expect(v, vt, cb);
+            this.line(vt.kind === "pubkey" ? `SolPubkey ${t} = *(${typed.c});` : `${valueC(vt)} ${t} = ${typed.c};`);
+            this.scopes.at(-1).set(needle, { c: t, type: vt, mutable: false });
+        }
+        if (method === "find") {
+            // Typed from the first element read inside the loop; declared here.
+            result = { c: res, type: BOOL };
+            this.line(`/* ${res} */`);
+        }
+        const findDecl = method === "find" ? this.lines.length - 1 : -1;
+        const ci = this.tmp("lm_i");
+        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, list);
+                this.line(`if (!(${ci} < ${n.c})) break;`);
+                if (valueForm) {
+                    const eq = place(f.createBinaryExpression(element, ts.SyntaxKind.EqualsEqualsEqualsToken, place(f.createIdentifier(needle))));
+                    const hit = this.expect(this.expr(eq, BOOL), BOOL, node);
+                    this.line(`if (${hit.c}) {`);
+                    this.line(method === "includes" ? `  ${res} = true;` : `  ${res} = (int64_t)${ci};`);
+                    this.line(`  break;`);
+                    this.line(`}`);
+                }
+                else {
+                    const closure = { node: fn, name: `${method}'s callback`, scopes: [...this.scopes] };
+                    const accId = method === "reduce" ? place(f.createIdentifier(`__acc${this.temp++}`)) : undefined;
+                    if (accId)
+                        this.scopes.at(-1).set(accId.text, { c: res, type: accType, mutable: true });
+                    const all = method === "reduce" ? [accId, element, indexId] : [element, indexId];
+                    const v = this.expandClosure(closure, all.slice(0, fn.parameters.length), cb);
+                    if (method === "forEach") {
+                        if (v)
+                            this.fail(cb, "forEach's callback returns nothing");
+                    }
+                    else if (method === "reduce") {
+                        if (!v)
+                            this.fail(cb, "reduce's callback returns the new accumulator");
+                        const nv = this.expect(v, accType, cb);
+                        this.line(accType.kind === "pubkey" ? `${res} = *(${nv.c});` : `${res} = ${nv.c};`);
+                    }
+                    else {
+                        if (!v)
+                            this.fail(cb, `${method}'s callback returns a boolean`);
+                        const b = this.expect(v, BOOL, cb);
+                        if (method === "some")
+                            this.line(`if (${b.c}) { ${res} = true; break; }`);
+                        if (method === "every")
+                            this.line(`if (!(${b.c})) { ${res} = false; break; }`);
+                        if (method === "findIndex")
+                            this.line(`if (${b.c}) { ${res} = (int64_t)${ci}; break; }`);
+                        if (method === "find") {
+                            this.line(`if (${b.c}) {`);
+                            this.block(() => {
+                                const e = this.expr(element);
+                                elemType = e.type;
+                                if (!["int", "bool", "pubkey", "enum"].includes(e.type.kind))
+                                    this.fail(node, "find returns an Option of the element, so the elements must be integers, booleans, Pubkeys or enums; use findIndex");
+                                this.line(`${res}.some = 1;`);
+                                this.line(e.type.kind === "pubkey" ? `${res}.v = *(${e.c});` : `${res}.v = ${e.c};`);
+                                this.line(`break;`);
+                            });
+                            this.line(`}`);
+                        }
+                    }
+                }
+                this.line(`${ci}++;`);
+            });
+            this.line(`}`);
+        });
+        this.line(`}`);
+        if (method === "find") {
+            const inner = elemType;
+            this.model.options.set(optionKey(inner), inner);
+            this.lines[findDecl] = `${"  ".repeat(this.indent)}${optC(inner)} ${res};\n${"  ".repeat(this.indent)}ts_memzero(&${res}, sizeof(${res}));`;
+            return { c: res, type: { kind: "option", inner } };
+        }
+        return result;
+    }
+    /** `return` inside an expanded closure: the value goes to the closure's result, then past its body. */
+    closureReturn(stmt, frame) {
+        if (!stmt.expression) {
+            if (frame.type)
+                this.fail(stmt, "this function returns a value");
+            this.line(`goto ${frame.label};`);
+            return;
+        }
+        this.closureResult(this.expr(stmt.expression, frame.type), stmt.expression, frame);
+    }
+    /** Store a closure's result (fixing its type on the first one) and jump past the rest of its body. */
+    closureResult(value, at, frame) {
+        let v = value;
+        const stmt = { expression: at };
+        if (v.isNull && !frame.type)
+            this.fail(stmt.expression, "give the function a return type to return null");
+        if (!frame.type) {
+            if (v.literal !== undefined)
+                v = this.literal(v.literal, U64, stmt.expression);
+            const t = v.type;
+            if (!["int", "bool", "pubkey", "string", "enum", "option"].includes(t.kind))
+                this.fail(stmt.expression, `closures return integers, booleans, Pubkeys, strings, enums or Options, not ${typeName(t)}`);
+            frame.type = t;
+            this.lines[frame.declAt] = `${frame.pad}${t.kind === "pubkey" ? "SolPubkey" : valueC(t)} ${frame.result};`;
+        }
+        v = this.expect(v, frame.type, stmt.expression);
+        if (frame.type.kind === "pubkey")
+            this.line(`${frame.result} = *(${v.c});`);
+        else if (frame.type.kind === "option" && v.isNull)
+            this.line(`ts_memzero(&${frame.result}, sizeof(${frame.result}));`);
+        else
+            this.line(`${frame.result} = ${this.ownedString(v).c};`);
+        this.line(`goto ${frame.label};`);
+    }
+    /** `do { … } while (cond)`: the body once, then the test; `continue` goes to the test. */
+    doLoop(stmt) {
+        const label = this.tmp("ts_continue_");
+        this.line(`while (1) {`);
+        this.block(() => {
+            this.loops.push(label);
+            this.line(`{`);
+            this.block(() => this.body(stmt.statement));
+            this.line(`}`);
+            this.loops.pop();
+            this.line(`${label}:;`);
+            const c = this.expect(this.expr(stmt.expression, BOOL), BOOL, stmt.expression);
+            this.line(`if (!${c.c}) break;`);
+        });
+        this.line(`}`);
+    }
     body(stmt) {
         if (ts.isBlock(stmt))
             stmt.statements.forEach((s) => this.reporter.guard(() => this.statement(s)));
@@ -290,6 +620,22 @@ 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)) {
+                // A closure: remembered with the scopes it can see, and expanded where it is called.
+                if (this.model.closureDecls.has(d)) {
+                    this.scopes.at(-1).set(d.name.text, {
+                        c: "",
+                        type: BOOL,
+                        mutable: false,
+                        closure: { node: d.initializer, name: d.name.text, scopes: [...this.scopes] },
+                    });
+                    continue;
+                }
+                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`);
@@ -313,9 +659,7 @@ export class StatementEmitter extends CpiEmitter {
                 continue;
             }
             // Struct values: `const p: Point = { x, y }` (or a copy of another Point) is a local of its own.
-            const structType = d.type && ts.isTypeReferenceNode(d.type) && ts.isIdentifier(d.type.typeName) && !d.type.typeArguments
-                ? this.model.structs.get(d.type.typeName.text)
-                : undefined;
+            const structType = d.type && structNameOf(d.type, this.scope) ? this.model.structs.get(structNameOf(d.type, this.scope)) : undefined;
             if (structType) {
                 if (mutable)
                     this.fail(d, "bind struct values with const (their fields can still be updated)");
@@ -449,8 +793,23 @@ 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 (op === ts.SyntaxKind.AsteriskAsteriskEqualsToken) {
+                // x **= n is x = x ** n; the target is read twice, so it must not run anything (no calls in it).
+                let hasCall = false;
+                const visit = (n) => {
+                    if (ts.isCallExpression(n) && !this.isStorageCall(n))
+                        hasCall = true;
+                    ts.forEachChild(n, visit);
+                };
+                visit(e.left);
+                if (hasCall)
+                    this.fail(e.left, "**= on a target that calls a function: write x = x ** n with the target in a local");
+                const f = ts.factory;
+                const pow = f.createBinaryExpression(e.left, ts.SyntaxKind.AsteriskAsteriskToken, e.right);
+                ts.setTextRange(pow, e);
+                pow.parent = e;
+                return this.assign(e.left, pow);
+            }
         }
         if ((ts.isPostfixUnaryExpression(e) || ts.isPrefixUnaryExpression(e)) &&
             (e.operator === ts.SyntaxKind.PlusPlusToken || e.operator === ts.SyntaxKind.MinusMinusToken)) {
@@ -498,14 +857,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 +875,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 +915,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

@@ -66,7 +66,13 @@ export declare abstract class StorageEmitter extends EmitterBase {
      * Write a struct or array into storage: from an object literal (field by field, every field
      * required) or by copying another location of the same type.
      */
+    /** A whole struct account copied as a value (`return vault`, `info = vault`): fixed-size structs only. */
+    private wholeAccount;
     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. */