@greenpandastudios/aug-cli 0.19.0

package/src/effects.js

@@ -0,0 +1,29 @@
+import { tyName } from "./types.js";
+export const capabilityKey = (type, operation) => `${type.id}<${type.args.map(tyName).join(',')}>.${operation}`;
+/** Resolves surface effect names once; callers compare capability identities. */
+export function effectContract(method, environment) {
+    const uses = new Map();
+    for (const effect of method.uses ?? []) {
+        if (effect.source === 'C') {
+            const native = environment.native(effect.operation);
+            if (!native)
+                environment.report(effect.span, `No imported extern C function ${effect.operation}`);
+            else
+                uses.set(`C:${native}`, effect);
+            continue;
+        }
+        const source = environment.source(effect.source);
+        const capabilities = source ? [source, ...environment.interfaces(source)].filter(type => type.def?.node.kind === 'interface' && type.def.node.capability && environment.operation(type, effect.operation)) : [];
+        if (!capabilities.length)
+            environment.report(effect.span, `${effect.source}.${effect.operation} must name an operation of a capability dependency or capability type`);
+        for (const type of capabilities)
+            uses.set(capabilityKey(type, effect.operation), { ...effect, capability: type });
+    }
+    return { changes: method.changes ?? [], uses };
+}
+export function coversChange(declared, actual) {
+    return declared.some(path => path === actual || actual.startsWith(`${path}.`));
+}
+export function missingEffects(required, allowed) {
+    return [...required.uses.keys()].filter(key => !allowed.uses.has(key));
+}

package/src/fixes.js

