@typesol/cli 0.17.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)));
@@ -292,6 +622,16 @@ export class StatementEmitter extends CpiEmitter {
                 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;
@@ -319,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)");
@@ -455,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)) {

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

@@ -66,6 +66,8 @@ 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"]>;

package/dist/compiler/emit/storage.js

@@ -242,6 +242,9 @@ export class StorageEmitter extends EmitterBase {
     ref(node) {
         if (ts.isParenthesizedExpression(node))
             return this.ref(node.expression);
+        const unbanged = this.withoutBang(node);
+        if (unbanged)
+            return this.ref(unbanged);
         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)) {
@@ -276,13 +279,13 @@ export class StorageEmitter extends EmitterBase {
                     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.
+                        // Growing needs the account's length at instruction entry: instructions have it, helpers get it passed.
                         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,
+                            resizable: isWritable(a.kind),
                         };
                     return r;
                 }
@@ -337,7 +340,7 @@ export class StorageEmitter extends EmitterBase {
         if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "get") {
             const owner = node.expression.expression;
             const l = ts.isIdentifier(owner) ? this.lookup(owner.text) : undefined;
-            if (l?.type.kind === "vecArg" && !isScalar(l.type.elem)) {
+            if (l?.type.kind === "vecArg" && !isScalar(l.type.elem) && l.type.elem.kind !== "string") {
                 // A Vec<Struct> argument: elements are read in place (validated when the instruction started).
                 if (node.arguments.length !== 1)
                     this.fail(node, "get(index) takes one argument");
@@ -478,6 +481,16 @@ export 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. */
+    wholeAccount(node) {
+        if (!ts.isIdentifier(node) || this.lookup(node.text))
+            return undefined;
+        const a = this.accounts.get(node.text);
+        if (!a || !(a.kind.kind === "account" || a.kind.kind === "init" || a.kind.kind === "initIfNeeded") || a.kind.struct.size === undefined || a.kind.struct.vec)
+            return undefined;
+        this.assertUsable(a, node);
+        return { lv: `(*d_${a.name})`, type: { kind: "struct", name: a.kind.struct.name }, writable: false };
+    }
     writeAggregate(target, valueNode) {
         if (ts.isParenthesizedExpression(valueNode))
             return this.writeAggregate(target, valueNode.expression);
@@ -604,7 +617,18 @@ export class StorageEmitter extends EmitterBase {
             this.line(`ts_memcpy(&${target.lv}, &${tmp}, sizeof(${tmp}));`);
             return;
         }
-        const src = this.ref(valueNode);
+        if (ts.isConditionalExpression(valueNode)) {
+            // `cond ? a : b` (places, literals or calls): each branch writes the target. A branch that reads the target
+            // copies it onto itself, which the copies below allow.
+            const cond = this.expect(this.expr(valueNode.condition, BOOL), BOOL, valueNode.condition);
+            this.line(`if (${cond.c}) {`);
+            this.block(() => this.writeAggregate(target, valueNode.whenTrue));
+            this.line(`} else {`);
+            this.block(() => this.writeAggregate(target, valueNode.whenFalse));
+            this.line(`}`);
+            return;
+        }
+        const src = this.ref(valueNode) ?? this.wholeAccount(valueNode);
         if (!src || !sameType(src.type, target.type))
             this.fail(valueNode, `expected a ${typeName(target.type)}: an object literal or another ${typeName(target.type)}`);
         // Same-typed places are either distinct or identical (`a.p = a.p`); ts_copy skips the latter.

package/dist/compiler/idl.js

@@ -45,6 +45,9 @@ function borshIdlType(t) {
         return { vec: borshIdlType(t.elem) };
     if (t.kind === "option")
         return { option: idlType(t.inner) };
+    // A data enum in a Borsh struct is the Borsh enum itself (tag, then the variant's fields).
+    if (t.kind === "dataEnum")
+        return { defined: { name: t.name } };
     return idlType(t);
 }
 function idlType(t, borshOption = false) {
@@ -90,7 +93,7 @@ function accountEntry(ix, name, k, programAddress) {
         entry.writable = true;
     if (param?.optional)
         entry.optional = true;
-    if (k.kind === "signer")
+    if (k.kind === "signer" || param?.signsInit)
         entry.signer = true;
     if (k.kind === "system")
         entry.address = SYSTEM_PROGRAM;

package/dist/compiler/model.d.ts

@@ -143,14 +143,22 @@ export interface StructDef {
      * Anchor's bytes, where strings, Vecs and Options take only what they hold).
      */
     layout: "fixed" | "borsh";
+    /**
+     * A @layout borsh struct with a `string` field or a data enum carrying strings: they are views of the bytes it was
+     * read from, so it is an argument, return value or event, never account data.
+     */
+    viewsOnly?: boolean;
 }
 export type TokenProgramKind = "token" | "token2022" | "tokenInterface";
 export type ParamKind = {
     kind: "signer";
     mut: boolean;
-} | {
+}
+/** `systemOwned`: a SystemAccount (Anchor's): owned by the System Program (3011). */
+ | {
     kind: "info";
     mut: boolean;
+    systemOwned?: boolean;
 } | {
     kind: "account";
     struct: StructDef;
@@ -175,9 +183,12 @@ export type ParamKind = {
     kind: "token";
     mut: boolean;
     init?: "create" | "ifNeeded";
-} | {
+}
+/** `init`: created in the body (`mint.create(payer, seeds | null, decimals, authority, freeze)`). */
+ | {
     kind: "mint";
     mut: boolean;
+    init?: "create" | "ifNeeded";
 } | {
     kind: "system";
 } | {
@@ -260,6 +271,8 @@ export interface AccountParam {
     optional?: boolean;
     node: ts.ParameterDeclaration;
     constraints: Constraints;
+    /** Created in the body as a new keypair account (`create(payer, null, …)`), so it signs: the IDL says so. */
+    signsInit?: boolean;
 }
 export interface ArgParam {
     name: string;
@@ -287,6 +300,8 @@ export interface Instruction {
     minArgsSize: number;
     /** Sent as return data: a scalar in Borsh, or a fixed-size struct in its fixed layout (as the IDL describes it). */
     returns: ScalarType | {
+        kind: "string";
+    } | {
         kind: "struct";
         name: string;
     } | undefined;
@@ -302,6 +317,8 @@ export interface Instruction {
 export interface GenericHelper {
     name: string;
     display: string;
+    /** Indexes of parameters with a function type (`f: (x: u64) => u64`): bound per call to a named function. */
+    fnParams: number[];
     node: HelperNode;
     typeParams: string[];
     imports: Map<string, string>;
@@ -327,6 +344,8 @@ export interface Helper {
     params: HelperParam[];
     /** A struct result is written through an out pointer (`TSS_<name> *ret`) that the caller provides. */
     returns: ScalarType | {
+        kind: "string";
+    } | {
         kind: "struct";
         name: string;
     } | undefined;
@@ -335,6 +354,12 @@ export interface Helper {
     statements: readonly ts.Statement[];
     /** A generic helper's instance: type parameter -> the type it stands for. */
     typeArgs?: Map<string, ScalarType>;
+    /** A generic helper's instance: type parameter -> the struct it stands for. */
+    structArgs?: Map<string, string>;
+    /** An instance's function parameters: name -> the helper passed for it (its calls go there). */
+    fnArgs?: Map<string, string>;
+    /** Their argument positions, which have no C parameter. */
+    fnArgIndexes?: number[];
     /** The declaring file's `typesol` imports (local name -> export name). */
     imports: Map<string, string>;
 }
@@ -383,6 +408,8 @@ export interface ProgramModel {
     generics: Map<string, GenericHelper>;
     /** Declaration (function, or the const of an arrow) -> helper or generic name, for calls to local arrows. */
     helperDecls: Map<ts.Node, string>;
+    /** Local closures (they read the enclosing function's variables): their declaration -> name; expanded where called. */
+    closureDecls: Map<ts.Node, string>;
     errors: ErrorDef[];
     /** Enum name -> member name -> error */
     errorEnums: Map<string, Map<string, ErrorDef>>;