@greenpandastudios/aug-cli 0.19.0 → 0.21.0

package/src/ir.js

@@ -0,0 +1,962 @@
+import { createHash } from 'node:crypto';
+import { relative, resolve } from 'node:path';
+import { isStatement, fieldsOf, initializationOf } from "./ast.js";
+import { typeName } from "./ast.js";
+import { errorNames, builtinProperties } from "./builtins.js";
+import { DataSchemas, schemaType } from "./schemas.js";
+import { runtimeAdapters, adapterSymbol } from "./runtime-adapters.js";
+import { generateOpenApi, apiExplorer, apiExplorerScript } from "./openapi.js";
+import { actionSchema, actionTransport } from "./actions.js";
+import { httpPolicyNames } from "./http-policies.js";
+import { interceptorChain, InterceptorInvocation } from "./interceptors.js";
+import { verifyIR } from "./ir-verify.js";
+import { isIRScalar } from "./ir-types.js";
+const dynamicType = { id: 'compiler:dynamic', name: 'Data', args: [], nullable: true, optional: false };
+const scalarType = (name) => ({ id: 'builtin:' + name, name, args: [], nullable: false, optional: false });
+const irType = (type) => ({ id: type.id, name: type.name, args: type.args.map(irType), nullable: type.nullable, optional: !!type.optional });
+export class BackendUnsupported extends Error {
+    span;
+    code = 'BACKEND_UNSUPPORTED';
+    constructor(span, feature) { super('LLVM preview does not support ' + feature + '. No C fallback occurred.'); this.span = span; }
+}
+/** Checked, resolved execution IR. Source AST and semantic facts remain read-only. */
+export function lowerToIR(checked, options = {}) {
+    if (checked.diagnostics.some(d => d.severity !== 'warning'))
+        throw new Error('Cannot lower a rejected August project');
+    const ir = new Lowering(checked, options).lower();
+    verifyIR(ir);
+    return ir;
+}
+class Lowering {
+    checked;
+    names = new Map();
+    functions = [];
+    schemas;
+    components = new Set();
+    routes = [];
+    coverage = new Map();
+    options;
+    constructor(checked, options) { this.checked = checked; this.options = options; let i = 0; for (const def of checked.project.definitions.values())
+        this.names.set(def.id, 'aug_fn_' + i++); this.schemas = new DataSchemas(checked.project, def => this.name(def)); }
+    name(def) { return this.names.get(def.id); }
+    method(def, name) { return this.name(def) + '_' + name; }
+    binding(key) { const i = this.checked.bindings.findIndex(b => b.key === key); if (i < 0)
+        throw new Error('Missing checked binding ' + key); return 'aug_resolve_' + i; }
+    definition(file, name) { return this.checked.project.scopes.get(file)?.get(name); }
+    lower() {
+        const active = new Set();
+        const visit = (file) => { if (active.has(file))
+            return; active.add(file); for (const item of this.checked.project.files.get(file)?.items ?? [])
+            if (item.kind === 'import')
+                for (const d of this.checked.project.imports.get(item) ?? [])
+                    visit(d.file); };
+        for (const file of this.checked.project.files.values())
+            if (!file.builtin)
+                visit(file.path);
+        for (const def of this.checked.project.definitions.values()) {
+            if (!active.has(def.file))
+                continue;
+            const node = def.node;
+            if (node.kind === 'function') {
+                if (node.body)
+                    this.add(def, this.name(def), node, node.params, node.body);
+                else if (node.externC && this.checked.interceptorPlans.get(node)?.length) {
+                    const body = new FunctionLowering(this, def.file, node.span);
+                    node.params.forEach((param, index) => body.parameter(param, index));
+                    body.nativeBody(def);
+                    this.functions.push(body.finish(interceptorChain(this.name(def), this.checked.interceptorPlans.get(node) ?? []).body));
+                    this.layers(node, this.name(def), node.params, false);
+                }
+                if (node.endpoint) {
+                    const body = new FunctionLowering(this, def.file, node.span);
+                    body.endpoint(def);
+                    this.functions.push(body.finish(this.name(def) + '_http'));
+                    this.components.add('http');
+                }
+            }
+            if (node.kind === 'class' || node.kind === 'interceptor') {
+                const methods = node.methods.filter(method => node.kind !== 'interceptor' || method.name !== 'around');
+                for (const entry of this.checked.defaults.get(def.id)?.values() ?? [])
+                    if (!methods.some(m => m.name === entry.method.name))
+                        methods.push(entry.method);
+                for (const method of methods)
+                    if (method.body)
+                        this.add(def, this.method(def, method.name), method, method.params, method.body, true);
+                const body = new FunctionLowering(this, def.file, node.span, def);
+                node.fields.forEach((param, i) => body.parameter(param, i));
+                body.instruction({ op: 'object', out: 0, type: def.id, fields: fieldsOf(node).map(f => f.name), owned: fieldsOf(node).map(f => f.ownership === 'own'), methods: methods.map(m => ({ name: m.name, function: this.method(def, m.name) })), record: node.kind === 'class' && !!node.record });
+                node.fields.forEach((param, i) => { body.runtime('SET_FIELD', [0, body.parameters[i]], undefined, i); if (param.ownership === 'own')
+                    body.instruction({ op: 'clear', slot: body.parameters[i] }); });
+                node.fields.forEach(param => body.locals.delete(param.name));
+                body.locals.set('self', 0);
+                if (node.kind === 'class')
+                    for (const stmt of initializationOf(node))
+                        body.statement(stmt);
+                if (node.kind === 'class' && node.record)
+                    body.runtime('FREEZE', [0]);
+                const chain = node.kind === 'class' ? interceptorChain(this.name(def), this.checked.interceptorPlans.get(node) ?? []) : { body: this.name(def) };
+                this.functions.push({ ...body.finish(chain.body), failedResult: true });
+                if (node.kind === 'class')
+                    this.layers(node, this.name(def), node.fields, false);
+            }
+        }
+        this.checked.bindings.forEach((binding, index) => {
+            const body = new FunctionLowering(this, binding.declaration.span.file, binding.declaration.span);
+            if (binding.lifetime !== 'fresh') {
+                body.instruction({ op: 'binding-get', out: 0, index });
+                const create = body.block(), done = body.block();
+                body.terminate({ op: 'null', input: 0, then: create, otherwise: done });
+                body.enter(done);
+                body.terminate({ op: 'jump', target: 'cleanup' });
+                body.enter(create);
+            }
+            const args = binding.constructorKeys.map(key => body.call(this.binding(key), []));
+            body.instruction({ op: 'call', out: 0, function: this.name(binding.target), args });
+            body.checkError();
+            if (binding.lifetime !== 'fresh')
+                body.instruction({ op: 'binding-set', input: 0, index });
+            this.functions.push(body.finish('aug_resolve_' + index));
+        });
+        const main = this.checked.project.main;
+        if (!main)
+            throw new Error('LLVM executable requires main.aug');
+        const body = new FunctionLowering(this, main.path, { file: main.path, start: 0, end: main.source.length, line: 1, column: 1 });
+        for (let index = 0; index <= main.items.length; index++) {
+            if (this.checked.project.testBodyStart === index)
+                body.runtime('TEST_CASE', []);
+            const stmt = main.items[index];
+            if (stmt && isStatement(stmt))
+                body.statement(stmt);
+        }
+        this.functions.push(body.finish('aug_main_body'));
+        const project = this.checked.project, scopes = [...project.packages.scopes.values()];
+        const hashes = [...project.files.values()].map(f => {
+            const scope = scopes.find(s => f.path.startsWith(s.sourceRoot + '/'));
+            const path = scope ? scope.name + '@' + scope.version + '/' + relative(scope.sourceRoot, f.path) : f.builtin ? 'august/' + relative(project.stdlibRoot, f.path) : relative(project.root, f.path);
+            return [path.replaceAll('\\', '/'), createHash('sha256').update(f.source).digest('hex')];
+        }).sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+        const dependencies = scopes.map(s => ({ name: s.name, version: s.version, digest: s.digest, native: s.native?.bindingsSha256 })).sort((a, b) => a.name.localeCompare(b.name, 'en'));
+        const web = project.config.web, tls = Object.fromEntries(Object.entries(web.tls).map(([key, value]) => [key, value ? resolve(project.root, value) : '']));
+        return { format: 1, sourceRevision: createHash('sha256').update(JSON.stringify({ sources: hashes, configuration: project.config, dependencies })).digest('hex'), functions: this.functions, main: 'aug_main_body', bindings: this.checked.bindings.map((b, i) => ({ function: 'aug_resolve_' + i, shared: b.lifetime === 'shared' })), scoped: this.checked.bindings.map(b => b.lifetime === 'scoped'), test: !!this.checked.project.testMode, schemas: this.schemas.nodes, components: [...this.components].sort(), routes: this.routes, web: { ...web, tls }, coverage: [...this.coverage.values()].sort((a, b) => a.file.localeCompare(b.file, 'en') || a.line - b.line) };
+    }
+    policy(plan) {
+        const options = plan.options;
+        return { kind: httpPolicyNames.indexOf(plan.name) + 1, permission: String(options.permission ?? ''), amount: Number(options.requests ?? options.milliseconds ?? 0), seconds: Number(options.seconds ?? 0), credentials: !!options.credentials, origins: (options.origins ?? []).join('\n'), headers: (options.headers ?? []).map(header => header.toLowerCase()).join(', ') };
+    }
+    routeTable(file, names) {
+        this.components.add('http');
+        const name = 'aug_routes_' + this.routes.length;
+        const items = names.map(name => {
+            const def = this.definition(file, name), fn = def.node, endpoint = fn.endpoint;
+            return { method: endpoint.method, path: endpoint.path, function: this.name(def) + '_http', stream: endpoint.streams ? fn.returns.name === 'ServerEvent' ? 1 : fn.returns.name === 'Bytes' ? 2 : 3 : 0, status: endpoint.status, policies: (this.checked.httpPolicies.get(fn) ?? []).map(plan => this.policy(plan)) };
+        });
+        // Reserve its name before adding generated documentation handlers.
+        this.routes.push({ name, items });
+        const config = this.checked.project.config.openapi;
+        const assets = config.enabled ? [
+            { path: config.path, type: 'application/json', content: JSON.stringify(generateOpenApi(this.checked).document) },
+            { path: config.docs, type: 'text/html; charset=utf-8', content: apiExplorer(config.path, config.docs + '/client.js') },
+            { path: config.docs + '/client.js', type: 'application/javascript; charset=utf-8', content: apiExplorerScript }
+        ] : [];
+        if (this.checked.actions.size)
+            assets.push({ path: '/__aug/actions.js', type: 'application/javascript; charset=utf-8', content: actionTransport });
+        assets.forEach((asset, index) => {
+            const body = new FunctionLowering(this, file, this.checked.project.main.items[0]?.span ?? { file, start: 0, end: 0, line: 1, column: 1 });
+            const bytes = body.runtime('STRING_BYTES', [body.literal(asset.content)]), headers = body.runtime('HTTP_HEADERS', []);
+            const typed = body.runtime('HTTP_HEADERS_WITH', [headers, body.literal('content-type'), body.literal(asset.type)]);
+            const result = body.runtime('HTTP_RESPONSE', [bytes, body.literal(null, { kind: 'int', text: '200' }), typed]);
+            body.instruction({ op: 'copy', out: 0, input: result });
+            const fn = name + '_asset_' + index;
+            this.functions.push(body.finish(fn));
+            items.push({ method: 'GET', path: asset.path, function: fn, stream: 0, status: 200, policies: [] });
+        });
+        return name;
+    }
+    add(def, name, method, params, stmts, receiver = false) {
+        const body = new FunctionLowering(this, method.span.file, method.span, receiver ? def : undefined);
+        body.sourceName = method.name;
+        if (receiver) {
+            body.receiver = body.slot();
+            body.locals.set('self', body.receiver);
+        }
+        params.forEach((p, i) => body.parameter(p, i));
+        stmts.forEach(s => body.statement(s));
+        this.functions.push(body.finish(interceptorChain(name, this.checked.interceptorPlans.get(method) ?? []).body));
+        this.layers(method, name, params, receiver);
+    }
+    layers(node, name, params, receiver) {
+        for (const entry of interceptorChain(name, this.checked.interceptorPlans.get(node) ?? []).entries) {
+            const body = new FunctionLowering(this, entry.layer.definition.file, entry.layer.around.span, entry.layer.definition);
+            body.sourceName = node.name + ' [' + entry.layer.definition.name + ']';
+            if (receiver) {
+                body.receiver = body.slot();
+                body.locals.set('self', body.receiver);
+            }
+            params.forEach((param, index) => body.parameter(param, index));
+            body.interceptor(entry.layer, params, entry.next);
+            entry.layer.around.body.forEach(stmt => body.statement(stmt));
+            this.functions.push(body.finish(entry.name));
+        }
+    }
+}
+class FunctionLowering {
+    generator;
+    file;
+    span;
+    owner;
+    parameters = [];
+    receiver;
+    locals = new Map();
+    owned = new Set();
+    values = [];
+    variables = [];
+    scopes = [];
+    debugScope;
+    sourceName;
+    continuation;
+    constructionNext = false;
+    constructorResults = new Set();
+    slots = 1;
+    sequence = 0;
+    source;
+    error = 'cleanup';
+    returning = 'cleanup';
+    blocks = [];
+    current;
+    constructor(generator, file, span, owner) { this.generator = generator; this.file = file; this.span = span; this.source = span; this.owner = owner; this.values.push({ storage: 'rooted-value', type: dynamicType, span }); this.current = { name: 'entry_body', instructions: [] }; this.blocks.push(this.current); }
+    slot(type = dynamicType) { this.values.push({ storage: 'rooted-value', type, span: this.source }); return this.slots++; }
+    block() { return 'block_' + this.sequence++; }
+    enter(name) { this.current = { name, instructions: [] }; this.blocks.push(this.current); }
+    terminate(terminator) { this.current.terminator = terminator; }
+    instruction(value) { if (this.current.terminator)
+        this.enter(this.block()); this.current.instructions.push({ ...value, span: this.source, debugScope: this.debugScope }); }
+    local(name, slot, span, type = this.values[slot].type) {
+        this.locals.set(name, slot);
+        this.values[slot].type = type;
+        const variable = this.variables.length;
+        this.variables.push({ name, slot, span, type, scope: this.debugScope });
+        const source = this.source;
+        this.source = span;
+        this.instruction({ op: 'debug-variable', variable });
+        this.source = source;
+    }
+    parameter(param, index) { const type = irType(schemaType(this.generator.checked.project, param.type, this.file)), slot = this.slot(type); this.parameters[index] = slot; this.locals.set(param.name, slot); this.variables.push({ name: param.name, slot, span: param.span, type, argument: index + 1 }); if (param.ownership === 'own')
+        this.owned.add(slot); }
+    checkError() { const errors = this.block(), next = this.block(); this.terminate({ op: 'cancel', then: this.returning, otherwise: errors }); this.enter(errors); this.terminate({ op: 'error', failed: this.error, success: next }); this.enter(next); }
+    runtime(operation, args, text, number, check = true) {
+        if (operation.startsWith('HTTP_'))
+            this.generator.components.add('http');
+        const comparisons = ['==', '!=', '<', '>', '<=', '>='], integers = args.length === 2 && args.every(slot => isIRScalar(this.values[slot].type) && this.values[slot].type.name === 'int');
+        const binary = operation === 'BINARY' && integers && (comparisons.includes(text) || ['+', '-', '*', '/'].includes(text));
+        const integerResult = ['LIST_LENGTH', 'TUPLE_LENGTH', 'SET_LENGTH', 'MAP_LENGTH', 'STRING_LENGTH', 'BYTES_LENGTH', 'JSON_INTEGER'].includes(operation);
+        const booleanResult = ['SET_CONTAINS', 'MAP_CONTAINS', 'STRING_STARTS_WITH', 'STRING_IS_TOKEN', 'IS_TYPE', 'JSON_BOOLEAN'].includes(operation);
+        const out = this.slot(integerResult ? scalarType('int') : booleanResult ? scalarType('bool') : binary ? scalarType(comparisons.includes(text) ? 'bool' : 'int') : dynamicType);
+        this.instruction({ op: 'runtime', out, operation, args, text, number });
+        if (check && !(binary && text !== '/'))
+            this.checkError();
+        return out;
+    }
+    call(name, args, receiver) { const out = this.slot(); this.instruction({ op: 'call', out, function: name, args, receiver }); this.checkError(); return out; }
+    literal(value, numeric) { const out = this.slot(numeric ? scalarType(numeric.kind) : typeof value === 'boolean' ? scalarType('bool') : dynamicType); this.instruction({ op: 'literal', out, value, numeric }); return out; }
+    fieldIndex(object, name) {
+        const node = this.generator.checked.expressionTypes.get(object)?.def?.node;
+        if (node?.kind === 'class' || node?.kind === 'interceptor') {
+            const i = fieldsOf(node).findIndex(f => f.name === name);
+            if (i >= 0)
+                return i;
+        }
+        const type = this.generator.checked.expressionTypes.get(object);
+        if (type?.kind === 'builtin') {
+            const index = builtinProperties[type.name]?.findIndex(field => field.name === name);
+            if (index !== undefined && index >= 0)
+                return index;
+        }
+        if (name === 'code')
+            return 0;
+        if (name === 'message')
+            return 1;
+        throw new BackendUnsupported(object.span, 'field ' + name);
+    }
+    field(name) { const node = this.owner?.node; if (node?.kind !== 'class' && node?.kind !== 'interceptor')
+        return; const i = fieldsOf(node).findIndex(f => f.name === name); return i < 0 ? undefined : i; }
+    arguments(expr, plan) {
+        const source = expr.args.map(a => this.expression(a));
+        return plan ? plan.sourceIndices.map((index, i) => {
+            if (index !== undefined)
+                return source[index];
+            const injected = plan.injectionSources?.[i];
+            if (injected?.startsWith('self.'))
+                return this.runtime('FIELD', [this.locals.get('self')], undefined, this.field(injected.slice(5)));
+            if (injected) {
+                const slot = this.locals.get(injected);
+                if (slot !== undefined)
+                    return slot;
+            }
+            return plan.bindingKeys[i] ? this.call(this.generator.binding(plan.bindingKeys[i]), []) : this.literal(null);
+        }) : source;
+    }
+    expression(expr) {
+        const firstNewSlot = this.slots, result = this.expressionValue(expr), type = this.generator.checked.expressionTypes.get(expr);
+        if (result >= firstNewSlot && type)
+            this.values[result].type = irType(type);
+        return result;
+    }
+    expressionValue(expr) {
+        this.source = expr.span;
+        if (expr.kind === 'handle') {
+            const plan = this.generator.checked.actions.get(expr), endpoint = plan.endpoint.node.endpoint;
+            const metadata = { method: endpoint.method, path: endpoint.path, parameters: plan.parameters.map(({ param, type, form }) => ({ name: param.source?.name ?? param.name, source: param.source?.kind, form, schema: actionSchema(this.generator.checked.project, type) })) };
+            const values = expr.call.args.map(argument => argument.kind === 'formInput' ? this.literal(null) : this.expression(argument));
+            const args = plan.parameters.map(parameter => parameter.form || parameter.source === undefined ? this.literal(null) : values[parameter.source]);
+            return this.runtime('HTTP_ACTION', args, JSON.stringify(metadata));
+        }
+        if (expr.kind === 'markupText')
+            return this.literal(expr.text);
+        if (expr.kind === 'markup') {
+            const component = this.generator.checked.markupCalls.get(expr);
+            if (component)
+                return this.expression(component);
+            this.generator.components.add('http');
+            const names = expr.attributes.map(attribute => this.literal(attribute.name));
+            const values = expr.attributes.map(attribute => this.expression(attribute.value)), children = expr.children.map(child => this.expression(child)), out = this.slot();
+            this.instruction({ op: 'html', out, tag: expr.tag, attributes: names.flatMap((name, index) => [name, values[index]]), children });
+            this.checkError();
+            return out;
+        }
+        if (expr.kind === 'literal')
+            return typeof expr.value === 'number' ? this.literal(null, { kind: expr.numericType ?? 'int', text: expr.numericText ?? String(expr.value) }) : this.literal(expr.value);
+        if (expr.kind === 'name') {
+            const slot = this.locals.get(expr.name);
+            if (slot !== undefined)
+                return slot;
+            const index = this.field(expr.name);
+            if (index !== undefined)
+                return this.runtime('FIELD', [this.locals.get('self')], undefined, index);
+            throw new BackendUnsupported(expr.span, 'unresolved value ' + expr.name);
+        }
+        if (expr.kind === 'resolve')
+            return this.call(this.generator.binding(expr.name + (expr.typeArgs.length ? '<' + expr.typeArgs.map(typeName).join(',') + '>' : '')), []);
+        if (expr.kind === 'member')
+            return this.runtime('FIELD', [this.expression(expr.object)], undefined, this.fieldIndex(expr.object, expr.name));
+        if (expr.kind === 'unary') {
+            const input = this.expression(expr.value), type = this.values[input].type;
+            const pure = isIRScalar(type) && (type.name === 'int' && expr.op === '-' || type.name === 'bool' && expr.op === '!');
+            return this.runtime('UNARY', [input], expr.op, undefined, !pure);
+        }
+        if (expr.kind === 'binary') {
+            const left = this.expression(expr.left);
+            if (expr.op === '&&' || expr.op === '||') {
+                const out = this.slot();
+                this.instruction({ op: 'copy', out, input: left });
+                const evaluate = this.block(), after = this.block();
+                this.terminate({ op: 'branch', condition: left, then: expr.op === '&&' ? evaluate : after, otherwise: expr.op === '&&' ? after : evaluate });
+                this.enter(evaluate);
+                const right = this.expression(expr.right);
+                this.instruction({ op: 'copy', out, input: right });
+                this.terminate({ op: 'jump', target: after });
+                this.enter(after);
+                return out;
+            }
+            const right = this.expression(expr.right), a = this.values[left].type, b = this.values[right].type;
+            const pure = isIRScalar(a) && isIRScalar(b) && (a.name === 'int' && b.name === 'int' && ['+', '-', '*', '==', '!=', '<', '>', '<=', '>='].includes(expr.op) || a.name === 'bool' && b.name === 'bool' && ['==', '!='].includes(expr.op));
+            return this.runtime('BINARY', [left, right], expr.op, undefined, !pure);
+        }
+        if (expr.kind === 'collection') {
+            const values = expr.items.map(item => this.expression(item)), kind = this.generator.checked.expressionTypes.get(expr)?.name ?? expr.collection;
+            if (kind === 'Map') {
+                const out = this.runtime('MAP', []);
+                for (let i = 0; i < values.length; i += 2)
+                    this.runtime('MAP_SET', [out, values[i], values[i + 1]]);
+                return out;
+            }
+            return this.runtime(kind.toUpperCase(), values);
+        }
+        if (expr.kind === 'wait') {
+            const tasks = expr.tasks.map(task => this.expression(task)), out = this.slot();
+            this.instruction({ op: 'wait', out, tasks });
+            this.checkError();
+            return out;
+        }
+        if (expr.kind === 'start' && expr.call.kind === 'call') {
+            const call = expr.call, receiver = call.callee.kind === 'member' ? this.expression(call.callee.object) : undefined;
+            // Capture evaluation and injected dependencies in the parent. The child
+            // receives those values; it never reevaluates an argument or resolves DI.
+            const args = this.arguments(call, this.generator.checked.callPlans.get(call));
+            const thunk = new FunctionLowering(this.generator, this.file, expr.span, this.owner);
+            if (receiver !== undefined)
+                thunk.receiver = thunk.slot();
+            args.forEach((_, i) => {
+                const slot = thunk.slot();
+                thunk.parameters[i] = slot;
+                if (this.generator.checked.callPlans.get(call)?.ownerships?.[i] === 'own')
+                    thunk.owned.add(slot);
+            });
+            const result = thunk.invoke(call, thunk.receiver, [...thunk.parameters]);
+            thunk.instruction({ op: 'copy', out: 0, input: result });
+            if (thunk.owned.has(result))
+                thunk.instruction({ op: 'clear', slot: result });
+            const name = 'aug_task_thunk_' + this.generator.functions.length;
+            this.generator.functions.push(thunk.finish(name));
+            const out = this.slot();
+            this.instruction({ op: 'start', out, function: name, receiver, args, owned: args.map((_, i) => this.generator.checked.callPlans.get(call)?.ownerships?.[i] === 'own') });
+            this.generator.checked.callPlans.get(call)?.ownerships?.forEach((mode, i) => { if (mode === 'own')
+                this.instruction({ op: 'clear', slot: args[i] }); });
+            this.checkError();
+            return out;
+        }
+        if (expr.kind !== 'call')
+            throw new BackendUnsupported(expr.span, expr.kind + ' expressions');
+        const receiver = expr.callee.kind === 'member' ? this.expression(expr.callee.object) : undefined;
+        const args = expr.callee.kind === 'name' && expr.callee.name === 'next' ? expr.args.map(arg => this.expression(arg)) : this.arguments(expr, this.generator.checked.callPlans.get(expr));
+        return this.invoke(expr, receiver, args);
+    }
+    invoke(expr, receiver, args, unwrapped = false) {
+        this.source = expr.span;
+        if (expr.callee.kind === 'member') {
+            const type = this.generator.checked.expressionTypes.get(expr.callee.object), name = expr.callee.name;
+            if (type.kind === 'builtin' && (type.name === 'Json' && name === 'decode' || type.name === 'HttpRequest' && name === 'form')) {
+                const out = this.slot(), schema = this.generator.schemas.request(this.generator.checked.expressionTypes.get(expr));
+                if (name === 'form')
+                    this.generator.components.add('http');
+                this.instruction({ op: 'decode', out, input: receiver, schema, format: name === 'form' ? 'form' : 'json' });
+                this.checkError();
+                return out;
+            }
+            const operations = {
+                'List.length': 'LIST_LENGTH', 'List.get': 'LIST_GET', 'List.at': 'LIST_AT', 'List.append': 'LIST_APPEND', 'Tuple.length': 'TUPLE_LENGTH', 'Tuple.get': 'TUPLE_GET',
+                'Set.length': 'SET_LENGTH', 'Set.add': 'SET_ADD', 'Set.contains': 'SET_CONTAINS', 'Map.length': 'MAP_LENGTH', 'Map.get': 'MAP_GET', 'Map.take': 'MAP_TAKE', 'Map.contains': 'MAP_CONTAINS', 'Map.set': 'MAP_SET',
+                'string.length': 'STRING_LENGTH', 'string.bytes': 'STRING_BYTES', 'string.split': 'STRING_SPLIT', 'string.startsWith': 'STRING_STARTS_WITH', 'string.isToken': 'STRING_IS_TOKEN',
+                'Bytes.length': 'BYTES_LENGTH', 'Bytes.text': 'BYTES_TEXT', 'Bytes.base64url': 'BYTES_BASE64URL',
+                'Json.stringify': 'JSON_STRINGIFY', 'Json.get': 'JSON_GET', 'Json.require': 'JSON_REQUIRE', 'Json.string': 'JSON_STRING',
+                'Json.integer': 'JSON_INTEGER', 'Json.boolean': 'JSON_BOOLEAN', 'Json.items': 'JSON_ITEMS',
+                'Headers.with': 'HTTP_HEADERS_WITH', 'Headers.get': 'HTTP_HEADERS_GET', 'Headers.all': 'HTTP_HEADERS_ALL', 'HttpTestClient.request': 'HTTP_CLIENT_REQUEST'
+            };
+            const operation = operations[type.name + '.' + name];
+            if (operation) {
+                const noFailure = ['LIST_LENGTH', 'LIST_AT', 'LIST_APPEND', 'TUPLE_LENGTH', 'SET_LENGTH', 'SET_ADD', 'SET_CONTAINS', 'MAP_LENGTH', 'MAP_SET', 'MAP_GET', 'MAP_TAKE', 'MAP_CONTAINS', 'STRING_LENGTH', 'STRING_BYTES', 'STRING_SPLIT', 'STRING_STARTS_WITH', 'STRING_IS_TOKEN', 'BYTES_LENGTH', 'BYTES_BASE64URL'].includes(operation);
+                return this.runtime(operation, [receiver, ...args], undefined, undefined, !noFailure);
+            }
+            args = this.transferArguments(expr, args, false);
+            const out = this.slot();
+            this.instruction({ op: 'method', out, receiver: receiver, name, args });
+            if (this.generator.checked.callPlans.get(expr)?.returnOwnership === 'own')
+                this.owned.add(out);
+            this.checkError();
+            return out;
+        }
+        if (expr.callee.kind !== 'name')
+            throw new BackendUnsupported(expr.span, 'indirect callable values');
+        const name = expr.callee.name;
+        if (name === 'next') {
+            const next = this.continuation, plan = this.generator.checked.callPlans.get(expr);
+            const { args: forwarded, transfers } = next.forward(plan.sourceIndices, args);
+            const argumentsList = [...forwarded];
+            for (const { original, replacement } of transfers) {
+                const temporary = this.slot();
+                this.instruction({ op: 'copy', out: temporary, input: replacement });
+                argumentsList[this.parameters.indexOf(original)] = temporary;
+                if (replacement !== original)
+                    this.instruction({ op: 'drop', slot: original });
+                this.instruction({ op: 'clear', slot: original });
+                if (replacement !== original && this.owned.has(replacement))
+                    this.instruction({ op: 'clear', slot: replacement });
+            }
+            const out = this.call(next.target, argumentsList, next.receiver);
+            if (this.constructionNext)
+                this.constructorResults.add(out);
+            if (plan.returnOwnership === 'own')
+                this.owned.add(out);
+            return out;
+        }
+        if (name === 'assert') {
+            this.instruction({ op: 'assert', input: args[0], expression: this.generator.checked.project.files.get(this.file)?.source.slice(expr.args[0].span.start, expr.args[0].span.end) ?? 'assertion' });
+            this.checkError();
+            return this.literal(null);
+        }
+        if (name === 'int')
+            return args[0];
+        if (errorNames.includes(name)) {
+            const out = this.slot();
+            this.instruction({ op: 'object', out, type: name, fields: [], owned: [], methods: [], record: false });
+            return out;
+        }
+        if (name === 'Shared') {
+            const result = this.runtime('SHARED', [args[0]]);
+            if (this.owned.has(args[0]))
+                this.instruction({ op: 'clear', slot: args[0] });
+            return result;
+        }
+        if (name === 'HttpTestClient') {
+            const endpoint = this.generator.checked.project.testEndpoint, out = this.slot(), routes = this.generator.routeTable(endpoint.file, [endpoint.name]);
+            this.instruction({ op: 'routes', out, name: routes });
+            this.checkError();
+            return out;
+        }
+        const builtins = { exit: 'EXIT', print: 'PRINT', arguments: 'ARGUMENTS', c_int: 'C_INT', read_file: 'READ_FILE', write_file: 'WRITE_FILE', base64url_decode: 'BASE64URL_DECODE', Json: 'JSON_WRAP', Headers: 'HTTP_HEADERS', HttpResponse: 'HTTP_RESPONSE', ServerEvent: 'HTTP_EVENT' };
+        if (builtins[name])
+            return this.runtime(builtins[name], args);
+        if (['List', 'Tuple', 'Set', 'Map'].includes(name))
+            return this.runtime(name.toUpperCase(), args);
+        const def = this.generator.definition(this.file, name);
+        if (!def)
+            throw new BackendUnsupported(expr.span, 'builtin ' + name);
+        if (def.node.kind === 'function' && def.node.externC) {
+            if (!unwrapped && this.generator.checked.interceptorPlans.get(def.node)?.length) {
+                const result = this.call(this.generator.name(def), this.transferArguments(expr, args, false));
+                if (def.node.returnOwnership === 'own')
+                    this.owned.add(result);
+                return result;
+            }
+            const binding = this.generator.checked.native.functions.get(def.node), out = this.slot();
+            if (binding) {
+                args = this.transferArguments(expr, args, true);
+                const resources = {};
+                for (const [node, resource] of this.generator.checked.native.resources) {
+                    if (this.generator.checked.native.providers.get(node) !== this.generator.checked.native.providers.get(def.node))
+                        continue;
+                    const definition = this.generator.definition(node.span.file, node.name);
+                    resources[resource.module + '.' + resource.name] = { id: definition.id, release: resource.release };
+                }
+                const error = this.generator.checked.native.errors.get(def.node);
+                this.instruction({ op: 'native', out, binding, args, resources, error: error?.id, errorFactory: error && this.generator.name(error) });
+            }
+            else {
+                if (def.node.valueAbi) {
+                    // Compiler-owned adapters use the target pack's pointer thunks. Arbitrary
+                    // aggregate C declarations remain unsupported, even on an LLVM host.
+                    const adapters = {
+                        _aug_json_parse: { types: ['string'], result: 'Json', operation: 'JSON_PARSE' },
+                        _aug_time_now: { types: [], result: 'int', operation: 'TIME_NOW' }
+                    };
+                    const adapter = adapters[def.node.name];
+                    const plain = (type) => !type.nullable && !type.optional && !type.args.length;
+                    if (adapter && plain(def.node.returns) && def.node.returns.name === adapter.result && def.node.params.length === adapter.types.length && def.node.params.every((param, i) => plain(param.type) && param.type.name === adapter.types[i]))
+                        this.instruction({ op: 'runtime', out, operation: adapter.operation, args });
+                    else {
+                        const entry = runtimeAdapters.find(entry => entry.name === def.node.name);
+                        if (!entry || def.node.typeParams.length || def.node.returnOwnership !== 'managed' || typeName(def.node.returns) !== entry.returns || def.node.params.length !== entry.parameters.length || def.node.params.some((param, i) => param.ownership !== 'managed' || typeName(param.type) !== entry.parameters[i]))
+                            throw new BackendUnsupported(expr.span, 'legacy AugValue native adapter ' + def.node.name + ' with this signature');
+                        this.generator.components.add(entry.component);
+                        this.instruction({ op: 'adapter', out, name: adapterSymbol(entry), args });
+                    }
+                }
+                else
+                    this.instruction({ op: 'extern', out, name: def.node.name, types: def.node.params.map(p => p.type.name), result: def.node.returns.name, args });
+            }
+            if (def.node.returnOwnership === 'own')
+                this.owned.add(out);
+            this.checkError();
+            return out;
+        }
+        args = this.transferArguments(expr, args, false);
+        const out = this.slot();
+        this.instruction({ op: 'call', out, function: this.generator.name(def), args });
+        if (def.node.kind === 'function' && def.node.returnOwnership === 'own')
+            this.owned.add(out);
+        this.checkError();
+        return out;
+    }
+    transferArguments(expr, args, native) {
+        const transferred = [...args], plan = this.generator.checked.callPlans.get(expr);
+        plan?.ownerships?.forEach((mode, i) => {
+            if (mode !== 'own')
+                return;
+            const temporary = this.slot();
+            this.instruction({ op: 'copy', out: temporary, input: args[i] });
+            this.instruction({ op: 'clear', slot: args[i] });
+            transferred[i] = temporary;
+            // Native marshalling can reject the input before ownership crosses the ABI.
+            // The move helper clears this slot only after every input is valid.
+            if (native)
+                this.owned.add(temporary);
+        });
+        return transferred;
+    }
+    interceptor(layer, params, next) {
+        this.constructionNext = layer.constructorResultFresh === true;
+        this.continuation = new InterceptorInvocation(layer, params, [...this.parameters], next, this.receiver);
+        const dependencies = this.continuation.dependencies().map(slot => slot ?? this.literal(null));
+        const self = this.call(this.generator.name(layer.definition), dependencies);
+        this.locals.set('self', self);
+        for (const input of this.continuation.inputs()) {
+            if (input.reuseOwnedSlot) {
+                this.locals.set(input.name, input.slot);
+                continue;
+            }
+            const slot = this.slot();
+            this.locals.set(input.name, slot);
+            this.instruction({ op: 'copy', out: slot, input: input.slot ?? this.literal(null) });
+        }
+    }
+    nativeBody(def) {
+        const call = { kind: 'call', callee: { kind: 'name', name: def.name, span: def.node.span }, args: [], argLabels: [], typeArgs: [], span: def.node.span };
+        const result = this.invoke(call, undefined, [...this.parameters], true);
+        this.instruction({ op: 'copy', out: 0, input: result });
+        if (this.owned.has(result))
+            this.instruction({ op: 'clear', slot: result });
+    }
+    scoped(stmts, composition = false, setup, span) {
+        const locals = new Map(this.locals), owned = new Set(this.owned), parent = this.debugScope;
+        const first = span ?? stmts[0]?.span ?? this.source, last = stmts.at(-1)?.span;
+        this.debugScope = 'scope_' + this.scopes.length;
+        this.scopes.push({ name: this.debugScope, parent, span: { ...first, end: last?.end ?? first.end } });
+        setup?.();
+        for (const stmt of stmts)
+            this.statement(stmt);
+        if (composition && !this.current.terminator)
+            this.instruction({ op: 'scope', action: 'join' });
+        if (!this.current.terminator)
+            for (const slot of this.owned)
+                if (!owned.has(slot))
+                    this.instruction({ op: 'drop', slot });
+        this.locals.clear();
+        for (const [name, slot] of locals)
+            this.locals.set(name, slot);
+        this.debugScope = parent;
+    }
+    endpoint(def) {
+        const fn = def.node, endpoint = fn.endpoint, request = this.slot(), failed = this.block(), finished = this.block();
+        this.parameters.push(request);
+        this.error = failed;
+        this.returning = failed;
+        this.instruction({ op: 'scope', action: 'enter' });
+        const args = fn.params.map(() => this.slot());
+        fn.params.forEach((param, index) => {
+            if (!param.injected)
+                return;
+            const type = schemaType(this.generator.checked.project, param.type, def.file);
+            const key = type.name + (type.args.length ? '<' + type.args.map(arg => arg.name).join(',') + '>' : '');
+            const value = this.call(this.generator.binding(key), []);
+            this.instruction({ op: 'copy', out: args[index], input: value });
+        });
+        for (const policy of this.generator.checked.httpPolicies.get(fn) ?? []) {
+            this.instruction({ op: 'http-policy', policy: this.generator.policy(policy), args: [request, ...[0, 1].map(index => policy.dependencies[index] === undefined ? this.literal(null) : args[policy.dependencies[index]])] });
+            this.checkError();
+        }
+        fn.params.forEach((param, index) => {
+            if (param.injected)
+                return;
+            const schema = param.source.kind === 'request' ? undefined : this.generator.schemas.request(schemaType(this.generator.checked.project, param.type, def.file));
+            this.instruction({ op: 'http-bind', out: args[index], request, source: param.source.kind, name: param.source.name ?? param.name, schema });
+            this.checkError();
+        });
+        const result = this.call(this.generator.name(def), args), response = this.runtime('HTTP_RESPONSE_STATUS', [result, this.literal(null, { kind: 'int', text: String(endpoint.status) })]);
+        this.instruction({ op: 'copy', out: 0, input: response });
+        this.terminate({ op: 'jump', target: finished });
+        this.enter(failed);
+        this.instruction({ op: 'http-failure', out: 0, errors: endpoint.errors.map(error => ({ type: this.generator.definition(def.file, error.type.name)?.id ?? error.type.name, status: error.status })) });
+        this.terminate({ op: 'jump', target: finished });
+        this.enter(finished);
+        this.error = 'cleanup';
+        this.returning = 'cleanup';
+        const completed = this.runtime('HTTP_FINISH', [0]);
+        this.instruction({ op: 'copy', out: 0, input: completed });
+    }
+    tryAlways(stmt) {
+        const outerError = this.error, outerReturn = this.returning, owned = new Set(this.owned);
+        const caught = this.block(), failed = this.block(), returned = this.block(), cleanup = this.block(), finalized = this.block(), done = this.block();
+        const depth = this.slot(), locks = this.slot(), pending = this.slot(), cancelled = this.slot(), returning = this.slot(), failure = this.slot();
+        this.instruction({ op: 'scope-depth', out: depth });
+        this.instruction({ op: 'lock-depth', out: locks });
+        this.instruction({ op: 'copy', out: returning, input: this.literal(false) });
+        this.instruction({ op: 'copy', out: failure, input: this.literal(false) });
+        this.error = caught;
+        this.returning = returned;
+        this.scoped(stmt.body);
+        if (!this.current.terminator)
+            this.terminate({ op: 'jump', target: cleanup });
+        this.enter(caught);
+        this.instruction({ op: 'lock', action: 'restore', depth: locks });
+        this.instruction({ op: 'scope', action: 'join', depth });
+        for (const slot of this.owned)
+            if (!owned.has(slot))
+                this.instruction({ op: 'drop', slot });
+        this.instruction({ op: 'scope', action: 'restore', depth });
+        const handlers = this.block();
+        this.terminate({ op: 'cancel', then: failed, otherwise: handlers });
+        this.enter(handlers);
+        this.error = failed;
+        for (const clause of stmt.catches) {
+            const handler = this.block(), next = this.block();
+            this.terminate({ op: 'error-type', type: this.generator.definition(this.file, clause.type.name)?.id ?? clause.type.name, then: handler, otherwise: next });
+            this.enter(handler);
+            const error = this.slot();
+            this.instruction({ op: 'take-error', out: error });
+            this.scoped(clause.body, false, () => this.local(clause.name, error, clause.span, irType(schemaType(this.generator.checked.project, clause.type, this.file))), clause.span);
+            if (!this.current.terminator)
+                this.terminate({ op: 'jump', target: cleanup });
+            this.enter(next);
+        }
+        this.terminate({ op: 'jump', target: failed });
+        this.enter(failed);
+        this.instruction({ op: 'copy', out: failure, input: this.literal(true) });
+        this.terminate({ op: 'jump', target: cleanup });
+        this.enter(returned);
+        this.instruction({ op: 'copy', out: returning, input: this.literal(true) });
+        this.terminate({ op: 'jump', target: cleanup });
+        this.enter(cleanup);
+        this.instruction({ op: 'lock', action: 'restore', depth: locks });
+        this.instruction({ op: 'scope', action: 'join', depth });
+        for (const slot of this.owned)
+            if (!owned.has(slot))
+                this.instruction({ op: 'drop', slot });
+        this.instruction({ op: 'scope', action: 'restore', depth });
+        this.instruction({ op: 'error-state', action: 'save', error: pending, cancelled });
+        this.error = finalized;
+        this.returning = finalized;
+        this.scoped(stmt.always);
+        if (!this.current.terminator)
+            this.terminate({ op: 'jump', target: finalized });
+        this.enter(finalized);
+        this.instruction({ op: 'error-state', action: 'restore', error: pending, cancelled });
+        const returnedCheck = this.block(), errorCheck = this.block(), failedCheck = this.block();
+        this.terminate({ op: 'cancel', then: outerReturn, otherwise: returnedCheck });
+        this.enter(returnedCheck);
+        this.terminate({ op: 'branch', condition: returning, then: outerReturn, otherwise: errorCheck });
+        this.enter(errorCheck);
+        this.terminate({ op: 'error', failed: outerError, success: failedCheck });
+        this.enter(failedCheck);
+        this.terminate({ op: 'branch', condition: failure, then: outerError, otherwise: done });
+        this.enter(done);
+        this.error = outerError;
+        this.returning = outerReturn;
+    }
+    statement(stmt) {
+        this.source = stmt.span;
+        if (this.current.terminator)
+            this.enter(this.block());
+        if (this.generator.options.coverage && !this.generator.checked.project.files.get(stmt.span.file)?.builtin) {
+            this.generator.coverage.set(stmt.span.file + ':' + stmt.span.line, { file: stmt.span.file, line: stmt.span.line });
+            this.instruction({ op: 'cover', file: stmt.span.file, line: stmt.span.line });
+        }
+        if (stmt.kind === 'serve') {
+            const port = this.expression(stmt.port), routes = this.generator.routeTable(this.file, stmt.names);
+            this.instruction({ op: 'routes', name: routes, port });
+            this.checkError();
+            return;
+        }
+        if (stmt.kind === 'yield') {
+            this.runtime('HTTP_YIELD', [this.expression(stmt.value)]);
+            return;
+        }
+        if (stmt.kind === 'expr') {
+            const value = this.expression(stmt.expr);
+            if (this.owned.has(value))
+                this.instruction({ op: 'drop', slot: value });
+            return;
+        }
+        if (stmt.kind === 'assign') {
+            const value = this.expression(stmt.value);
+            this.source = stmt.span;
+            let targetOwns = stmt.ownership === 'own';
+            if (stmt.target.kind === 'name') {
+                const field = this.field(stmt.target.name);
+                if (!this.locals.has(stmt.target.name) && field !== undefined) {
+                    targetOwns ||= this.owner?.node.kind === 'class' && fieldsOf(this.owner.node)[field].ownership === 'own';
+                    this.runtime('SET_FIELD', [this.locals.get('self'), value], undefined, field);
+                }
+                else {
+                    let out = this.locals.get(stmt.target.name);
+                    if (out === undefined) {
+                        const type = stmt.declaredType ? irType(schemaType(this.generator.checked.project, stmt.declaredType, this.file)) : this.values[value].type;
+                        out = this.slot(type);
+                        this.local(stmt.target.name, out, stmt.span, type);
+                    }
+                    this.instruction({ op: 'copy', out, input: value });
+                    if (stmt.ownership === 'own')
+                        this.owned.add(out);
+                }
+            }
+            else if (stmt.target.kind === 'member') {
+                const fieldName = stmt.target.name;
+                const node = this.generator.checked.expressionTypes.get(stmt.target.object)?.def?.node;
+                targetOwns ||= node?.kind === 'class' && fieldsOf(node).some(field => field.name === fieldName && field.ownership === 'own');
+                this.runtime('SET_FIELD', [this.expression(stmt.target.object), value], undefined, this.fieldIndex(stmt.target.object, stmt.target.name));
+            }
+            if (targetOwns && this.owned.has(value))
+                this.instruction({ op: 'clear', slot: value });
+            return;
+        }
+        if (stmt.kind === 'return') {
+            if (stmt.value) {
+                const value = this.expression(stmt.value);
+                this.instruction({ op: 'copy', out: 0, input: value });
+                if (this.owned.has(value))
+                    this.instruction({ op: 'clear', slot: value });
+            }
+            this.terminate({ op: 'jump', target: this.returning });
+            return;
+        }
+        if (stmt.kind === 'throw') {
+            this.instruction({ op: 'throw', input: this.expression(stmt.value) });
+            this.terminate({ op: 'jump', target: this.error });
+            return;
+        }
+        if (stmt.kind === 'unsafe' || stmt.kind === 'borrow') {
+            this.scoped(stmt.body);
+            return;
+        }
+        if (stmt.kind === 'scope') {
+            this.instruction({ op: 'scope', action: 'enter' });
+            this.scoped(stmt.body, true);
+            if (!this.current.terminator) {
+                this.instruction({ op: 'scope', action: 'leave' });
+                this.checkError();
+            }
+            return;
+        }
+        if (stmt.kind === 'lock') {
+            const value = this.runtime('SHARED_LOCK', [this.expression(stmt.value)]);
+            this.scoped(stmt.body, false, () => this.local(stmt.name, value, stmt.span), stmt.span);
+            if (!this.current.terminator) {
+                this.instruction({ op: 'lock', action: 'leave' });
+                this.checkError();
+            }
+            return;
+        }
+        if (stmt.kind === 'if') {
+            const condition = this.expression(stmt.test), yes = this.block(), no = this.block(), done = this.block();
+            this.terminate({ op: 'branch', condition, then: yes, otherwise: no });
+            this.enter(yes);
+            this.scoped(stmt.then);
+            if (!this.current.terminator)
+                this.terminate({ op: 'jump', target: done });
+            this.enter(no);
+            this.scoped(stmt.otherwise);
+            if (!this.current.terminator)
+                this.terminate({ op: 'jump', target: done });
+            this.enter(done);
+            return;
+        }
+        if (stmt.kind === 'match') {
+            const value = this.expression(stmt.value), done = this.block();
+            // Match literals are checked constants. Keep the source ordering used by
+            // the reference backend, while evaluating the matched value only once.
+            const literals = stmt.cases.map(clause => clause.literal ? this.expression(clause.literal) : undefined);
+            for (const [index, clause] of stmt.cases.entries()) {
+                const body = this.block(), next = this.block();
+                if (clause.pattern === 'else')
+                    this.terminate({ op: 'jump', target: body });
+                else if (clause.pattern === 'null' || clause.pattern === 'some')
+                    this.terminate({ op: 'null', input: value, then: clause.pattern === 'null' ? body : next, otherwise: clause.pattern === 'null' ? next : body });
+                else {
+                    const condition = clause.pattern === 'type' ? this.runtime('IS_TYPE', [value], this.generator.definition(this.file, clause.type.name)?.id ?? clause.type.name) : this.runtime('BINARY', [value, literals[index]], '==');
+                    this.terminate({ op: 'branch', condition, then: body, otherwise: next });
+                }
+                this.enter(body);
+                this.scoped(clause.body, false, () => { if (clause.name)
+                    this.local(clause.name, value, clause.span); }, clause.span);
+                if (!this.current.terminator)
+                    this.terminate({ op: 'jump', target: done });
+                this.enter(next);
+            }
+            this.terminate({ op: 'jump', target: done });
+            this.enter(done);
+            return;
+        }
+        if (stmt.kind === 'while') {
+            const test = this.block(), body = this.block(), done = this.block();
+            this.terminate({ op: 'jump', target: test });
+            this.enter(test);
+            this.instruction({ op: 'checkpoint' });
+            this.checkError();
+            const condition = this.expression(stmt.test);
+            this.terminate({ op: 'branch', condition, then: body, otherwise: done });
+            this.enter(body);
+            this.scoped(stmt.body);
+            if (!this.current.terminator)
+                this.terminate({ op: 'jump', target: test });
+            this.enter(done);
+            return;
+        }
+        if (stmt.kind === 'freeze') {
+            const value = this.expression(stmt.value), out = this.runtime('FREEZE', [value]);
+            this.local(stmt.name, out, stmt.span);
+            if (this.owned.has(value))
+                this.instruction({ op: 'clear', slot: value });
+            return;
+        }
+        if (stmt.kind === 'destructure') {
+            const value = this.expression(stmt.value);
+            stmt.names.forEach((name, i) => this.local(name, this.runtime('TUPLE_GET', [value, this.literal(null, { kind: 'int', text: String(i) })]), stmt.span, this.values[value].type.args[i] ?? dynamicType));
+            return;
+        }
+        if (stmt.kind === 'for') {
+            const iterable = this.expression(stmt.iterable), map = this.generator.checked.expressionTypes.get(stmt.iterable)?.name === 'Map' && stmt.names.length === 2;
+            const values = this.runtime(map ? 'MAP_ITER' : 'ITER', [iterable]), index = this.slot(scalarType('int')), one = this.literal(null, { kind: 'int', text: '1' });
+            this.instruction({ op: 'copy', out: index, input: this.literal(null, { kind: 'int', text: '0' }) });
+            const length = this.runtime('LIST_LENGTH', [values]), test = this.block(), body = this.block(), done = this.block();
+            this.terminate({ op: 'jump', target: test });
+            this.enter(test);
+            this.instruction({ op: 'checkpoint' });
+            this.checkError();
+            const condition = this.runtime('BINARY', [index, length], '<');
+            this.terminate({ op: 'branch', condition, then: body, otherwise: done });
+            this.enter(body);
+            this.scoped(stmt.body, false, () => {
+                // The private snapshot cannot be changed by source code. Its length
+                // guards this index; map snapshots contain an even number of cells.
+                // Source List.get still retains its checked bounds behavior.
+                if (map) {
+                    stmt.names.forEach((name, i) => { this.local(name, this.runtime('LIST_AT', [values, index], undefined, undefined, false), stmt.span, this.values[iterable].type.args[i] ?? dynamicType); this.instruction({ op: 'copy', out: index, input: this.runtime('BINARY', [index, one], '+') }); });
+                }
+                else {
+                    const item = this.runtime('LIST_AT', [values, index], undefined, undefined, false);
+                    stmt.names.forEach((name, i) => this.local(name, stmt.names.length === 1 ? item : this.runtime('TUPLE_GET', [item, this.literal(null, { kind: 'int', text: String(i) })]), stmt.span, (stmt.names.length === 1 ? this.values[iterable].type.args[0] : this.values[iterable].type.args[0]?.args[i]) ?? dynamicType));
+                    this.instruction({ op: 'copy', out: index, input: this.runtime('BINARY', [index, one], '+') });
+                }
+            }, stmt.span);
+            if (!this.current.terminator)
+                this.terminate({ op: 'jump', target: test });
+            this.enter(done);
+            return;
+        }
+        if (stmt.kind === 'try') {
+            if (stmt.always) {
+                this.tryAlways(stmt);
+                return;
+            }
+            const outer = this.error, failed = this.block(), done = this.block(), owned = new Set(this.owned), depth = this.slot(), locks = this.slot();
+            this.instruction({ op: 'scope-depth', out: depth });
+            this.instruction({ op: 'lock-depth', out: locks });
+            this.error = failed;
+            this.scoped(stmt.body);
+            if (!this.current.terminator)
+                this.terminate({ op: 'jump', target: done });
+            this.enter(failed);
+            this.error = outer;
+            this.instruction({ op: 'lock', action: 'restore', depth: locks });
+            this.instruction({ op: 'scope', action: 'join', depth });
+            for (const slot of this.owned)
+                if (!owned.has(slot))
+                    this.instruction({ op: 'drop', slot });
+            this.instruction({ op: 'scope', action: 'restore', depth });
+            stmt.catches.forEach(clause => {
+                const handler = this.block(), next = this.block();
+                this.terminate({ op: 'error-type', type: this.generator.definition(this.file, clause.type.name)?.id ?? clause.type.name, then: handler, otherwise: next });
+                this.enter(handler);
+                const error = this.slot();
+                this.instruction({ op: 'take-error', out: error });
+                this.scoped(clause.body, false, () => this.local(clause.name, error, clause.span, irType(schemaType(this.generator.checked.project, clause.type, this.file))), clause.span);
+                if (!this.current.terminator)
+                    this.terminate({ op: 'jump', target: done });
+                this.enter(next);
+            });
+            this.terminate({ op: 'jump', target: outer });
+            this.enter(done);
+            return;
+        }
+        const unreachable = stmt;
+        throw new Error('Unexpected August statement ' + JSON.stringify(unreachable));
+    }
+    finish(name) {
+        for (const value of this.values)
+            if (isIRScalar(value.type))
+                value.storage = 'scalar-value';
+        if (!this.current.terminator)
+            this.terminate({ op: 'jump', target: 'cleanup' });
+        this.enter('cleanup');
+        this.terminate({ op: 'return' });
+        return { name, sourceName: this.sourceName ?? this.owner?.name ?? (name === 'aug_main_body' ? 'main' : name), span: this.span, slots: this.slots, values: this.values, variables: this.variables, scopes: this.scopes, parameters: this.parameters, receiver: this.receiver, owned: [...this.owned], constructorResults: [...this.constructorResults], blocks: this.blocks };
+    }
+}