@@ -0,0 +1,222 @@
+import { resolve } from 'node:path';
+import { importItems } from "./editor.js";
+import { languageHelp } from "./help.js";
+import { lex } from "./lexer.js";
+import { tyName } from "./types.js";
+import { migrateFile } from "./formatter.js";
+function offsetAt(source, line, column) {
+    let start = 0;
+    for (let current = 1; current < line; current++) {
+        const next = source.indexOf('\n', start);
+        if (next < 0)
+            return source.length;
+        start = next + 1;
+    }
+    return Math.min(source.length, start + Math.max(0, column - 1));
+}
+function distance(left, right) {
+    const row = [...Array(right.length + 1)].map((_, index) => index);
+    for (let i = 1; i <= left.length; i++) {
+        let previous = row[0];
+        row[0] = i;
+        for (let j = 1; j <= right.length; j++) {
+            const old = row[j];
+            row[j] = Math.min(row[j] + 1, row[j - 1] + 1, previous + (left[i - 1] === right[j - 1] ? 0 : 1));
+            previous = old;
+        }
+    }
+    return row[right.length];
+}
+function containingStatement(file, offset) {
+    const result = [];
+    function visit(body) {
+        for (const stmt of body) {
+            if (stmt.span.start > offset || offset >= stmt.span.end)
+                continue;
+            result.push(stmt);
+            if (stmt.kind === 'if') {
+                visit(stmt.then);
+                visit(stmt.otherwise);
+            }
+            else if (stmt.kind === 'while' || stmt.kind === 'for' || stmt.kind === 'scope' || stmt.kind === 'unsafe' || stmt.kind === 'borrow')
+                visit(stmt.body);
+            else if (stmt.kind === 'lock')
+                visit(stmt.body);
+            else if (stmt.kind === 'try') {
+                visit(stmt.body);
+                for (const clause of stmt.catches)
+                    visit(clause.body);
+                visit(stmt.always ?? []);
+            }
+            else if (stmt.kind === 'match')
+                for (const clause of stmt.cases)
+                    visit(clause.body);
+        }
+    }
+    for (const item of file.items) {
+        if (item.kind === 'function')
+            visit(item.body ?? []);
+        else if (item.kind === 'class' || item.kind === 'interface' || item.kind === 'interceptor') {
+            if (item.kind === 'class')
+                visit(item.constructorBody ?? []);
+            for (const method of item.methods)
+                visit(method.body ?? []);
+        }
+        else if (item.kind === 'test')
+            for (const group of item.groups) {
+                visit(group.setup.filter((entry) => entry.kind !== 'bind' && entry.kind !== 'include'));
+                for (const test of group.cases)
+                    visit(test.body);
+            }
+        else if (['expr', 'assign', 'destructure', 'return', 'throw', 'if', 'while', 'for', 'scope', 'match', 'try', 'unsafe', 'borrow']
+            .includes(item.kind))
+            visit([item]);
+    }
+    return result.at(-1);
+}
+function wrappedStatement(file, issue, opener, closer = '}') {
+    const stmt = containingStatement(file, offsetAt(file.source, issue.line, issue.column));
+    // A declaration moved into a new block would become invisible afterward.
+    if (!stmt || (stmt.kind !== 'expr' && !(stmt.kind === 'assign' && !stmt.declaredType)))
+        return undefined;
+    const lineStart = file.source.lastIndexOf('\n', stmt.span.start - 1) + 1;
+    const before = file.source.slice(lineStart, stmt.span.start);
+    const indent = /^[ \t]*$/.test(before) ? before : '';
+    const body = file.source.slice(stmt.span.start, stmt.span.end)
+        .replace(/\n/g, `\n${indent}    `);
+    return { file: file.path, start: stmt.span.start, end: stmt.span.end,
+        text: `${opener} {\n${indent}    ${body}\n${indent}${closer}` };
+}
+export function suggestedFixes(checked, fileName) {
+    const file = checked.project.files.get(resolve(fileName));
+    if (!file)
+        return [];
+    const fixes = [];
+    const syntaxIssue = checked.diagnostics.find(issue => issue.file === file.path && issue.code === 'SYNTAX');
+    if (syntaxIssue) {
+        try {
+            const text = migrateFile(checked.project, file);
+            if (text !== file.source)
+                fixes.push({ title: 'Upgrade this file to the current August syntax', issue: syntaxIssue,
+                    edits: [{ file: file.path, start: 0, end: file.source.length, text }] });
+        }
+        catch { /* Offer a migration only when the whole file can be parsed safely. */ }
+    }
+    for (const item of file.items)
+        if (item.kind === 'import' && item.everything) {
+            const names = checked.project.imports.get(item)?.map(def => def.name) ?? [];
+            if (names.length)
+                fixes.push({ title: 'Expand to named imports', issue: { code: 'IMPORT', line: item.span.line, column: item.span.column,
+                        message: 'Make imported dependencies explicit' }, edits: [{ file: file.path, start: item.span.start, end: item.span.end,
+                            text: `import ${names.join(' and ')} from ${item.from.join('.')}` }] });
+        }
+    for (const issue of checked.diagnostics.filter(issue => issue.file === file.path)) {
+        const add = (title, edit) => {
+            if (edit)
+                fixes.push({ title, issue, edits: [edit] });
+        };
+        const unknown = /^(?:Unknown name|Unknown type|Unknown interceptor) ([A-Za-z_][A-Za-z0-9_]*)$/.exec(issue.message);
+        const mistyped = /^Expected ([A-Za-z_]+), found "([A-Za-z_]+)"$/.exec(issue.message);
+        const redundant = /^Remove (class|function|fuction); declarations start with their name$/.exec(issue.message);
+        if (issue.code === 'PARSE' && redundant) {
+            const start = offsetAt(file.source, issue.line, issue.column);
+            if (file.source.slice(start, start + redundant[1].length) === redundant[1])
+                add(`Remove ${redundant[1]}`, { file: file.path, start,
+                    end: start + redundant[1].length + 1, text: '' });
+        }
+        if (issue.code === 'PARSE' && mistyped &&
+            languageHelp[mistyped[1]]?.category === 'keyword' &&
+            distance(mistyped[1], mistyped[2]) <= 2) {
+            const start = offsetAt(file.source, issue.line, issue.column);
+            if (file.source.slice(start, start + mistyped[2].length) === mistyped[2])
+                add(`Replace ${mistyped[2]} with ${mistyped[1]}`, { file: file.path, start, end: start + mistyped[2].length, text: mistyped[1] });
+        }
+        if (unknown) {
+            const seen = new Set();
+            for (const item of importItems(checked, file).filter(item => item.label === unknown[1])) {
+                const declaration = `import ${item.insertText ?? ''}`;
+                if (seen.has(declaration))
+                    continue;
+                seen.add(declaration);
+                add(`Import ${unknown[1]} from ${item.detail.split(' from ')[1]}`, { file: file.path, start: 0, end: 0, text: `${declaration}\n` });
+            }
+        }
+        if (issue.code === 'INTERCEPTOR' && /constructor parameter .* must be marked resolve/.test(issue.message)) {
+            const start = offsetAt(file.source, issue.line, issue.column);
+            add('Inject interceptor constructor parameter with resolve', { file: file.path, start, end: start, text: 'resolve ' });
+        }
+        if (issue.code === 'INTERCEPTOR' && /must define around/.test(issue.message)) {
+            const start = offsetAt(file.source, issue.line, issue.column);
+            const node = file.items.find(item => item.kind === 'interceptor' && item.span.start === start);
+            if (node?.kind === 'interceptor') {
+                const process = node.methods.find(method => method.name === 'process');
+                if (process)
+                    add('Rename process to around', { file: file.path, start: process.span.start,
+                        end: process.span.start + process.name.length, text: 'around' });
+                else {
+                    const end = file.source.lastIndexOf('}', node.span.end - 1);
+                    if (end >= start) {
+                        const type = node.typeParams[0];
+                        add('Add an around implementation', { file: file.path, start: end, end,
+                            text: `\n    around()${type ? ` returns ${type}` : ''} {\n        ${type ? 'return ' : ''}next();\n    }\n` });
+                    }
+                }
+            }
+        }
+        if (issue.code === 'FFI' && /requires unsafe \{ \.\.\. \}/.test(issue.message))
+            add('Wrap statement in unsafe block', wrappedStatement(file, issue, 'unsafe'));
+        if (issue.code === 'PARSE' && issue.message === 'Use unless instead of throws in error contracts') {
+            const start = offsetAt(file.source, issue.line, issue.column);
+            add('Replace throws with unless', { file: file.path, start, end: start + 'throws'.length, text: 'unless' });
+        }
+        const borrow = /requires borrow ([A-Za-z_][A-Za-z0-9_]*)/.exec(issue.message);
+        if (issue.code === 'BORROW' && borrow) {
+            const name = borrow[1];
+            add(`Wrap statement in borrow ${name} block`, wrappedStatement(file, issue, `borrow ${name}`));
+        }
+        const thrown = /^Unhandled ([A-Za-z_][A-Za-z0-9_]*); catch it or declare unless/.exec(issue.message);
+        const offset = offsetAt(file.source, issue.line, issue.column);
+        const functions = file.items.flatMap(item => item.kind === 'function' ? [item] : 'methods' in item ? item.methods : []);
+        const callable = functions.find(fn => fn.span.start <= offset && offset < fn.span.end || fn.annotations?.some(tag => tag.span.start <= offset && offset < tag.span.end));
+        const headerClose = (fn) => {
+            const tokens = lex(file.path, file.source).tokens.filter(token => fn.span.start <= token.span.start && token.span.start < (fn.body?.[0]?.span.start ?? fn.span.end));
+            return tokens.find(token => token.kind === '{' || token.kind === ':')?.span.start;
+        };
+        if (issue.code === 'THROWS' && thrown) {
+            const end = callable && headerClose(callable);
+            if (callable && end !== undefined)
+                add(`Propagate ${thrown[1]} with unless`, { file: file.path, start: end, end,
+                    text: `${callable.throws.length ? 'and' : 'unless'} ${thrown[1]} ` });
+            if (!callable)
+                add(`Catch ${thrown[1]} and report the failure`, wrappedStatement(file, issue, 'try', `} catch ${thrown[1]} error {\n    print(value=error)\n}`));
+        }
+        const policyEffect = /^Declare uses ([\w]+\.[\w]+) for /.exec(issue.message);
+        if (issue.code === 'HTTP' && policyEffect && callable) {
+            const end = headerClose(callable);
+            if (end !== undefined) {
+                const header = file.source.slice(callable.span.start, end), trailing = /\bunless\b/.exec(header);
+                const last = callable.uses?.at(-1);
+                const insert = last ? last.span.end : trailing ? callable.span.start + trailing.index : end;
+                add(`Declare uses ${policyEffect[1]}`, { file: file.path, start: insert, end: insert, text: last ? ` and ${policyEffect[1]}` : `uses ${policyEffect[1]} ` });
+            }
+        }
+        if (issue.code === 'DI' && callable && issue.message.startsWith('Declare resolve dependencies in')) {
+            const stmt = containingStatement(file, offset);
+            const expr = stmt?.kind === 'assign' ? stmt.value : stmt?.kind === 'expr' ? stmt.expr : undefined;
+            if (expr?.kind === 'resolve') {
+                const type = checked.expressionTypes.get(expr);
+                const name = stmt?.kind === 'assign' && stmt.target.kind === 'name' ? stmt.target.name : expr.name[0].toLowerCase() + expr.name.slice(1);
+                const open = file.source.indexOf('(', callable.span.start);
+                if (type?.kind === 'interface' && type.name === expr.name && open >= 0) {
+                    const first = callable.params[0]?.span.start ?? open + 1;
+                    fixes.push({ title: `Lift ${expr.name} into the dependency header`, issue, edits: [
+                            { file: file.path, start: first, end: first, text: `resolve ${tyName(type)} ${name}${callable.params.length ? ', ' : ''}` },
+                            stmt.kind === 'assign' ? { file: file.path, start: stmt.span.start, end: stmt.span.end, text: '' } :
+                                { file: file.path, start: expr.span.start, end: expr.span.end, text: name },
+                        ] });
+                }
+            }
+        }
+    }
+    return fixes;
+}

package/src/formatter.js

@@ -0,0 +1,296 @@
+import { typeName } from "./ast.js";
+import { lex } from "./lexer.js";
+import { parse } from "./parser.js";
+/** Canonical syntax comes from the parsed program; comments stay with their lexical owner. */
+export function formatFile(project, file) {
+    return printFile(project, file, false);
+}
+/** Upgrade rejected legacy spellings without accepting them during compilation. */
+export function migrateFile(project, file) {
+    return printFile(project, file, true);
+}
+function printFile(project, file, migrate) {
+    const parsed = parse(file.path, file.source);
+    if (parsed.diagnostics.some(issue => !migrate || issue.code !== 'SYNTAX'))
+        throw new Error('Fix syntax errors before formatting this file');
+    if (migrate) {
+        const inspect = (value) => {
+            if (!value || typeof value !== 'object')
+                return;
+            if (Array.isArray(value)) {
+                value.forEach(inspect);
+                return;
+            }
+            const node = value;
+            if (node.kind === 'match' && node.cases.filter(clause => clause.pattern === 'null').length > 1 && /\bwhen\s+missing\b/.test(file.source.slice(node.span.start, node.span.end)))
+                throw new Error('Merge the old missing and null cases into one null case before migrating; optional values now have two states');
+            for (const [key, child] of Object.entries(value))
+                if (key !== 'span')
+                    inspect(child);
+        };
+        inspect(parsed.file.items);
+    }
+    const printer = new Printer(project, file);
+    const result = printer.print();
+    const verified = parse(file.path, result);
+    if (verified.diagnostics.length) {
+        const issue = verified.diagnostics[0];
+        throw new Error(`Formatter produced invalid syntax at ${file.path}:${issue.line}:${issue.column}: ${issue.message}`);
+    }
+    const shape = (value) => {
+        if (Array.isArray(value))
+            return value.filter(item => !(item?.kind === 'expr' && item.expr.kind === 'literal' && item.expr.value === null)).map(shape);
+        if (!value || typeof value !== 'object')
+            return value;
+        const node = value;
+        return Object.fromEntries(Object.entries(node).filter(([key, value]) => !['span', 'nameSpan', 'sourceSpan'].includes(key) && value !== undefined)
+            .sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => [key, shape(value)]));
+    };
+    if (JSON.stringify(shape(parsed.file.items)) !== JSON.stringify(shape(verified.file.items)))
+        throw new Error('Formatter would change the parsed program; the file has been left unchanged');
+    return result;
+}
+class Printer {
+    comments;
+    lines = [];
+    level = 0;
+    step;
+    indent;
+    assign;
+    project;
+    file;
+    constructor(project, file) {
+        this.project = project;
+        this.file = file;
+        this.comments = lex(file.path, file.source, true).tokens.filter(token => token.kind === 'comment');
+        this.step = project.config.indentation === 'tabs' ? '\t' : '    ';
+        this.indent = project.config.block_style === 'indent';
+        this.assign = project.config.assignment === 'to' ? 'to' : '=';
+    }
+    line(text = '') { this.lines.push(text ? this.step.repeat(this.level) + text : ''); }
+    before(offset, parentColumn) {
+        while (this.comments[0]?.span.start < offset) {
+            if (parentColumn !== undefined && this.comments[0].span.column <= parentColumn)
+                break;
+            const comment = this.comments.shift().value;
+            for (const line of comment.split(/\r?\n/))
+                this.line(line.trimStart());
+        }
+    }
+    inline(offset) {
+        const comments = [];
+        while (this.comments[0]?.span.start < offset) {
+            let comment = this.comments.shift().value;
+            if (comment.startsWith('//') || comment.startsWith('#'))
+                comment = `/* ${comment.replace(/^(\/\/|#)\s*/, '').replaceAll('*/', '* /')} */`;
+            comments.push(comment);
+        }
+        return comments.length ? comments.join(' ') + ' ' : '';
+    }
+    block(header, body, span) {
+        this.line(header + (this.indent ? ':' : ' {'));
+        this.level++;
+        const count = this.lines.length;
+        body();
+        const empty = this.lines.length === count;
+        if (span)
+            this.before(span.end, this.file.source[span.end - 1] === '}' ? undefined : span.column);
+        if (empty)
+            this.line('pass');
+        this.level--;
+        if (!this.indent)
+            this.line('}');
+    }
+    generics(node) {
+        return node.typeParams.length ? '<' + node.typeParams.map(name => `${node.typeVariance?.[name] ? node.typeVariance[name] + ' ' : ''}${name}` +
+            (node.typeConstraints?.[name]?.length ? ` implements ${node.typeConstraints[name].map(typeName).join(' and ')}` : '')).join(', ') + '>' : '';
+    }
+    param(param, field = false) {
+        const label = field ? param.label ?? param.name : param.name;
+        return this.inline(param.span.start) + `${param.injected ? 'resolve ' : ''}${param.mutable ? 'mutable ' : ''}` +
+            `${param.ownership === 'managed' ? '' : param.ownership + ' '}${typeName(param.type)} ${label}` +
+            (label !== param.name ? ` to ${param.name}` : '') + (param.source ? ` from ${param.source.kind}${param.source.name ? ' ' + JSON.stringify(param.source.name) : ''}` : '') + this.inline(param.span.end);
+    }
+    annotations(tags = []) {
+        for (const tag of tags) {
+            this.before(tag.span.start);
+            this.line(`[${tag.name}${tag.typeArgs.length ? '<' + tag.typeArgs.map(typeName).join(', ') + '>' : ''}` +
+                (tag.mappings.length ? '(' + tag.mappings.map(mapping => `${mapping.name}=${mapping.value ? this.expression(mapping.value) : mapping.source}`).join(', ') + ')' : '') + ']');
+        }
+    }
+    method(method) {
+        this.before(method.annotations?.[0]?.span.start ?? method.span.start);
+        this.annotations(method.annotations);
+        const header = `${method.endpoint ? `endpoint ${method.endpoint.method} ${JSON.stringify(method.endpoint.path)} as ` : ''}${method.fixture ? 'fixture ' : ''}${method.externC ? 'extern C ' + (method.valueAbi ? 'value ' : '') + (method.nativePure ? 'pure ' : '') : ''}${method.name}${this.generics(method)}` +
+            `(${method.params.map(param => this.param(param)).join(', ')})` +
+            (method.returns.name !== 'void' ? ` ${method.endpoint?.streams ? 'streams' : 'returns'} ${method.returnOwnership === 'own' ? 'own ' : ''}${typeName(method.returns)}` : '') +
+            (method.endpoint && method.endpoint.status !== 200 ? ` with status ${method.endpoint.status}` : '') +
+            (method.changes?.length ? ` changes ${method.changes.join(' and ')}` : '') +
+            (method.uses?.length ? ` uses ${method.uses.map(use => `${use.source}.${use.operation}`).join(' and ')}` : '') +
+            (method.throws.length ? ` unless ${method.throws.map(type => typeName(type) + (method.endpoint?.errors.find(error => typeName(error.type) === typeName(type)) ? ' with status ' + method.endpoint.errors.find(error => typeName(error.type) === typeName(type)).status : '')).join(' and ')}` : '');
+        if (method.body)
+            this.block(header, () => method.body.forEach(stmt => this.statement(stmt)), method.span);
+        else {
+            this.line(header);
+            this.before(method.span.end);
+        }
+    }
+    expression(expr, precedence = 0) {
+        const comment = this.inline(expr.span.start);
+        let value;
+        if (expr.kind === 'markupText')
+            value = expr.text;
+        else if (expr.kind === 'markup')
+            value = '<' + expr.tag + expr.attributes.map(attribute => ' ' + attribute.name + '={' + this.expression(attribute.value) + '}').join('') +
+                (expr.children.length || !expr.tag ? '>' + expr.children.map(child => child.kind === 'markup' || child.kind === 'markupText' ? this.expression(child) : '{' + this.expression(child) + '}').join('') + '</' + expr.tag + '>' : ' />');
+        else if (expr.kind === 'literal')
+            value = expr.numericText ?? JSON.stringify(expr.value);
+        else if (expr.kind === 'name')
+            value = expr.name;
+        else if (expr.kind === 'handle')
+            value = `handle ${this.expression(expr.call, 8)}`;
+        else if (expr.kind === 'formInput')
+            value = 'input from form';
+        else if (expr.kind === 'start')
+            value = `start ${this.expression(expr.call, 8)}`;
+        else if (expr.kind === 'wait')
+            value = `wait for ${expr.tasks.map(task => this.expression(task, 8)).join(' and ')}`;
+        else if (expr.kind === 'resolve')
+            value = `resolve ${expr.name}` + (expr.typeArgs.length ? '<' + expr.typeArgs.map(typeName).join(', ') + '>' : '');
+        else if (expr.kind === 'member')
+            value = `${this.expression(expr.object, 8)}.${expr.name}`;
+        else if (expr.kind === 'call')
+            value = this.expression(expr.callee, 8) + (expr.typeArgs.length ? '<' + expr.typeArgs.map(typeName).join(', ') + '>' : '') +
+                '(' + expr.args.map((arg, index) => (expr.argLabels[index] ? expr.argLabels[index] + '=' : '') + this.expression(arg)).join(', ') + this.inline(expr.span.end) + ')';
+        else if (expr.kind === 'collection') {
+            const open = expr.collection === 'List' ? '[' : expr.collection === 'Tuple' ? '(' : '{';
+            const close = open === '[' ? ']' : open === '(' ? ')' : '}';
+            const values = expr.collection === 'Map' ? expr.items.filter((_, index) => index % 2 === 0).map((item, index) => `${this.expression(item)}: ${this.expression(expr.items[index * 2 + 1])}`) : expr.items.map(item => this.expression(item));
+            value = open + values.join(', ') + (expr.collection === 'Tuple' && values.length === 1 ? ',' : '') + this.inline(expr.span.end) + close;
+        }
+        else if (expr.kind === 'unary') {
+            const power = expr.op === '!' ? 2.5 : 7;
+            value = (expr.op === '!' ? 'not ' : expr.op) + this.expression(expr.value, power);
+            if (power < precedence)
+                value = '(' + value + ')';
+        }
+        else {
+            const powers = { '||': 1, '&&': 2, '==': 3, '!=': 3, '<': 4, '>': 4, '<=': 4, '>=': 4, '+': 5, '-': 5, '*': 6, '/': 6 };
+            const power = powers[expr.op];
+            value = `${this.expression(expr.left, power)} ${expr.op === '&&' ? 'and' : expr.op === '||' ? 'or' : expr.op} ${this.expression(expr.right, power + 1)}`;
+            if (power < precedence)
+                value = '(' + value + ')';
+        }
+        return comment + value;
+    }
+    statement(stmt) {
+        this.before(stmt.span.start);
+        if (stmt.kind === 'serve')
+            this.line(`serve ${stmt.names.join(' and ')} on port ${this.expression(stmt.port)}`);
+        else if (stmt.kind === 'lock')
+            this.block(`lock ${this.expression(stmt.value)} as ${stmt.name}`, () => stmt.body.forEach(child => this.statement(child)), stmt.span);
+        else if (stmt.kind === 'freeze')
+            this.line(`freeze ${this.expression(stmt.value)} as ${stmt.name}`);
+        else if (stmt.kind === 'expr')
+            this.line(stmt.expr.kind === 'literal' && stmt.expr.value === null ? 'pass' : this.expression(stmt.expr));
+        else if (stmt.kind === 'yield')
+            this.line('yield ' + this.expression(stmt.value));
+        else if (stmt.kind === 'assign')
+            this.line(stmt.value.kind === 'resolve' && !stmt.declaredType && stmt.target.kind === 'name' ?
+                `${this.expression(stmt.value)} to ${stmt.target.name}` : `${stmt.ownership === 'own' ? 'own ' : ''}` +
+                `${stmt.declaredType ? typeName(stmt.declaredType) + ' ' : ''}${this.expression(stmt.target)} ${this.assign} ${this.expression(stmt.value)}`);
+        else if (stmt.kind === 'destructure')
+            this.line(`(${stmt.names.join(', ')}) ${this.assign} ${this.expression(stmt.value)}`);
+        else if (stmt.kind === 'return')
+            this.line('return' + (stmt.value ? ' ' + this.expression(stmt.value) : ''));
+        else if (stmt.kind === 'throw')
+            this.line('throw ' + this.expression(stmt.value));
+        else if (stmt.kind === 'if') {
+            this.block('if ' + this.expression(stmt.test), () => stmt.then.forEach(child => this.statement(child)));
+            if (stmt.otherwise.length)
+                this.block('else', () => stmt.otherwise.forEach(child => this.statement(child)));
+        }
+        else if (stmt.kind === 'while')
+            this.block('while ' + this.expression(stmt.test), () => stmt.body.forEach(child => this.statement(child)), stmt.span);
+        else if (stmt.kind === 'for')
+            this.block(`for ${stmt.names.length === 1 ? stmt.names[0] : '(' + stmt.names.join(', ') + ')'} in ${this.expression(stmt.iterable)}`, () => stmt.body.forEach(child => this.statement(child)), stmt.span);
+        else if (stmt.kind === 'match')
+            this.block('match ' + this.expression(stmt.value), () => stmt.cases.forEach(clause => {
+                const pattern = clause.pattern === 'else' ? 'else' : 'when ' + (clause.pattern === 'some' ? 'some ' + clause.name :
+                    clause.pattern === 'literal' ? this.expression(clause.literal) : clause.pattern === 'type' ? typeName(clause.type) + ' ' + clause.name : clause.pattern);
+                this.block(pattern, () => clause.body.forEach(child => this.statement(child)), clause.span);
+            }), stmt.span);
+        else if (stmt.kind === 'try') {
+            this.block('try', () => stmt.body.forEach(child => this.statement(child)));
+            stmt.catches.forEach(clause => this.block(`catch ${typeName(clause.type)} ${clause.name}`, () => clause.body.forEach(child => this.statement(child)), clause.span));
+            if (stmt.always)
+                this.block('always', () => stmt.always.forEach(child => this.statement(child)), stmt.span);
+        }
+        else
+            this.block(stmt.kind + (stmt.kind === 'borrow' ? ' ' + stmt.name : ''), () => stmt.body.forEach(child => this.statement(child)), stmt.span);
+    }
+    item(item) {
+        this.before('annotations' in item ? item.annotations?.[0]?.span.start ?? item.span.start : item.span.start);
+        if (item.kind === 'import') {
+            this.line(`import ${item.everything ? 'everything' : item.names.join(' and ')} from ${item.from.join('.')}`);
+        }
+        else if (item.kind === 'export')
+            this.line('export ' + (item.folder ? 'folder ' + item.name : `${item.name} from ${item.from}`));
+        else if (item.kind === 'include')
+            this.line('include ' + item.name);
+        else if (item.kind === 'bind')
+            this.line(`implement ${item.key}${item.keyTypeArgs.length ? '<' + item.keyTypeArgs.map(typeName).join(', ') + '>' : ''} with ${typeName(item.target)}` +
+                (item.lifetime ? ' ' + item.lifetime : '') + (item.sharedMutation ? ' mutable' : ''));
+        else if (item.kind === 'composition')
+            this.block('composition ' + item.name, () => item.bindings.forEach(binding => this.item(binding)), item.span);
+        else if (item.kind === 'function')
+            this.method(item);
+        else if (item.kind === 'class') {
+            this.annotations(item.annotations);
+            const header = `${item.record ? 'record ' : ''}${item.name}${this.generics(item)}(${item.fields.map(field => this.param(field, true)).join(', ')})`;
+            if (item.record) {
+                const errors = item.validationErrors?.length ? ` unless ${item.validationErrors.map(typeName).join(' and ')}` : '';
+                if (item.constructorBody)
+                    this.block(header + errors, () => this.initializer(item), item.span);
+                else
+                    this.line(header + errors);
+            }
+            else {
+                this.block(header + ' implements ' + item.implements.map(typeName).join(', '), () => {
+                    for (const field of item.stateFields ?? []) {
+                        this.before(field.span.start);
+                        this.line(`${field.mutable ? 'mutable ' : ''}${typeName(field.type)} ${field.name} = ${this.expression(field.initializer)}`);
+                    }
+                    if (item.constructorBody)
+                        this.initializer(item);
+                    item.methods.forEach(method => this.method(method));
+                }, item.span);
+            }
+        }
+        else if (item.kind === 'interface')
+            this.block(`${item.capability ? 'capability' : 'interface'} ${item.name}${this.generics(item)}` +
+                (item.extends.length ? ' extends ' + item.extends.map(typeName).join(', ') : ''), () => item.methods.forEach(method => this.method(method)), item.span);
+        else if (item.kind === 'interceptor')
+            this.block(`interceptor ${item.name}${this.generics(item)}(${item.fields.map(field => this.param(field, true)).join(', ')})`, () => item.methods.forEach(method => this.method(method)), item.span);
+        else if (item.kind === 'test')
+            this.block(`test ${item.endpointSuite ? 'endpoint ' : ''}${typeName(item.type)}${item.functionSuite ? '' : ' ' + item.name}`, () => item.groups.forEach(group => this.block('when ' + JSON.stringify(group.name), () => {
+                group.setup.forEach(entry => this.item(entry));
+                group.cases.forEach(test => this.block('it ' + JSON.stringify(test.name) + (test.parameters ? ` for (${test.parameters.join(', ')}) in [` +
+                    test.rows.map(row => this.expression(row)).join(', ') + ']' : ''), () => test.body.forEach(stmt => this.statement(stmt)), test.span));
+            }, group.span)), item.span);
+        else
+            this.statement(item);
+    }
+    print() {
+        for (const item of this.file.items)
+            this.item(item);
+        this.before(Infinity);
+        return this.lines.join('\n').trimEnd() + '\n';
+    }
+    initializer(item) {
+        const span = item.constructorBody.span;
+        if (span)
+            this.before(span.start);
+        this.block('initialize', () => item.constructorBody.forEach(stmt => this.statement(stmt)), span);
+    }
+}