radiance · commit

compiler: Add lexical regions

9a8d09d29db1f7eebae771702e2d703635f8dadb93e45700b3b5969e17abeb6a

Alexis Sellier committed 9 days ago 1 parent 0d7c8248

compiler/radiance.rad +246 -111

use std::lang::package;
use std::lang::il;
use std::lang::lower;
use std::arch::rv64;
use std::arch::rv64::asm;
use std::arch::rv64::emit;
use std::arch::rv64::printer;
use std::lang::sexpr;
use std::lang::gen::data;
use std::lang::il::binary;
use std::lang::il::binary::collect;
use std::lang::il::binary::program;
use std::lang::gen::labels;
use std::lang::gen::types;
use std::sys;
use std::sys::unix;
use std::collections::dict;

/// Maximum number of modules we can load per package.
constant MAX_LOADED_MODULES: u32 = module::MAX_MODULES;
constant MAX_LOADED_MODULES: u32 = 128;
/// Maximum number of packages we can compile.
constant MAX_PACKAGES: u32 = 4;
/// Total module entries across all packages.
constant MAX_TOTAL_MODULES: u32 = 192;
/// Source code buffer arena (2 MB).
constant MAX_SOURCES_SIZE: u32 = 2097152;
/// Source code buffer arena (4 MB).
constant MAX_SOURCES_SIZE: u32 = 4194304;
/// Maximum number of test functions we can discover.
constant MAX_TESTS: u32 = 1024;
/// Maximum number of assembly source paths we can load per package.
constant MAX_ASM_MODULES: u32 = 64;

/// AST arena size (64 MB) - retains parsed nodes throughout compilation.
constant TEMP_ARENA_SIZE: u32 = 67108864;
/// Per-function lowering and register-allocation arena size (16 MB).
constant FN_ARENA_SIZE: u32 = 16777216;
/// Main arena size (96 MB) - lives throughout compilation.
/// Main arena size (160 MB) - lives throughout compilation.
/// Used for: resolver data, types, symbols, global IL data, and codegen output.
constant MAIN_ARENA_SIZE: u32 = 100663296;
constant MAIN_ARENA_SIZE: u32 = 167772160;

/// AST storage arena.
static TEMP_ARENA: [u8; TEMP_ARENA_SIZE] = [0; TEMP_ARENA_SIZE];
/// Scratch storage reclaimed after each generated function.
static FN_ARENA: [u8; FN_ARENA_SIZE] = [0; FN_ARENA_SIZE];

static MAIN_ARENA: [u8; MAIN_ARENA_SIZE] = [0; MAIN_ARENA_SIZE];

/// Module source code.
static MODULE_SOURCES: [u8; MAX_SOURCES_SIZE] = [0; MAX_SOURCES_SIZE];
/// Module entries for all packages.
unsafe static MODULE_ENTRIES: [module::ModuleEntry; MAX_TOTAL_MODULES] = undefined;
unsafe static MODULE_ENTRIES: [?*module::ModuleEntry; module::MAX_MODULES] = [nil; module::MAX_MODULES];
/// String pool.
unsafe static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };

/// Package scope.
unsafe static RESOLVER_PKG_SCOPE: resolver::Scope = undefined;


/// Code generation storage.
unsafe static CODEGEN_DATA_SYMS: [data::DataSym; data::MAX_DATA_SYMS] = undefined;
/// Hash table entries for data symbol lookup.
unsafe static CODEGEN_DATA_SYM_ENTRIES: [dict::Entry; data::DATA_SYM_TABLE_SIZE] = undefined;
/// Emitted instruction storage.
static CODEGEN_INSTRUCTIONS: [u32; emit::MAX_INSTRS] = [0; emit::MAX_INSTRS];
/// Local branch patch storage.
unsafe static CODEGEN_PENDING_BRANCHES: [emit::PendingBranch; emit::MAX_PENDING] = undefined;
/// Function call patch storage.
unsafe static CODEGEN_PENDING_CALLS: [emit::PendingCall; emit::MAX_PENDING] = undefined;
/// Assembly jump patch storage.
unsafe static CODEGEN_PENDING_JUMPS: [emit::PendingJump; emit::MAX_PENDING] = undefined;
/// Address load patch storage.
unsafe static CODEGEN_PENDING_ADDR_LOADS: [emit::PendingAddrLoad; emit::MAX_PENDING] = undefined;
/// Per-function block offset storage.
static CODEGEN_BLOCK_OFFSETS: [i32; labels::MAX_BLOCKS_PER_FN] = [0; labels::MAX_BLOCKS_PER_FN];
/// Function label hash table storage.
unsafe static CODEGEN_FUNC_ENTRIES: [dict::Entry; labels::FUNC_TABLE_SIZE] = undefined;
/// Printed function address storage.
unsafe static CODEGEN_FUNCS: [types::FuncAddr; emit::MAX_FUNCS] = undefined;
/// Debug location storage.
unsafe static CODEGEN_DEBUG_ENTRIES: [types::DebugEntry; emit::MAX_DEBUG_ENTRIES] = undefined;

/// Maximum number of exported definitions in one binary package.
constant MAX_PACKAGE_EXPORTS: u32 = 8192;
/// Maximum number of indexed names in one binary package.
constant MAX_PACKAGE_SYMBOLS: u32 = 16384;


    let moduleId = try package::registerModule(pkg, graph, &mut STRING_POOL, path) catch {
        throw error(&["error registering module"]);
    };
    // Read file into remaining arena space.
    let buffer = alloc::remainingBuf(sourceArena);
    let buffer = alloc::remainingBuf(&mut *sourceArena);
    if buffer.len == 0 {
        throw error(&["fatal:", "source arena exhausted"]);
    }
    let sourceLen = unix::readFile(path, buffer) else {
        throw error(&["error reading file"]);

        throw error(&["no root module found"]);
    };
    let rootEntry = module::get(graph, rootId) else {
        throw error(&["root module entry not found"]);
    };
    let rootAst = rootEntry.ast else {
    let rootAst = module::astFor(rootEntry) else {
        throw error(&["root module has no AST"]);
    };
    return RootModule { entry: rootEntry, ast: rootAst };
}


    ast::printer::printTree(root.ast, &mut arena);
}

/// Lower all packages into a single IL program.
/// Dependencies are lowered first, then the entry package.
unsafe fn lowerAllPackages(
unsafe fn lowerAllPackages 'arena (
    ctx: *unsafe mut CompileContext,
    res: *unsafe mut resolver::Resolver
    res: *unsafe mut resolver::Resolver 'arena
) -> il::Program throws (Error) {
    let entryIdx = ctx.entryPkgIdx else {
        panic "lowerAllPackages: no entry package";
    };
    let entryPkg = &ctx.packages[entryIdx];

    // Create the lowerer accumulator using entry package's name.
    let options = lower::LowerOptions { debug: ctx.debug, buildTest: ctx.config.buildTest };
    let mut low = lower::lowerer(
        res, &ctx.graph, entryPkg.name, &mut res.arena, &mut res.arena, options
    );
    try lowerAllPackagesInto(ctx, res, &mut low);
    let arena = (&mut *res.arena) as *unsafe mut alloc::Arena;
    let resolved: 'phase = &*res, graph = &ctx.graph where 'arena: 'phase in {
        let mut low = lower::lowerer(
            resolved, graph, entryPkg.name, arena, options
        );
        try lowerAllPackagesInto(ctx, &mut low, &mut *arena);

    // Finalize and return the unified program.
    return lower::finalize(low);
        // Finalize and return the unified program.
        return lower::finalize(low);
    }
}

/// Lower all packages into an existing lowerer.
unsafe fn lowerAllPackagesInto(
    ctx: *unsafe mut CompileContext,
    res: *unsafe mut resolver::Resolver,
    low: &mut lower::Lowerer
) throws (Error) {
unsafe fn lowerAllPackagesInto 'arena 'phase (
    ctx: &CompileContext,
    low: &mut lower::Lowerer 'arena 'phase,
    functionArena: &mut alloc::Arena
) throws (Error) where 'arena: 'phase {
    let entryIdx = ctx.entryPkgIdx else {
        panic "lowerAllPackagesInto: no entry package";
    };
    // Lower all packages except entry.
    for i in 0..ctx.packageCount {
        if i <> entryIdx {
            try lowerPackage(ctx, res, low, &ctx.packages[i], false);
            try lowerPackage(ctx, low, &ctx.packages[i], false, functionArena);
        }
    }
    // Lower entry package.
    try lowerPackage(ctx, res, low, &ctx.packages[entryIdx], true);
    try lowerPackage(ctx, low, &ctx.packages[entryIdx], true, functionArena);
}

/// Lower all modules in a package into the lowerer accumulator.
unsafe fn lowerPackage(
unsafe fn lowerPackage 'arena 'phase (
    ctx: &CompileContext,
    res: *unsafe mut resolver::Resolver,
    low: &mut lower::Lowerer,
    low: &mut lower::Lowerer 'arena 'phase,
    pkg: &package::Package,
    isEntry: bool
) throws (Error) {
    isEntry: bool,
    functionArena: &mut alloc::Arena
) throws (Error) where 'arena: 'phase {
    let rootId = pkg.rootModuleId else {
        throw error(&["no root module found"]);
    };
    // Set lowerer's package context for qualified name generation.
    // TODO: We shouldn't have to call this manually.
    lower::setPackage(low, &ctx.graph, pkg.name);
    lower::setPackage(low, pkg.name);

    try lowerModuleTreeInto(ctx, low, &ctx.graph, rootId, isEntry, pkg);
    try lowerModuleTreeInto(ctx, low, &ctx.graph, rootId, isEntry, pkg, functionArena);
}

/// Recursively lower a module and all its children into the accumulator.
unsafe fn lowerModuleTreeInto(
unsafe fn lowerModuleTreeInto 'arena 'phase (
    ctx: &CompileContext,
    low: &mut lower::Lowerer,
    low: &mut lower::Lowerer 'arena 'phase,
    graph: &module::ModuleGraph,
    modId: u16,
    isRoot: bool,
    pkg: &package::Package
) throws (Error) {
    pkg: &package::Package,
    functionArena: &mut alloc::Arena
) throws (Error) where 'arena: 'phase {
    let entry = module::get(graph, modId) else {
        throw error(&["module entry not found"]);
    };
    let modAst = entry.ast else {
    let modAst = module::astFor(entry) else {
        throw error(&["module has no AST"]);
    };
    pkgLog(pkg, &["lowering", "(", entry.filePath, ")", ".."]);

    try lower::lowerModule(low, modId, modAst, isRoot) catch err {
    try lower::lowerModule(low, modId, modAst, isRoot, functionArena) catch err {
        io::printError("radiance: ");
        io::printError("internal error during lowering: ");
        lower::printError(err);
        io::printError("\n");

        throw Error::Other;
    };
    // Recurse into children.
    for i in 0..entry.childrenLen {
    for i in 0..module::childCount(entry) {
        let childId = module::childAt(entry, i);
        try lowerModuleTreeInto(ctx, low, graph, childId, false, pkg);
        try lowerModuleTreeInto(ctx, low, graph, childId, false, pkg, functionArena);
    }
}

/// Build a scope access chain: a::b::c from a slice of identifiers.
unsafe fn synthScopeAccess(arena: &mut ast::NodeArena, path: &[*[u8]]) -> *ast::Node {

fn collectModuleTests(
    entry: *module::ModuleEntry,
    tests: &mut [TestDesc],
    testCount: &mut u32
) {
    let modAst = entry.ast else {
    let modAst = module::astFor(entry) else {
        return;
    };
    let case ast::NodeValue::Block(block) = modAst.value else {
        return;
    };

    return ast::synthNode(arena, ast::NodeValue::Call(ast::Call { callee, args }));
}

/// Inject a test runner into the entry package's root module.
///
/// Scans all parsed modules for `@test fn` declarations, then appends
/// Scans the entry package for `@test fn` declarations, then appends
/// a synthetic entry point to the root module's AST block:
///
/// ```
/// @default fn #testMain() -> i32 {
///     return testing::runAllTests(&[

    arena: &mut ast::NodeArena
) throws (Error) {
    let entryPkg = try getEntryPackage(ctx);
    let root = try getRootModule(&entryPkg, &ctx.graph);

    // Collect all test functions across all modules.
    // Collect test functions from the entry package's modules.
    let mut tests: [TestDesc; MAX_TESTS] = undefined;
    let mut testCount: u32 = 0;

    for modIdx in 0..ctx.graph.entriesLen {
        if let entry = module::get(&ctx.graph, modIdx as u16) {
            collectModuleTests(entry, &mut tests[..], &mut testCount);
            if entry.packageId == entryPkg.id {
                collectModuleTests(entry, &mut tests[..], &mut testCount);
            }
        }
    }
    if testCount == 0 {
        throw error(&["fatal:", "no test functions found"]);
    }

    let unsafeAttr = ast::synthNode(arena, ast::NodeValue::Attribute(ast::Attribute::Unsafe));
    let attrList = ast::nodeSlice(arena, 2).append(attrNode, a).append(unsafeAttr, a);
    let fnAttrs = ast::Attributes { list: attrList };

    return ast::synthNode(arena, ast::NodeValue::FnDecl(ast::FnDecl {
        name: fnName, sig: fnSig, body: fnBody, attrs: fnAttrs,
        name: fnName, regions: &[], sig: fnSig, body: fnBody, attrs: fnAttrs,
    }));
}

/// Build a block node with a declaration appended to its statement list.
unsafe fn injectIntoBlock(

) throws (Error) {
    if entries.len == 0 {
        return;
    }
    // Use remaining arena space as serialization buffer.
    let buf = alloc::remainingBuf(arena);
    let buf = alloc::remainingBuf(&mut *arena);
    let mut pos: u32 = 0;

    for i in 0..entries.len {
        let entry = &entries[i];
        let modEntry = module::get(graph, entry.moduleId) else {

    }
    try writeDataWithExt(&buf[..pos], basePath, DEBUG_EXT);
}

/// Run the resolver on the parsed modules.
unsafe fn runResolver(ctx: *unsafe mut CompileContext, nodeCount: u32) -> resolver::Resolver throws (Error) {
    let mut mainArena = alloc::new(&mut MAIN_ARENA[..]);
unsafe fn runResolver 'arena (ctx: *unsafe mut CompileContext, mainArena: &'arena mut alloc::Arena, nodeCount: u32) -> resolver::Resolver 'arena throws (Error) {
    let entryPkg = try getEntryPackage(ctx);

    pkgLog(&entryPkg, &["resolving", ".."]);

    let nodeDataSize = nodeCount * @sizeOf(resolver::NodeData);
    let nodeDataPtr = try! alloc::alloc(&mut mainArena, nodeDataSize, @alignOf(resolver::NodeData));
    let nodeDataPtr = try! alloc::alloc(&mut *mainArena, nodeDataSize, @alignOf(resolver::NodeData));
    let nodeData = @sliceOf(nodeDataPtr as *mut resolver::NodeData, nodeCount);
    let storage = resolver::ResolverStorage {
        arena: mainArena,
        nodeData,
        pkgScope: &mut RESOLVER_PKG_SCOPE,
        errors: &mut RESOLVER_ERRORS[..],
    };
    let mut res = resolver::resolver(storage, ctx.config);
    let mut res = resolver::resolver(mainArena, storage, ctx.config);

    // Build the semantic package list consumed by the resolver.
    let mut resolverPkgs: [resolver::Pkg; MAX_PACKAGES] = undefined;
    let mut resolverPackageCount: u32 = 0;
    for i in 0..ctx.packageCount {

    pkgLog(pkg, &["asm:", "parsing", "(", path, ")", ".."]);

    let sourceLen = unix::readFile(path, &mut ASM_SOURCE_BUF[..]) else {
        throw error(&["error reading assembly file"]);
    };
    let source = &ASM_SOURCE_BUF[..sourceLen];
    if source.len == ASM_SOURCE_BUF.len {
    let input = &ASM_SOURCE_BUF[..sourceLen];
    if input.len == ASM_SOURCE_BUF.len {
        throw error(&["fatal:", "assembly source too large:", path]);
    }
    // Assembly symbols borrow source bytes until final linking.
    let buffer = try alloc::allocSlice(arena, 1, 1, input.len) catch {
        throw error(&["assembly source workspace exhausted"]);
    };
    let source = buffer as *mut [u8];
    try! mem::copy(source, input);
    let program = try asm::assemble(
        asm::scanner::SourceKind::File { path },
        source,
        &mut ASM_TEXT_BUF[..],
        &mut ASM_DATA_BUF[..],

        }
    }
    return &ASM_RO_DATA_BUF[..*asmDataLen];
}

/// Generate dependency packages before the entry package.
unsafe fn generateAllPackagesInto 'arena 'phase (
    ctx: &CompileContext, low: &mut lower::Lowerer 'arena 'phase,
    generator: &mut rv64::Generator, fnArena: &mut alloc::Arena
) throws (Error) where 'arena: 'phase {
    let entryIdx = ctx.entryPkgIdx else panic "generateAllPackagesInto: no entry package";
    for i in 0..ctx.packageCount {
        if i <> entryIdx {
            try generatePackageInto(ctx, low, &ctx.packages[i], false, generator, fnArena);
        }
    }
    try generatePackageInto(ctx, low, &ctx.packages[entryIdx], true, generator, fnArena);
}

/// Generate all functions in one package.
unsafe fn generatePackageInto 'arena 'phase (
    ctx: &CompileContext, low: &mut lower::Lowerer 'arena 'phase,
    pkg: &package::Package, isEntry: bool,
    generator: &mut rv64::Generator, fnArena: &mut alloc::Arena
) throws (Error) where 'arena: 'phase {
    let rootId = pkg.rootModuleId else throw error(&["no root module found"]);
    lower::setPackage(low, pkg.name);
    try generateModuleTree(ctx, low, rootId, isEntry, pkg, generator, fnArena);
}

/// Lower and consume each function before visiting the next declaration.
unsafe fn generateModuleTree 'arena 'phase (
    ctx: &CompileContext, low: &mut lower::Lowerer 'arena 'phase,
    modId: u16, isRoot: bool, pkg: &package::Package,
    generator: &mut rv64::Generator, fnArena: &mut alloc::Arena
) throws (Error) where 'arena: 'phase {
    let entry = module::get(&ctx.graph, modId) else throw error(&["module entry not found"]);
    let modAst = module::astFor(entry) else throw error(&["module has no AST"]);
    pkgLog(pkg, &["lowering", "(", entry.filePath, ")", ".."]);
    set low.currentMod = modId;
    let mut cursor = try lower::moduleCursor(modAst, isRoot) catch err {
        io::printError("radiance: internal error during lowering: ");
        lower::printError(err);
        io::printError("\n");
        throw Error::Other;
    };
    loop {
        let result = try lower::lowerNext(low, &mut cursor, fnArena) catch err {
            io::printError("radiance: internal error during lowering: ");
            lower::printError(err);
            io::printError("\n");
            throw Error::Other;
        };
        let next = result else break;
        codegen::emit(generator, fnArena, &*next.function, next.role);
    }
    for i in 0..module::childCount(entry) {
        let childId = module::childAt(entry, i);
        try generateModuleTree(ctx, low, childId, false, pkg, generator, fnArena);
    }
}

/// Lower all packages while streaming each lowered function into RV64 codegen.
unsafe fn lowerAndGenerateAllPackages(
unsafe fn lowerAndGenerateAllPackages 'arena (
    ctx: *unsafe mut CompileContext,
    res: *unsafe mut resolver::Resolver,
    res: *unsafe mut resolver::Resolver 'arena,
    fnArena: &mut alloc::Arena,
    codegenOptions: CodegenOptions
) -> rv64::Program throws (Error) {
    let entryIdx = ctx.entryPkgIdx else {
        panic "lowerAndGenerateAllPackages: no entry package";

        case CodegenEntryMode::DefaultEntry => {
            set entryPatch = rv64::EntryPatch::Reserved(nil);
        }
        else => {}
    }
    let mut generator = try rv64::beginProgram(
        rv64::ProgramOptions { entryPatch, debug: codegenOptions.debug, placement: rv64::image::Placement::Hosted },
        &mut res.arena
    ) catch { throw error(&["code generation workspace exhausted"]); };
    let mut codegenCtx = codegen::Context {
        generator: &mut generator,
        fnArena: (&mut *fnArena) as *unsafe mut alloc::Arena,
    let emitterStorage = emit::Storage {
        code: &mut CODEGEN_INSTRUCTIONS[..],
        pendingBranches: &mut CODEGEN_PENDING_BRANCHES[..],
        pendingCalls: &mut CODEGEN_PENDING_CALLS[..],
        pendingJumps: &mut CODEGEN_PENDING_JUMPS[..],
        pendingAddrLoads: &mut CODEGEN_PENDING_ADDR_LOADS[..],
        blockOffsets: &mut CODEGEN_BLOCK_OFFSETS[..],
        funcEntries: &mut CODEGEN_FUNC_ENTRIES[..],
        funcs: &mut CODEGEN_FUNCS[..],
        debugEntries: &mut CODEGEN_DEBUG_ENTRIES[..],
    };
    let mut low = lower::lowerer(
        res, &ctx.graph, entryPkg.name, &mut res.arena, fnArena as *unsafe mut alloc::Arena, options
    let mut generator = rv64::beginProgramWithStorage(
        rv64::ProgramOptions {
            entryPatch,
            debug: codegenOptions.debug,
            placement: rv64::image::Placement::Hosted,
        },
        emitterStorage
    );
    set low.output = lower::FnOutput::Stream(lower::FnSink {
        ctx: &mut codegenCtx as *unsafe mut opaque,
        emitFn: codegen::emit,
    });
    let mut asmDataLen: u32 = 0;
    if let path = startupPath {
        try assembleAsmModule(&mut generator, entryPkg, path, &mut asmDataLen, &mut res.arena);
    }
    try lowerAllPackagesInto(ctx, res, &mut low);
    let asmData = try assembleAsmInputs(ctx, &mut generator, &mut asmDataLen, &mut res.arena);
    let arena = (&mut *res.arena) as *unsafe mut alloc::Arena;
    let resolved: 'phase = &*res, graph = &ctx.graph where 'arena: 'phase in {
        let mut low = lower::lowerer(
            resolved, graph, entryPkg.name, arena, options
        );
        let mut asmDataLen: u32 = 0;
        if let path = startupPath {
            try assembleAsmModule(&mut generator, entryPkg, path, &mut asmDataLen, arena);
        }
        try generateAllPackagesInto(ctx, &mut low, &mut generator, fnArena);
        let asmData = try assembleAsmInputs(ctx, &mut generator, &mut asmDataLen, arena);

    match generator.entryPatch {
        case rv64::EntryPatch::Reserved(targetName) => {
            if targetName == nil {
                throw error(&["fatal:", "no default function found"]);
        match generator.entryPatch {
            case rv64::EntryPatch::Reserved(targetName) => {
                if targetName == nil {
                    throw error(&["fatal:", "no default function found"]);
                }
            }
            else => {
            }
        }
        else => {}
    }
    if let path = codegenOptions.logPath {
        pkgLog(entryPkg, &["generating code", "(", path, ")", ".."]);
        if let path = codegenOptions.logPath {
            pkgLog(entryPkg, &["generating code", "(", path, ")", ".."]);
        }
        return try rv64::finishProgram(
            generator, low.data, storage, asmData,
            &mut RO_DATA_BUF[..], &mut RW_DATA_BUF[..]
        ) catch err {
            match err {
                case rv64::Error::Allocation => throw error(&["code generation workspace exhausted"]),
                case rv64::Error::Capacity => throw error(&["code generation output capacity exceeded"]),
                case rv64::Error::Symbol => throw error(&["code generation has an unresolved symbol"]),
                case rv64::Error::Relocation => throw error(&["code generation relocation is out of range"]),
                case rv64::Error::Image(_) => throw error(&["code generation image layout is invalid"]),
                case rv64::Error::Data(_) => throw error(&["code generation data layout is invalid"]),
            }
        };
    }
    return try rv64::finishProgram(&mut generator, low.data, storage, asmData, &mut RO_DATA_BUF[..], &mut RW_DATA_BUF[..]) catch {
        throw error(&["code generation failed: capacity, symbol, relocation, or image layout"]);
    };
}

/// Source exports selected for one binary RIL package.
record PackageExports: Copy {
    /// Number of initialized entries in the caller's export table.

) -> PackageExports throws (Error) {
    let mut count: u32 = 0;
    let mut entryName: ?*[u8] = nil;
    for i in 0..ctx.graph.entriesLen {
        let modEntry = module::get(&ctx.graph, i as u16) else continue;
        if modEntry.packageId <> pkg.id { continue; }
        let root = modEntry.ast else continue;
        if modEntry.packageId <> pkg.id {
            continue;
        }
        let root = module::astFor(modEntry) else continue;
        let case ast::NodeValue::Block(block) = root.value else continue;
        for node in block.statements {
            let mut ident: ?*ast::Node = nil;
            let mut attrs: ?ast::Attributes = nil;
            let mut kind = binary::ExportKind::Function;
            match node.value {
                case ast::NodeValue::FnDecl(decl) => { set ident = decl.name; set attrs = decl.attrs; },
                case ast::NodeValue::FnDecl(decl) => {
                    set ident = decl.name;
                    set attrs = decl.attrs;
                },
                case ast::NodeValue::ConstDecl(decl) => {
                    set ident = decl.ident; set attrs = decl.attrs; set kind = binary::ExportKind::Data;
                },
                case ast::NodeValue::StaticDecl(decl) => {
                    set ident = decl.ident; set attrs = decl.attrs; set kind = binary::ExportKind::Data;
                },
                else => continue,
            }
            let attributes = attrs else continue;
            if ast::attributesContains(&attributes, ast::Attribute::Intrinsic) {
                continue;
            }
            let isDefault = ast::attributesContains(&attributes, ast::Attribute::Default)
                and pkg.rootModuleId == modEntry.id;
            if not isDefault and not ast::attributesContains(&attributes, ast::Attribute::Export) {
                continue;
            }

            let qualified = il::formatQualifiedName(arena, module::moduleQualifiedPath(modEntry), name);
            let mut present = false;
            match kind {
                case binary::ExportKind::Function => {
                    for func in ilProgram.fns {
                        if mem::eq(func.name, qualified) { set present = true; }
                        if mem::eq(func.name, qualified) {
                            set present = true;
                        }
                    }
                },
                case binary::ExportKind::Data => {
                    for item in ilProgram.data {
                        if mem::eq(item.name, qualified) { set present = true; }
                        if mem::eq(item.name, qualified) {
                            set present = true;
                        }
                    }
                },
            }
            if not present { continue; }
            if count == exports.len { throw error(&["too many package exports"]); }
            if not present {
                continue;
            }
            if count == exports.len {
                throw error(&["too many package exports"]);
            }
            set exports[count] = binary::Export { name: qualified, kind };
            set count += 1;
            if isDefault { set entryName = qualified; }
            if isDefault {
                set entryName = qualified;
            }
        }
    }
    return PackageExports { count, entry: entryName };
}

/// Emit one binary RIL file per package into an existing directory.
unsafe fn emitPackages(ctx: *unsafe mut CompileContext, res: *unsafe mut resolver::Resolver, directory: *[u8]) throws (Error) {
unsafe fn emitPackages 'arena (
    ctx: *unsafe mut CompileContext,
    res: *unsafe mut resolver::Resolver 'arena,
    directory: *[u8]
) throws (Error) {
    for i in 0..ctx.packageCount {
        if ctx.inputs[i].asmPathCount > 0 or ctx.inputs[i].startupPath <> nil {
            throw error(&["binary RIL output requires Radiance source modules"]);
        }
    }
    let unified = try lowerAllPackages(ctx, res);
    let allocator = alloc::arenaAllocator(&mut res.arena);
    let allocator = alloc::arenaAllocator(&mut *res.arena);
    for i in 0..ctx.packageCount {
        let pkg = &ctx.packages[i];
        let mut dataItems: *mut [il::Data] = &mut [];
        let mut functions: *unsafe mut [*unsafe il::Fn] = &mut [];
        for item in unified.data {
            if ownsSymbol(pkg.name, item.name) { dataItems.append(item, allocator); }
            if ownsSymbol(pkg.name, item.name) {
                dataItems.append(item, allocator);
            }
        }
        for func in unified.fns {
            if ownsSymbol(pkg.name, func.name) { functions.append(func, allocator); }
            if ownsSymbol(pkg.name, func.name) {
                functions.append(func, allocator);
            }
        }
        let local = il::Program { data: &dataItems[..], fns: functions };
        let selected = try packageExports(ctx, pkg, &local, &mut PACKAGE_EXPORTS[..], &mut res.arena);
        let selected = try packageExports(ctx, pkg, &local, &mut PACKAGE_EXPORTS[..], &mut *res.arena);
        let mut dependencies: [*[u8]; MAX_PACKAGES] = undefined;
        let mut names = collect::new(&mut PACKAGE_SYMBOLS[..], &mut dependencies[..]);
        let image = try collect::package(&mut names, pkg.name, local, &PACKAGE_EXPORTS[..selected.count], selected.entry) catch {
            throw error(&["cannot collect binary RIL package", pkg.name]);
        };

    let suffix = mem::stripPrefix(owner, name) else return false;
    return suffix.len > 2 and suffix[0] == ':' and suffix[1] == ':';
}

/// Lower, optionally dump, and optionally generate binary output.
unsafe fn compile(
unsafe fn compile 'arena (
    ctx: *unsafe mut CompileContext,
    res: *unsafe mut resolver::Resolver,
    res: *unsafe mut resolver::Resolver 'arena,
    fnArena: &mut alloc::Arena
) throws (Error) {
    let entryPkg = try getEntryPackage(ctx);
    if let directory = ctx.rilDirectory {
        try emitPackages(ctx, res, directory);

        let result = try lowerAndGenerateAllPackages(ctx, res, fnArena, CodegenOptions {
            logPath: nil,
            debug: false,
            entryMode: CodegenEntryMode::None,
        });
        printer::printCodeTo(&mut out, entryPkg.name, result.code, result.funcs, &mut res.arena);
        printer::printCodeTo(&mut out, entryPkg.name, result.code, result.funcs, res.arena);
        io::print("\n");

        return;
    }
    // Generate binary output if path specified.

        throw error(&["fatal:", "failed to write output file"]);
    }

    // Write debug info file if enabled.
    if ctx.debug {
        try writeDebugInfo(result.debugEntries, &ctx.graph, outPath, &mut res.arena);
        try writeDebugInfo(result.debugEntries, &ctx.graph, outPath, res.arena);
    }
    pkgLog(&entryPkg, &["ok", "(", outPath, ")"]);
}

@default unsafe fn main(env: *sys::Env) -> i32 {

        try generateTestRunner(&mut ctx, &mut arena) catch {
            return 1;
        };
    }
    // Run resolution phase.
    let mut res = try runResolver(&mut ctx, arena.nextId) catch {
        return 1;
    };
    let mut fnArena = alloc::new(&mut FN_ARENA[..]);
    let mut mainArena = alloc::new(&mut MAIN_ARENA[..]);
    let arenaRef: 'arena = &mut mainArena in {
        let mut res = try runResolver(&mut ctx, arenaRef, arena.nextId) catch {
            return 1;
        };
        let mut fnArena = alloc::new(&mut FN_ARENA[..]);

    // Lower, dump, and/or generate output.
    try compile(&mut ctx, &mut res, &mut fnArena) catch {
        return 1;
    };
    return 0;
        // Lower, dump, and/or generate output.
        try compile(&mut ctx, &mut res, &mut fnArena) catch {
            return 1;
        };
        return 0;
    }
}

compiler/radiance/codegen.rad +9 -18

use std::arch::rv64;
use std::lang::alloc;
use std::lang::il;
use std::lang::lower;

/// State carried by the streaming lowerer/codegen callback.
export record Context: Copy {
    /// Generator receiving functions. It must remain valid for every callback.
    generator: *unsafe mut rv64::Generator,
    /// Arena for function IL. It must remain valid for every callback.
    fnArena: *unsafe mut alloc::Arena,
}

/// Emit one lowered function to machine code and reclaim its IL arena.
/// The context must point to a valid `Context` with live generator and arena storage.
export unsafe fn emit(ctxPtr: *unsafe mut opaque, func: *unsafe il::Fn, role: lower::FnRole) {
    let ctx = ctxPtr as *unsafe mut Context;

/// The function's storage can be reclaimed after code generation returns.
export unsafe fn emit(
    generator: &mut rv64::Generator, arena: &mut alloc::Arena,
    func: &il::Fn, role: lower::FnRole
) {
    match role {
        case lower::FnRole::Default => {
            rv64::recordFunctionAlias(ctx.generator, super::DEFAULT_ENTRY_SYMBOL);
            match ctx.generator.entryPatch {
            rv64::recordFunctionAlias(generator, super::DEFAULT_ENTRY_SYMBOL);
            match generator.entryPatch {
                case rv64::EntryPatch::Reserved(_) => {
                    set ctx.generator.entryPatch = rv64::EntryPatch::Reserved(func.name);
                    set generator.entryPatch = rv64::EntryPatch::Reserved(func.name);
                }
                // Startup assembly calls the default function through its
                // default entry symbol when no entry jump is reserved.
                case rv64::EntryPatch::None => {}
            }
        }
        else => {}
    }
    let generator = ctx.generator;
    let arena = ctx.fnArena;
    rv64::generateFunction(generator, func, arena);
    alloc::reset(ctx.fnArena);
    alloc::reset(arena);
}

lib/std/arch/rv64.rad +73 -25

//! * isel: Instruction selection (IL to RV64 instructions)
//! * printer: Assembly text output

export mod image;
export mod atomics;
export mod shared;
export mod encode;
export mod decode;
export mod emit;
export mod isel;
export mod printer;
export mod asm;
export mod shared;

@test mod tests;
@test mod bounds;
@test mod atomicTests;


export constant INSTR_SIZE: i32 = 4;
/// Stack alignment requirement in bytes.
export constant STACK_ALIGNMENT: i32 = 16;

/// Minimum blit size (in bytes) to use a loop instead of inline copy.
/// Blits below this threshold are fully unrolled as LD/SD pairs.
export constant BLIT_LOOP_THRESHOLD: i32 = 256;
/// Blits below this threshold use unrolled byte loads and stores.
export constant BLIT_LOOP_THRESHOLD: i32 = 33;

/////////////////////////
// Codegen Allocation  //
/////////////////////////


    let mut e = try emit::emitter(arena, options.debug) catch {
        alloc::restore(arena, checkpoint);
        throw Error::Allocation;
    };

    return beginProgramWithEmitter(options, e);
}

/// Begin RV64 code generation with caller-owned emitter storage.
export fn beginProgramWithStorage(
    options: ProgramOptions,
    storage: emit::Storage
) -> Generator {
    let e = emit::emitterWithStorage(storage, options.debug);
    return beginProgramWithEmitter(options, e);
}

/// Initialize a program generator from an emitter.
fn beginProgramWithEmitter(options: ProgramOptions, input: emit::Emitter) -> Generator {
    let mut e = input;

    // Emit placeholder entry jump when requested.
    // We'll patch this at the end once we know where the function is.
    match options.entryPatch {
        case EntryPatch::Reserved(_) => {
            emit::emit(&mut e, encode::nop()); // Placeholder for two-instruction jump.


/// Generate code for one IL function.
/// Record failures in the emitter and restore the function arena offset.
export unsafe fn generateFunction(
    generator: &mut Generator,
    func: *unsafe il::Fn,
    func: &il::Fn,
    arena: &mut alloc::Arena
) {
    if generator.e.error <> nil or func.isExtern {
        return;
    }
    let checkpoint = alloc::save(arena);
    let config = targetConfig();
    let ralloc = try regalloc::allocate(func, &config, arena) catch {
        alloc::restore(arena, checkpoint);
        set generator.e.error = Error::Allocation;
        return;
    };

    isel::selectFn(&mut generator.e, &ralloc, func);
    use *arena as scratch in {
        try generateFunctionWithStorage(generator, func, &config, &scratch) catch {
            set generator.e.error = Error::Allocation;
        };
    }

    // Reclaim unused memory after instruction selection.
    alloc::restore(arena, checkpoint);
}

/// Allocate registers and select one function within a scratch session.
unsafe fn generateFunctionWithStorage 'scratch (
    generator: &mut Generator,
    func: &il::Fn,
    config: &regalloc::TargetConfig,
    storage: &Session 'scratch
) throws (alloc::AllocError) {
    let ralloc = try regalloc::allocate(func, config, storage);
    isel::selectFn(&mut generator.e, &ralloc, func);
}

/// Record an alternate name for the next function emitted.
export fn recordFunctionAlias(generator: &mut Generator, name: *[u8]) {
    let codeLen = generator.e.codeLen;
    emit::recordFuncOffsetAt(&mut generator.e, name, codeLen);
}

    }
}

/// Finish RV64 code generation and return the emitted program.
export unsafe fn finishProgram(
    generator: &mut Generator,
    input: Generator,
    globalData: &[il::Data],
    storage: Storage,
    roDataPrefix: *[u8],
    roDataBuf: &mut [u8],
    rwDataBuf: &mut [u8]
) -> Program throws (Error) {
    let mut generator = input;
    try emit::check(&generator.e);
    let mut roBase: u64 = RO_DATA_BASE as u64;
    let mut rwBase: u64 = RW_DATA_BASE as u64;
    match generator.placement {
        case image::Placement::Physical { roData, rwData, .. } => {
            set roBase = roData;
            set rwBase = rwData;
        },
        else => {},
        else => {
        },
    }
    // Build data map after function lowering. Function-local literals can add
    // global data while functions are lowered, so final layout belongs here.
    let case Storage { dataSyms: symbolBuf, dataSymEntries } = storage
        else panic "expected code generation storage";
    let mut dataSymCount: u32 = 0;
    let roLayoutSize = try data::layoutSectionAtOffset(
        globalData, symbolBuf, &mut dataSymCount, roBase, roDataPrefix.len, true
    ) catch err { throw Error::Data(err); };
    let rwLayoutSize = try data::layoutSection(globalData, symbolBuf, &mut dataSymCount, rwBase, false) catch err { throw Error::Data(err); };
    ) catch err {
        throw Error::Data(err);
    };
    let rwLayoutSize = try data::layoutSection(globalData, symbolBuf, &mut dataSymCount, rwBase, false) catch err {
        throw Error::Data(err);
    };

    let dataSyms = &symbolBuf[..dataSymCount];
    let dataSymMap = try data::buildMap(dataSyms, dataSymEntries) catch err { throw Error::Data(err); };
    let dataSymMap = try data::buildMap(dataSyms, dataSymEntries) catch err {
        throw Error::Data(err);
    };
    if roBase > 0xffffffffffffffff - roLayoutSize as u64 - 7 {
        throw Error::Image(image::Error::Overflow);
    }
    let mut codeBase: u64 = (roBase + roLayoutSize as u64 + 7) & ~7;
    let mut entry = codeBase;
    match generator.placement {
        case image::Placement::Physical { code, entry: address, .. } => {
            set codeBase = code;
            set entry = address;
        },
        else => {},
        else => {
        },
    }
    let codeBytes = generator.e.codeLen * 4;
    let mut layout = image::Layout {
        entry,
        code: image::Segment { address: codeBase, initialized: codeBytes, memory: codeBytes },
        roData: image::Segment { address: roBase, initialized: 0, memory: roLayoutSize },
        rwData: image::Segment { address: rwBase, initialized: 0, memory: rwLayoutSize },
    };
    try image::validate(layout) catch err { throw Error::Image(err); };
    try image::validate(layout) catch err {
        throw Error::Image(err);
    };

    match generator.entryPatch {
        case EntryPatch::Reserved(targetName) => {
            let target = targetName else {
                throw Error::Symbol;

    try emit::patchAddrLoads(&mut generator.e, &dataSymMap, codeBase);

    try emit::check(&generator.e);

    // Emit data sections.
    if roDataPrefix.len > roDataBuf.len { throw Error::Capacity; }
    if roDataPrefix.len > roDataBuf.len {
        throw Error::Capacity;
    }
    try! mem::copy(roDataBuf, roDataPrefix);

    let roDataSize = try data::emitSectionAtOffset(
        globalData, &dataSymMap, &generator.e.labels, codeBase, roDataBuf, true, roDataPrefix.len
    ) catch err { throw Error::Data(err); };
    ) catch err {
        throw Error::Data(err);
    };
    let rwDataSize = try data::emitSection(
        globalData, &dataSymMap, &generator.e.labels, codeBase, rwDataBuf, false
    ) catch err { throw Error::Data(err); };
    ) catch err {
        throw Error::Data(err);
    };
    set layout.roData.initialized = roDataSize;
    set layout.rwData.initialized = rwDataSize;
    try image::validate(layout) catch err { throw Error::Image(err); };
    try image::validate(layout) catch err {
        throw Error::Image(err);
    };
    let case Generator { e, .. } = generator else panic "expected program generator";
    let case emit::Emitter {
        code, codeLen, funcs, funcsLen, debugEntries, debugEntriesLen, ..
    } = e else panic "expected program emitter";
    return Program {
        code: emit::getCode(&generator.e),
        funcs: &generator.e.funcs[..],
        code: &code[..codeLen],
        funcs: &funcs[..funcsLen],
        roDataSize,
        rwDataSize,
        debugEntries: emit::getDebugEntries(&generator.e),
        debugEntries: &debugEntries[..debugEntriesLen],
        layout,
    };
}

lib/std/arch/rv64/asm.rad +50 -9

    { name: "tp",   reg: rv64::TP },
    { name: "zero", reg: rv64::ZERO },
];

/// Sorted CSR-name lookup table used by the assembler parser.
export constant CSRS: [CsrEntry; 9] = [
export constant CSRS: [CsrEntry; 10] = [
    { name: "instret",  csr: 0xC02 },
    { name: "mcause",   csr: 0x342 },
    { name: "mepc",     csr: 0x341 },
    { name: "mhartid",  csr: 0xF14 },
    { name: "mie",      csr: 0x304 },
    { name: "mip",      csr: 0x344 },

    arena: *unsafe mut alloc::Arena,
    /// Assembler lexical scanner.
    scan: scanner::Scanner,
    /// Output text buffer.
    text: *mut [u32],
    /// Number of emitted text words.
    textLen: u32,
    /// Output data buffer.
    data: *mut [u8],
    /// Number of emitted data bytes.
    dataLen: u32,
    /// Current output section.
    section: Section,
    /// Defined symbols.
    symbols: *mut [Symbol],
    /// Number of defined symbols.
    symbolsLen: u32,
    /// Name-to-symbol index map.
    symbolMap: dict::Dict,
    /// Name-to-integer map.
    constMap: dict::Dict,
    /// Names marked by `.export`.
    exportMap: dict::Dict,
    /// Pending fixups.
    fixups: *mut [Fixup],
    /// Number of pending fixups.
    fixupsLen: u32,
    /// Fixups that reference text outside this assembly fragment.
    externalFixups: *mut [Fixup],
    /// Number of external fixups.
    externalFixupsLen: u32,
    /// Absolute runtime address of data-section offset zero.
    dataBase: u32,
}

/// Assemble source using `dataBase` as the runtime address of the data-section.

    dataBuf: *mut [u8],
    arena: &mut alloc::Arena,
    pool: *unsafe mut strings::Pool,
    dataBase: u32
) -> Program throws (Error) {
    let slotCap = source.len + SOURCE_CAP_PADDING;
    let slotCap = tokenCapacity(sourceKind, source, pool);
    let tableCap = nextPowerOfTwo(slotCap * TABLE_CAPACITY_SCALE);

    let symbols = try! alloc::allocSlice(arena, @sizeOf(Symbol), @alignOf(Symbol), slotCap);
    let fixups = try! alloc::allocSlice(arena, @sizeOf(Fixup), @alignOf(Fixup), slotCap);
    let externalFixups = try! alloc::allocSlice(arena, @sizeOf(Fixup), @alignOf(Fixup), slotCap);

    let fixupBuf = fixups as *mut [Fixup];
    let externalBuf = externalFixups as *mut [Fixup];
    let mut a = Assembler {
        arena: arena as *unsafe mut alloc::Arena,
        scan: scanner::scanner(sourceKind, source, pool),
        text: &mut textBuf[..0],
        data: &mut dataBuf[..0],
        text: textBuf,
        textLen: 0,
        data: dataBuf,
        dataLen: 0,
        section: Section::Text,
        symbols: &mut symbolBuf[..0],
        symbols: symbolBuf,
        symbolsLen: 0,
        symbolMap: dict::init(entries as *mut [dict::Entry]),
        constMap: dict::init(constEntries as *mut [dict::Entry]),
        exportMap: dict::init(exportEntries as *mut [dict::Entry]),
        fixups: &mut fixupBuf[..0],
        externalFixups: &mut externalBuf[..0],
        fixups: fixupBuf,
        fixupsLen: 0,
        externalFixups: externalBuf,
        externalFixupsLen: 0,
        dataBase,
    };
    // Parse assembly source and emit instructions.
    try parser::parseProgram(&mut a);
    // Resolve fixups and finalize program.
    try emit::finishProgram(&mut a);

    let case Assembler { text, data, symbols: definedSymbols, externalFixups: pendingFixups, .. } = a
    let case Assembler {
        text, textLen, data, dataLen, symbols: definedSymbols, symbolsLen,
        externalFixups: pendingFixups, externalFixupsLen, ..
    } = a
        else panic "expected assembler state";
    return Program { text, data, symbols: definedSymbols, externalFixups: pendingFixups };
    return Program {
        text: &text[..textLen],
        data: &data[..dataLen],
        symbols: &definedSymbols[..symbolsLen],
        externalFixups: &pendingFixups[..externalFixupsLen],
    };
}

/// Bound symbol and fixup counts by lexical tokens, including one spare slot.
unsafe fn tokenCapacity(kind: scanner::SourceKind, source: *[u8], pool: *unsafe mut strings::Pool) -> u32 {
    let mut scan = scanner::scanner(kind, source, pool);
    let mut count = SOURCE_CAP_PADDING;
    while true {
        let token = scanner::next(&mut scan);
        if token.kind == scanner::TokenKind::Eof {
            break;
        }
        set count += 1;
        if token.kind == scanner::TokenKind::Invalid {
            break;
        }
    }
    return count;
}

/// Return the next power of two at least as large as `value`.
fn nextPowerOfTwo(value: u32) -> u32 {
    let mut n: u32 = MIN_TABLE_CAPACITY;

lib/std/arch/rv64/asm/emit.rad +25 -12

use std::arch::rv64::encode;
use std::arch::rv64;
use std::fmt;

use std::collections::dict;
use std::lang::alloc;
use std::lang::gen;

/// Define a symbol at the current text or data offset.
export unsafe fn defineSymbol(a: &mut super::Assembler, name: *[u8]) {
    let idx = a.symbols.len;
    let offset: i32 = a.data.len as i32
    let idx = a.symbolsLen;
    let offset: i32 = a.dataLen as i32
        if a.section == super::Section::Data
        else a.text.len as i32 * rv64::INSTR_SIZE;
        else a.textLen as i32 * rv64::INSTR_SIZE;

    a.symbols.append(super::Symbol {
    assert a.symbolsLen < a.symbols.len, "defineSymbol: symbol buffer full";
    set a.symbols[a.symbolsLen] = super::Symbol {
        name,
        section: a.section,
        offset,
        isExported: dict::get(&a.exportMap, name) <> nil,
    }, alloc::arenaAllocator(a.arena));
    };
    set a.symbolsLen += 1;
    dict::insert(&mut a.symbolMap, name, idx as i32);
}

/// Append one encoded instruction word to the text section.
export unsafe fn emitText(a: &mut super::Assembler, word: u32) throws (super::Error) {
    a.text.append(word, alloc::arenaAllocator(a.arena));
    if a.textLen >= a.text.len {
        throw super::Error::TextOverflow;
    }
    set a.text[a.textLen] = word;
    set a.textLen += 1;
}

/// Append `words` no-op instructions to the text section.
export unsafe fn emitTextPadding(a: &mut super::Assembler, words: u32) throws (super::Error) {
    for _ in 0..words {

    }
}

/// Append one byte to the data section.
export unsafe fn emitByte(a: &mut super::Assembler, byte: u8) throws (super::Error) {
    a.data.append(byte, alloc::arenaAllocator(a.arena));
    if a.dataLen >= a.data.len {
        throw super::Error::DataOverflow;
    }
    set a.data[a.dataLen] = byte;
    set a.dataLen += 1;
}

/// Emit a little-endian integer with `bytes` bytes.
unsafe fn emitDataInt(a: &mut super::Assembler, bits: u64, bytes: u32) throws (super::Error) {
    for i in 0..bytes {

    }
}

/// Record a data-section symbol fixup and reserve its bytes.
export unsafe fn recordDataFixup(a: &mut super::Assembler, target: *[u8], width: super::DataWidth) throws (super::Error) {
    let offset = a.data.len;
    let offset = a.dataLen;
    match width {
        case super::DataWidth::Word => {
            recordFixup(a, target, super::FixupInfo::Word { offset });
            try emitDataInt(a, 0, rv64::WORD_SIZE as u32);
        }

    }
}

/// Record a pending symbol fixup.
unsafe fn recordFixup(a: &mut super::Assembler, symbol: *[u8], info: super::FixupInfo) {
    a.fixups.append(super::Fixup { symbol, info }, alloc::arenaAllocator(a.arena));
    assert a.fixupsLen < a.fixups.len, "recordFixup: fixup buffer full";
    set a.fixups[a.fixupsLen] = super::Fixup { symbol, info };
    set a.fixupsLen += 1;
}

/// Record a text fixup that must be resolved after all program text is known.
unsafe fn recordExternalFixup(a: &mut super::Assembler, fixup: super::Fixup) {
    a.externalFixups.append(fixup, alloc::arenaAllocator(a.arena));
    assert a.externalFixupsLen < a.externalFixups.len, "recordExternalFixup: fixup buffer full";
    set a.externalFixups[a.externalFixupsLen] = fixup;
    set a.externalFixupsLen += 1;
}

/// Record a text-section symbol fixup and reserve its instruction words.
export unsafe fn recordTextFixup(a: &mut super::Assembler, symbol: *[u8], info: super::FixupInfo, words: u32) throws (super::Error) {
    recordFixup(a, symbol, info);

    return symbol.offset + (a.dataBase as i32);
}

/// Resolve final symbol references and patch all delayed output.
export unsafe fn finishProgram(a: &mut super::Assembler) throws (super::Error) {
    for i in 0..a.fixups.len {
    for i in 0..a.fixupsLen {
        let fixup = a.fixups[i];
        let symbol = findSymbol(a, fixup.symbol) else {
            match fixup.info {
                case super::FixupInfo::Jal { .. }, super::FixupInfo::Addr { .. } => {
                    recordExternalFixup(a, fixup);

lib/std/arch/rv64/asm/parser.rad +29 -13

        throw failOnToken(tok, "instructions are only valid in the text section");
    }
    if let format = atomics::parse(name) {
        let rd = try parseRegister(a);
        let mut rs2 = rv64::ZERO;
        if format.operation <> 2 { set rs2 = try parseRegister(a); }
        if format.operation <> 2 {
            set rs2 = try parseRegister(a);
        }
        let memory = try parseMemory(a);
        if memory.offset <> 0 { throw fail(a, "atomic memory offset must be zero"); }
        if memory.offset <> 0 {
            throw fail(a, "atomic memory offset must be zero");
        }
        try emit::emitText(a, atomics::encode(atomics::Instruction { format, rd, rs1: memory.base, rs2 }));
        return;
    }
    let form = lookupInstruction(name) else {
        throw failOnToken(tok, "unknown instruction");


/// Parse the `la` pseudo-instruction.
unsafe fn parseLa(a: &mut super::Assembler) throws (super::Error) {
    let rd = try parseRegister(a);
    let target = try parseLabelName(a);
    let index = a.text.len;
    let index = a.textLen;

    try emit::recordTextFixup(a, target, super::FixupInfo::Addr { rd, index }, 2);
}

/// Parse a CSR read-like instruction with destination register then CSR.

    return try parseLabelName(a);
}

/// Parse a branch target as either a label fixup or immediate offset.
unsafe fn parseBranchLabel(a: &mut super::Assembler, op: super::BranchOp, rs1: gen::Reg, rs2: gen::Reg) throws (super::Error) {
    let index = a.text.len;
    let index = a.textLen;
    if let target = try parseOptionalLabel(a) {
        try emit::recordTextFixup(a, target, super::FixupInfo::Branch { op, rs1, rs2, index }, 1);
        return;
    }
    let imm = try parseBranchImm(a);

    try parseJ(a, rd);
}

/// Parse a jump target for `jal` or a jump pseudo-instruction.
unsafe fn parseJ(a: &mut super::Assembler, rd: gen::Reg) throws (super::Error) {
    let index = a.text.len;
    let index = a.textLen;
    if let target = try parseOptionalLabel(a) {
        try emit::recordTextFixup(a, target, super::FixupInfo::Jal { rd, index }, 1);
        return;
    }
    let imm = try parseJumpImm(a);

    if count < 0 {
        throw fail(a, "space size must be non-negative");
    }
    // The data section grows on demand; only reject sizes that cannot be
    // represented as a section offset.
    if count > super::U32_MAX_VALUE - a.data.len as i64 {
    if count > super::U32_MAX_VALUE - a.dataLen as i64 {
        throw super::Error::DataOverflow;
    }
    for _ in 0..count as u32 {
        try emit::emitByte(a, 0);
    }

    match a.section {
        case super::Section::Text => {
            if amount % rv64::INSTR_SIZE as u32 <> 0 {
                throw fail(a, "text alignment must be a multiple of 4");
            }
            let bytes = a.text.len * rv64::INSTR_SIZE as u32;
            let bytes = a.textLen * rv64::INSTR_SIZE as u32;
            let aligned = checkedAlignUp(bytes, amount) else {
                throw super::Error::TextOverflow;
            };
            let words = (aligned - bytes) / rv64::INSTR_SIZE as u32;
            try emit::emitTextPadding(a, words);
        }
        case super::Section::Data => {
            let aligned = checkedAlignUp(a.data.len, amount) else {
            let aligned = checkedAlignUp(a.dataLen, amount) else {
                throw super::Error::DataOverflow;
            };
            for _ in a.data.len..aligned {
            for _ in a.dataLen..aligned {
                try emit::emitByte(a, 0);
            }
        }
    }
}


/// Parse an access-class mask without duplicate fields.
unsafe fn parseFenceMask(a: &mut super::Assembler) -> u32 throws (super::Error) {
    if a.scan.current.kind == scanner::TokenKind::Number {
        let value = try parseValue(a);
        if value <> 0 { throw fail(a, "numeric fence mask must be zero"); }
        if value <> 0 {
            throw fail(a, "numeric fence mask must be zero");
        }
        return 0;
    }
    let token = try expectToken(a, scanner::TokenKind::Ident, "expected fence access classes");
    let mut mask: u32 = 0;
    for ch in token.source {
        let mut bit: u32 = 0;
        match ch {
            case 'i' => { set bit = 8; }, case 'o' => { set bit = 4; },
            case 'r' => { set bit = 2; }, case 'w' => { set bit = 1; },
            case 'i' => {
                set bit = 8;
            }, case 'o' => {
                set bit = 4;
            },
            case 'r' => {
                set bit = 2;
            }, case 'w' => {
                set bit = 1;
            },
            else => throw failOnToken(token, "invalid fence access class"),
        }
        if (mask & bit) <> 0 { throw failOnToken(token, "duplicate fence access class"); }
        if (mask & bit) <> 0 {
            throw failOnToken(token, "duplicate fence access class");
        }
        set mask |= bit;
    }
    return mask;
}


lib/std/arch/rv64/asm/tests.rad +62 -0

static ASM_DATA_STORAGE: [u8; 1024] = [0; 1024];
unsafe static ASM_STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
static PRINT_ARENA_STORAGE: [u8; 1024] = [0; 1024];
static PRINT_BUFFER: [u8; 128] = [0; 128];

/// The retired-instruction CSR assembles to its exact architectural encoding.
@test unsafe fn retiredCounter() throws (testing::TestError) {
    let program = try assembleSource(".text;\ncsrr %a0 instret;\n");
    assert program.text.len == 1 and program.text[0] == 0xc0202573;
}

/// Source buffer for comment capacity tests.
static SOURCE: [u8; 4096] = [0; 4096];

/// Long comments consume source space while leaving symbol and fixup demand small.
@test unsafe fn commentStorage() throws (testing::TestError) {
    let source = &mut SOURCE[..];
    for i in 0..source.len {
        set source[i] = 32;
    }
    set source[0] = '/'; set source[1] = '/';
    let text = "\n.text;\nret;\n";
    for byte, i in text {
        set source[source.len - text.len + i] = byte;
    }
    let program = try assembleSource(&SOURCE[..]);
    try testing::expect(program.text.len == 1 and program.text[0] == encode::ret());
}

unsafe fn assembleSource(source: *[u8]) -> super::Program throws (testing::TestError) {
    let mut arena = alloc::new(&mut ASM_ARENA_STORAGE[..]);
    return try super::assemble(
        scanner::SourceKind::String,
        source,

    try testing::expect(mem::eq(program.externalFixups[1].symbol, "::default"));
    try testing::expect(addrRd == rv64::T0);
    try testing::expect(addrIndex == 1);
}

@test unsafe fn testAssembleTextOverflow() throws (testing::TestError) {
    let mut arena = alloc::new(&mut ASM_ARENA_STORAGE[..]);
    try super::assemble(
        scanner::SourceKind::String,
        ".text;\nret;\nret;\n",
        &mut ASM_TEXT_STORAGE[..1],
        &mut ASM_DATA_STORAGE[..1],
        &mut arena,
        &mut ASM_STRING_POOL,
        rv64::RO_DATA_BASE
    ) catch err {
        match err {
            case super::Error::TextOverflow => return,
            else => throw testing::TestError::Failed,
        }
    };
    throw testing::TestError::Failed;
}

@test unsafe fn testAssembleDataOverflow() throws (testing::TestError) {
    let mut arena = alloc::new(&mut ASM_ARENA_STORAGE[..]);
    try super::assemble(
        scanner::SourceKind::String,
        ".data;\n.byte 1, 2;\n",
        &mut ASM_TEXT_STORAGE[..1],
        &mut ASM_DATA_STORAGE[..1],
        &mut arena,
        &mut ASM_STRING_POOL,
        rv64::RO_DATA_BASE
    ) catch err {
        match err {
            case super::Error::DataOverflow => return,
            else => throw testing::TestError::Failed,
        }
    };
    throw testing::TestError::Failed;
}

@test unsafe fn testAssembleInvalidOperandsFail() throws (testing::TestError) {
    try expectAssembleFail(
        ".text;\nbeq %a0 %a1 @missing;\n"
    );
    try expectAssembleFail(

lib/std/arch/rv64/atomicTests.rad +18 -6

                    format: atomics::Format { operation, width: 2 + wide, order },
                    rd: super::A0, rs1: super::A1, rs2: super::ZERO if operation == 2 else super::A2,
                };
                let word = words[i] | (wide << 12) | (order << 25);
                try testing::expect(atomics::encode(item) == word);
                let decoded = atomics::decode(word) else { throw testing::TestError::Failed; };
                let decoded = atomics::decode(word) else {
                    throw testing::TestError::Failed;
                };
                try testing::expect(decoded == item);
                let case decode::Instr::Atomic(instruction) = decode::decode(word) else { throw testing::TestError::Failed; };
                let case decode::Instr::Atomic(instruction) = decode::decode(word) else {
                    throw testing::TestError::Failed;
                };
                try testing::expect(instruction == item);
            }
        }
    }
}

        try testing::expect(atomics::decode(word) == nil);
    }
    for name in &["lr", "lr.q", "lr.w.aq.rl", "sc.d.rl.aq", "amoswap.d.bad", "amoadd.wextra"] {
        try testing::expect(atomics::parse(name) == nil);
    }
    let format = atomics::parse("amoswap.d.aqrl") else { throw testing::TestError::Failed; };
    let format = atomics::parse("amoswap.d.aqrl") else {
        throw testing::TestError::Failed;
    };
    try testing::expect(format.operation == 1 and format.width == 3 and format.order == 3);
}

/// Assemble one instruction and return its exact word.
unsafe fn assemble(source: *[u8]) -> u32 throws (testing::TestError) {
    let mut arena = alloc::new(&mut MEMORY[..]);
    let words = &mut WORDS[..];
    let data: *mut [u8] = &mut [];
    let result = try asm::assemble(asm::scanner::SourceKind::String, source,
        &mut words[..], &mut data[..], &mut arena, &mut STRINGS, 0)
        catch { throw testing::TestError::Failed; };
        catch {
            throw testing::TestError::Failed;
        };
    try testing::expect(result.text.len == 1);
    return result.text[0];
}

/// Check instruction suffix scanning and assembler operand order.

/// Decode fence classes and local instruction synchronization.
@test fn fences() throws (testing::TestError) {
    try testing::expect(encode::fenceI() == 0x0000100f);
    try testing::expect(decode::decode(encode::fenceI()) == decode::Instr::FenceI);
    let case decode::Instr::Fence { predecessor, successor } = decode::decode(encode::fenceOrder(15, 15))
        else { throw testing::TestError::Failed; };
        else {
            throw testing::TestError::Failed;
        };
    try testing::expect(predecessor == 15 and successor == 15);
    let case decode::Instr::Unknown { .. } = decode::decode(0x0000200f)
        else { throw testing::TestError::Failed; };
        else {
            throw testing::TestError::Failed;
        };
}

/// Reject invalid atomic operands and fence access classes.
@test unsafe fn invalidAssembly() throws (testing::TestError) {
    for source in &[

lib/std/arch/rv64/atomics.rad +32 -10

    { name: "amomaxu", code: 28 },
];

/// Look up an operation's canonical mnemonic stem.
export fn name(code: u32) -> ?*[u8] {
    for operation in &OPERATIONS[..] { if operation.code == code { return operation.name; } }
    for operation in &OPERATIONS[..] {
        if operation.code == code {
            return operation.name;
        }
    }
    return nil;
}

/// Parse an atomic mnemonic with mandatory width and optional ordering suffix.
export fn parse(text: *[u8]) -> ?Format {
    for operation in &OPERATIONS[..] {
        let n = operation.name.len;
        if text.len < n + 2 or not mem::eq(&text[..n], operation.name) or text[n] <> '.' { continue; }
        if text.len < n + 2 or not mem::eq(&text[..n], operation.name) or text[n] <> '.' {
            continue;
        }
        let mut width: u32 = 2;
        if text[n + 1] == 'd' { set width = 3; }
        else if text[n + 1] <> 'w' { return nil; }
        if text[n + 1] == 'd' {
            set width = 3;
        }
        else if text[n + 1] <> 'w' {
            return nil;
        }
        let suffix = &text[n + 2..];
        let mut order: u32 = 0;
        if mem::eq(suffix, ".aq") { set order = 2; }
        else if mem::eq(suffix, ".rl") { set order = 1; }
        else if mem::eq(suffix, ".aqrl") { set order = 3; }
        else if suffix.len <> 0 { return nil; }
        if mem::eq(suffix, ".aq") {
            set order = 2;
        }
        else if mem::eq(suffix, ".rl") {
            set order = 1;
        }
        else if mem::eq(suffix, ".aqrl") {
            set order = 3;
        }
        else if suffix.len <> 0 {
            return nil;
        }
        return Format { operation: operation.code, width, order };
    }
    return nil;
}


/// Decode a supported atomic word and reject reserved width and LR fields.
export fn decode(word: u32) -> ?Instruction {
    let operation = word >> 27;
    let width = (word >> 12) & 7;
    let rs2 = super::reg(((word >> 20) & 31) as u8);
    if (word & 127) <> 0x2f or name(operation) == nil or (width <> 2 and width <> 3) { return nil; }
    if operation == 2 and rs2 <> super::ZERO { return nil; }
    if (word & 127) <> 0x2f or name(operation) == nil or (width <> 2 and width <> 3) {
        return nil;
    }
    if operation == 2 and rs2 <> super::ZERO {
        return nil;
    }
    return Instruction {
        format: Format { operation, width, order: (word >> 25) & 3 },
        rd: super::reg(((word >> 7) & 31) as u8), rs1: super::reg(((word >> 15) & 31) as u8), rs2,
    };
}

lib/std/arch/rv64/bounds.rad +39 -24

@test unsafe fn emissionCapacity() throws (testing::TestError) {
    for kind in 0..8 {
        let mut arena = alloc::new(&mut MEMORY[..]);
        let mut e = try! emit::emitter(&mut arena, false);
        match kind {
            case 0 => { set e.code = &mut e.code[..0]; emit::emit(&mut e, encode::nop()); },
            case 0 => {
                set e.code = &mut e.code[..0];
                emit::emit(&mut e, encode::nop());
            },
            case 1 => {
                set e.pendingBranches.len = 0; set e.pendingBranches.cap = 0;
                set e.pendingBranchesLen = e.pendingBranches.len;
                emit::recordBranch(&mut e, 0, emit::BranchKind::Jump);
            },
            case 2 => {
                set e.pendingCalls.len = 0; set e.pendingCalls.cap = 0;
                set e.pendingCallsLen = e.pendingCalls.len;
                emit::recordCall(&mut e, "p::call");
            },
            case 3 => {
                set e.pendingJumps.len = 0; set e.pendingJumps.cap = 0;
                set e.pendingJumpsLen = e.pendingJumps.len;
                emit::recordJumpAt(&mut e, "p::jump", super::ZERO, 0);
            },
            case 4 => {
                set e.pendingAddrLoads.len = 0; set e.pendingAddrLoads.cap = 0;
                set e.pendingAddrLoadsLen = e.pendingAddrLoads.len;
                emit::recordDataAddrLoad(&mut e, "p::data", super::A0);
            },
            case 5 => {
                set e.funcs.len = 0; set e.funcs.cap = 0;
                set e.funcsLen = e.funcs.len;
                emit::recordFunc(&mut e, "p::call");
            },
            case 6 => {
                let entries = &mut ENTRIES[..2];
                set e.labels.funcs = dict::init(&mut entries[..]);
                emit::recordFuncOffset(&mut e, "p::first");
                emit::recordFuncOffset(&mut e, "p::second");
            },
            else => { emit::recordSrcLoc(&mut e, il::SrcLoc { moduleId: 0, offset: 0 }); },
            else => {
                emit::recordSrcLoc(&mut e, il::SrcLoc { moduleId: 0, offset: 0 });
            },
        }
        try testing::expect(e.error == super::Error::Capacity);
        let count = e.codeLen;
        emit::emit(&mut e, encode::ebreak());
        try testing::expect(e.codeLen == count);

}

/// Spill candidate storage fails explicitly when too many values are live.
@test unsafe fn registerStorage() throws (testing::TestError) {
    let mut arena = alloc::new(&mut SCRATCH[..]);
    let mut liveSet = try! bitset::allocate(&mut arena, 257);
    for i in 0..257 { bitset::put(&mut liveSet, i); }
    let mut out = [liveSet];
    let live = regalloc::liveness::LiveInfo {
        liveIn: &mut [], liveOut: &mut out[..], defs: &mut [], uses: &mut [], blockCount: 1, maxReg: 257,
    };
    let func = il::Fn {
        name: "p::pressure", params: &[], returnType: il::Type::W64, isExtern: false, isLeaf: true,
        blocks: &[il::Block { label: "entry", params: &[], instrs: &mut [], locs: &[], preds: &[], loopDepth: 0 }],
    };
    let mut failed = false;
    try regalloc::spill::analyze(&func, &live, 23, 11, 8, &mut arena) catch {
        set failed = true;
    };
    try testing::expect(failed);
    use arena as bits in {
        let liveSet = try! bitset::allocate(&bits, 257);
        for i in 0..257 {
            bitset::put(liveSet, i);
        }
        let live = regalloc::liveness::LiveInfo 'bits {
            liveIn: &liveSet[..0], liveOut: &liveSet[..],
            defs: &liveSet[..0], uses: &liveSet[..0],
            words: bitset::wordsFor(257), blockCount: 1, maxReg: 257,
        };
        let func = il::Fn {
            name: "p::pressure", params: &[], returnType: il::Type::W64, isExtern: false, isLeaf: true,
            blocks: &[il::Block { label: "entry", params: &[], instrs: &mut [], locs: &[], preds: &[], loopDepth: 0 }],
        };
        let mut failed = false;
        try regalloc::spill::analyze(&func, &live, 23, 11, 8, &bits) catch {
            set failed = true;
        };
        try testing::expect(failed);
    }
}

/// Data output and symbol maps reject insufficient or ambiguous storage.
@test unsafe fn dataStorage() throws (testing::TestError) {
    let mut arena = alloc::new(&mut MEMORY[..]);

    try data::buildMap(&duplicate[..], &mut larger[..]) catch err {
        try testing::expect(err == data::Error::Symbol); set failed += 1;
    };
    try testing::expect(failed == 3);
    let length = try data::emitSection(items, &map, &e.labels, 0x80000000, &mut bytes[..], false)
        catch { throw testing::TestError::Failed; };
        catch {
            throw testing::TestError::Failed;
        };
    try testing::expect(length == 8 and bytes[0] == 1);
}

/// Name the failed invariant before returning to the test runner.
fn check(condition: bool, name: *[u8]) throws (testing::TestError) {
    if not condition { io::printLn(name); throw testing::TestError::Failed; }
    if not condition {
        io::printLn(name);
        throw testing::TestError::Failed;
    }
}

lib/std/arch/rv64/decode.rad +6 -2

    let rs1 = super::reg(rs1(instr));
    let rs2 = super::reg(rs2(instr));

    match op {
        case 0x2f => {
            if let atomic = atomics::decode(instr) { return Instr::Atomic(atomic); }
            if let atomic = atomics::decode(instr) {
                return Instr::Atomic(atomic);
            }
            return Instr::Unknown { bits: instr };
        },
        case 0x0f => {
            if instr == 0x100f { return Instr::FenceI; }
            if instr == 0x100f {
                return Instr::FenceI;
            }
            if (instr & 0xf00fffff) == 0x0f {
                return Instr::Fence { predecessor: (instr >> 24) & 15, successor: (instr >> 20) & 15 };
            }
            return Instr::Unknown { bits: instr };
        },

lib/std/arch/rv64/emit.rad +223 -82

use std::mem;

use super::encode;

/// Maximum number of instructions in code buffer.
constant MAX_INSTRS: u32 = 2097152;
export constant MAX_INSTRS: u32 = 2097152;
/// Maximum code length before byte offset overflows signed 32-bits.
constant MAX_CODE_LEN: u32 = 0x7FFFFFFF / super::INSTR_SIZE as u32;
/// Maximum number of pending branches awaiting patching.
constant MAX_PENDING: u32 = 65536;
export constant MAX_PENDING: u32 = 65536;
/// Maximum number of function entries.
constant MAX_FUNCS: u32 = 4096;
export constant MAX_FUNCS: u32 = 4096;
/// Maximum number of debug entries.
constant MAX_DEBUG_ENTRIES: u32 = 524288;
export constant MAX_DEBUG_ENTRIES: u32 = 524288;

//////////////////////
// Emission Context //
//////////////////////


    code: *mut [u32],
    /// Current number of emitted instructions.
    codeLen: u32,
    /// Local branches needing offset patching.
    pendingBranches: *mut [PendingBranch],
    /// Number of local branches that need patching.
    pendingBranchesLen: u32,
    /// Function calls needing offset patching.
    pendingCalls: *mut [PendingCall],
    /// Number of function calls that need patching.
    pendingCallsLen: u32,
    /// Assembly jumps needing offset patching.
    pendingJumps: *mut [PendingJump],
    /// Number of assembly jumps that need patching.
    pendingJumpsLen: u32,
    /// Function address loads needing offset patching.
    pendingAddrLoads: *mut [PendingAddrLoad],
    /// Number of function address loads that need patching.
    pendingAddrLoadsLen: u32,
    /// Block label tracking.
    labels: labels::Labels,
    /// Function start positions for printing.
    funcs: *mut [types::FuncAddr],
    /// Number of function start positions recorded.
    funcsLen: u32,
    /// Debug entries mapping PCs to source locations.
    debugEntries: *mut [types::DebugEntry],
    /// Number of debug entries recorded.
    debugEntriesLen: u32,
}

/// Caller-owned storage for program emission.
export record Storage {
    /// Emitted instruction buffer.
    code: *mut [u32],
    /// Local branch patch buffer.
    pendingBranches: *mut [PendingBranch],
    /// Function call patch buffer.
    pendingCalls: *mut [PendingCall],
    /// Assembly jump patch buffer.
    pendingJumps: *mut [PendingJump],
    /// Address load patch buffer.
    pendingAddrLoads: *mut [PendingAddrLoad],
    /// Per-function block offset buffer.
    blockOffsets: *mut [i32],
    /// Function label hash table storage.
    funcEntries: *mut [dict::Entry],
    /// Printed function address buffer.
    funcs: *mut [types::FuncAddr],
    /// Debug location buffer.
    debugEntries: *mut [types::DebugEntry],
}

/// Computed stack frame layout for a function.
export record Frame: Copy {
    /// Total frame size in bytes (aligned).
    totalSize: i32,
    /// Callee-saved registers and their offsets.

    return frame;
}

/// Create a new emitter.
export unsafe fn emitter(arena: &mut alloc::Arena, debug: bool) -> Emitter throws (alloc::AllocError) {
    let storage = try allocateStorage(arena, debug);
    return emitterWithStorage(storage, debug);
}

/// Allocate emitter storage from an arena.
export unsafe fn allocateStorage(arena: &mut alloc::Arena, debug: bool) -> Storage throws (alloc::AllocError) {
    let code = try alloc::allocSlice(arena, @sizeOf(u32), @alignOf(u32), MAX_INSTRS);
    let pendingBranches = try alloc::allocSlice(arena, @sizeOf(PendingBranch), @alignOf(PendingBranch), MAX_PENDING);
    let pendingCalls = try alloc::allocSlice(arena, @sizeOf(PendingCall), @alignOf(PendingCall), MAX_PENDING);
    let pendingJumps = try alloc::allocSlice(arena, @sizeOf(PendingJump), @alignOf(PendingJump), MAX_PENDING);
    let pendingAddrLoads = try alloc::allocSlice(arena, @sizeOf(PendingAddrLoad), @alignOf(PendingAddrLoad), MAX_PENDING);

    if debug {
        set debugEntries = try alloc::allocSlice(
            arena, @sizeOf(types::DebugEntry), @alignOf(types::DebugEntry), MAX_DEBUG_ENTRIES
        ) as *mut [types::DebugEntry];
    }
    let mut pendingBranchesBuf = pendingBranches as *mut [PendingBranch];
    let mut pendingCallsBuf = pendingCalls as *mut [PendingCall];
    let mut pendingJumpsBuf = pendingJumps as *mut [PendingJump];
    let mut pendingAddrLoadsBuf = pendingAddrLoads as *mut [PendingAddrLoad];
    let mut funcsBuf = funcs as *mut [types::FuncAddr];
    set pendingBranchesBuf.len = 0;
    set pendingCallsBuf.len = 0;
    set pendingJumpsBuf.len = 0;
    set pendingAddrLoadsBuf.len = 0;
    set funcsBuf.len = 0;
    return Storage {
        code: code as *mut [u32],
        pendingBranches: pendingBranches as *mut [PendingBranch],
        pendingCalls: pendingCalls as *mut [PendingCall],
        pendingJumps: pendingJumps as *mut [PendingJump],
        pendingAddrLoads: pendingAddrLoads as *mut [PendingAddrLoad],
        blockOffsets: blockOffsets as *mut [i32],
        funcEntries: funcEntries as *mut [dict::Entry],
        funcs: funcs as *mut [types::FuncAddr],
        debugEntries,
    };
}

/// Create an emitter from caller-owned storage.
export fn emitterWithStorage(storage: Storage, debug: bool) -> Emitter {
    let case Storage {
        code, pendingBranches, pendingCalls, pendingJumps, pendingAddrLoads,
        blockOffsets, funcEntries, funcs, debugEntries,
    } = storage else panic "expected emitter storage";
    assert code.len >= MAX_INSTRS, "emitterWithStorage: code buffer too small";
    assert pendingBranches.len >= MAX_PENDING, "emitterWithStorage: branch buffer too small";
    assert pendingCalls.len >= MAX_PENDING, "emitterWithStorage: call buffer too small";
    assert pendingJumps.len >= MAX_PENDING, "emitterWithStorage: jump buffer too small";
    assert pendingAddrLoads.len >= MAX_PENDING, "emitterWithStorage: address buffer too small";
    assert blockOffsets.len >= labels::MAX_BLOCKS_PER_FN, "emitterWithStorage: block buffer too small";
    assert funcEntries.len >= labels::FUNC_TABLE_SIZE, "emitterWithStorage: label table too small";
    assert funcs.len >= MAX_FUNCS, "emitterWithStorage: function buffer too small";
    let mut activeDebugEntries: *mut [types::DebugEntry] = &mut [];
    if debug {
        assert debugEntries.len >= MAX_DEBUG_ENTRIES, "emitterWithStorage: debug buffer too small";
        set activeDebugEntries = debugEntries;
    }
    return Emitter {
        error: nil,
        sharedData: false,
        code: code as *mut [u32],
        code,
        codeLen: 0,
        pendingBranches: pendingBranchesBuf,
        pendingCalls: pendingCallsBuf,
        pendingJumps: pendingJumpsBuf,
        pendingAddrLoads: pendingAddrLoadsBuf,
        labels: labels::init(blockOffsets as *mut [i32], funcEntries as *mut [dict::Entry]),
        funcs: funcsBuf,
        debugEntries,
        pendingBranches,
        pendingBranchesLen: 0,
        pendingCalls,
        pendingCallsLen: 0,
        pendingJumps,
        pendingJumpsLen: 0,
        pendingAddrLoads,
        pendingAddrLoadsLen: 0,
        labels: labels::init(blockOffsets, funcEntries),
        funcs,
        funcsLen: 0,
        debugEntries: activeDebugEntries,
        debugEntriesLen: 0,
    };
}

///////////////////////
// Emission Helpers  //
///////////////////////

/// Emit a single instruction.
export fn emit(e: &mut Emitter, instr: u32) {
    if e.error <> nil { return; }
    if e.codeLen == e.code.len { set e.error = super::Error::Capacity; return; }
    if e.error <> nil {
        return;
    }
    if e.codeLen == e.code.len {
        set e.error = super::Error::Capacity;
        return;
    }
    set e.code[e.codeLen] = instr;
    set e.codeLen += 1;
}

/// Compute branch offset to a function by name.
export fn branchOffsetToFunc(e: &mut Emitter, srcIndex: u32, name: *[u8]) -> i32 {
    if e.error <> nil { return 0; }
    if e.error <> nil {
        return 0;
    }
    let target = dict::get(&e.labels.funcs, name) else {
        set e.error = super::Error::Symbol; return 0;
    };
    return target - srcIndex as i32 * super::INSTR_SIZE;
}

/// Patch an instruction at a given index.
export fn patch(e: &mut Emitter, index: u32, instr: u32) {
    if e.error <> nil { return; }
    if index >= e.codeLen { set e.error = super::Error::Capacity; return; }
    if e.error <> nil {
        return;
    }
    if index >= e.codeLen {
        set e.error = super::Error::Capacity;
        return;
    }
    set e.code[index] = instr;
}

/// Record a block's address for branch resolution.
export fn recordBlock(e: &mut Emitter, blockIdx: u32) {
    if e.error <> nil { return; }
    if e.error <> nil {
        return;
    }
    if e.codeLen > MAX_CODE_LEN or blockIdx >= e.labels.blockOffsets.len {
        set e.error = super::Error::Capacity; return;
    }
    labels::recordBlock(&mut e.labels, blockIdx, e.codeLen as i32 * super::INSTR_SIZE);
}

    recordFuncOffsetAt(e, name, codeLen);
}

/// Record a function's code offset at `index` for call resolution.
export fn recordFuncOffsetAt(e: &mut Emitter, name: *[u8], index: u32) {
    if e.error <> nil { return; }
    if index > MAX_CODE_LEN { set e.error = super::Error::Capacity; return; }
    if name.len == 0 { set e.error = super::Error::Symbol; return; }
    if e.error <> nil {
        return;
    }
    if index > MAX_CODE_LEN {
        set e.error = super::Error::Capacity;
        return;
    }
    if name.len == 0 {
        set e.error = super::Error::Symbol;
        return;
    }
    if e.labels.funcs.count >= e.labels.funcs.entries.len / 2 and dict::get(&e.labels.funcs, name) == nil {
        set e.error = super::Error::Capacity; return;
    }
    dict::insert(&mut e.labels.funcs, name, index as i32 * super::INSTR_SIZE);
}

    recordFuncAt(e, name, codeLen);
}

/// Record a function's start position at `index` for printing.
export fn recordFuncAt(e: &mut Emitter, name: *[u8], index: u32) {
    if e.error <> nil { return; }
    if e.funcs.len == e.funcs.cap { set e.error = super::Error::Capacity; return; }
    let count = e.funcs.len;
    unsafe { set e.funcs.len = count + 1; }
    set e.funcs[count] = types::FuncAddr { name, index };
    if e.error <> nil {
        return;
    }
    if e.funcsLen == e.funcs.len {
        set e.error = super::Error::Capacity;
        return;
    }
    set e.funcs[e.funcsLen] = types::FuncAddr { name, index };
    set e.funcsLen += 1;
}

/// Record a local branch needing later patching.
/// Unconditional jumps use a single slot (J-type, +-1MB range).
/// Conditional branches use two slots (B-type has only +-4KB range,
/// so large functions may need the inverted-branch + JAL fallback).
export fn recordBranch(e: &mut Emitter, targetBlock: u32, kind: BranchKind) {
    if e.error <> nil { return; }
    if e.pendingBranches.len == e.pendingBranches.cap { set e.error = super::Error::Capacity; return; }
    let count = e.pendingBranches.len;
    unsafe { set e.pendingBranches.len = count + 1; }
    set e.pendingBranches[count] = PendingBranch {
    if e.error <> nil {
        return;
    }
    if e.pendingBranchesLen == e.pendingBranches.len {
        set e.error = super::Error::Capacity;
        return;
    }
    set e.pendingBranches[e.pendingBranchesLen] = PendingBranch {
        index: e.codeLen,
        target: targetBlock,
        kind: kind,
        kind,
    };
    set e.pendingBranchesLen += 1;

    emit(e, encode::nop()); // First slot, always needed.

    match kind {
        case BranchKind::Jump => {},


/// Record a function call needing later patching.
/// Emits placeholder instructions that will be patched later.
/// Uses two slots to support long-distance calls.
export fn recordCall(e: &mut Emitter, target: *[u8]) {
    if e.error <> nil { return; }
    if e.pendingCalls.len == e.pendingCalls.cap { set e.error = super::Error::Capacity; return; }
    let count = e.pendingCalls.len;
    unsafe { set e.pendingCalls.len = count + 1; }
    set e.pendingCalls[count] = PendingCall {
    if e.error <> nil {
        return;
    }
    if e.pendingCallsLen == e.pendingCalls.len {
        set e.error = super::Error::Capacity;
        return;
    }
    set e.pendingCalls[e.pendingCallsLen] = PendingCall {
        index: e.codeLen,
        target,
    };
    set e.pendingCallsLen += 1;

    emit(e, encode::nop()); // Placeholder for AUIPC.
    emit(e, encode::nop()); // Placeholder for JALR.
}

/// Record a jump emitted by assembly that needs whole-program patching.
export fn recordJumpAt(e: &mut Emitter, target: *[u8], rd: gen::Reg, index: u32) {
    if e.error <> nil { return; }
    if e.pendingJumps.len == e.pendingJumps.cap { set e.error = super::Error::Capacity; return; }
    let count = e.pendingJumps.len;
    unsafe { set e.pendingJumps.len = count + 1; }
    set e.pendingJumps[count] = PendingJump {
    if e.error <> nil {
        return;
    }
    if e.pendingJumpsLen == e.pendingJumps.len {
        set e.error = super::Error::Capacity;
        return;
    }
    set e.pendingJumps[e.pendingJumpsLen] = PendingJump {
        index,
        target,
        rd,
    };
    set e.pendingJumpsLen += 1;
}

/// Record a function address load needing later patching.
/// Emits placeholder instructions that will be patched to load the function's address.
/// Uses two slots to compute long-distance addresses.

    emit(e, encode::nop()); // Placeholder for ADDI.
}

/// Record a function address load already reserved by assembly.
export fn recordAddrLoadAt(e: &mut Emitter, target: *[u8], rd: gen::Reg, index: u32) {
    if e.error <> nil { return; }
    if e.pendingAddrLoads.len == e.pendingAddrLoads.cap { set e.error = super::Error::Capacity; return; }
    let count = e.pendingAddrLoads.len;
    unsafe { set e.pendingAddrLoads.len = count + 1; }
    set e.pendingAddrLoads[count] = PendingAddrLoad {
    if e.error <> nil {
        return;
    }
    if e.pendingAddrLoadsLen == e.pendingAddrLoads.len {
        set e.error = super::Error::Capacity;
        return;
    }
    set e.pendingAddrLoads[e.pendingAddrLoadsLen] = PendingAddrLoad {
        index,
        target,
        rd: rd,
        rd,
        isData: false,
    };
    set e.pendingAddrLoadsLen += 1;
}

/// Record a data address load needing later patching.
/// Reserves two instructions for a PC-relative address load.
export fn recordDataAddrLoad(e: &mut Emitter, target: *[u8], rd: gen::Reg) {
    if e.error <> nil { return; }
    if e.pendingAddrLoads.len == e.pendingAddrLoads.cap { set e.error = super::Error::Capacity; return; }
    let count = e.pendingAddrLoads.len;
    unsafe { set e.pendingAddrLoads.len = count + 1; }
    set e.pendingAddrLoads[count] = PendingAddrLoad {
    if e.error <> nil {
        return;
    }
    if e.pendingAddrLoadsLen == e.pendingAddrLoads.len {
        set e.error = super::Error::Capacity;
        return;
    }
    set e.pendingAddrLoads[e.pendingAddrLoadsLen] = PendingAddrLoad {
        index: e.codeLen,
        target,
        rd: rd,
        rd,
        isData: true,
    };
    set e.pendingAddrLoadsLen += 1;

    emit(e, encode::nop()); // Address-load upper instruction.
    emit(e, encode::nop()); // Address-load lower instruction.
    if e.sharedData {
        emit(e, encode::nop()); // Package offset addition.

/// Called after each function.
///
/// Uses two-instruction sequences: short branches use `branch` and `nop`,
/// long branches use inverted branch  and `jal` or `auipc` and `jalr`.
export unsafe fn patchLocalBranches(e: &mut Emitter) {
    if e.error <> nil { return; }
    for i in 0..e.pendingBranches.len {
    if e.error <> nil {
        return;
    }
    for i in 0..e.pendingBranchesLen {
        let p = e.pendingBranches[i];
        if p.target >= e.labels.blockCount { set e.error = super::Error::Symbol; return; }
        if p.target >= e.labels.blockCount {
            set e.error = super::Error::Symbol;
            return;
        }
        let offset = labels::branchToBlock(&e.labels, p.index, p.target, super::INSTR_SIZE);
        match p.kind {
            case BranchKind::Cond { op, rs1, rs2 } => {
                if encode::isBranchImm(offset) {
                    patch(e, p.index, encodeCondBranch(op, rs1, rs2, offset));
                    patch(e, p.index + 1, encode::nop());
                } else {
                    let adj = offset - super::INSTR_SIZE;
                    if not encode::isJumpImm(adj) { set e.error = super::Error::Relocation; return; }
                    if not encode::isJumpImm(adj) {
                        set e.error = super::Error::Relocation;
                        return;
                    }
                    patch(e, p.index, encodeInvertedBranch(op, rs1, rs2, super::INSTR_SIZE * 2));
                    patch(e, p.index + 1, encode::jal(super::ZERO, adj));
                }
            },
            case BranchKind::InvertedCond { op, rs1, rs2 } => {
                if encode::isBranchImm(offset) {
                    patch(e, p.index, encodeInvertedBranch(op, rs1, rs2, offset));
                    patch(e, p.index + 1, encode::nop());
                } else {
                    let adj = offset - super::INSTR_SIZE;
                    if not encode::isJumpImm(adj) { set e.error = super::Error::Relocation; return; }
                    if not encode::isJumpImm(adj) {
                        set e.error = super::Error::Relocation;
                        return;
                    }
                    patch(e, p.index, encodeCondBranch(op, rs1, rs2, super::INSTR_SIZE * 2));
                    patch(e, p.index + 1, encode::jal(super::ZERO, adj));
                }
            },
            case BranchKind::Jump => {
                // Single-slot jump (J-type, +-1MB range).
                if not encode::isJumpImm(offset) { set e.error = super::Error::Relocation; return; }
                if not encode::isJumpImm(offset) {
                    set e.error = super::Error::Relocation;
                    return;
                }
                patch(e, p.index, encode::jal(super::ZERO, offset));
            },
        }
    }
    set e.pendingBranches.len = 0;
    set e.pendingBranchesLen = 0;
}

/// Encode a conditional branch instruction.
fn encodeCondBranch(op: il::CmpOp, rs1: gen::Reg, rs2: gen::Reg, offset: i32) -> u32 {
    match op {

}

/// Patch all pending function calls.
/// Called after all functions have been generated.
export fn patchCalls(e: &mut Emitter) {
    for i in 0..e.pendingCalls.len {
    for i in 0..e.pendingCallsLen {
        let p = e.pendingCalls[i];
        let offset = branchOffsetToFunc(e, p.index, p.target);
        if offset > 0x7ffff7ff { set e.error = super::Error::Relocation; return; }
        if offset > 0x7ffff7ff {
            set e.error = super::Error::Relocation;
            return;
        }
        let s = splitImm(offset);

        // `AUIPC scratch, hi(offset)`.
        patch(e, p.index, encode::auipc(super::SCRATCH1, s.hi));
        // `JALR ra, scratch, lo(offset)`.

    }
}

/// Patch all pending assembly jumps.
export fn patchJumps(e: &mut Emitter) {
    for i in 0..e.pendingJumps.len {
    for i in 0..e.pendingJumpsLen {
        let p = e.pendingJumps[i];
        let offset = branchOffsetToFunc(e, p.index, p.target);

        if not encode::isJumpImm(offset) { set e.error = super::Error::Relocation; return; }
        if not encode::isJumpImm(offset) {
            set e.error = super::Error::Relocation;
            return;
        }
        patch(e, p.index, encode::jal(p.rd, offset));
    }
}

/// Patch all pending function and data address loads.
/// Called after all functions have been generated and data layout is known.
export fn patchAddrLoads(e: &mut Emitter, dataSymMap: &data::DataSymMap, codeBase: u64) throws (super::Error) {
    try check(e);
    for i in 0..e.pendingAddrLoads.len {
    for i in 0..e.pendingAddrLoadsLen {
        let p = e.pendingAddrLoads[i];
        if p.isData {
            let addr = data::lookupAddr(dataSymMap, p.target) else {
                throw super::Error::Symbol;
            };


            continue;
        }

        let offset = branchOffsetToFunc(e, p.index, p.target);
        if offset > 0x7ffff7ff { set e.error = super::Error::Relocation; return; }
        if offset > 0x7ffff7ff {
            set e.error = super::Error::Relocation;
            return;
        }
        let s = splitImm(offset);
        // `AUIPC rd, hi(offset)`.
        patch(e, p.index, encode::auipc(p.rd, s.hi));
        // `ADDI rd, rd, lo(offset)`.
        patch(e, p.index + 1, encode::addi(p.rd, p.rd, s.lo));

//////////////////
// Code Access  //
//////////////////

/// Get emitted code as a slice.
export fn getCode(e: &Emitter) -> *[u32] {
export fn getCode 'code (e: &'code Emitter) -> &'code [u32] {
    return &e.code[..e.codeLen];
}

/// Record a debug entry mapping the current PC to a source location.
/// Deduplicates consecutive entries with the same location.
export fn recordSrcLoc(e: &mut Emitter, loc: il::SrcLoc) {
    if e.error <> nil { return; }
    if e.error <> nil {
        return;
    }
    let pc = e.codeLen * super::INSTR_SIZE as u32;

    // Skip if this is the same location as the previous entry.
    if e.debugEntriesLen > 0 {
        let prev = &e.debugEntries[e.debugEntriesLen - 1];
        if prev.offset == loc.offset and prev.moduleId == loc.moduleId {
            return;
        }
    }
    if e.debugEntriesLen == e.debugEntries.len { set e.error = super::Error::Capacity; return; }
    if e.debugEntriesLen == e.debugEntries.len {
        set e.error = super::Error::Capacity;
        return;
    }
    set e.debugEntries[e.debugEntriesLen] = types::DebugEntry {
        pc,
        moduleId: loc.moduleId,
        offset: loc.offset,
    };
    set e.debugEntriesLen += 1;
}

/// Get debug entries as a slice.
export fn getDebugEntries(e: &Emitter) -> *[types::DebugEntry] {
export fn getDebugEntries 'code (e: &'code Emitter) -> &'code [types::DebugEntry] {
    return &e.debugEntries[..e.debugEntriesLen];
}

/// Return the first emission failure before any generated output is published.
export fn check(e: &Emitter) throws (super::Error) {
    if let error = e.error { throw error; }
    if let error = e.error {
        throw error;
    }
}

lib/std/arch/rv64/image.rad +6 -2

/// Compute a signed displacement for a two-instruction AUIPC/ADDI load.
export fn displacement(source: u64, target: u64) -> ?i32 {
    if target >= source {
        let distance = target - source;
        // AUIPC sign-extends its upper immediate before ADDI applies the low part.
        if distance > 0x7ffff7ff { return nil; }
        if distance > 0x7ffff7ff {
            return nil;
        }
        return distance as i32;
    }
    let distance = source - target;
    if distance > 0x80000000 { return nil; }
    if distance > 0x80000000 {
        return nil;
    }
    return (-(distance as i64)) as i32;
}

lib/std/arch/rv64/image/tests.rad +14 -6

    };
}

/// Check the exact 64-byte little-endian header.
@test fn header() throws (testing::TestError) {
    let bytes = try image::header(layout()) catch { throw testing::TestError::Failed; };
    let bytes = try image::header(layout()) catch {
        throw testing::TestError::Failed;
    };
    try testing::expectBytesEq(&bytes[..], &[
        82, 65, 68, 48, 2, 0, 0, 0, 4, 0, 0, 128, 0, 0, 0, 0,
        0, 0, 0, 128, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0,
        0, 16, 0, 128, 0, 0, 0, 0, 3, 0, 0, 0, 16, 0, 0, 0,
        0, 32, 0, 128, 0, 0, 0, 0, 4, 0, 0, 0, 0, 16, 0, 0,

    set item = layout();
    set item.rwData.address = 0xfffffffffffffff8;
    try invalid(item, image::Error::Overflow);
    set item = layout();
    set item.roData.address = item.code.address + 8;
    try image::validate(item) catch { throw testing::TestError::Failed; };
    try image::validate(item) catch {
        throw testing::TestError::Failed;
    };
}

/// Check AUIPC/ADDI limits without overflowing unsigned address arithmetic.
@test fn displacements() throws (testing::TestError) {
    try testing::expect(image::displacement(0x180000000, 0x180002000) == 8192);

        },
    ];
    unsafe static syms: [data::DataSym; 2] = undefined;
    let mut ro: [u8; 8] = [0; 8];
    let mut rw: [u8; 8] = [0; 8];
    let result = try rv64::finishProgram(&mut generator, globals,
    let result = try rv64::finishProgram(generator, globals,
        rv64::Storage { dataSyms: &mut syms[..], dataSymEntries: &mut ENTRIES[..] },
        &[], &mut ro[..], &mut rw[..]
    ) catch { throw testing::TestError::Failed; };
    ) catch {
        throw testing::TestError::Failed;
    };
    try testing::expect(result.layout.code.address == 0x180000000);
    try testing::expect(result.layout.rwData.initialized == 8);
    try testing::expect(result.layout.rwData.memory == 4104);
    try testing::expect(syms[1].addr == 0x180002008);
    try testing::expectBytesEq(&rw[..], &[0, 0, 0, 128, 1, 0, 0, 0]);

        },
    ];
    unsafe static syms: [data::DataSym; 2] = undefined;
    let mut ro: [u8; 0] = [];
    let mut rw: [u8; 16] = [255; 16];
    let result = try rv64::finishProgram(&mut generator, globals,
    let result = try rv64::finishProgram(generator, globals,
        rv64::Storage { dataSyms: &mut syms[..], dataSymEntries: &mut ENTRIES[..] },
        &[], &mut ro[..], &mut rw[..]
    ) catch { throw testing::TestError::Failed; };
    ) catch {
        throw testing::TestError::Failed;
    };
    try testing::expect(result.layout.rwData.initialized == 16);
    try testing::expect(syms[1].addr == 0x80002008);
    try testing::expectBytesEq(&rw[..], &[97, 0, 0, 0, 0, 0, 0, 0, 98, 0, 0, 0, 0, 0, 0, 0]);
}

lib/std/arch/rv64/isel.rad +172 -198

////////////////////
// Selector State //
////////////////////

/// Instruction selector state.
export record Selector: Copy {
export record Selector: 'scratch + 'selection where 'scratch: 'selection {
    /// Emitter for outputting instructions.
    e: *unsafe mut emit::Emitter,
    e: &'selection mut emit::Emitter,
    /// Register allocation result.
    ralloc: *unsafe regalloc::AllocResult,
    ralloc: &'selection regalloc::AllocResult 'scratch,
    /// Total stack frame size.
    frameSize: i32,
    /// Running offset into the reserve region of the frame.
    /// Tracks current position within the pre-allocated reserve slots.
    reserveOffset: i32,

/////////////////////////
// Register Allocation //
/////////////////////////

/// Get the physical register for an already-allocated SSA register.
unsafe fn getReg(s: &Selector, ssa: il::Reg) -> gen::Reg {
unsafe fn getReg 'scratch 'selection (s: &Selector 'scratch 'selection, ssa: il::Reg) -> gen::Reg where 'scratch: 'selection {
    let phys = s.ralloc.assignments[ssa.n] else {
        panic "getReg: spilled register has no physical assignment";
    };
    return phys;
}

/// Compute the offset for a spill slot.
/// When using FP (dynamic): offset from FP = `slot - totalSize`.
/// When using SP: offset from SP = `slot`.
fn spillOffset(s: &Selector, slot: i32) -> i32 {
fn spillOffset 'scratch 'selection (s: &Selector 'scratch 'selection, slot: i32) -> i32 where 'scratch: 'selection {
    if s.isDynamic {
        return slot - s.frameSize;
    }
    return slot;
}

/// Get the base register for spill slot addressing (FP or SP).
fn spillBase(s: &Selector) -> gen::Reg {
fn spillBase 'scratch 'selection (s: &Selector 'scratch 'selection) -> gen::Reg where 'scratch: 'selection {
    if s.isDynamic {
        return super::FP;
    }
    return super::SP;
}

/// Get the destination register for an SSA register.
/// If the register is spilled, records a pending spill and returns the scratch
/// register. The pending spill is auto-committed by [`selectBlock`] after each
/// instruction. If not spilled, returns the physical register.
unsafe fn getDstReg(s: &mut Selector, ssa: il::Reg, scratch: gen::Reg) -> gen::Reg {
unsafe fn getDstReg 'scratch 'selection (s: &mut Selector 'scratch 'selection, ssa: il::Reg, scratch: gen::Reg) -> gen::Reg where 'scratch: 'selection {
    if let _ = regalloc::spill::spillSlot(&s.ralloc.spill, ssa) {
        set s.pendingSpill = PendingSpill { ssa, rd: scratch };
        return scratch;
    }
    return getReg(s, ssa);
}

/// Get the source register for an SSA register.
/// If the register is spilled, loads the value from the spill slot into the
/// scratch register and returns it. Otherwise returns the physical register.
unsafe fn getSrcReg(s: &mut Selector, ssa: il::Reg, scratch: gen::Reg) -> gen::Reg {
unsafe fn getSrcReg 'scratch 'selection (s: &mut Selector 'scratch 'selection, ssa: il::Reg, scratch: gen::Reg) -> gen::Reg where 'scratch: 'selection {
    if let slot = regalloc::spill::spillSlot(&s.ralloc.spill, ssa) {
        emit::emitLd(s.e, scratch, spillBase(s), spillOffset(s, slot));
        return scratch;
    }
    return getReg(s, ssa);
}

/// Resolve an IL value to the physical register holding it.
/// For non-spilled register values, returns the physical register directly.
/// For immediates, symbols, and spilled registers, materializes into `scratch`.
unsafe fn resolveVal(s: &mut Selector, scratch: gen::Reg, val: il::Val) -> gen::Reg {
unsafe fn resolveVal 'scratch 'selection (s: &mut Selector 'scratch 'selection, scratch: gen::Reg, val: il::Val) -> gen::Reg where 'scratch: 'selection {
    match val {
        case il::Val::Reg(r) => {
            return getSrcReg(s, r, scratch);
        },
        case il::Val::Imm(imm) => {

    }
}

/// Load an IL value into a specific physical register.
/// Like [`resolveVal`], but ensures the value ends up in `rd`.
unsafe fn loadVal(s: &mut Selector, rd: gen::Reg, val: il::Val) -> gen::Reg {
unsafe fn loadVal 'scratch 'selection (s: &mut Selector 'scratch 'selection, rd: gen::Reg, val: il::Val) -> gen::Reg where 'scratch: 'selection {
    let rs = resolveVal(s, rd, val);
    emitMv(s, rd, rs);
    return rd;
}

/// Emit a move instruction if source and destination differ.
unsafe fn emitMv(s: &mut Selector, rd: gen::Reg, rs: gen::Reg) {
unsafe fn emitMv 'scratch 'selection (s: &mut Selector 'scratch 'selection, rd: gen::Reg, rs: gen::Reg) where 'scratch: 'selection {
    if *rd <> *rs {
        emit::emit(s.e, encode::mv(rd, rs));
    }
}


    }
}

/// Resolve a divisor in its declared width, trap if it becomes zero, and
/// return the canonicalized register.
unsafe fn resolveAndTrapIfZero(
    s: &mut Selector,
unsafe fn resolveAndTrapIfZero 'scratch 'selection (
    s: &mut Selector 'scratch 'selection,
    b: il::Val,
    typ: il::Type,
    signed: bool
) -> gen::Reg {
) -> gen::Reg where 'scratch: 'selection {
    let mut divisor = b;
    if let case il::Val::Imm(imm) = b {
        set divisor = il::Val::Imm(canonicalCmpImm(imm, typ, signed));
    }
    let rs2 = resolveVal(s, super::SCRATCH2, divisor);

    isDynamic: bool,
}

/// Pre-scan all blocks for constant-sized reserve instructions.
/// Returns the total size needed for all static reserves, respecting alignment.
unsafe fn computeReserveInfo(func: *unsafe il::Fn) -> ?ReserveInfo {
unsafe fn computeReserveInfo(func: &il::Fn) -> ?ReserveInfo {
    let mut offset: i32 = 0;
    let mut isDynamic = false;

    for b in 0..func.blocks.len {
        let block = &func.blocks[b];
        for instr in block.instrs {
            match instr {
                case il::Instr::Reserve { size, alignment, .. } => {
                    if let case il::Val::Imm(sz) = size {
                        if alignment == 0 or (alignment & (alignment - 1)) <> 0 or sz < 0 { return nil; }
                        if alignment == 0 or (alignment & (alignment - 1)) <> 0 or sz < 0 {
                            return nil;
                        }
                        let aligned = (offset as u64 + alignment as u64 - 1) & ~(alignment as u64 - 1);
                        if aligned > 0x7fff0000 or sz as u64 > 0x7fff0000 - aligned { return nil; }
                        if aligned > 0x7fff0000 or sz as u64 > 0x7fff0000 - aligned {
                            return nil;
                        }
                        set offset = (aligned + sz as u64) as i32;
                    } else {
                        set isDynamic = true;
                    }
                },

    }
    return ReserveInfo { size: offset, isDynamic };
}

/// Select instructions for a function.
export unsafe fn selectFn(
export unsafe fn selectFn 'scratch (
    e: &mut emit::Emitter,
    ralloc: &regalloc::AllocResult,
    func: *unsafe il::Fn
    ralloc: &regalloc::AllocResult 'scratch,
    func: &il::Fn
) {
    if e.error <> nil { return; }
    if e.error <> nil {
        return;
    }
    // Reset block offsets for this function.
    labels::resetBlocks(&mut e.labels);
    // Pre-scan for constant-sized reserves to promote to fixed frame slots.
    let reserveInfo = computeReserveInfo(func) else { set e.error = super::Error::Capacity; return; };
    let reserveInfo = computeReserveInfo(func) else {
        set e.error = super::Error::Capacity;
        return;
    };
    if reserveInfo.size as u64 + ralloc.spill.frameSize as u64 > 0x7fffff00 {
        set e.error = super::Error::Capacity; return;
    }
    let isLeaf = func.isLeaf;
    // Compute frame layout from spill slots, reserve slots, and used callee-saved registers.

        func.blocks.len,
        isLeaf,
        reserveInfo.isDynamic
    );
    // Synthetic block indices start after real blocks and the epilogue block.
    let mut s = Selector {
        e: e as *unsafe mut emit::Emitter,
        ralloc: ralloc as *unsafe regalloc::AllocResult,
        frameSize: frame.totalSize,
        reserveOffset: 0, pendingSpill: nil,
        nextSynthBlock: func.blocks.len + 1,
        isDynamic: frame.isDynamic,
    };
    // Record function name for printing.
    emit::recordFunc(s.e, func.name);
    // Record function code offset for call patching.
    emit::recordFuncOffset(s.e, func.name);
    // Emit prologue.
    emit::emitPrologue(s.e, &frame);

    // Move function params from arg registers to assigned registers.
    // Cross-call params may have been assigned to callee-saved registers
    // instead of their natural arg registers. Spilled params are stored
    // directly to their spill slots.
    for funcParam, i in func.params {
        if i < super::ARG_REGS.len {
            let param = funcParam.value;
            let argReg = super::ARG_REGS[i];

            if let slot = regalloc::spill::spillSlot(&ralloc.spill, param) {
                // Spilled parameter: store arg register to spill slot.
                emit::emitSd(s.e, argReg, spillBase(&s), spillOffset(&s, slot));
            } else if let assigned = ralloc.assignments[param.n] {
                emitMv(&mut s, assigned, argReg);
    let resultRef: 'selection = &*ralloc, emitterRef = &mut *e where 'scratch: 'selection in {
        let mut s = Selector 'scratch 'selection {
            e: emitterRef,
            ralloc: resultRef,
            frameSize: frame.totalSize,
            reserveOffset: 0, pendingSpill: nil,
            nextSynthBlock: func.blocks.len + 1,
            isDynamic: frame.isDynamic,
        };
        // Record function name for printing.
        emit::recordFunc(s.e, func.name);
        // Record function code offset for call patching.
        emit::recordFuncOffset(s.e, func.name);
        // Emit prologue.
        emit::emitPrologue(s.e, &frame);

        // Move function params from arg registers to assigned registers.
        // Cross-call params may have been assigned to callee-saved registers
        // instead of their natural arg registers. Spilled params are stored
        // directly to their spill slots.
        for funcParam, i in func.params {
            if i < super::ARG_REGS.len {
                let param = funcParam.value;
                let argReg = super::ARG_REGS[i];

                if let slot = regalloc::spill::spillSlot(&ralloc.spill, param) {
                    // Spilled parameter: store arg register to spill slot.
                    emit::emitSd(s.e, argReg, spillBase(&s), spillOffset(&s, slot));
                } else if let assigned = ralloc.assignments[param.n] {
                    emitMv(&mut s, assigned, argReg);
                }
            }
        }
    }

    // Emit each block.
    for i in 0..func.blocks.len {
        if s.e.error <> nil { return; }
        selectBlock(&mut s, i, &func.blocks[i], &frame, func);
        // Emit each block.
        for i in 0..func.blocks.len {
            if s.e.error <> nil {
                return;
            }
            selectBlock(&mut s, i, &func.blocks[i], &frame, func);
        }
        // Emit epilogue.
        emit::emitEpilogue(s.e, &frame);
        // Patch local branches now that all blocks are emitted.
        emit::patchLocalBranches(s.e);
    }
    // Emit epilogue.
    emit::emitEpilogue(s.e, &frame);
    // Patch local branches now that all blocks are emitted.
    emit::patchLocalBranches(s.e);
}

/// Select instructions for a block.
unsafe fn selectBlock(s: &mut Selector, blockIdx: u32, block: *unsafe il::Block, frame: &emit::Frame, func: *unsafe il::Fn) {
unsafe fn selectBlock 'scratch 'selection (s: &mut Selector 'scratch 'selection, blockIdx: u32, block: &il::Block, frame: &emit::Frame, func: &il::Fn) where 'scratch: 'selection {
    // Record block address for branch patching.
    emit::recordBlock(s.e, blockIdx);

    // Block parameters are handled at jump sites (in `Jmp`/`Br`).
    // By the time we enter the block, the arguments have already been
    // moved to the parameter registers by the predecessor's terminator.

    // Process each instruction, auto-committing any pending spill after each.
    let hasLocs = block.locs.len > 0;
    for instr, i in block.instrs {
        if s.e.error <> nil { return; }
        if s.e.error <> nil {
            return;
        }
        // Record debug location before emitting machine instructions.
        if hasLocs {
            emit::recordSrcLoc(s.e, block.locs[i]);
        }
        set s.pendingSpill = nil;

        }
    }
}

/// Select instructions for a single IL instruction.
unsafe fn selectInstr(s: &mut Selector, blockIdx: u32, instr: il::Instr, frame: &emit::Frame, func: *unsafe il::Fn) {
unsafe fn selectInstr 'scratch 'selection (s: &mut Selector 'scratch 'selection, blockIdx: u32, instr: il::Instr, frame: &emit::Frame, func: &il::Fn) where 'scratch: 'selection {
    match instr {
        case il::Instr::BinOp { op, typ, dst, a, b } => {
            let rd = getDstReg(s, dst, super::SCRATCH1);
            let rs1 = resolveVal(s, super::SCRATCH1, a);
            selectAluBinOp(s, op, typ, rd, rs1, b);

                else =>
                    panic "selectInstr: invalid reserve operand",
            }
        },
        case il::Instr::Blit { dst, src, size } => {
            let case il::Val::Imm(staticSize) = size
                else panic "selectInstr: blit requires immediate size";

            let bothSpilled = regalloc::spill::isSpilled(&s.ralloc.spill, dst)
                and regalloc::spill::isSpilled(&s.ralloc.spill, src);

            // When both are spilled, offsets must fit 12-bit immediates
            // since we can't advance base registers (they live in spill
            // slots, not real registers we can mutate).
            assert not (bothSpilled and staticSize as i32 > super::MAX_IMM), "selectInstr: blit both-spilled with large size";

            // Resolve dst/src base registers.
            let mut rdst = super::SCRATCH2;
            let mut rsrc = super::SCRATCH1;
            let mut srcReload: ?i32 = nil;

            if bothSpilled {
                let dstSlot = regalloc::spill::spillSlot(&s.ralloc.spill, dst) else {
                    panic "selectInstr: blit dst not spilled";
                };
                let srcSlot = regalloc::spill::spillSlot(&s.ralloc.spill, src) else {
                    panic "selectInstr: blit src not spilled";
                };
                emit::emitLd(s.e, super::SCRATCH2, spillBase(s), spillOffset(s, dstSlot));
                set srcReload = spillOffset(s, srcSlot);
            } else {
                set rdst = getSrcReg(s, dst, super::SCRATCH2);
                set rsrc = getSrcReg(s, src, super::SCRATCH2);
            }
            let mut offset: i32 = 0;
            let mut remaining = staticSize as i32;

            // For large blits where both pointers are in real registers,
            // use an inline loop instead of unrolled LD/SD pairs.
            let dwordBytes = remaining & ~(super::DWORD_SIZE - 1);
            let canLoop = not bothSpilled
                and *rsrc <> *super::SCRATCH1 and *rsrc <> *super::SCRATCH2
                and *rdst <> *super::SCRATCH1 and *rdst <> *super::SCRATCH2;

            if canLoop and dwordBytes >= super::BLIT_LOOP_THRESHOLD {
                emit::emitAddImm(s.e, super::SCRATCH1, rsrc, dwordBytes);

                let loopStart = s.e.codeLen;

                emit::emitLd(s.e, super::SCRATCH2, rsrc, 0);
                emit::emitSd(s.e, super::SCRATCH2, rdst, 0);
                emit::emit(s.e, encode::addi(rsrc, rsrc, super::DWORD_SIZE));

                if *rdst <> *rsrc {
                    emit::emit(s.e, encode::addi(rdst, rdst, super::DWORD_SIZE));
                }
                let brOff = (loopStart as i32 - s.e.codeLen as i32) * super::INSTR_SIZE;

                emit::emit(s.e, encode::bne(rsrc, super::SCRATCH1, brOff));
                set remaining -= dwordBytes;
            }

            // Copy remaining: 8 bytes, then 4 bytes, then 1 byte at a time.
            // Before each load/store pair, check whether the offset is
            // about to exceed the 12-bit signed immediate range. When
            // it does, advance the base registers by the accumulated
            // offset and reset to zero.
            while remaining >= super::DWORD_SIZE {
                if offset > super::MAX_IMM - super::DWORD_SIZE {
                    emit::emitAddImm(s.e, rsrc, rsrc, offset);
                    if *rdst <> *rsrc {
                        emit::emitAddImm(s.e, rdst, rdst, offset);
                    }
                    set offset = 0;
                }
                if let off = srcReload {
                    emit::emitLd(s.e, super::SCRATCH1, spillBase(s), off);
                    emit::emitLd(s.e, super::SCRATCH1, super::SCRATCH1, offset);
                } else {
                    emit::emitLd(s.e, super::SCRATCH1, rsrc, offset);
                }
                emit::emitSd(s.e, super::SCRATCH1, rdst, offset);
                set offset += super::DWORD_SIZE;
                set remaining -= super::DWORD_SIZE;
            }
            if remaining >= super::WORD_SIZE {
                if offset > super::MAX_IMM - super::WORD_SIZE {
                    emit::emitAddImm(s.e, rsrc, rsrc, offset);
                    if *rdst <> *rsrc {
                        emit::emitAddImm(s.e, rdst, rdst, offset);
                    }
                    set offset = 0;
                }
                if let off = srcReload {
                    emit::emitLd(s.e, super::SCRATCH1, spillBase(s), off);
                    emit::emitLw(s.e, super::SCRATCH1, super::SCRATCH1, offset);
                } else {
                    emit::emitLw(s.e, super::SCRATCH1, rsrc, offset);
                }
                emit::emitSw(s.e, super::SCRATCH1, rdst, offset);
                set offset += super::WORD_SIZE;
                set remaining -= super::WORD_SIZE;
            let case il::Val::Imm(staticSize) = size else {
                set s.e.error = super::Error::Capacity; return;
            };
            if staticSize < 0 or staticSize > 0x7fffffff {
                set s.e.error = super::Error::Capacity; return;
            }
            while remaining > 0 {
                if offset > super::MAX_IMM - 1 {
                    emit::emitAddImm(s.e, rsrc, rsrc, offset);
                    if *rdst <> *rsrc {
                        emit::emitAddImm(s.e, rdst, rdst, offset);
                    }
                    set offset = 0;
                }
                if let off = srcReload {
                    emit::emitLd(s.e, super::SCRATCH1, spillBase(s), off);
                    emit::emitLb(s.e, super::SCRATCH1, super::SCRATCH1, offset);
                } else {
                    emit::emitLb(s.e, super::SCRATCH1, rsrc, offset);
                }
                emit::emitSb(s.e, super::SCRATCH1, rdst, offset);
                set offset += 1;
                set remaining -= 1;
            if staticSize == 0 {
                return;
            }
            // Restore base registers if they were advanced (never happens
            // in the both-spilled case since size <= MAX_IMM).
            if not bothSpilled {
                let advanced = staticSize as i32 - offset;
                if advanced <> 0 {
                    emit::emitAddImm(s.e, rsrc, rsrc, 0 - advanced);
                    if *rdst <> *rsrc {
                        emit::emitAddImm(s.e, rdst, rdst, 0 - advanced);
                    }
            let rdst = getSrcReg(s, dst, super::SCRATCH2);
            let rsrc = getSrcReg(s, src, super::SCRATCH1);
            // Blit addresses have byte alignment. Small copies need no loop state.
            if staticSize < super::BLIT_LOOP_THRESHOLD as i64 {
                for offset in 0..staticSize as u32 {
                    emit::emitLb(s.e, super::ADDR_SCRATCH, rsrc, offset as i32);
                    emit::emitSb(s.e, super::ADDR_SCRATCH, rdst, offset as i32);
                }
            } else {
                // Private cursors preserve both input pointers. Save the count
                // register because it can hold a live allocated value.
                emit::emit(s.e, encode::addi(super::ADDR_SCRATCH, rsrc, 0));
                emit::emit(s.e, encode::addi(super::SCRATCH2, rdst, 0));
                emit::emit(s.e, encode::addi(super::SP, super::SP, -16));
                emit::emitSd(s.e, super::T3, super::SP, 0);
                emit::loadImm(s.e, super::T3, staticSize);
                let start = s.e.codeLen;
                emit::emitLb(s.e, super::SCRATCH1, super::ADDR_SCRATCH, 0);
                emit::emitSb(s.e, super::SCRATCH1, super::SCRATCH2, 0);
                emit::emit(s.e, encode::addi(super::ADDR_SCRATCH, super::ADDR_SCRATCH, 1));
                emit::emit(s.e, encode::addi(super::SCRATCH2, super::SCRATCH2, 1));
                emit::emit(s.e, encode::addi(super::T3, super::T3, -1));
                let offset = (start as i32 - s.e.codeLen as i32) * super::INSTR_SIZE;
                emit::emit(s.e, encode::bne(super::T3, super::ZERO, offset));
                emit::emitLd(s.e, super::T3, super::SP, 0);
                emit::emit(s.e, encode::addi(super::SP, super::SP, 16));
            }
        },
        case il::Instr::Zext { typ, dst, val } => {
            let rd = getDstReg(s, dst, super::SCRATCH1);
            let rs = resolveVal(s, super::SCRATCH1, val);

            if let case il::Val::Reg(r) = func {
                let target = getSrcReg(s, r, super::SCRATCH2);
                emitMv(s, super::SCRATCH2, target);
            }
            // Move arguments to A0-A7 using parallel move resolution.
            if args.len > super::ARG_REGS.len { set s.e.error = super::Error::Capacity; return; }
            if args.len > super::ARG_REGS.len {
                set s.e.error = super::Error::Capacity;
                return;
            }
            emitParallelMoves(s, &super::ARG_REGS[..], args);

            // Emit call.
            match func {
                case il::Val::FnAddr(name) => {


            // Result in A0.
            let ecallRd = getDstReg(s, dst, super::SCRATCH1);
            emitMv(s, ecallRd, super::A0);
        },
        case il::Instr::DeviceRead { typ, dst, handle, offset } => {
            deviceAddress(s, typ, handle, offset, il::Val::Imm(0), false);
            let rd = getDstReg(s, dst, super::SCRATCH1);
            match typ {
                case il::Type::W8 => emit::emit(s.e, encode::lbu(rd, super::A0, 0)),
                case il::Type::W16 => emit::emit(s.e, encode::lhu(rd, super::A0, 0)),
                case il::Type::W32 => emit::emit(s.e, encode::lwu(rd, super::A0, 0)),
                case il::Type::W64 => emit::emit(s.e, encode::ld(rd, super::A0, 0)),
            }
            emit::emit(s.e, encode::fence());
        },
        case il::Instr::DeviceWrite { typ, handle, offset, value } => {
            deviceAddress(s, typ, handle, offset, value, true);
            match typ {
                case il::Type::W8 => emit::emit(s.e, encode::sb(super::A3, super::A0, 0)),
                case il::Type::W16 => emit::emit(s.e, encode::sh(super::A3, super::A0, 0)),
                case il::Type::W32 => emit::emit(s.e, encode::sw(super::A3, super::A0, 0)),
                case il::Type::W64 => emit::emit(s.e, encode::sd(super::A3, super::A0, 0)),
            }
            emit::emit(s.e, encode::fence());
        },
        case il::Instr::Ebreak => {
            emit::emit(s.e, encode::ebreak());
        },
        case il::Instr::MemoryFence => {
            emit::emit(s.e, encode::fence());

    return false;
}

/// Select a binary ALU operation, dispatching to the appropriate
/// instruction pattern based on the operation kind and type.
unsafe fn selectAluBinOp(s: &mut Selector, op: il::BinOp, typ: il::Type, rd: gen::Reg, rs1: gen::Reg, b: il::Val) {
unsafe fn selectAluBinOp 'scratch 'selection (s: &mut Selector 'scratch 'selection, op: il::BinOp, typ: il::Type, rd: gen::Reg, rs1: gen::Reg, b: il::Val) where 'scratch: 'selection {
    match op {
        case il::BinOp::Add => {
            if typ == il::Type::W32 {
                // Inline W32 ADD with immediate optimization.
                if let case il::Val::Imm(imm) = b {

            selectCmp(s, typ, rd, rs1, b, CmpOp::Ult, true, super::SCRATCH2),
    }
}

/// Select a unary ALU operation.
unsafe fn selectAluUnOp(s: &mut Selector, op: il::UnOp, typ: il::Type, rd: gen::Reg, rs: gen::Reg) {
unsafe fn selectAluUnOp 'scratch 'selection (s: &mut Selector 'scratch 'selection, op: il::UnOp, typ: il::Type, rd: gen::Reg, rs: gen::Reg) where 'scratch: 'selection {
    match op {
        case il::UnOp::Neg => {
            if typ == il::Type::W32 {
                emit::emit(s.e, encode::subw(rd, super::ZERO, rs));
            } else {

            emit::emit(s.e, encode::not_(rd, rs)),
    }
}

/// Select binary operation with immediate optimization.
unsafe fn selectBinOp(s: &mut Selector, rd: gen::Reg, rs1: gen::Reg, b: il::Val, op: BinOp, scratch: gen::Reg) {
unsafe fn selectBinOp 'scratch 'selection (s: &mut Selector 'scratch 'selection, rd: gen::Reg, rs1: gen::Reg, b: il::Val, op: BinOp, scratch: gen::Reg) where 'scratch: 'selection {
    // Try immediate optimization first.
    if let case il::Val::Imm(imm) = b {
        if encode::isSmallImm64(imm) {
            let simm = imm as i32;
            match op {

}

/// Select shift operation with immediate optimization.
/// For 32-bit operations, uses the `*w` variants that operate on the lower 32 bits
/// and sign-extend the result.
unsafe fn selectShift(s: &mut Selector, rd: gen::Reg, rs1: gen::Reg, b: il::Val, op: ShiftOp, typ: il::Type, scratch: gen::Reg) {
unsafe fn selectShift 'scratch 'selection (s: &mut Selector 'scratch 'selection, rd: gen::Reg, rs1: gen::Reg, b: il::Val, op: ShiftOp, typ: il::Type, scratch: gen::Reg) where 'scratch: 'selection {
    let isW32: bool = typ == il::Type::W32;

    // Try immediate optimization first.
    if let case il::Val::Imm(shamt) = b {
        // Keep immediate forms only for encodable shift amounts.

/// 1. Identifies "ready" moves.
/// 2. Executes ready moves.
/// 3. Breaks cycles using scratch register.
///
/// Entries with `ZERO` destination are skipped, as they are handled by caller.
unsafe fn emitParallelMoves(s: &mut Selector, dsts: &[gen::Reg], args: &[il::Val]) {
unsafe fn emitParallelMoves 'scratch 'selection (s: &mut Selector 'scratch 'selection, dsts: &[gen::Reg], args: &[il::Val]) where 'scratch: 'selection {
    let n: u32 = args.len;
    if n == 0 {
        return;
    }
    if n > MAX_BLOCK_ARGS { set s.e.error = super::Error::Capacity; return; }
    if n > MAX_BLOCK_ARGS {
        set s.e.error = super::Error::Capacity;
        return;
    }
    // Source registers for each arg.
    let mut srcRegs: [gen::Reg; MAX_BLOCK_ARGS] = [super::ZERO; MAX_BLOCK_ARGS];
    // If this is a register-to-register move.
    let mut isRegMove: [bool; MAX_BLOCK_ARGS] = [false; MAX_BLOCK_ARGS];
    // If this move still needs to be executed.

/// Emit moves from block arguments to target block's parameter registers.
///
/// Handles spilled destinations directly, then delegates to [`emitParallelMoves`]
/// for the remaining register-to-register parallel move resolution. Edges that
/// would overwrite an unconsumed spill source are unsupported.
unsafe fn emitBlockArgs(s: &mut Selector, func: *unsafe il::Fn, target: u32, args: &[il::Val]) {
unsafe fn emitBlockArgs 'scratch 'selection (s: &mut Selector 'scratch 'selection, func: &il::Fn, target: u32, args: &[il::Val]) where 'scratch: 'selection {
    if args.len == 0 {
        return;
    }
    let block = &func.blocks[target];
    assert args.len == block.params.len, "emitBlockArgs: argument/parameter count mismatch";
    if args.len > MAX_BLOCK_ARGS { set s.e.error = super::Error::Capacity; return; }
    if args.len > MAX_BLOCK_ARGS {
        set s.e.error = super::Error::Capacity;
        return;
    }

    // The parallel-move resolver only handles register destinations. Keep eager
    // stores for independent spill slots, but reject dependencies that would
    // require stack staging rather than silently miscompiling them.
    for arg, i in args {

    }
    emitParallelMoves(s, &dsts[..], args);
}

/// Select a comparison with immediate optimization.
unsafe fn selectCmp(
    s: &mut Selector,
unsafe fn selectCmp 'scratch 'selection (
    s: &mut Selector 'scratch 'selection,
    typ: il::Type,
    rd: gen::Reg,
    rs1: gen::Reg,
    b: il::Val,
    op: CmpOp,
    invert: bool,
    scratch: gen::Reg
) {
) where 'scratch: 'selection {
    let mut signed = false;
    if let case CmpOp::Slt = op {
        set signed = true;
    }
    let useSext = cmpUsesSext(typ, signed);

    }
    if invert {
        emit::emit(s.e, encode::xori(rd, rd, 1));
    }
}

/// Resolve one live Device access before an ordered user-mode register instruction.
unsafe fn deviceAddress 'scratch 'selection (
    s: &mut Selector 'scratch 'selection,
    typ: il::Type,
    handle: il::Val,
    offset: il::Val,
    value: il::Val,
    writing: bool
) where 'scratch: 'selection {
    let mut flags = il::typeSize(typ) as i64;
    if writing {
        set flags |= 0x100;
    }
    let dsts: [gen::Reg; 5] = [super::A7, super::A0, super::A1, super::A2, super::A3];
    let args: [il::Val; 5] = [il::Val::Imm(il::DEVICE_ACCESS as i64), handle, offset, il::Val::Imm(flags), value];
    emitParallelMoves(s, &dsts[..], &args[..]);
    emit::emit(s.e, encode::ecall());
    emit::emit(s.e, encode::fence());
}

lib/std/arch/rv64/printer.rad +22 -7

            let stem = atomics::name(instruction.format.operation) else panic "invalid atomic operation";
            write(out, stem);
            write(out, ".w" if instruction.format.width == 2 else ".d");
            match instruction.format.order {
                case 1 => write(out, ".rl"), case 2 => write(out, ".aq"), case 3 => write(out, ".aqrl"),
                else => {},
                else => {
                },
            }
            write(out, " "); write(out, regNameR(instruction.rd)); write(out, ", ");
            if instruction.format.operation <> 2 { write(out, regNameR(instruction.rs2)); write(out, ", "); }
            if instruction.format.operation <> 2 {
                write(out, regNameR(instruction.rs2));
                write(out, ", ");
            }
            write(out, "0("); write(out, regNameR(instruction.rs1)); write(out, ")");
        },
        case decode::Instr::Fence { predecessor, successor } => {
            write(out, "fence "); fenceMask(out, predecessor); write(out, ", "); fenceMask(out, successor);
        },

    return nil;
}

/// Print a memory-ordering mask in canonical order.
unsafe fn fenceMask(out: &mut sexpr::Output, mask: u32) {
    if mask == 0 { write(out, "0"); return; }
    if (mask & 8) <> 0 { write(out, "i"); }
    if (mask & 4) <> 0 { write(out, "o"); }
    if (mask & 2) <> 0 { write(out, "r"); }
    if (mask & 1) <> 0 { write(out, "w"); }
    if mask == 0 {
        write(out, "0");
        return;
    }
    if (mask & 8) <> 0 {
        write(out, "i");
    }
    if (mask & 4) <> 0 {
        write(out, "o");
    }
    if (mask & 2) <> 0 {
        write(out, "r");
    }
    if (mask & 1) <> 0 {
        write(out, "w");
    }
}

lib/std/arch/rv64/shared.rad +191 -56

//! Shared package code, private data templates, and qualified symbol linking.

@test export mod tests;
export mod catalog;

use std::mem;
use std::lang::alloc;
use std::lang::il;
use std::lang::il::binary;
use std::lang::gen;
use std::lang::gen::data;
use super::emit;
use super::encode;
use super::image;
use super::asm;

/// Maximum number of resident package slots in a domain state table.
export constant MAX_PACKAGES: u32 = 256;

/// Package linking or instance storage failure.

}

/// Find exactly one qualified symbol in a bounded table.
export fn lookup(symbols: &[Symbol], name: &[u8]) -> ?Target {
    for symbol in symbols {
        if mem::eq(symbol.name, name) { return symbol.target; }
        if mem::eq(symbol.name, name) {
            return symbol.target;
        }
    }
    return nil;
}

/// Resolve a local or imported symbol.
fn resolve(local: &[Symbol], imports: &[Symbol], name: *[u8]) -> Target throws (Error) {
    if let target = lookup(local, name) { return target; }
    let target = lookup(imports, name) else { throw Error::Symbol; };
    if let target = lookup(local, name) {
        return target;
    }
    let target = lookup(imports, name) else {
        throw Error::Symbol;
    };
    return target;
}

/// Append a unique local definition to bounded symbol storage.
fn define(symbols: &mut [Symbol], count: &mut u32, name: *[u8], target: Target) throws (Error) {
    if lookup(&symbols[..*count], name) <> nil { throw Error::Symbol; }
    if *count == symbols.len { throw Error::Capacity; }
    if lookup(&symbols[..*count], name) <> nil {
        throw Error::Symbol;
    }
    if *count == symbols.len {
        throw Error::Capacity;
    }
    set symbols[*count] = Symbol { name, target };
    set *count += 1;
}

/// Resolve a shared function address with its required kind.


/// Patch a PC-relative call or function address load.
unsafe fn relative(e: &mut emit::Emitter, index: u32, base: u64, target: u64, rd: gen::Reg, call: bool)
    throws (Error)
{
    let delta = image::displacement(base + index as u64 * 4, target) else { throw Error::Range; };
    let delta = image::displacement(base + index as u64 * 4, target) else {
        throw Error::Range;
    };
    let parts = emit::splitImm(delta);
    emit::patch(e, index, encode::auipc(rd, parts.hi));
    if call {
        emit::patch(e, index + 1, encode::jalr(super::RA, rd, parts.lo));
    } else {

    }
}

/// Link shared code against local definitions and dependency exports.
unsafe fn link(e: &mut emit::Emitter, base: u64, local: &[Symbol], imports: &[Symbol]) throws (Error) {
    for i in 0..e.pendingCalls.len {
    for i in 0..e.pendingCallsLen {
        let pending = e.pendingCalls[i];
        let address = try function(local, imports, pending.target);
        try relative(e, pending.index, base, address, super::SCRATCH1, true);
    }
    for i in 0..e.pendingJumps.len {
    for i in 0..e.pendingJumpsLen {
        let pending = e.pendingJumps[i];
        let address = try function(local, imports, pending.target);
        let delta = image::displacement(base + pending.index as u64 * 4, address) else { throw Error::Range; };
        if not encode::isJumpImm(delta) { throw Error::Range; }
        let delta = image::displacement(base + pending.index as u64 * 4, address) else {
            throw Error::Range;
        };
        if not encode::isJumpImm(delta) {
            throw Error::Range;
        }
        emit::patch(e, pending.index, encode::jal(pending.rd, delta));
    }
    for i in 0..e.pendingAddrLoads.len {
    for i in 0..e.pendingAddrLoadsLen {
        let pending = e.pendingAddrLoads[i];
        if not pending.isData {
            try relative(e, pending.index, base, try function(local, imports, pending.target), pending.rd, false);
            continue;
        }
        let target = try resolve(local, imports, pending.target);
        let location = try dataRef(target);
        if location.slot >= MAX_PACKAGES or location.offset > 0x7ffff7ff { throw Error::Range; }
        if location.slot >= MAX_PACKAGES or location.offset > 0x7ffff7ff {
            throw Error::Range;
        }
        if pending.rd == super::ADDR_SCRATCH or pending.rd == super::GP or pending.rd == super::ZERO {
            throw Error::Symbol;
        }
        let parts = emit::splitImm(location.offset as i32);
        emit::patch(e, pending.index, encode::ld(pending.rd, super::GP, location.slot as i32 * 8));

    }
}

/// Write a little-endian integer into a validated byte extent.
fn integer(bytes: &mut [u8], offset: u32, value: u64, width: u32) {
    for i in 0..width { set bytes[offset + i] = (value >> (i as u64 * 8)) as u8; }
    for i in 0..width {
        set bytes[offset + i] = (value >> (i as u64 * 8)) as u8;
    }
}

/// Initialized output extents.
record TemplateSize: Copy {
    /// Initialized byte count.

    -> TemplateSize throws (Error)
{
    let mut initialized: u32 = 0;
    let mut count: u32 = 0;
    for item in items {
        if item.isZeroInit { continue; }
        if item.isZeroInit {
            continue;
        }
        let location = try dataRef(try resolve(local, &[], item.name));
        if location.offset > bytes.len or item.size > bytes.len - location.offset { throw Error::Capacity; }
        if location.offset > bytes.len or item.size > bytes.len - location.offset {
            throw Error::Capacity;
        }
        let end = location.offset + item.size;
        if end > initialized { set initialized = end; }
        if end > initialized {
            set initialized = end;
        }
    }
    for i in 0..initialized {
        set bytes[i] = 0;
    }
    for i in 0..initialized { set bytes[i] = 0; }
    for item in items {
        if item.isZeroInit { continue; }
        if item.isZeroInit {
            continue;
        }
        let location = try dataRef(try resolve(local, &[], item.name));
        let mut offset = location.offset;
        let end = offset + item.size;
        for value in item.values {
            let mut width: u32 = 1;
            let mut number: u64 = 0;
            match value.item {
                case il::DataItem::Val { typ, val } => { set width = il::typeSize(typ); set number = val as u64; },
                case il::DataItem::Fn(name) => { set width = 8; set number = try function(local, imports, name); },
                case il::DataItem::Val { typ, val } => {
                    set width = il::typeSize(typ);
                    set number = val as u64;
                },
                case il::DataItem::Fn(name) => {
                    set width = 8;
                    set number = try function(local, imports, name);
                },
                case il::DataItem::Sym(name) => {
                    set width = 8;
                    let target = try dataRef(try resolve(local, imports, name));
                    if value.count > 0 {
                        if count == relocs.len { throw Error::Capacity; }
                        if count == relocs.len {
                            throw Error::Capacity;
                        }
                        set relocs[count] = Relocation { offset, count: value.count, target };
                        set count += 1;
                    }
                },
                case il::DataItem::Str(s) => { set width = s.len; },
                case il::DataItem::Undef => {},
                case il::DataItem::Str(s) => {
                    set width = s.len;
                },
                case il::DataItem::Undef => {
                },
            }
            if width > 0 and value.count > (end - offset) / width {
                throw Error::Range;
            }
            if width == 0 {
                continue;
            }
            if width > 0 and value.count > (end - offset) / width { throw Error::Range; }
            if width == 0 { continue; }
            for _ in 0..value.count {
                match value.item {
                    case il::DataItem::Str(s) => { try! mem::copy(&mut bytes[offset..offset + width], s); },
                    else => { integer(bytes, offset, number, width); },
                    case il::DataItem::Str(s) => {
                        try! mem::copy(&mut bytes[offset..offset + width], s);
                    },
                    else => {
                        integer(bytes, offset, number, width);
                    },
                }
                set offset += width;
            }
        }
    }
    return TemplateSize { bytes: initialized, relocations: count };
}

/// Package definitions and their native assembly boundaries.
export record AssemblyInput: Copy {
    /// Trusted binary RIL definitions that remain valid during compilation.
    package: *unsafe binary::Package,
    /// Text-only assembly prefix with exported native boundaries.
    assembly: asm::Program,
}

/// Compile one package into caller-owned code, symbol, and private template storage.
/// Imports must contain unique exports from the package's admitted dependencies.
/// Arena storage and binary package names must outlive the returned catalog entry.
export unsafe fn compile(input: &binary::Package, slot: u32, codeAddress: u64, imports: &[Symbol],
    storage: Storage, arena: &mut alloc::Arena, scratch: &mut alloc::Arena) -> Package throws (Error)
{
    return try compileAssembly(AssemblyInput { package: input as *unsafe binary::Package,
        assembly: asm::Program { text: &[], data: &[], symbols: &[], externalFixups: &[] } },
        slot, codeAddress, imports, storage, arena, scratch);
}

/// Compile a package with a text-only assembly prefix and its exported boundaries.
/// Assembly and RIL definitions share one native code extent and package-state slot.
export unsafe fn compileAssembly(source: AssemblyInput, slot: u32, codeAddress: u64, imports: &[Symbol],
    storage: Storage, arena: &mut alloc::Arena, scratch: &mut alloc::Arena) -> Package throws (Error)
{
    let case Storage { data: dataStorage, symbols: symbolStorage, exports: exportStorage, template: templateStorage, relocations: relocationStorage } = storage
        else panic "expected shared linker storage";
    if slot >= MAX_PACKAGES { throw Error::Range; }
    if (codeAddress & 3) <> 0 { throw Error::Alignment; }
    let input = source.package;
    let assembly = source.assembly;
    if assembly.data.len <> 0 {
        throw Error::Range;
    }
    if slot >= MAX_PACKAGES {
        throw Error::Range;
    }
    if (codeAddress & 3) <> 0 {
        throw Error::Alignment;
    }
    for imported, i in imports {
        if lookup(&imports[..i], imported.name) <> nil { throw Error::Symbol; }
        if lookup(&imports[..i], imported.name) <> nil {
            throw Error::Symbol;
        }
    }
    let mut generator = try super::beginProgram(super::ProgramOptions {
        entryPatch: super::EntryPatch::None, debug: false, placement: image::Placement::Hosted,
    }, arena) catch err { throw Error::Codegen(err); };
    }, arena) catch err {
        throw Error::Codegen(err);
    };
    set generator.e.sharedData = true;
    for func in input.program.fns { super::generateFunction(&mut generator, func, scratch); }
    try emit::check(&generator.e) catch err { throw Error::Codegen(err); };
    if codeAddress > 0xffffffffffffffff - generator.e.codeLen as u64 * 4 { throw Error::Range; }
    super::addAssembly(&mut generator, assembly);
    for func in input.program.fns {
        super::generateFunction(&mut generator, func, scratch);
    }
    try emit::check(&generator.e) catch err {
        throw Error::Codegen(err);
    };
    if codeAddress > 0xffffffffffffffff - generator.e.codeLen as u64 * 4 {
        throw Error::Range;
    }
    let mut symbols: u32 = 0;
    for func in &generator.e.funcs[..] {
    for func in &generator.e.funcs[..generator.e.funcsLen] {
        try define(symbolStorage, &mut symbols, func.name, Target::Function(codeAddress + func.index as u64 * 4));
    }
    let mut dataCount: u32 = 0;
    let roSize = try data::layoutSection(input.program.data, dataStorage, &mut dataCount, 0, true)
        catch { throw Error::Range; };
        catch {
            throw Error::Range;
        };
    let memory = try data::layoutSectionAtOffset(input.program.data, dataStorage, &mut dataCount, 0, roSize, false)
        catch { throw Error::Range; };
    if memory > 0x7ffff7ff { throw Error::Range; }
        catch {
            throw Error::Range;
        };
    if memory > 0x7ffff7ff {
        throw Error::Range;
    }
    for item in &dataStorage[..dataCount] {
        try define(symbolStorage, &mut symbols, item.name, Target::Data(DataRef { slot, offset: item.addr as u32 }));
    }
    let local = &symbolStorage[..symbols];
    for symbol in local { if lookup(imports, symbol.name) <> nil { throw Error::Symbol; } }
    for symbol in local {
        if lookup(imports, symbol.name) <> nil {
            throw Error::Symbol;
        }
    }
    try link(&mut generator.e, codeAddress, local, imports);
    try emit::check(&generator.e) catch err { throw Error::Codegen(err); };
    try emit::check(&generator.e) catch err {
        throw Error::Codegen(err);
    };
    let size = try template(input.program.data, local, imports, templateStorage, relocationStorage);
    if input.exports.len > exportStorage.len { throw Error::Capacity; }
    if input.exports.len > exportStorage.len {
        throw Error::Capacity;
    }
    for exported, i in input.exports {
        let target = try resolve(local, &[], exported.name);
        match exported.kind {
            case binary::ExportKind::Function => { try function(local, &[], exported.name); },
            case binary::ExportKind::Data => { try dataRef(target); },
            case binary::ExportKind::Function => {
                try function(local, &[], exported.name);
            },
            case binary::ExportKind::Data => {
                try dataRef(target);
            },
        }
        if lookup(&exportStorage[..i], exported.name) <> nil {
            throw Error::Symbol;
        }
        if lookup(&exportStorage[..i], exported.name) <> nil { throw Error::Symbol; }
        set exportStorage[i] = Symbol { name: exported.name, target };
    }
    let mut entry: ?u64 = nil;
    if let name = input.entry { set entry = try function(&exportStorage[..input.exports.len], &[], name); }
    if let name = input.entry {
        set entry = try function(&exportStorage[..input.exports.len], &[], name);
    }
    let mut alignment: u32 = 8;
    for item in input.program.data { if item.alignment > alignment { set alignment = item.alignment; } }
    for item in input.program.data {
        if item.alignment > alignment {
            set alignment = item.alignment;
        }
    }
    let case super::Generator { e, .. } = generator else panic "expected package generator";
    let case emit::Emitter { code, codeLen, .. } = e else panic "expected package emitter";
    return Package {
        name: input.name, dependencies: input.dependencies, slot, codeAddress,
        code: emit::getCode(&generator.e), exports: &exportStorage[..input.exports.len], entry,
        code: &code[..codeLen], exports: &exportStorage[..input.exports.len], entry,
        template: &templateStorage[..size.bytes], memory, alignment,
        relocations: &relocationStorage[..size.relocations],
    };
}

/// Initialize private package memory after all graph bases have been assigned.
/// Validate every fixup before writing bytes so a rejected instance stays intact.
export fn instantiate(package: &Package, bases: &[u64], memory: &mut [u8]) throws (Error) {
    if package.slot >= bases.len or bases[package.slot] == 0 { throw Error::Instance; }
    if memory.len < package.memory or package.template.len > package.memory { throw Error::Capacity; }
    if (bases[package.slot] & (package.alignment as u64 - 1)) <> 0 { throw Error::Alignment; }
    if bases[package.slot] > 0xffffffffffffffff - package.memory as u64 { throw Error::Range; }
    if package.slot >= bases.len or bases[package.slot] == 0 {
        throw Error::Instance;
    }
    if memory.len < package.memory or package.template.len > package.memory {
        throw Error::Capacity;
    }
    if (bases[package.slot] & (package.alignment as u64 - 1)) <> 0 {
        throw Error::Alignment;
    }
    if bases[package.slot] > 0xffffffffffffffff - package.memory as u64 {
        throw Error::Range;
    }
    for fixup in package.relocations {
        if fixup.target.slot >= bases.len or bases[fixup.target.slot] == 0 { throw Error::Instance; }
        if bases[fixup.target.slot] > 0xffffffffffffffff - fixup.target.offset as u64 { throw Error::Range; }
        if fixup.offset > package.memory or fixup.count > (package.memory - fixup.offset) / 8 { throw Error::Range; }
        if fixup.target.slot >= bases.len or bases[fixup.target.slot] == 0 {
            throw Error::Instance;
        }
        if bases[fixup.target.slot] > 0xffffffffffffffff - fixup.target.offset as u64 {
            throw Error::Range;
        }
        if fixup.offset > package.memory or fixup.count > (package.memory - fixup.offset) / 8 {
            throw Error::Range;
        }
    }
    for i in 0..package.memory {
        set memory[i] = 0;
    }
    for i in 0..package.memory { set memory[i] = 0; }
    try! mem::copy(memory, package.template);
    for fixup in package.relocations {
        let address = bases[fixup.target.slot] + fixup.target.offset as u64;
        for i in 0..fixup.count { integer(memory, fixup.offset + i * 8, address, 8); }
        for i in 0..fixup.count {
            integer(memory, fixup.offset + i * 8, address, 8);
        }
    }
}

lib/std/arch/rv64/shared/catalog.rad added +131 -0

1	+	//! Persistent native boot catalogs for the RV64 record ABI.
2	+
3	+	use std::mem;
4	+	use std::arch::rv64::shared;
5	+
6	+	/// Binary package identity and its resident native descriptor.
7	+	export record Entry: Copy {
8	+	/// Complete immutable binary RIL bytes.
9	+	source: *[u8],
10	+	/// Shared code, exports, and private-state template.
11	+	package: shared::Package,
12	+	}
13	+
14	+	/// Reserve aligned bytes in the native catalog output.
15	+	fn reserve(output: &mut [u8], used: &mut u32, size: u32, alignment: u32) -> u32 throws (shared::Error) {
16	+	let padding = (alignment - (*used & (alignment - 1))) & (alignment - 1);
17	+	if padding > output.len - *used {
18	+	throw shared::Error::Capacity;
19	+	}
20	+	let offset = *used + padding;
21	+	if size > output.len - offset {
22	+	throw shared::Error::Capacity;
23	+	}
24	+	for i in *used..offset {
25	+	set output[i] = 0;
26	+	}
27	+	set *used = offset + size;
28	+	return offset;
29	+	}
30	+
31	+	/// View the native bytes of a caller-owned record or array.
32	+	unsafe fn raw(value: &opaque, size: u32) -> unsafe [u8] { return @sliceOf((value as &u8) as unsafe u8, size); }
33	+
34	+	/// Obtain a field's byte offset from the compiler's native record layout.
35	+	unsafe fn field(container: &opaque, value: &opaque) -> u32 { return (value as u64 - container as u64) as u32; }
36	+
37	+	/// Write one little-endian integer into a reserved native field.
38	+	fn integer(output: &mut [u8], offset: u32, value: u64, width: u32) {
39	+	for i in 0..width {
40	+	set output[offset + i] = (value >> (i as u64 * 8)) as u8;
41	+	}
42	+	}
43	+
44	+	/// Write the RV64 pointer, length, and capacity of a native immutable slice.
45	+	fn slice(output: &mut [u8], offset: u32, address: u64, length: u32) {
46	+	integer(output, offset, address, 8);
47	+	integer(output, offset + 8, length as u64, 4);
48	+	integer(output, offset + 12, length as u64, 4);
49	+	}
50	+
51	+	/// Copy bytes into the catalog and return their target-relative offset.
52	+	fn bytes(input: *[u8], output: &mut [u8], used: &mut u32) -> u32 throws (shared::Error) {
53	+	let offset = try reserve(output, used, input.len, 1);
54	+	try! mem::copy(&mut output[offset..offset + input.len], input);
55	+	return offset;
56	+	}
57	+
58	+	/// Copy a dependency list and each name into native catalog storage.
59	+	unsafe fn dependencies(input: unsafe [[u8]], base: u64, output: &mut [u8], used: &mut u32) -> u32 throws (shared::Error) {
60	+	if input.len > output.len / @sizeOf(*[u8]) {
61	+	throw shared::Error::Capacity;
62	+	}
63	+	let offset = try reserve(output, used, input.len * @sizeOf([u8]), @alignOf([u8]));
64	+	for name, i in input {
65	+	let at = try bytes(name, output, used);
66	+	slice(output, offset + i * @sizeOf(*[u8]), base + at as u64, name.len);
67	+	}
68	+	return offset;
69	+	}
70	+
71	+	/// Copy public symbols and their names into native catalog storage.
72	+	unsafe fn symbols(input: *[shared::Symbol], base: u64, output: &mut [u8], used: &mut u32) -> u32 throws (shared::Error) {
73	+	if input.len > output.len / @sizeOf(shared::Symbol) {
74	+	throw shared::Error::Capacity;
75	+	}
76	+	let offset = try reserve(output, used, input.len * @sizeOf(shared::Symbol), @alignOf(shared::Symbol));
77	+	for symbol, i in input {
78	+	let at = offset + i * @sizeOf(shared::Symbol);
79	+	try! mem::copy(&mut output[at..at + @sizeOf(shared::Symbol)], raw(&symbol, @sizeOf(shared::Symbol)));
80	+	let name = try bytes(symbol.name, output, used);
81	+	slice(output, at + field(&symbol, &symbol.name), base + name as u64, symbol.name.len);
82	+	}
83	+	return offset;
84	+	}
85	+
86	+	/// Copy private-state relocation records into native catalog storage.
87	+	unsafe fn relocations(input: *[shared::Relocation], output: &mut [u8], used: &mut u32) -> u32 throws (shared::Error) {
88	+	if input.len > output.len / @sizeOf(shared::Relocation) {
89	+	throw shared::Error::Capacity;
90	+	}
91	+	let size = input.len * @sizeOf(shared::Relocation);
92	+	let offset = try reserve(output, used, size, @alignOf(shared::Relocation));
93	+	try! mem::copy(&mut output[offset..offset + size], raw(input.ptr, size));
94	+	return offset;
95	+	}
96	+
97	+	/// Pack native Entry records followed by all referenced metadata and source bytes.
98	+	/// Code is placed separately at each package's codeAddress. The target base must
99	+	/// have Entry alignment. Return the used extent. Failure leaves partial output.
100	+	export unsafe fn pack(entries: &[Entry], base: u64, output: &mut [u8]) -> u32 throws (shared::Error) {
101	+	assert @sizeOf(*[u8]) == 16;
102	+	if (base & (@alignOf(Entry) as u64 - 1)) <> 0 {
103	+	throw shared::Error::Alignment;
104	+	}
105	+	if base > 0xffffffffffffffff - output.len as u64 {
106	+	throw shared::Error::Range;
107	+	}
108	+	if entries.len > output.len / @sizeOf(Entry) {
109	+	throw shared::Error::Capacity;
110	+	}
111	+	let mut used: u32 = 0;
112	+	let start = try reserve(output, &mut used, entries.len * @sizeOf(Entry), @alignOf(Entry));
113	+	for entry, i in entries {
114	+	let at = i * @sizeOf(Entry);
115	+	try! mem::copy(&mut output[at..at + @sizeOf(Entry)], raw(&entry, @sizeOf(Entry)));
116	+	let source = try bytes(entry.source, output, &mut used);
117	+	let name = try bytes(entry.package.name, output, &mut used);
118	+	let required = try dependencies(entry.package.dependencies, base, output, &mut used);
119	+	let exports = try symbols(entry.package.exports, base, output, &mut used);
120	+	let template = try bytes(entry.package.template, output, &mut used);
121	+	let fixups = try relocations(entry.package.relocations, output, &mut used);
122	+	slice(output, at + field(&entry, &entry.source), base + source as u64, entry.source.len);
123	+	slice(output, at + field(&entry, &entry.package.name), base + name as u64, entry.package.name.len);
124	+	slice(output, at + field(&entry, &entry.package.dependencies), base + required as u64, entry.package.dependencies.len);
125	+	slice(output, at + field(&entry, &entry.package.code), entry.package.codeAddress, entry.package.code.len);
126	+	slice(output, at + field(&entry, &entry.package.exports), base + exports as u64, entry.package.exports.len);
127	+	slice(output, at + field(&entry, &entry.package.template), base + template as u64, entry.package.template.len);
128	+	slice(output, at + field(&entry, &entry.package.relocations), base + fixups as u64, entry.package.relocations.len);
129	+	}
130	+	return used;
131	+	}

lib/std/arch/rv64/shared/tests.rad +115 -8

//! Private template relocation and bounded linking checks.

use std::testing;
use std::mem;
use std::arch::rv64::shared::catalog;
use std::arch::rv64::asm;
use std::lang::alloc;
use std::lang::il;
use std::lang::il::binary;
use std::lang::gen::data;


unsafe static DATA: [data::DataSym; 8] = undefined;
/// Persistent initialized bytes.
static TEMPLATE: [u8; 64] = [0; 64];
/// Persistent private data relocations.
unsafe static RELOCS: [super::Relocation; 8] = undefined;
/// Aligned storage for a native boot catalog and its retained payloads.
static CATALOG: [u64; 512] = [0; 512];

/// Exported assembly boundaries occupy the same code extent as their package.
@test unsafe fn assemblyPrefix() throws (testing::TestError) {
    let input = binary::Package {
        symbols: &[], name: "p", dependencies: &[],
        exports: &[binary::Export { name: "p::entry", kind: binary::ExportKind::Function }],
        entry: "p::entry", program: il::Program { data: &[], fns: &[] },
    };
    let assembly = asm::Program {
        text: &[0x02a00513 as u32, 0x00008067], data: &[],
        symbols: &[asm::Symbol { name: "p::entry", section: asm::Section::Text, offset: 0, isExported: true }],
        externalFixups: &[],
    };
    let mut arena = alloc::new(&mut ARENA[..]);
    let mut scratch = alloc::new(&mut SCRATCH[..]);
    let package = try super::compileAssembly(super::AssemblyInput { package: &input, assembly }, 0, 0x180000000, &[],
        super::Storage {
            data: &mut DATA[..], symbols: &mut SYMBOLS[..], exports: &mut EXPORTS[..],
            template: &mut TEMPLATE[..], relocations: &mut RELOCS[..],
        }, &mut arena, &mut scratch) catch {
            throw testing::TestError::Failed;
        };
    let entry = package.entry else {
        throw testing::TestError::Failed;
    };
    try testing::expect(entry == 0x180000000 and package.code.len == 2);
    try testing::expect(package.code[0] == 0x02a00513 and package.exports[0].target == super::Target::Function(entry));
}

/// Packed catalog pointers resolve to retained metadata at the supplied native base.
@test unsafe fn nativeCatalog() throws (testing::TestError) {
    let package = try compile(imports(), 64) catch {
        throw testing::TestError::Failed;
    };
    let output = @sliceOf(&mut CATALOG[0] as *mut u8, @sizeOf([u64; 512]));
    let base = output.ptr as u64;
    let used = try catalog::pack(&[catalog::Entry { source: "trusted binary", package }], base, output)
        catch {
            throw testing::TestError::Failed;
        };
    let storage = &CATALOG[0] as *opaque;
    let entry = storage as *catalog::Entry;
    try testing::expect(used > @sizeOf(catalog::Entry) and used <= output.len);
    try testing::expect(mem::eq(entry.source, "trusted binary") and mem::eq(entry.package.name, "p"));
    try testing::expect(mem::eq(entry.package.dependencies[0], "dep"));
    try testing::expect(entry.package.code.ptr as u64 == package.codeAddress and entry.package.code.len == package.code.len);
    try testing::expect(entry.source.ptr as u64 >= base and entry.source.ptr as u64 < base + used as u64);
    set TEMPLATE[0] = 91;
    set EXPORTS[0].name = "changed";
    try testing::expect(entry.package.template[0] == 0 and mem::eq(entry.package.exports[0].name, "p::refs"));
    let mut state: [u8; 48] = [255; 48];
    try super::instantiate(&entry.package, &[0, 0x180002000, 0x180008000], &mut state[..])
        catch {
            throw testing::TestError::Failed;
        };
    try testing::expect(pointer(&state[..], 0) == 0x180004000 and pointer(&state[..], 16) == 0x180001234);
    let relocated = try catalog::pack(&[catalog::Entry { source: "trusted binary", package }], 0x180000000, output)
        catch {
            throw testing::TestError::Failed;
        };
    try testing::expect(entry.source.ptr as u64 >= 0x180000000 and entry.source.ptr as u64 < 0x180000000 + relocated as u64);
}

/// Catalog bounds and native alignment failures are recoverable.
@test unsafe fn nativeCatalogBounds() throws (testing::TestError) {
    let package = try compile(imports(), 64) catch {
        throw testing::TestError::Failed;
    };
    let entries = [catalog::Entry { source: "binary", package }];
    let output = @sliceOf(&mut CATALOG[0] as *mut u8, @sizeOf([u64; 512]));
    let mut failures: u32 = 0;
    try catalog::pack(&entries[..], 0x80000000, &mut output[..@sizeOf(catalog::Entry)]) catch err {
        try testing::expect(err == super::Error::Capacity); set failures += 1;
    };
    try catalog::pack(&entries[..], 0x80000001, output) catch err {
        try testing::expect(err == super::Error::Alignment); set failures += 1;
    };
    try catalog::pack(&entries[..], 0xfffffffffffffff8, output) catch err {
        try testing::expect(err == super::Error::Range); set failures += 1;
    };
    try testing::expect(failures == 3);
    let used = try catalog::pack(&entries[..], 0x80000000, output) catch {
        throw testing::TestError::Failed;
    };
    try testing::expect(used > @sizeOf(catalog::Entry));
}

/// Build a package with repeated dependency pointers and a high code pointer.
unsafe fn input() -> binary::Package {
    return binary::Package {
        symbols: &[], name: "p", dependencies: &["dep"],

}

/// Read a little-endian pointer without requiring buffer alignment.
fn pointer(bytes: &[u8], offset: u32) -> u64 {
    let mut value: u64 = 0;
    for i in 0..8 { set value |= bytes[offset + i] as u64 << (i as u64 * 8); }
    for i in 0..8 {
        set value |= bytes[offset + i] as u64 << (i as u64 * 8);
    }
    return value;
}

/// Check repeated pointers, full-width code addresses, padding, and zero-filled tails.
@test unsafe fn privateRelocations() throws (testing::TestError) {
    let package = try compile(imports(), 64) catch { throw testing::TestError::Failed; };
    let package = try compile(imports(), 64) catch {
        throw testing::TestError::Failed;
    };
    try testing::expect(package.template.len == 32 and package.memory == 48 and package.alignment == 16);
    try testing::expect(package.relocations.len == 1 and package.relocations[0].count == 2);
    try testing::expect(pointer(package.template, 16) == 0x180001234);
    let mut first: [u8; 48] = [255; 48];
    let mut second: [u8; 48] = [255; 48];
    try super::instantiate(&package, &[0, 0x180002000, 0x180008000], &mut first[..])
        catch { throw testing::TestError::Failed; };
        catch {
            throw testing::TestError::Failed;
        };
    try super::instantiate(&package, &[0, 0x280002000, 0x280008000], &mut second[..])
        catch { throw testing::TestError::Failed; };
        catch {
            throw testing::TestError::Failed;
        };
    try testing::expect(pointer(&first[..], 0) == 0x180004000 and pointer(&first[..], 8) == 0x180004000);
    try testing::expect(pointer(&second[..], 0) == 0x280004000 and pointer(&second[..], 8) == 0x280004000);
    try testing::expect(pointer(&first[..], 16) == pointer(&second[..], 16));
    for i in 24..48 { try testing::expect(first[i] == 0 and second[i] == 0); }
    for i in 24..48 {
        try testing::expect(first[i] == 0 and second[i] == 0);
    }
}

/// A missing instance, bad base, or short buffer leaves instance bytes untouched.
@test unsafe fn instanceFailures() throws (testing::TestError) {
    let package = try compile(imports(), 64) catch { throw testing::TestError::Failed; };
    let package = try compile(imports(), 64) catch {
        throw testing::TestError::Failed;
    };
    let mut bytes: [u8; 48] = [255; 48];
    let mut failed: u32 = 0;
    try super::instantiate(&package, &[0, 0, 0x8000], &mut bytes[..]) catch err {
        try testing::expect(err == super::Error::Instance); set failed += 1;
    };

    };
    try super::instantiate(&package, &[0, 0xffffffffffffffff, 0x8000], &mut bytes[..]) catch err {
        try testing::expect(err == super::Error::Range); set failed += 1;
    };
    try testing::expect(failed == 4);
    for byte in &bytes[..] { try testing::expect(byte == 255); }
    for byte in &bytes[..] {
        try testing::expect(byte == 255);
    }
}

/// Missing symbols, duplicate imports, kind mismatches, and short output fail explicitly.
@test unsafe fn linkFailures() throws (testing::TestError) {
    let mut failed: u32 = 0;

    };
    try compile(names, 31) catch err {
        try testing::expect(err == super::Error::Capacity); set failed += 1;
    };
    try testing::expect(failed == 4);
    let package = try compile(names, 64) catch { throw testing::TestError::Failed; };
    let package = try compile(names, 64) catch {
        throw testing::TestError::Failed;
    };
    try testing::expect(package.exports.len == 1);
}

lib/std/collections/dict.rad +2 -2

export fn insert(m: &mut Dict, key: *[u8], value: i32) {
    let mask = m.entries.len - 1;
    let mut idx = hash(key) & mask;

    loop {
        let entry = &m.entries[idx];
        let entry = m.entries[idx];
        if entry.key.len == 0 {
            assert m.count < m.entries.len / 2, "dict::insert: table full";
            set m.entries[idx] = Entry { key, value };
            set m.count += 1;
            return;

export fn get(m: &Dict, key: *[u8]) -> ?i32 {
    let mask = m.entries.len - 1;
    let mut idx = hash(key) & mask;

    loop {
        let entry = &m.entries[idx];
        let entry = m.entries[idx];
        if entry.key.len == 0 {
            return nil;
        }
        if mem::eq(entry.key, key) {
            return entry.value;

lib/std/lang/alloc.rad +54 -12

//! byte buffer. Memory is never freed individually - the entire arena is
//! reset at once. This is ideal for compiler passes where all allocations
//! have the same lifetime.
@test mod tests;

use std::mem;

/// Error thrown by allocator.
export union AllocError: Copy {
    /// Allocator is out of memory.
    OutOfMemory,
}

/// Allocate `size` bytes with the given alignment.
///
/// Returns an opaque pointer to the allocated memory. Throws `AllocError` if
/// the arena is exhausted. The caller is responsible for casting to the
/// appropriate type and initializing the memory.
export fn alloc(arena: &mut Arena, size: u32, alignment: u32) -> *mut opaque throws (AllocError) {
/// Size must be positive. Alignment must be a positive power of two.
/// Failure leaves the allocation offset unchanged.
/// The caller must keep the storage live and must not reclaim live allocations.
export unsafe fn alloc(arena: *unsafe mut Arena, size: u32, alignment: u32) -> *mut opaque throws (AllocError) {
    assert alignment > 0;
    assert size > 0;

    let aligned64 = (arena.offset as u64 + alignment as u64 - 1) & ~(alignment as u64 - 1);
    if aligned64 > arena.data.len as u64 or size as u64 > arena.data.len as u64 - aligned64 {
    assert (alignment & (alignment - 1)) == 0;

    let capacity = arena.data.len;
    if arena.offset >= capacity {
        throw AllocError::OutOfMemory;
    }
    let address = (&arena.data[0]) as u64;
    let mask = (alignment - 1) as u64;
    let remainder = ((address & mask) + (arena.offset as u64 & mask)) & mask;
    let padding = ((alignment as u64 - remainder) & mask) as u32;
    let available = capacity - arena.offset;
    if padding > available or size > available - padding {
        throw AllocError::OutOfMemory;
    }
    let aligned = aligned64 as u32;
    let aligned = arena.offset + padding;
    let newOffset = aligned + size;

    let base: *mut u8 = &mut arena.data[aligned];
    set arena.offset = newOffset;


export fn remaining(arena: &Arena) -> u32 {
    return arena.data.len as u32 - arena.offset;
}

/// Returns the remaining buffer as a mutable slice.
export fn remainingBuf(arena: &mut Arena) -> *mut [u8] {
/// The caller must keep the storage live and must commit each written prefix
/// before another allocation can use that prefix.
export unsafe fn remainingBuf(arena: *unsafe mut Arena) -> *mut [u8] {
    return &mut arena.data[arena.offset..];
}

/// Commits `size` bytes of allocation, advancing the offset.
/// Use after writing to the buffer returned by [`remainingBuf`].

/// Throws `AllocError` if the arena is exhausted.
export unsafe fn allocSlice(arena: &mut Arena, size: u32, alignment: u32, count: u32) -> *mut [opaque] throws (AllocError) {
    if count == 0 {
        return &mut [];
    }
    if size > 0xffffffff / count { throw AllocError::OutOfMemory; }
    let ptr = try alloc(arena, size * count, alignment);
    let bytes = try allocationSize(size, count);
    let ptr = try alloc(&mut *arena, bytes, alignment);

    return @sliceOf(ptr, count);
}

/// Generic allocator interface.

}

/// Arena allocation function conforming to the `Allocator` interface.
unsafe fn arenaAllocFn(ctx: *unsafe mut opaque, size: u32, alignment: u32) -> *mut opaque {
    let arena = ctx as *unsafe mut Arena;
    return try! alloc(arena, size, alignment);
    return try! alloc(&mut *arena, size, alignment);
}

/// Allocate raw storage that remains valid until the arena is reset.
export unsafe fn allocRaw(arena: &mut Arena, size: u32, alignment: u32) -> *unsafe mut opaque throws (AllocError) {
    let owner = try alloc(arena, size, alignment);
    let owner = try alloc(&mut *arena, size, alignment);
    let byte = owner as *mut u8;
    let raw: *unsafe mut u8 = &mut *byte;
    return raw as *unsafe mut opaque;
}

/// Allocate a raw slice that remains valid until the arena is reset.
export unsafe fn allocRawSlice(arena: &mut Arena, size: u32, alignment: u32, count: u32) -> *unsafe mut [opaque] throws (AllocError) {
    if count == 0 {
        return &mut [];
    }
    let raw = try allocRaw(arena, size * count, alignment);
    let bytes = try allocationSize(size, count);
    let raw = try allocRaw(arena, bytes, alignment);
    return @sliceOf(raw, count);
}

/// Raw storage provider for allocation sessions.
export trait Alloc {
    /// Reserve one uninitialized object.
    unsafe fn (&mut Alloc) reserve(size: u32, alignment: u32) -> *unsafe mut opaque throws (AllocError);
    /// Reserve an uninitialized slice.
    unsafe fn (&mut Alloc) reserveSlice(itemSize: u32, itemAlignment: u32, count: u32) -> *unsafe mut [opaque] throws (AllocError);
}

instance Alloc for Arena {
    /// Reserve one uninitialized object in the arena.
    unsafe fn (arena: &mut Arena) reserve(size: u32, alignment: u32) -> *unsafe mut opaque throws (AllocError) {
        return try allocRaw(arena, size, alignment);
    }

    /// Reserve an uninitialized slice in the arena.
    unsafe fn (arena: &mut Arena) reserveSlice(size: u32, alignment: u32, count: u32) -> *unsafe mut [opaque] throws (AllocError) {
        return try allocRawSlice(arena, size, alignment, count);
    }
}

/// Compute a slice allocation size without unsigned multiplication overflow.
fn allocationSize(size: u32, count: u32) -> u32 throws (AllocError) {
    if size <> 0 and count > 4294967295 / size {
        throw AllocError::OutOfMemory;
    }
    return size * count;
}

lib/std/lang/alloc/tests.rad +83 -14

//! Tests for the bump allocator.

use std::testing;

/// Test basic allocation.
@test fn testAllocBasic() throws (testing::TestError) {
@test unsafe fn testAllocBasic() throws (testing::TestError) {
    static STORAGE: [u8; 64] = [0; 64];
    let mut arena = super::new(&mut STORAGE[..]);

    let ptr = try! super::alloc(&mut arena, 4, 4);
    try testing::expect(super::used(&arena) == 4);
    try testing::expect(super::remaining(&arena) == 60);
}

/// Test that allocations are properly aligned.
@test fn testAllocAlignment() throws (testing::TestError) {
@test unsafe fn testAllocAlignment() throws (testing::TestError) {
    static STORAGE: [u8; 64] = [0; 64];
    let mut arena = super::new(&mut STORAGE[..]);

    // Allocate 1 byte with 1-byte alignment.
    let p1 = try! super::alloc(&mut arena, 1, 1);

    let p2 = try! super::alloc(&mut arena, 4, 4);
    try testing::expect(super::used(&arena) == 8); // 1 + 3 padding + 4
}

/// Test multiple allocations.
@test fn testAllocMultiple() throws (testing::TestError) {
@test unsafe fn testAllocMultiple() throws (testing::TestError) {
    static STORAGE: [u8; 128] = [0; 128];
    let mut arena = super::new(&mut STORAGE[..]);

    let p1 = try! super::alloc(&mut arena, 8, 4);
    let p2 = try! super::alloc(&mut arena, 16, 4);


    try testing::expect(super::used(&arena) == 28); // 8 + 16 + 4
}

/// Test that arena throws when exhausted.
@test fn testAllocExhausted() throws (testing::TestError) {
@test unsafe fn testAllocExhausted() throws (testing::TestError) {
    static STORAGE: [u8; 16] = [0; 16];
    let mut arena = super::new(&mut STORAGE[..]);

    // This should succeed.
    let p1 = try! super::alloc(&mut arena, 8, 4);

    };
    try testing::expect(failed);
}

/// Test that reset allows reuse of memory.
@test fn testAllocReset() throws (testing::TestError) {
@test unsafe fn testAllocReset() throws (testing::TestError) {
    static STORAGE: [u8; 32] = [0; 32];
    let mut arena = super::new(&mut STORAGE[..]);

    let p1 = try! super::alloc(&mut arena, 16, 4);
    try testing::expect(super::used(&arena) == 16);

    // Should be able to allocate again.
    let p2 = try! super::alloc(&mut arena, 32, 4);
}

/// Test alignment when offset is already aligned.
@test fn testAllocAlreadyAligned() throws (testing::TestError) {
@test unsafe fn testAllocAlreadyAligned() throws (testing::TestError) {
    static STORAGE: [u8; 64] = [0; 64];
    let mut arena = super::new(&mut STORAGE[..]);

    // Allocate 4 bytes - offset becomes 4, already aligned for next 4-byte alloc.
    let p1 = try! super::alloc(&mut arena, 4, 4);

    let p2 = try! super::alloc(&mut arena, 4, 4);
    try testing::expect(super::used(&arena) == 8);
}

/// Test allocation that would overflow with alignment padding.
@test fn testAllocOverflowWithPadding() throws (testing::TestError) {
@test unsafe fn testAllocOverflowWithPadding() throws (testing::TestError) {
    static STORAGE: [u8; 16] = [0; 16];
    let mut arena = super::new(&mut STORAGE[..]);

    // Allocate 1 byte, offset is now 1.
    let p1 = try! super::alloc(&mut arena, 1, 1);

    let mut arena = super::new(&mut STORAGE[..]);
    let a = super::arenaAllocator(&mut arena);

    // Allocate through the Allocator indirection.
    let p1 = a.func(a.ctx, 16, 4);
    try testing::expect(super::used(&arena) == 16);
    try testing::expect((p1 as u64 & 3) == 0);

    let p2 = a.func(a.ctx, 8, 8);
    try testing::expect(super::used(&arena) == 24);
    try testing::expect((p2 as u64 & 7) == 0);
    try testing::expect(super::used(&arena) as u64 == p2 as u64 - &STORAGE[0] as u64 + 8);

    // Verify the pointers are distinct.
    try testing::expect(p1 as u64 <> p2 as u64);
}


@test unsafe fn testAllocOverflow() throws (testing::TestError) {
    static bytes: [u8; 64] = [0; 64];
    let mut arena = super::new(&mut bytes[..]);
    set arena.offset = 8;
    let mut failed: u32 = 0;
    try super::allocSlice(&mut arena, 8, 8, 0x20000000) catch { set failed += 1; };
    try super::alloc(&mut arena, 0xffffffff, 8) catch { set failed += 1; };
    try super::allocSlice(&mut arena, 8, 8, 0x20000000) catch {
        set failed += 1;
    };
    try super::alloc(&mut arena, 0xffffffff, 8) catch {
        set failed += 1;
    };
    try testing::expect(failed == 2 and arena.offset == 8);
    set arena.offset = 0xfffffff8;
    try super::alloc(&mut arena, 16, 16) catch { set failed += 1; };
    try super::alloc(&mut arena, 16, 16) catch {
        set failed += 1;
    };
    try testing::expect(failed == 3 and arena.offset == 0xfffffff8);
    set arena.offset = 8;
    let storage = try super::alloc(&mut arena, 8, 8) catch { throw testing::TestError::Failed; };
    try testing::expect(arena.offset == 16);
    let storage = try super::alloc(&mut arena, 8, 8) catch {
        throw testing::TestError::Failed;
    };
    try testing::expect((storage as u64 & 7) == 0);
    try testing::expect(arena.offset as u64 == storage as u64 - &bytes[0] as u64 + 8);
}

/// Allocation alignment uses the backing address and preserves distinct objects.
@test unsafe fn testAllocUnalignedBacking() throws (testing::TestError) {
    static STORAGE: [u8; 96] = [0; 96];
    for start in 0..16 {
        let mut arena = super::new(&mut STORAGE[start..]);
        let first = try! super::allocRaw(&mut arena, 8, 16) as *unsafe mut u64;
        set *first = 123;
        let second = try! super::allocRaw(&mut arena, 8, 16) as *unsafe mut u64;
        set *second = 456;
        try testing::expect((first as u64 & 15) == 0);
        try testing::expect((second as u64 & 15) == 0);
        try testing::expect(second as u64 >= first as u64 + 8);
        try testing::expect(*first == 123);
        try testing::expect(*second == 456);
    }
}

/// Capacity failure and arithmetic overflow leave the arena and live data intact.
@test unsafe fn testAllocFailureAtomicity() throws (testing::TestError) {
    static STORAGE: [u8; 64] = [0; 64];
    let mut arena = super::new(&mut STORAGE[..]);
    let first = try! super::allocRaw(&mut arena, 1, 1) as *unsafe mut u8;
    set *first = 42;
    for size in [64 as u32, 4294967295 as u32] {
        let saved = super::used(&arena);
        let mut failed = false;
        try super::alloc(&mut arena, size, 1) catch {
            set failed = true;
        };
        try testing::expect(failed);
        try testing::expect(super::used(&arena) == saved);
        try testing::expect(*first == 42);
    }
    let next = try! super::allocRaw(&mut arena, 1, 1) as *unsafe mut u8;
    try testing::expect(next as u64 == first as u64 + 1);
}

/// Slice count multiplication fails before either allocation API changes state.
@test unsafe fn testAllocSliceOverflowAtomicity() throws (testing::TestError) {
    static STORAGE: [u8; 64] = [0; 64];
    let mut arena = super::new(&mut STORAGE[..]);
    let first = try! super::allocRaw(&mut arena, 1, 1) as *unsafe mut u8;
    set *first = 42;
    let saved = super::used(&arena);
    let mut failed = false;
    try super::allocSlice(&mut arena, 4, 4, 1073741825) catch {
        set failed = true;
    };
    try testing::expect(failed);
    try testing::expect(super::used(&arena) == saved);
    set failed = false;
    try super::allocRawSlice(&mut arena, 4, 4, 1073741825) catch {
        set failed = true;
    };
    try testing::expect(failed);
    try testing::expect(super::used(&arena) == saved);
    try testing::expect(*first == 42);
}

lib/std/lang/ast.rad +91 -11

export mod printer;

use std::io;
use std::fmt;
use std::lang::alloc;
use std::lang::types;

/// Ownership and safety qualifier written in a pointer type.
/// Named reference regions are separate `TypeSig::RegionRef` nodes.
export union PointerClass: Copy {
    /// Owned pointer introduced by `*`.
    Owned,
    /// Borrowed reference introduced by `&`.
    Ref,
    /// Raw pointer introduced by `*unsafe`.
    Unsafe,
}

/// Maximum number of trait methods.
export constant MAX_TRAIT_METHODS: u32 = 8;

/// Arena for all parser allocations.

        length: *Node,
    },
    /// Slice type, eg. `*[i32]`, `&[i32]`, or `*unsafe [i32]`.
    Slice {
        /// Ownership and safety class.
        class: types::PointerClass,
        class: PointerClass,
        /// Slice element type.
        itemType: *Node,
        /// Whether the slice is mutable.
        mutable: bool,
    },
    /// Pointer type, eg. `*i32`, `&i32`, or `*unsafe i32`.
    Pointer {
        /// Ownership and safety class.
        class: types::PointerClass,
        class: PointerClass,
        /// Pointer target type.
        valueType: *Node,
        /// Whether the pointer is mutable.
        mutable: bool,
    },
    /// Optional, eg. `?i32`.
    Optional {
        /// Underlying type.
        valueType: *Node,
    },
    /// Shared cell pointer with value access to its payload.
    Cell {
        /// Storage lifetime and ownership class.
        class: PointerClass,
        /// Copy payload type.
        payload: *Node,
    },
    /// Nominal type, points to identifier node.
    Nominal(*Node),
    /// Reference qualified by a lexical region.
    RegionRef {
        /// Region name node.
        region: *Node,
        /// Reference type node.
        type: *Node,
    },
    /// Nominal type with invariant region arguments.
    Applied {
        /// Nominal type path.
        name: *Node,
        /// Region arguments in declaration order.
        regions: *[*Node],
    },
    /// Inline record type for union variant payloads.
    Record {
        /// Field declaration nodes.
        fields: *[*Node],
        /// Whether this record has labeled fields.

    },
    /// Trait object type, eg. `*opaque Allocator`, `&opaque Allocator`, or
    /// `*unsafe opaque Allocator`.
    TraitObject {
        /// Ownership and safety class.
        class: types::PointerClass,
        class: PointerClass,
        /// Trait name identifier.
        traitName: *Node,
        /// Whether the pointer is mutable.
        mutable: bool,
    },

    name: *Node,
    /// Field declaration nodes.
    fields: *[*Node],
    /// Optional attribute list applied to the record.
    attrs: ?Attributes,
    /// Trait derivations attached to the record.
    /// Region parameters in declaration order.
    regions: *[*Node],
    /// Ownership trait derivations attached to the record.
    derives: *[*Node],
    /// Whether this record has labeled fields.
    labeled: bool,
}


    name: *Node,
    /// Variant nodes making up the union.
    variants: *[*Node],
    /// Optional attribute list applied to the union.
    attrs: ?Attributes,
    /// Trait derivations attached to the union.
    /// Region parameters in declaration order.
    regions: *[*Node],
    /// Ownership trait derivations attached to the union.
    derives: *[*Node],
}

/// Union variant declaration.
export record UnionDeclVariant: Copy {


/// Function declaration.
export record FnDecl: Copy {
    /// Identifier naming the function.
    name: *Node,
    /// Region parameters in declaration order.
    regions: *[*Node],
    /// Function type signature.
    sig: FnSig,
    /// Optional function body (`nil` for extern functions).
    body: ?*Node,
    /// Optional attribute list applied to the function.
    attrs: ?Attributes,
}

/// Method declaration modifiers.
export record MethodModifiers: Copy {
    /// Region parameters in declaration order.
    regions: *[*Node],
    /// Optional attribute list.
    attrs: ?Attributes,
}

/// Array repeat literal metadata.
export record ArrayRepeatLit: Copy {
    /// Expression providing the repeated value.
    item: *Node,
    /// Expression providing the repetition count.

    Char(u8),
    /// String literal like `"Hello World!"`.
    String(*[u8]),
    /// Identifier expression.
    Ident(*[u8]),
    /// Lexical region name, including its apostrophe prefix.
    Region {
        /// Source name.
        name: *[u8],
        /// Declared parent for a region parameter.
        parent: ?*Node,
    },
    /// Function or nominal constructor applied to explicit region arguments.
    RegionApply {
        /// Function or constructor expression.
        value: *Node,
        /// Region argument nodes in declaration order.
        regions: *[*Node],
    },
    /// Named source place for a lexical region binding.
    RegionBinding(Arg),
    /// Block with explicit storage bindings for a concrete region.
    RegionBlock {
        /// Region name introduced by this block.
        region: *Node,
        /// Binding nodes with address expressions as initializers.
        bindings: *[*Node],
        /// Statements within the region.
        body: *Node,
        /// Whether a `use` block supplies an allocation interface.
        isSession: bool,
    },
    /// Numeric literal such as `42` or `0xFF`.
    Number(fmt::IntLiteral),
    /// Range expression such as `0..10` or `..`.
    Range(Range),
    /// Array literal expression.

    },
    /// Method signature inside a trait declaration.
    TraitMethodSig {
        /// Method name identifier.
        name: *Node,
        /// Region parameters and attributes.
        modifiers: *MethodModifiers,
        /// Receiver type node (eg. `*mut Allocator`).
        receiver: *Node,
        /// Function signature.
        sig: FnSig,
        /// Optional declaration modifiers.
        attrs: ?Attributes,
    },
    /// Instance block.
    InstanceDecl {
        /// Trait name identifier.
        traitName: *Node,
        /// Target type identifier.
        targetType: *Node,
        /// Region parameters in declaration order.
        regions: *[*Node],
        /// Method definition nodes ([`MethodDecl`]).
        methods: *[*Node],
    },
    /// Method definition with a receiver.
    /// Used both inside `instance` blocks and as standalone methods.
    MethodDecl {
        /// Method name identifier.
        name: *Node,
        /// Region parameters and attributes.
        modifiers: *MethodModifiers,
        /// Receiver binding name ([`Ident`] node).
        receiverName: *Node,
        /// Receiver type node (eg. `*mut Arena`).
        receiverType: *Node,
        /// Function signature.
        sig: FnSig,
        /// Method body.
        body: *Node,
        /// Optional attribute list.
        attrs: ?Attributes,
    },
}

/// Full AST node with shared metadata and variant-specific payload.
export record Node: Copy {

    let params: *[*Node] = &[];
    let throwList: *[*Node] = &[];
    let fnSig = FnSig { params, returnType: nil, throwList };
    let fnBody: *Node = synthNode(arena, NodeValue::Block(Block { statements: bodyStmts, isUnsafe: false }));
    let fnDecl = synthNode(arena, NodeValue::FnDecl(FnDecl {
        name: fnName, sig: fnSig, body: fnBody, attrs: nil,
        name: fnName, regions: &[], sig: fnSig, body: fnBody, attrs: nil,
    }));
    let mut rootStmts: *mut [*Node] = &mut [];
    rootStmts.append(fnDecl, a);
    let modBody = synthNode(arena, NodeValue::Block(Block { statements: rootStmts, isUnsafe: false }));

    return SynthFnMod { modBody, fnBody };
}

/// Describe the immutable binding introduced by a lexical region header.
export fn borrowBinding(binding: Arg) -> Let {
    let ident = binding.label else panic "borrowBinding: missing name";
    return Let { ident, type: nil, value: binding.value, alignment: nil, mutable: false };
}

lib/std/lang/ast/printer.rad +66 -10

//! AST pretty printer using S-expression syntax.

use std::io;
use std::lang::sexpr;
use std::lang::alloc;
use std::lang::types;

/// Return the symbol for a binary operator.
fn binOpName(op: super::BinaryOp) -> *[u8] {
    match op {
        case super::BinaryOp::Add => return "+",

    }
}

/// Return the S-expression head for a pointer class.
fn pointerClassHead(
    class: types::PointerClass,
    class: super::PointerClass,
    ownedHead: *[u8],
    refHead: *[u8],
    unsafeHead: *[u8],
) -> *[u8] {
    match class {
        case types::PointerClass::Owned => return ownedHead,
        case types::PointerClass::Ref => return refHead,
        case types::PointerClass::Unsafe => return unsafeHead,
        case super::PointerClass::Owned => return ownedHead,
        case super::PointerClass::Ref => return refHead,
        case super::PointerClass::Unsafe => return unsafeHead,
    }
}

/// Convert a type signature to an S-expression.
unsafe fn typeSigToExpr(a: &mut alloc::Arena, sig: super::TypeSig) -> sexpr::Expr {

            return sexpr::list(a, head, &[sexpr::sym("mut"), toExpr(a, valueType)]) if mutable
                else sexpr::list(a, head, &[toExpr(a, valueType)]);
        }
        case super::TypeSig::Optional { valueType } =>
            return sexpr::list(a, "?", &[toExpr(a, valueType)]),
        case super::TypeSig::Cell { class, payload } =>
            return sexpr::list(a, pointerClassHead(class, "cell-ptr", "cell-ref", "unsafe-cell-ptr"), &[toExpr(a, payload)]),
        case super::TypeSig::Nominal(name) => return toExpr(a, name),
        case super::TypeSig::RegionRef { region, type } =>
            return sexpr::list(a, "region-ref", &[toExpr(a, region), toExpr(a, type)]),
        case super::TypeSig::Applied { name, regions } =>
            return sexpr::list(a, "apply", &[toExpr(a, name), sexpr::list(a, "regions", nodeListToExprs(a, regions))]),
        case super::TypeSig::Record { fields, .. } =>
            return sexpr::list(a, "record", nodeListToExprs(a, fields)),
        case super::TypeSig::Fn { sig, isUnsafe } => {
            let mut ret = sexpr::sym("void");
            if let rt = sig.returnType {

            return sexpr::block(a, "match", &[toExpr(a, m.subject)], children);
        }
        case super::NodeValue::MatchProng(p) => {
            return prongToExpr(a, p);
        }
        case super::NodeValue::RegionApply { value, regions } =>
            return sexpr::list(a, "apply", &[toExpr(a, value), sexpr::list(a, "regions", nodeListToExprs(a, regions))]),
        case super::NodeValue::RegionBinding(b) =>
            return sexpr::list(a, "binding", &[toExprOrNull(a, b.label), toExpr(a, b.value)]),
        case super::NodeValue::Region { name, parent } => {
            if let p = parent {
                return sexpr::list(a, "region", &[sexpr::sym(name), toExpr(a, p)]);
            }
            return sexpr::sym(name);
        }
        case super::NodeValue::RegionBlock { region, bindings, body, isSession } => {
            let head = "use-region" if isSession else "let-region";
            return sexpr::block(a, head, &[toExpr(a, region), sexpr::list(a, "bindings", nodeListToExprs(a, bindings))], &[toExpr(a, body)]);
        }
        case super::NodeValue::FnDecl(f) => {
            let params = sexpr::list(a, "params", nodeListToExprs(a, f.sig.params));
            let ret = toExprOrNull(a, f.sig.returnType);
            if f.regions.len > 0 {
                let regions = sexpr::list(a, "regions", nodeListToExprs(a, f.regions));
                if let body = f.body {
                    return sexpr::block(a, "fn", &[toExpr(a, f.name), regions, params, ret], &[toExpr(a, body)]);
                }
                return sexpr::list(a, "fn", &[toExpr(a, f.name), regions, params, ret]);
            }
            if let body = f.body {
                return sexpr::block(a, "fn", &[toExpr(a, f.name), params, ret], &[toExpr(a, body)]);
            }
            return sexpr::list(a, "fn", &[toExpr(a, f.name), params, ret]);
        }
        case super::NodeValue::Mod(m) => return sexpr::list(a, "mod", &[toExpr(a, m.name)]),
        case super::NodeValue::Use(u_) => return sexpr::list(a, "use", &[toExpr(a, u_.path)]),
        case super::NodeValue::RecordDecl(r) => {
            let children = fieldListToExprs(a, r.fields);
            if r.regions.len > 0 or r.derives.len > 0 {
                return sexpr::block(a, "record", &[
                    toExpr(a, r.name),
                    sexpr::list(a, "regions", nodeListToExprs(a, r.regions)),
                    sexpr::list(a, "derives", nodeListToExprs(a, r.derives)),
                ], children);
            }
            return sexpr::block(a, "record", &[toExpr(a, r.name)], children);
        }
        case super::NodeValue::RecordField { field, type, value } => {
            return fieldToExpr(a, field, type, value);
        }
        case super::NodeValue::UnionDecl(u_) => {
            let children = variantListToExprs(a, u_.variants);
            if u_.regions.len > 0 or u_.derives.len > 0 {
                return sexpr::block(a, "union", &[
                    toExpr(a, u_.name),
                    sexpr::list(a, "regions", nodeListToExprs(a, u_.regions)),
                    sexpr::list(a, "derives", nodeListToExprs(a, u_.derives)),
                ], children);
            }
            return sexpr::block(a, "union", &[toExpr(a, u_.name)], children);
        }
        case super::NodeValue::UnionDeclVariant(v) => {
            return variantToExpr(a, v.name, v.type);
        }

        case super::NodeValue::TraitDecl { name, supertraits, methods, .. } => {
            let children = nodeListToExprs(a, methods);
            let supers = sexpr::list(a, "supertraits", nodeListToExprs(a, supertraits));
            return sexpr::block(a, "trait", &[toExpr(a, name), supers], children);
        }
        case super::NodeValue::TraitMethodSig { name, receiver, sig, attrs } => {
        case super::NodeValue::TraitMethodSig { name, modifiers, receiver, sig } => {
            let regions = modifiers.regions;
            let attrs = modifiers.attrs;
            let params = sexpr::list(a, "params", nodeListToExprs(a, sig.params));
            let ret = toExprOrNull(a, sig.returnType);
            let attributes = attributesToExpr(a, attrs);
            return sexpr::list(
                a,
                "methodSig",
                &[attributes, toExpr(a, receiver), toExpr(a, name), params, ret],
                &[
                    attributes,
                    toExpr(a, receiver),
                    toExpr(a, name),
                    sexpr::list(a, "regions", nodeListToExprs(a, regions)),
                    params,
                    ret,
                ],
            );
        }
        case super::NodeValue::InstanceDecl { traitName, targetType, methods } => {
        case super::NodeValue::InstanceDecl { traitName, targetType, regions, methods } => {
            let children = nodeListToExprs(a, methods);
            return sexpr::block(a, "instance", &[toExpr(a, traitName), toExpr(a, targetType)], children);
            return sexpr::block(a, "instance", &[
                toExpr(a, traitName),
                toExpr(a, targetType),
                sexpr::list(a, "regions", nodeListToExprs(a, regions)),
            ], children);
        }
        case super::NodeValue::MethodDecl {
            name, receiverName, receiverType, sig, body, attrs,
            name, modifiers, receiverName, receiverType, sig, body,
        } => {
            let regions = modifiers.regions;
            let attrs = modifiers.attrs;
            let params = sexpr::list(a, "params", nodeListToExprs(a, sig.params));
            let ret = toExprOrNull(a, sig.returnType);
            let attributes = attributesToExpr(a, attrs);
            return sexpr::block(
                a,

                &[
                    attributes,
                    toExpr(a, receiverType),
                    toExpr(a, receiverName),
                    toExpr(a, name),
                    sexpr::list(a, "regions", nodeListToExprs(a, regions)),
                    params,
                    ret,
                ],
                &[toExpr(a, body)],
            );

lib/std/lang/gen/bitset.rad +48 -93

    return b;
}

/// Calculate the number of 32-bit words needed to store `n` bits.
export fn wordsFor(n: u32) -> u32 {
    return (n + 31) / 32;
    return n / 32 + (1 if n % 32 > 0 else 0);
}

/// A fixed-size bitset backed by an array of 32-bit words.
export record Bitset: Copy {
    /// Backing words. The storage must outlive the bitset and its iterators.
    bits: *unsafe mut [u32],
    /// Number of bits this bitset can hold.
    len: u32,
}

/// Create a new bitset backed by the given zero-initialized storage.
/// The storage must outlive the bitset and its iterators.
export unsafe fn new(bits: &mut [u32]) -> Bitset {
    let len = bits.len * 32;
    return Bitset { bits: bits as *unsafe mut [u32], len };
}

/// Create a new bitset backed by the given storage, zeroing it first.
/// The storage must outlive the bitset and its iterators.
export unsafe fn init(bits: &mut [u32]) -> Bitset {
    for i in 0..bits.len {
        set bits[i] = 0;
    }
    return new(bits);
}

/// Create a bitset from arena allocation.
export unsafe fn allocate(arena: &mut alloc::Arena, len: u32) -> Bitset throws (alloc::AllocError) {
    let numWords = wordsFor(len);
    let bits = try alloc::allocRawSlice(arena, @sizeOf(u32), @alignOf(u32), numWords) as *unsafe mut [u32];

    return init(bits);
/// Allocate zeroed words for at least `len` bits in a session.
export fn allocate 'bits (storage: &Session 'bits, len: u32) -> &'bits mut [u32] throws (alloc::AllocError) {
    return try storage.fill(0 as u32, wordsFor(len));
}

/// Set bit `n` in the bitset.
export unsafe fn put(bs: &mut Bitset, n: u32) {
    if n >= bs.len {
export fn put(bs: &mut [u32], n: u32) {
    let word = n / 32;
    if word >= bs.len {
        return;
    }
    let word = n / 32;
    let b = n % 32;

    set bs.bits[word] |= (1 << b);
    set bs[word] |= (1 << b);
}

/// Clear bit `n` in the bitset.
export unsafe fn clear(bs: &mut Bitset, n: u32) {
    if n >= bs.len {
export fn clear(bs: &mut [u32], n: u32) {
    let word = n / 32;
    if word >= bs.len {
        return;
    }
    let word = n / 32;
    let b = n % 32;

    set bs.bits[word] &= ~(1 << b);
    set bs[word] &= ~(1 << b);
}

/// Check if bit `n` is set.
export unsafe fn contains(bs: &Bitset, n: u32) -> bool {
    if n >= bs.len {
export fn contains(bs: &[u32], n: u32) -> bool {
    let word = n / 32;
    if word >= bs.len {
        return false;
    }
    let word = n / 32;
    let b = n % 32;

    return (bs.bits[word] & (1 << b)) <> 0;
    return (bs[word] & (1 << b)) <> 0;
}

/// Count the number of set bits.
export unsafe fn count(bs: &Bitset) -> u32 {
export fn count(bs: &[u32]) -> u32 {
    let mut total: u32 = 0;
    let numWords = bs.bits.len;
    for i in 0..numWords {
        let word = bs.bits[i];
    for word in bs {
        if word <> 0 {
            set total += popCount(word);
        }
    }
    return total;


    return n & 0x3F;
}

/// Union: `dst = dst | src`.
export unsafe fn union_(dst: &mut Bitset, src: &Bitset) {
    let numWords = dst.bits.len;
    let srcWords = src.bits.len;
    let minWords = min(numWords, srcWords);
    for i in 0..minWords {
        set dst.bits[i] |= src.bits[i];
export fn union_(dst: &mut [u32], src: &[u32]) {
    for i in 0..min(dst.len, src.len) {
        set dst[i] |= src[i];
    }
}

/// Subtract: `dst = dst - src`.
export unsafe fn subtract(dst: &mut Bitset, src: &Bitset) {
    let numWords = dst.bits.len;
    let srcWords = src.bits.len;
    let minWords = min(numWords, srcWords);
    for i in 0..minWords {
        set dst.bits[i] &= ~src.bits[i];
export fn subtract(dst: &mut [u32], src: &[u32]) {
    for i in 0..min(dst.len, src.len) {
        set dst[i] &= ~src[i];
    }
}

/// Check if two bitsets are equal.
export unsafe fn eq(a: &Bitset, b: &Bitset) -> bool {
    let numWordsA = a.bits.len;
    let numWordsB = b.bits.len;
    let minWords = min(numWordsA, numWordsB);
export fn eq(a: &[u32], b: &[u32]) -> bool {
    let minWords = min(a.len, b.len);

    for i in 0..minWords {
        if a.bits[i] <> b.bits[i] {
        if a[i] <> b[i] {
            return false;
        }
    }
    for i in minWords..numWordsA {
        if a.bits[i] <> 0 {
    for i in minWords..a.len {
        if a[i] <> 0 {
            return false;
        }
    }
    for i in minWords..numWordsB {
        if b.bits[i] <> 0 {
    for i in minWords..b.len {
        if b[i] <> 0 {
            return false;
        }
    }
    return true;
}

/// Copy bits from source to destination.
export unsafe fn copy(dst: &mut Bitset, src: &Bitset) {
    let numWords = dst.bits.len;
    let srcWords = src.bits.len;
    let minWords = min(numWords, srcWords);
export fn copy(dst: &mut [u32], src: &[u32]) {
    let minWords = min(dst.len, src.len);

    for i in 0..minWords {
        set dst.bits[i] = src.bits[i];
        set dst[i] = src[i];
    }
    // Clear remaining words if destination is larger.
    for i in minWords..numWords {
        set dst.bits[i] = 0;
    for i in minWords..dst.len {
        set dst[i] = 0;
    }
}

/// Clear all bits.
export unsafe fn clearAll(bs: &mut Bitset) {
    let numWords = bs.bits.len;
    for i in 0..numWords {
        set bs.bits[i] = 0;
export fn clearAll(bs: &mut [u32]) {
    for i in 0..bs.len {
        set bs[i] = 0;
    }
}

/// Iterator state for iterating set bits.
export record BitIter: Copy {
    /// Bitset being iterated. It must outlive this iterator.
    bs: *unsafe Bitset,
    /// Current word index.
    wordIdx: u32,
    /// Remaining bits in the current word (visited bits cleared).
    remaining: u32,
}

/// Create an iterator over set bits.
/// The bitset and its backing words must outlive the iterator.
export unsafe fn iter(bs: &Bitset) -> BitIter {
    let remaining = bs.bits[0] if bs.len > 0 else 0;
    return BitIter { bs: bs as *unsafe Bitset, wordIdx: 0, remaining };
/// The cursor retains the first word mask and its position.
export fn iter(bs: &[u32]) -> BitIter {
    let remaining = bs[0] if bs.len > 0 else 0;
    return BitIter { wordIdx: 0, remaining };
}

/// Get the next set bit, or nil if none remain.
export unsafe fn iterNext(it: &mut BitIter) -> ?u32 {
    let numWords = it.bs.bits.len;
/// Get the next set bit from the supplied bitset, or nil if none remain.
/// The current word mask is a value snapshot; later words are read on demand.
export fn iterNext(it: &mut BitIter, bs: &[u32]) -> ?u32 {
    // Skip to next non-zero word.
    while it.remaining == 0 {
        set it.wordIdx += 1;
        if it.wordIdx >= numWords {
        if it.wordIdx >= bs.len {
            return nil;
        }
        set it.remaining = it.bs.bits[it.wordIdx];
        set it.remaining = bs[it.wordIdx];
    }
    // Find lowest set bit position using de Bruijn sequence.
    let b = ctz(it.remaining);
    let n = it.wordIdx * 32 + b;
    if n >= it.bs.len {
        return nil;
    }
    // Clear the lowest set bit.
    set it.remaining &= it.remaining - 1;

    return n;
}

lib/std/lang/gen/bitset/tests.rad +132 -112

//! Tests for the bitset module.

use std::testing;
use std::lang::alloc;

/// Test [`super::init`] and basic set/contains operations.

/// Test word initialization and basic set/contains operations.
@test unsafe fn testInit() throws (testing::TestError) {
    let mut bits: [u32; 4] = undefined;
    let mut bs = super::init(&mut bits[..]);
    let bs = &mut bits[..];
    super::clearAll(bs);

    // `init` should zero-initialize, so all bits start unset.
    try testing::expect(not super::contains(&bs, 0));
    try testing::expect(not super::contains(&bs, 31));
    try testing::expect(not super::contains(&bs, 32));
    try testing::expect(not super::contains(&bs, 127));
    // All bits start unset after clearing the words.
    try testing::expect(not super::contains(bs, 0));
    try testing::expect(not super::contains(bs, 31));
    try testing::expect(not super::contains(bs, 32));
    try testing::expect(not super::contains(bs, 127));

    // Set various bits including word boundaries.
    super::put(&mut bs, 0);
    super::put(&mut bs, 31);
    super::put(&mut bs, 32);
    super::put(&mut bs, 127);
    super::put(bs, 0);
    super::put(bs, 31);
    super::put(bs, 32);
    super::put(bs, 127);

    try testing::expect(super::contains(&bs, 0));
    try testing::expect(super::contains(&bs, 31));
    try testing::expect(super::contains(&bs, 32));
    try testing::expect(super::contains(&bs, 127));
    try testing::expect(super::contains(bs, 0));
    try testing::expect(super::contains(bs, 31));
    try testing::expect(super::contains(bs, 32));
    try testing::expect(super::contains(bs, 127));

    // Other bits still unset.
    try testing::expect(not super::contains(&bs, 1));
    try testing::expect(not super::contains(&bs, 30));
    try testing::expect(not super::contains(&bs, 33));
    try testing::expect(not super::contains(&bs, 126));
    try testing::expect(not super::contains(bs, 1));
    try testing::expect(not super::contains(bs, 30));
    try testing::expect(not super::contains(bs, 33));
    try testing::expect(not super::contains(bs, 126));
}

/// Test clear operation.
@test unsafe fn testClear() throws (testing::TestError) {
    let mut bits: [u32; 2] = [0; 2];
    let mut bs = super::new(&mut bits[..]);
    let bs = &mut bits[..];

    super::put(&mut bs, 0);
    super::put(&mut bs, 31);
    super::put(&mut bs, 32);
    super::put(bs, 0);
    super::put(bs, 31);
    super::put(bs, 32);

    try testing::expect(super::contains(&bs, 0));
    try testing::expect(super::contains(&bs, 31));
    try testing::expect(super::contains(&bs, 32));
    try testing::expect(super::contains(bs, 0));
    try testing::expect(super::contains(bs, 31));
    try testing::expect(super::contains(bs, 32));

    super::clear(&mut bs, 31);
    super::clear(bs, 31);

    try testing::expect(super::contains(&bs, 0));
    try testing::expect(not super::contains(&bs, 31));
    try testing::expect(super::contains(&bs, 32));
    try testing::expect(super::contains(bs, 0));
    try testing::expect(not super::contains(bs, 31));
    try testing::expect(super::contains(bs, 32));
}

/// Test population count.
@test unsafe fn testCount() throws (testing::TestError) {
    let mut bits: [u32; 2] = [0; 2];
    let mut bs = super::new(&mut bits[..]);
    let bs = &mut bits[..];

    try testing::expect(super::count(&bs) == 0);
    try testing::expect(super::count(bs) == 0);

    super::put(&mut bs, 0);
    try testing::expect(super::count(&bs) == 1);
    super::put(bs, 0);
    try testing::expect(super::count(bs) == 1);

    super::put(&mut bs, 31);
    super::put(&mut bs, 32);
    super::put(&mut bs, 63);
    try testing::expect(super::count(&bs) == 4);
    super::put(bs, 31);
    super::put(bs, 32);
    super::put(bs, 63);
    try testing::expect(super::count(bs) == 4);

    super::clear(&mut bs, 31);
    try testing::expect(super::count(&bs) == 3);
    super::clear(bs, 31);
    try testing::expect(super::count(bs) == 3);
}

/// Test union operation.
@test unsafe fn testUnion() throws (testing::TestError) {
    let mut bits_a: [u32; 2] = [0; 2];
    let mut bits_b: [u32; 2] = [0; 2];
    let mut a = super::new(&mut bits_a[..]);
    let mut b = super::new(&mut bits_b[..]);
    let a = &mut bits_a[..];
    let b = &mut bits_b[..];

    super::put(&mut a, 0);
    super::put(&mut a, 10);
    super::put(a, 0);
    super::put(a, 10);

    super::put(&mut b, 10);
    super::put(&mut b, 20);
    super::put(b, 10);
    super::put(b, 20);

    super::union_(&mut a, &b);
    super::union_(a, b);

    try testing::expect(super::contains(&a, 0));
    try testing::expect(super::contains(&a, 10));
    try testing::expect(super::contains(&a, 20));
    try testing::expect(super::count(&a) == 3);
    try testing::expect(super::contains(a, 0));
    try testing::expect(super::contains(a, 10));
    try testing::expect(super::contains(a, 20));
    try testing::expect(super::count(a) == 3);
}

/// Test subtract operation.
@test unsafe fn testSubtract() throws (testing::TestError) {
    let mut bits_a: [u32; 2] = [0; 2];
    let mut bits_b: [u32; 2] = [0; 2];
    let mut a = super::new(&mut bits_a[..]);
    let mut b = super::new(&mut bits_b[..]);
    let a = &mut bits_a[..];
    let b = &mut bits_b[..];

    super::put(&mut a, 0);
    super::put(&mut a, 10);
    super::put(&mut a, 20);
    super::put(a, 0);
    super::put(a, 10);
    super::put(a, 20);

    super::put(&mut b, 10);
    super::put(&mut b, 30);
    super::put(b, 10);
    super::put(b, 30);

    super::subtract(&mut a, &b);
    super::subtract(a, b);

    try testing::expect(super::contains(&a, 0));
    try testing::expect(not super::contains(&a, 10));
    try testing::expect(super::contains(&a, 20));
    try testing::expect(super::count(&a) == 2);
    try testing::expect(super::contains(a, 0));
    try testing::expect(not super::contains(a, 10));
    try testing::expect(super::contains(a, 20));
    try testing::expect(super::count(a) == 2);
}

/// Test equality check.
@test unsafe fn testEq() throws (testing::TestError) {
    let mut bits_a: [u32; 2] = [0; 2];
    let mut bits_b: [u32; 2] = [0; 2];
    let mut a = super::new(&mut bits_a[..]);
    let mut b = super::new(&mut bits_b[..]);
    let a = &mut bits_a[..];
    let b = &mut bits_b[..];

    // Both empty.
    try testing::expect(super::eq(&a, &b));
    try testing::expect(super::eq(a, b));

    super::put(&mut a, 5);
    try testing::expect(not super::eq(&a, &b));
    super::put(a, 5);
    try testing::expect(not super::eq(a, b));

    super::put(&mut b, 5);
    try testing::expect(super::eq(&a, &b));
    super::put(b, 5);
    try testing::expect(super::eq(a, b));

    super::put(&mut a, 32);
    super::put(&mut b, 32);
    try testing::expect(super::eq(&a, &b));
    super::put(a, 32);
    super::put(b, 32);
    try testing::expect(super::eq(a, b));

    super::put(&mut b, 33);
    try testing::expect(not super::eq(&a, &b));
    super::put(b, 33);
    try testing::expect(not super::eq(a, b));
}

/// Test copy operation.
@test unsafe fn testCopy() throws (testing::TestError) {
    let mut bits_a: [u32; 2] = [0; 2];
    let mut bits_b: [u32; 2] = [0; 2];
    let mut a = super::new(&mut bits_a[..]);
    let mut b = super::new(&mut bits_b[..]);
    let a = &mut bits_a[..];
    let b = &mut bits_b[..];

    super::put(&mut a, 0);
    super::put(&mut a, 31);
    super::put(&mut a, 63);
    super::put(a, 0);
    super::put(a, 31);
    super::put(a, 63);

    super::copy(&mut b, &a);
    super::copy(b, a);

    try testing::expect(super::eq(&a, &b));
    try testing::expect(super::contains(&b, 0));
    try testing::expect(super::contains(&b, 31));
    try testing::expect(super::contains(&b, 63));
    try testing::expect(super::eq(a, b));
    try testing::expect(super::contains(b, 0));
    try testing::expect(super::contains(b, 31));
    try testing::expect(super::contains(b, 63));
}

/// Test clearAll operation.
@test unsafe fn testClearAll() throws (testing::TestError) {
    let mut bits: [u32; 2] = [0; 2];
    let mut bs = super::new(&mut bits[..]);

    super::put(&mut bs, 0);
    super::put(&mut bs, 31);
    super::put(&mut bs, 32);
    super::put(&mut bs, 63);
    try testing::expect(super::count(&bs) == 4);

    super::clearAll(&mut bs);
    try testing::expect(super::count(&bs) == 0);
    try testing::expect(not super::contains(&bs, 0));
    try testing::expect(not super::contains(&bs, 31));
    let bs = &mut bits[..];

    super::put(bs, 0);
    super::put(bs, 31);
    super::put(bs, 32);
    super::put(bs, 63);
    try testing::expect(super::count(bs) == 4);

    super::clearAll(bs);
    try testing::expect(super::count(bs) == 0);
    try testing::expect(not super::contains(bs, 0));
    try testing::expect(not super::contains(bs, 31));
}

/// Test iteration over set bits.
@test unsafe fn testIter() throws (testing::TestError) {
    let mut bits: [u32; 2] = [0; 2];
    let mut bs = super::new(&mut bits[..]);
    let bs = &mut bits[..];

    super::put(&mut bs, 3);
    super::put(&mut bs, 31);
    super::put(&mut bs, 32);
    super::put(&mut bs, 50);
    super::put(bs, 3);
    super::put(bs, 31);
    super::put(bs, 32);
    super::put(bs, 50);

    let mut it = super::iter(&bs);
    let mut it = super::iter(bs);
    let mut count: u32 = 0;
    let mut sum: u32 = 0;

    while let n = super::iterNext(&mut it) {
    while let n = super::iterNext(&mut it, bs) {
        set count += 1;
        set sum += n;
    }

    try testing::expect(count == 4);

}

/// Test iteration on empty bitset.
@test unsafe fn testIterEmpty() throws (testing::TestError) {
    let mut bits: [u32; 2] = [0; 2];
    let mut bs = super::new(&mut bits[..]);
    let mut it = super::iter(&bs);
    let result = super::iterNext(&mut it);
    let bs = &mut bits[..];
    let mut it = super::iter(bs);
    let result = super::iterNext(&mut it, bs);

    try testing::expect(result == nil);
}

/// Test [`super::wordsFor`] calculation.

    try testing::expect(super::wordsFor(31) == 1);
    try testing::expect(super::wordsFor(32) == 1);
    try testing::expect(super::wordsFor(33) == 2);
    try testing::expect(super::wordsFor(64) == 2);
    try testing::expect(super::wordsFor(65) == 3);
    try testing::expect(super::wordsFor(0xFFFFFFFF) == 134217728);
}

/// Test out-of-bounds access is safe.
@test unsafe fn testOutOfBounds() throws (testing::TestError) {
    let mut bits: [u32; 1] = [0; 1];
    let mut bs = super::new(&mut bits[..]);
    let bs = &mut bits[..];

    // Setting beyond length should be ignored.
    super::put(&mut bs, 100);
    try testing::expect(not super::contains(&bs, 100));
    super::put(bs, 100);
    try testing::expect(not super::contains(bs, 100));

    // Clearing beyond length should be safe.
    super::clear(&mut bs, 100);
    super::clear(bs, 100);

    // Contains beyond length should return false.
    try testing::expect(not super::contains(&bs, 100));
    try testing::expect(not super::contains(bs, 100));
}

/// Allocate initialized words with a retained session lifetime.
@test unsafe fn testSession() throws (testing::TestError) {
    static DATA: [u8; 64] = [0; 64];
    let mut arena = alloc::new(&mut DATA[..]);
    use arena as bits in {
        let words = try! super::allocate(&bits, 65);
        try testing::expect(words.len == 3);
        try testing::expect(super::count(words) == 0);
        super::put(words, 64);
        try testing::expect(super::count(words) == 1);
        let empty = try! super::allocate(&bits, 0);
        try testing::expect(empty.len == 0);
        try testing::expect(super::count(empty) == 0);
    }
}

lib/std/lang/gen/data.rad +47 -16

    throws (Error)
{
    if item.alignment == 0 or (item.alignment & (item.alignment - 1)) <> 0 {
        throw Error::Alignment;
    }
    if (base & (item.alignment as u64 - 1)) <> 0 { throw Error::Alignment; }
    if (base & (item.alignment as u64 - 1)) <> 0 {
        throw Error::Alignment;
    }
    let aligned = (*offset as u64 + item.alignment as u64 - 1) & ~(item.alignment as u64 - 1);
    let end = aligned + item.size as u64;
    if end > 0xffffffff or base > 0xffffffffffffffff - end {
        throw Error::Overflow;
    }
    if *count >= syms.len { throw Error::Capacity; }
    if *count >= syms.len {
        throw Error::Capacity;
    }
    set syms[*count] = DataSym { name: item.name, addr: base + aligned };
    set *count += 1;
    set *offset = end as u32;
}


    buf: &mut [u8],
    readOnly: bool,
    startOffset: u32
) -> u32 throws (Error) {
    let mut offset: u32 = startOffset;
    if offset > buf.len { throw Error::Capacity; }
    if offset > buf.len {
        throw Error::Capacity;
    }

    for i in 0..items.len {
        let data = items[i];
        if data.readOnly == readOnly and not data.isZeroInit {
            let start = offset;
            if data.alignment == 0 or (data.alignment & (data.alignment - 1)) <> 0 { throw Error::Alignment; }
            if data.alignment == 0 or (data.alignment & (data.alignment - 1)) <> 0 {
                throw Error::Alignment;
            }
            let aligned = (offset as u64 + data.alignment as u64 - 1) & ~(data.alignment as u64 - 1);
            if aligned > buf.len as u64 { throw Error::Capacity; }
            if aligned > buf.len as u64 {
                throw Error::Capacity;
            }
            set offset = aligned as u32;
            if data.size > buf.len - offset { throw Error::Capacity; }
            if data.size > buf.len - offset {
                throw Error::Capacity;
            }
            let end = offset + data.size;
            for j in start..end { set buf[j] = 0; }
            for j in start..end {
                set buf[j] = 0;
            }
            for j in 0..data.values.len {
                let v = &data.values[j];
                let mut width: u32 = 1;
                match v.item {
                    case il::DataItem::Val { typ, .. } => { set width = il::typeSize(typ); },
                    case il::DataItem::Sym(_), il::DataItem::Fn(_) => { set width = 8; },
                    case il::DataItem::Str(bytes) => { set width = bytes.len; },
                    else => {},
                    case il::DataItem::Val { typ, .. } => {
                        set width = il::typeSize(typ);
                    },
                    case il::DataItem::Sym(_), il::DataItem::Fn(_) => {
                        set width = 8;
                    },
                    case il::DataItem::Str(bytes) => {
                        set width = bytes.len;
                    },
                    else => {
                    },
                }
                if width > 0 and v.count > (end - offset) / width {
                    throw Error::Overflow;
                }
                if width == 0 {
                    continue;
                }
                if width > 0 and v.count > (end - offset) / width { throw Error::Overflow; }
                if width == 0 { continue; }
                for _ in 0..v.count {
                    match v.item {
                        case il::DataItem::Val { typ, val } => {
                            let size = il::typeSize(typ);
                            try! mem::copy(&mut buf[offset..], @sliceOf(&val as &u8, size));

                            try! mem::copy(&mut buf[offset..], @sliceOf(&addr64 as &u8, 8));

                            set offset += @sizeOf(u64);
                        },
                        case il::DataItem::Fn(name) => {
                            let fnOffset = dict::get(&fnLabels.funcs, name) else { throw Error::Symbol; };
                            if fnOffset < 0 or codeBase > 0xffffffffffffffff - fnOffset as u64 { throw Error::Overflow; }
                            let fnOffset = dict::get(&fnLabels.funcs, name) else {
                                throw Error::Symbol;
                            };
                            if fnOffset < 0 or codeBase > 0xffffffffffffffff - fnOffset as u64 {
                                throw Error::Overflow;
                            }
                            let addr = codeBase + fnOffset as u64;
                            let addr64: u64 = addr as u64;
                            try! mem::copy(&mut buf[offset..], @sliceOf(&addr64 as &u8, 8));

                            set offset += @sizeOf(*u8);

    if entries.len == 0 or (entries.len & (entries.len - 1)) <> 0 or syms.len > entries.len / 2 {
        throw Error::Capacity;
    }
    let mut d = dict::init(entries);
    for i in 0..syms.len {
        if syms[i].name.len == 0 or dict::get(&d, syms[i].name) <> nil { throw Error::Symbol; }
        if syms[i].name.len == 0 or dict::get(&d, syms[i].name) <> nil {
            throw Error::Symbol;
        }
        dict::insert(&mut d, syms[i].name, i as i32);
    }
    return DataSymMap { dict: d, syms };
}


lib/std/lang/gen/regalloc.rad +11 -11

    /// Size of a spill slot in bytes.
    slotSize: u32,
}

/// Complete register allocation result.
export record AllocResult: Copy {
export record AllocResult: 'scratch + Copy {
    /// SSA register to physical register mapping.
    assignments: *unsafe [?super::Reg],
    assignments: &'scratch [?super::Reg],
    /// Spill slot information.
    spill: spill::SpillInfo,
    spill: spill::SpillInfo 'scratch,
    /// Bitmask of used callee-saved registers.
    usedCalleeSaved: u32,
}

/// Run register allocation on a function.
///
/// Returns a mapping from SSA registers to physical registers, plus
/// spill information.
export unsafe fn allocate(
    func: *unsafe il::Fn,
export unsafe fn allocate 'scratch (
    func: &il::Fn,
    config: &TargetConfig,
    arena: &mut alloc::Arena
) -> AllocResult throws (alloc::AllocError) {
    storage: &Session 'scratch
) -> AllocResult 'scratch throws (alloc::AllocError) {
    // Phase 1: Liveness analysis.
    let live = try liveness::analyze(func, arena);
    let live = try liveness::analyze(func, storage);
    // Phase 2: Spill analysis (determine which values need stack slots).
    let spillInfo = try spill::analyze(func, &live, config.allocatable.len, config.calleeSaved.len, config.slotSize, arena);
    let spillInfo = try spill::analyze(func, &live, config.allocatable.len, config.calleeSaved.len, config.slotSize, storage);
    // Phase 3: Register assignment (map SSA registers to physical registers).
    let assignInfo = try assign::assign(func, &live, &spillInfo, config, arena);
    let assignInfo = try assign::assign(func, &live, &spillInfo, config, storage);

    return AllocResult {
    return AllocResult 'scratch {
        assignments: assignInfo.assignments,
        spill: spillInfo,
        usedCalleeSaved: assignInfo.usedCalleeSaved,
    };
}

lib/std/lang/gen/regalloc/assign.rad +78 -96

/// Maximum number of active register mappings.
constant MAX_ACTIVE: u32 = 64;

/// Register mapping at a program point.
/// Maps SSA registers to physical registers.
export record RegMap {
export record RegMap: 'scratch {
    /// SSA (virtual) registers that have mappings.
    virtRegs: *mut [u32],
    virtRegs: &'scratch mut [u32],
    /// Physical register for each virtual register.
    physRegs: *mut [gen::Reg],
    physRegs: &'scratch mut [gen::Reg],
    /// Number of active mappings.
    n: u32,
}

/// Register assignment result, per function.
export record AssignInfo: Copy {
export record AssignInfo: 'scratch + Copy {
    /// SSA register -> physical register mapping.
    assignments: *unsafe mut [?gen::Reg],
    assignments: &'scratch [?gen::Reg],
    /// Bitmask of used callee-saved registers.
    usedCalleeSaved: u32,
}

/// Per-instruction context for freeing and allocating register uses.
record InstrCtx: Copy {
    current: *unsafe mut RegMap,
    usedRegs: *unsafe mut bitset::Bitset,
record InstrCtx: 'scratch + 'step where 'scratch: 'step {
    current: &'step mut RegMap 'scratch,
    usedRegs: &'step mut [u32],
    /// Last operand-use index for each register used in the current block.
    lastUse: *unsafe [u32],
    live: *unsafe liveness::LiveInfo,
    lastUse: &'step [u32],
    live: &'step liveness::LiveInfo 'scratch,
    blockIdx: u32,
    instrIdx: u32,
    allocatable: *[gen::Reg],
    calleeSaved: *[gen::Reg],
    assignments: *unsafe mut [?gen::Reg],
    spillInfo: *unsafe spill::SpillInfo,
}

/// Context for recording the last operand-use index in a block.
record LastUseCtx: Copy {
    /// Per-register indices, shared by all blocks in the function.
    lastUse: *unsafe mut [u32],
    /// Index of the instruction whose operands are being recorded.
    index: u32,
    assignments: &'step mut [?gen::Reg],
    spillInfo: &'step spill::SpillInfo 'scratch,
}

/// Compute register assignment.
export unsafe fn assign(
    func: *unsafe il::Fn,
    live: &liveness::LiveInfo,
    spillInfo: &spill::SpillInfo,
export unsafe fn assign 'scratch (
    func: &il::Fn,
    live: &liveness::LiveInfo 'scratch,
    spillInfo: &spill::SpillInfo 'scratch,
    config: &super::TargetConfig,
    arena: &mut alloc::Arena
) -> AssignInfo throws (alloc::AllocError) {
    storage: &Session 'scratch
) -> AssignInfo 'scratch throws (alloc::AllocError) {
    let maxReg = live.maxReg;
    let blockCount = func.blocks.len;
    let allocatable = config.allocatable;

    if maxReg == 0 or blockCount == 0 {
        return AssignInfo {
            assignments: &mut [],
        return AssignInfo 'scratch {
            assignments: try storage.fill(nil as ?gen::Reg, 0),
            usedCalleeSaved: 0,
        };
    }

    // Allocate output structures.
    let assignments = try alloc::allocRawSlice(arena, @sizeOf(?gen::Reg), @alignOf(?gen::Reg), maxReg) as *unsafe mut [?gen::Reg];
    for i in 0..maxReg {
        set assignments[i] = nil;
    }
    // Reuse one last-use table for all blocks in the function.
    let lastUse = try alloc::allocRawSlice(arena, @sizeOf(u32), @alignOf(u32), maxReg) as *unsafe mut [u32];
    let assignments = try storage.fill(nil as ?gen::Reg, maxReg);
    // Pre-assign function parameters to argument registers.
    // Cross-call params are NOT pre-assigned here; they will be allocated
    // to callee-saved registers by the normal path, and isel emits moves
    // from the arg register to the assigned register at function entry.
    for param, i in func.params {
        if i < config.argRegs.len {
            if not bitset::contains(&spillInfo.calleeClass, param.value.n) {
            if not bitset::contains(spillInfo.calleeClass, param.value.n) {
                set assignments[param.value.n] = config.argRegs[i];
            }
        }
    }
    // Allocate used registers bitset (32 physical registers per 32-bit word).
    let usedRegsBits = try alloc::allocRawSlice(arena, @sizeOf(u32), @alignOf(u32), 1) as *unsafe mut [u32];
    let mut usedRegs = bitset::init(usedRegsBits);
    let usedRegs = try bitset::allocate(storage, 32);

    // Current register mapping.
    let mut current = try createRegMap(arena);
    // Reuse one last-use table for all blocks in the function.
    let lastUse = try storage.fill(0 as u32, maxReg);
    let mut current = try createRegMap(storage);

    // Phase 2: Linear scan allocation.
    for b in 0..blockCount {
        let block = &func.blocks[b];

        // Record every operand before allocation. Only current-block operands
        // query this table, so every read is initialized by this scan.
        // Entries for other registers need not be cleared between blocks.
        for instr, i in block.instrs {
            let mut ctx = LastUseCtx { lastUse, index: i };
            il::forEachReg(instr, recordLastUseCb, &mut ctx as &mut opaque);
            let mut registers = il::registers(&instr);
            while let reg = il::nextReg(&mut registers, &instr) {
                recordLastUse(reg, &mut lastUse[..], i);
            }
        }

        // Reset for new block.
        set current.n = 0;
        bitset::clearAll(&mut usedRegs);
        bitset::clearAll(usedRegs);

        // Mark all live-in values' registers as used.
        // This ensures we don't reuse registers for values that flow in
        // from predecessors, even at merge points with multiple predecessors.
        // Values that are live-in but have no assignment yet (e.g. callee-saved
        // function parameters not used before a phi block) are allocated now to
        // prevent conflicts with block parameters.
        let mut liveInIter = bitset::iter(&live.liveIn[b]);
        while let ssaReg = bitset::iterNext(&mut liveInIter) {
        let mut liveInIter = bitset::iter(liveness::liveInRow(live, b));
        while let ssaReg = bitset::iterNext(&mut liveInIter, liveness::liveInRow(live, b)) {
            let reg = il::Reg { n: ssaReg };
            if not spill::isSpilled(spillInfo, reg) {
                if let phys = assignments[ssaReg] {
                    bitset::put(&mut usedRegs, *phys as u32);
                    bitset::put(usedRegs, *phys as u32);
                    rmapSet(&mut current, ssaReg, phys);
                } else {
                    set assignments[ssaReg] = rallocReg(&mut current, &mut usedRegs, ssaReg, allocatable, config.calleeSaved, spillInfo);
                    set assignments[ssaReg] = rallocReg(&mut current, usedRegs, ssaReg, allocatable, config.calleeSaved, spillInfo);
                }
            }
        }

        // Allocate block parameters.
        for p in block.params {
            if p.value.n < maxReg and not spill::isSpilled(spillInfo, p.value) {
                set assignments[p.value.n] = rallocReg(&mut current, &mut usedRegs, p.value.n, allocatable, config.calleeSaved, spillInfo);
                set assignments[p.value.n] = rallocReg(&mut current, usedRegs, p.value.n, allocatable, config.calleeSaved, spillInfo);
            }
        }

        // Process each instruction.
        for instr, i in block.instrs {
            let mut ctx = InstrCtx {
                current: &mut current,
                usedRegs: &mut usedRegs,
                lastUse,
                live: live as *unsafe liveness::LiveInfo,
                blockIdx: b,
                instrIdx: i,
                allocatable,
                calleeSaved: config.calleeSaved,
                assignments,
                spillInfo: spillInfo as *unsafe spill::SpillInfo,
            };
            il::forEachReg(instr, processInstrRegCb, &mut ctx as &mut opaque);
            let currentRef: 'step = &mut current, usedRef = &mut usedRegs[..],
                lastUseRef = &lastUse[..], liveRef = &*live,
                assignmentsRef = &mut assignments[..], spillRef = &*spillInfo
            where 'scratch: 'step in {
                let mut ctx = InstrCtx 'scratch 'step {
                    current: currentRef,
                    usedRegs: usedRef,
                    lastUse: lastUseRef,
                    live: liveRef,
                    blockIdx: b,
                    instrIdx: i,
                    allocatable,
                    calleeSaved: config.calleeSaved,
                    assignments: assignmentsRef,
                    spillInfo: spillRef,
                };
                let mut registers = il::registers(&instr);
                while let reg = il::nextReg(&mut registers, &instr) {
                    processInstrReg(reg, &mut ctx);
                }
            }

            // Allocate destination.
            if let dst = il::instrDst(instr) {
                if dst.n < maxReg and not spill::isSpilled(spillInfo, dst) {
                    set assignments[dst.n] = rallocReg(&mut current, &mut usedRegs, dst.n, allocatable, config.calleeSaved, spillInfo);
                    set assignments[dst.n] = rallocReg(&mut current, usedRegs, dst.n, allocatable, config.calleeSaved, spillInfo);
                }
            }
        }
    }
    // Compute bitmask of used callee-saved registers.

                }
            }
        }
    }

    return AssignInfo {
        assignments,
    return AssignInfo 'scratch {
        assignments: &assignments[..],
        usedCalleeSaved,
    };
}

/// Create an empty register map.
unsafe fn createRegMap(arena: &mut alloc::Arena) -> RegMap throws (alloc::AllocError) {
    let virtRegs = try alloc::allocSlice(arena, @sizeOf(u32), @alignOf(u32), MAX_ACTIVE) as *mut [u32];
    let physRegs = try alloc::allocSlice(arena, @sizeOf(gen::Reg), @alignOf(gen::Reg), MAX_ACTIVE) as *mut [gen::Reg];

    return RegMap { virtRegs, physRegs, n: 0 };
fn createRegMap 'scratch (storage: &Session 'scratch) -> RegMap 'scratch throws (alloc::AllocError) {
    let virtRegs = try storage.fill(0 as u32, MAX_ACTIVE);
    let physRegs = try storage.fill(gen::Reg(0), MAX_ACTIVE);
    return RegMap 'scratch { virtRegs, physRegs, n: 0 };
}

/// Find physical register for a virtual register in RegMap.
fn rmapFind(rmap: &RegMap, virtReg: u32) -> ?gen::Reg {
fn rmapFind 'scratch (rmap: &RegMap 'scratch, virtReg: u32) -> ?gen::Reg {
    for i in 0..rmap.n {
        if rmap.virtRegs[i] == virtReg {
            return rmap.physRegs[i];
        }
    }
    return nil;
}

/// Add a mapping to the register map.
fn rmapSet(rmap: &mut RegMap, virtReg: u32, physReg: gen::Reg) {
fn rmapSet 'scratch (rmap: &mut RegMap 'scratch, virtReg: u32, physReg: gen::Reg) {
    assert rmap.n < MAX_ACTIVE, "rmapSet: register map overflow";
    set rmap.virtRegs[rmap.n] = virtReg;
    set rmap.physRegs[rmap.n] = physReg;
    set rmap.n += 1;
}

/// Remove a mapping from the register map and return its physical register.
fn rmapRemove(rmap: &mut RegMap, virtReg: u32) -> ?gen::Reg {
fn rmapRemove 'scratch (rmap: &mut RegMap 'scratch, virtReg: u32) -> ?gen::Reg {
    for i in 0..rmap.n {
        if rmap.virtRegs[i] == virtReg {
            let phys = rmap.physRegs[i];
            // Swap with last and decrement.
            set rmap.n -= 1;

    }
    return nil;
}

/// Find first free register in pool, allocate it, return it.
unsafe fn findFreeInPool(usedRegs: &mut bitset::Bitset, current: &mut RegMap, ssaReg: u32, pool: *[gen::Reg]) -> ?gen::Reg {
    for i in 0..pool.len {
        let r = pool[i];
fn findFreeInPool 'scratch (usedRegs: &mut [u32], current: &mut RegMap 'scratch, ssaReg: u32, pool: *[gen::Reg]) -> ?gen::Reg {
    for r in pool {
        if not bitset::contains(usedRegs, *r as u32) {
            bitset::put(usedRegs, *r as u32);
            rmapSet(current, ssaReg, r);
            return r;
        }

    return nil;
}

/// Allocate a physical register for an SSA register.
/// Cross-call values are steered to callee-saved registers.
unsafe fn rallocReg(
    current: &mut RegMap,
    usedRegs: &mut bitset::Bitset,
fn rallocReg 'scratch (
    current: &mut RegMap 'scratch,
    usedRegs: &mut [u32],
    ssaReg: u32,
    allocatable: *[gen::Reg],
    calleeSaved: *[gen::Reg],
    spillInfo: &spill::SpillInfo
    spillInfo: &spill::SpillInfo 'scratch
) -> gen::Reg {
    // Check if already assigned.
    if let phys = rmapFind(current, ssaReg) {
        return phys;
    }
    let crossCall = bitset::contains(&spillInfo.calleeClass, ssaReg);
    // Allocate from appropriate pool. Cross-call values must use callee-saved
    // registers since they are live across function calls.
    if crossCall {
    if bitset::contains(spillInfo.calleeClass, ssaReg) {
        if let r = findFreeInPool(usedRegs, current, ssaReg, calleeSaved) {
            return r;
        }
        panic "rallocReg: no callee-saved register for cross-call value";
    }

        return r;
    }
    panic "rallocReg: no free register, spilling fault";
}

/// Record the current index; forward traversal leaves the last operand use.
unsafe fn recordLastUseCb(reg: il::Reg, ctxPtr: &mut opaque) {
    let index = (ctxPtr as &mut LastUseCtx).index;
    recordLastUse(reg, &mut (ctxPtr as &mut LastUseCtx).lastUse[..], index);
}

/// Record the last instruction that uses the register.
fn recordLastUse(reg: il::Reg, lastUse: &mut [u32], index: u32) {
    set lastUse[reg.n] = index;
}

/// Free operands with no later block use or live-out use, then allocate missing uses.
unsafe fn processInstrRegCb(reg: il::Reg, ctxPtr: &mut opaque) {
    processInstrReg(reg, ctxPtr as &mut InstrCtx);
}

/// Release expired registers and assign a register for this operand.
unsafe fn processInstrReg(reg: il::Reg, ctx: &mut InstrCtx) {
    if not (bitset::contains(&ctx.live.liveOut[ctx.blockIdx], reg.n) or ctx.lastUse[reg.n] > ctx.instrIdx) {
fn processInstrReg 'scratch 'step (reg: il::Reg, ctx: &mut InstrCtx 'scratch 'step) where 'scratch: 'step {
    if not (bitset::contains(liveness::liveOutRow(ctx.live, ctx.blockIdx), reg.n) or ctx.lastUse[reg.n] > ctx.instrIdx) {
        if let phys = rmapRemove(ctx.current, reg.n) {
            bitset::clear(ctx.usedRegs, *phys as u32);
        }
    }
    assert reg.n < ctx.assignments.len, "processInstrRegCb: register out of bounds";
    assert reg.n < ctx.assignments.len, "processInstrReg: register out of bounds";
    if spill::isSpilled(ctx.spillInfo, reg) {
        return; // Spilled values don't get physical registers.
    }
    if ctx.assignments[reg.n] == nil {
        let current = ctx.current;
        let usedRegs = ctx.usedRegs;
        set ctx.assignments[reg.n] = rallocReg(
            current, usedRegs, reg.n, ctx.allocatable,
            ctx.current, ctx.usedRegs, reg.n, ctx.allocatable,
            ctx.calleeSaved, ctx.spillInfo
        );
    }
}

lib/std/lang/gen/regalloc/liveness.rad +86 -100

//!   let live = liveness::analyze(func, ...);
//!   if not liveness::hasLaterUse(&live, func, blockIdx, instrIdx, reg) {
//!       // `reg` dies at this instruction.
//!   }

use std::mem;
@test mod tests;

use std::lang::il;
use std::lang::alloc;
use std::lang::gen::bitset;

/// Maximum number of SSA registers supported.
export constant MAX_SSA_REGS: u32 = 8192;

/// Liveness information for a function.
export record LiveInfo: Copy {
    /// Per-block live-in sets (indexed by block index).
    liveIn: *unsafe mut [bitset::Bitset],
    /// Per-block live-out sets (indexed by block index).
    liveOut: *unsafe mut [bitset::Bitset],
    /// Per-block defs sets (registers defined in block).
    defs: *unsafe mut [bitset::Bitset],
    /// Per-block uses sets (registers used before defined in block).
    uses: *unsafe mut [bitset::Bitset],
export record LiveInfo: 'scratch + Copy {
    /// Per-block live-in words, stored in consecutive rows.
    liveIn: &'scratch [u32],
    /// Per-block live-out words, stored in consecutive rows.
    liveOut: &'scratch [u32],
    /// Per-block definition words, stored in consecutive rows.
    defs: &'scratch [u32],
    /// Per-block use-before-definition words, stored in consecutive rows.
    uses: &'scratch [u32],
    /// Number of words in one block row.
    words: u32,
    /// Number of blocks.
    blockCount: u32,
    /// Maximum register number used.
    maxReg: u32,
}

/// Context for collecting defs and uses during block analysis.
record DefsUses: Copy {
    defs: *unsafe bitset::Bitset,
    uses: *unsafe mut bitset::Bitset,
}

/// Context for searching for a specific register in an instruction.
record FindCtx: Copy {
    target: u32,
    found: bool,
}

/// Compute liveness by growing live sets until no live-in set changes.
export unsafe fn analyze(func: *unsafe il::Fn, arena: &mut alloc::Arena) -> LiveInfo throws (alloc::AllocError) {
export unsafe fn analyze 'scratch (func: &il::Fn, storage: &Session 'scratch) -> LiveInfo 'scratch throws (alloc::AllocError) {
    let blockCount = func.blocks.len;
    if blockCount == 0 {
        return LiveInfo {
            liveIn: &mut [],
            liveOut: &mut [],
            defs: &mut [],
            uses: &mut [],
            blockCount: 0,
            maxReg: 0,
        };
        let empty = try storage.fill(0 as u32, 0);
        let frozen: &'scratch [u32] = &empty[..];
        return LiveInfo 'scratch { liveIn: frozen, liveOut: frozen, defs: frozen, uses: frozen, words: 0, blockCount: 0, maxReg: 0 };
    }

    // Find max register number.
    let mut maxReg: u32 = 0;
    for p in func.params {

    for b in 0..blockCount {
        let block = &func.blocks[b];
        for p in block.params {
            set maxReg = maxRegNum(p.value.n, maxReg);
        }
        for i in 0..block.instrs.len {
            il::forEachReg(block.instrs[i], maxRegCallback, &mut maxReg as &mut opaque);
            if let dst = il::instrDst(block.instrs[i]) {
        for instr in block.instrs {
            let mut registers = il::registers(&instr);
            while let reg = il::nextReg(&mut registers, &instr) {
                updateMaxReg(reg, &mut maxReg);
            }
            if let dst = il::instrDst(instr) {
                set maxReg = maxRegNum(dst.n, maxReg);
            }
        }
    }
    if maxReg > MAX_SSA_REGS { throw alloc::AllocError::OutOfMemory; }
    // Allocate per-block bitsets.
    let liveIn = try alloc::allocRawSlice(arena, @sizeOf(bitset::Bitset), @alignOf(bitset::Bitset), blockCount) as *unsafe mut [bitset::Bitset];
    let liveOut = try alloc::allocRawSlice(arena, @sizeOf(bitset::Bitset), @alignOf(bitset::Bitset), blockCount) as *unsafe mut [bitset::Bitset];
    let defs = try alloc::allocRawSlice(arena, @sizeOf(bitset::Bitset), @alignOf(bitset::Bitset), blockCount) as *unsafe mut [bitset::Bitset];
    let uses = try alloc::allocRawSlice(arena, @sizeOf(bitset::Bitset), @alignOf(bitset::Bitset), blockCount) as *unsafe mut [bitset::Bitset];

    for b in 0..blockCount {
        set liveIn[b] = try bitset::allocate(arena, maxReg);
        set liveOut[b] = try bitset::allocate(arena, maxReg);
        set defs[b] = try bitset::allocate(arena, maxReg);
        set uses[b] = try bitset::allocate(arena, maxReg);
    if maxReg > MAX_SSA_REGS {
        throw alloc::AllocError::OutOfMemory;
    }
    // Allocate one contiguous word matrix for each set class.
    let words = bitset::wordsFor(maxReg);
    let count64 = blockCount as u64 * words as u64;
    if count64 > 0xFFFFFFFF {
        throw alloc::AllocError::OutOfMemory;
    }
    let count = count64 as u32;
    let liveIn = try storage.fill(0 as u32, count);
    let liveOut = try storage.fill(0 as u32, count);
    let defs = try storage.fill(0 as u32, count);
    let uses = try storage.fill(0 as u32, count);

    // Compute local defs and uses for each block.
    for b in 0..blockCount {
        computeLocalDefsUses(&func.blocks[b], &mut defs[b], &mut uses[b]);
        computeLocalDefsUses(&func.blocks[b], &mut defs[b * words..(b + 1) * words], &mut uses[b * words..(b + 1) * words]);
    }
    // Live sets grow monotonically from empty sets; no scratch set is needed.
    let mut changed = true;

    while changed {

        while b > 0 {
            set b -= 1;
            let block = &func.blocks[b];

            // Add successor live-in sets directly to this block's live-out set.
            addSuccessorLiveIn(func, block, liveIn, &mut liveOut[b]);
            addSuccessorLiveIn(func, block, liveIn, words, &mut liveOut[b * words..(b + 1) * words]);

            if computeAndUpdateLiveIn(&mut liveIn[b], &liveOut[b], &defs[b], &uses[b]) {
            if computeAndUpdateLiveIn(&mut liveIn[b * words..(b + 1) * words], &liveOut[b * words..(b + 1) * words], &defs[b * words..(b + 1) * words], &uses[b * words..(b + 1) * words]) {
                set changed = true;
            }
        }
    }
    return LiveInfo { liveIn, liveOut, defs, uses, blockCount, maxReg };
    return LiveInfo 'scratch { liveIn: &liveIn[..], liveOut: &liveOut[..], defs: &defs[..], uses: &uses[..], words, blockCount, maxReg };
}

/// Compute `liveIn = uses | (liveOut - defs)` and update `dst`.
/// Returns `true` if `dst` changed. Combined loop avoids multiple passes.
unsafe fn computeAndUpdateLiveIn(
    dst: *unsafe mut bitset::Bitset,
    liveOut: *unsafe bitset::Bitset,
    defs: *unsafe bitset::Bitset,
    uses: *unsafe bitset::Bitset
fn computeAndUpdateLiveIn(
    dst: &mut [u32],
    liveOut: &[u32],
    defs: &[u32],
    uses: &[u32]
) -> bool {
    let numWords = dst.bits.len;
    let mut changed = false;
    for i in 0..numWords {
        let newWord = uses.bits[i] | (liveOut.bits[i] & ~defs.bits[i]);
        if dst.bits[i] <> newWord {
            set dst.bits[i] = newWord;
    for i in 0..dst.len {
        let newWord = uses[i] | (liveOut[i] & ~defs[i]);
        if dst[i] <> newWord {
            set dst[i] = newWord;
            set changed = true;
        }
    }
    return changed;
}

/// Compute local defs and uses for a single block.
unsafe fn computeLocalDefsUses(block: *unsafe il::Block, defs: *unsafe mut bitset::Bitset, uses: *unsafe mut bitset::Bitset) {
unsafe fn computeLocalDefsUses(block: &il::Block, defs: &mut [u32], uses: &mut [u32]) {
    for p in block.params {
        bitset::put(defs, p.value.n);
    }
    for i in 0..block.instrs.len {
        let instr = block.instrs[i];
        let mut ctx = DefsUses { defs, uses };
        il::forEachReg(instr, addUseCallback, &mut ctx as &mut opaque);
    for instr in block.instrs {
        let mut registers = il::registers(&instr);
        while let reg = il::nextReg(&mut registers, &instr) {
            addUse(reg, defs, uses);
        }

        if let dst = il::instrDst(instr) {
            bitset::put(defs, dst.n);
        }
    }
}

/// Callback for [`il::forEachReg`]: adds register to uses if not already defined.
unsafe fn addUseCallback(reg: il::Reg, ctx: &mut opaque) {
    addUse(reg, ctx as &mut DefsUses);
}

/// Add an undefined register to the use set.
unsafe fn addUse(reg: il::Reg, c: &mut DefsUses) {
    if not bitset::contains(c.defs, reg.n) {
        bitset::put(c.uses, reg.n);
fn addUse(reg: il::Reg, defs: &[u32], uses: &mut [u32]) {
    if not bitset::contains(defs, reg.n) {
        bitset::put(uses, reg.n);
    }
}

/// Callback for [`il::forEachReg`]: updates max register number.
unsafe fn maxRegCallback(reg: il::Reg, ctx: &mut opaque) {
    updateMaxReg(reg, ctx as &mut u32);
}

/// Update the largest register number.
fn updateMaxReg(reg: il::Reg, max: &mut u32) {
    set *max = maxRegNum(reg.n, *max);
}

/// Return the larger of n+1 and current.
fn maxRegNum(n: u32, current: u32) -> u32 {
    if n >= MAX_SSA_REGS { return MAX_SSA_REGS + 1; }
    if n >= MAX_SSA_REGS {
        return MAX_SSA_REGS + 1;
    }
    if n + 1 > current {
        return n + 1;
    }
    return current;
}

/// Add successor live-in sets to the block's live-out set.
unsafe fn addSuccessorLiveIn(func: *unsafe il::Fn, block: *unsafe il::Block, liveIn: *unsafe [bitset::Bitset], liveOut: *unsafe mut bitset::Bitset) {
unsafe fn addSuccessorLiveIn(func: &il::Fn, block: &il::Block, liveIn: &[u32], words: u32, liveOut: &mut [u32]) {
    if block.instrs.len == 0 {
        return;
    }
    let term = block.instrs[block.instrs.len - 1];

    match term {
        case il::Instr::Jmp { target, .. } =>
            unionBlockLiveIn(target, liveIn, liveOut),
            unionBlockLiveIn(target, liveIn, words, liveOut),
        case il::Instr::Br { thenTarget, elseTarget, .. } => {
            unionBlockLiveIn(thenTarget, liveIn, liveOut);
            unionBlockLiveIn(elseTarget, liveIn, liveOut);
            unionBlockLiveIn(thenTarget, liveIn, words, liveOut);
            unionBlockLiveIn(elseTarget, liveIn, words, liveOut);
        },
        case il::Instr::Switch { defaultTarget, cases, .. } => {
            unionBlockLiveIn(defaultTarget, liveIn, liveOut);
            unionBlockLiveIn(defaultTarget, liveIn, words, liveOut);
            for c in cases {
                unionBlockLiveIn(c.target, liveIn, liveOut);
                unionBlockLiveIn(c.target, liveIn, words, liveOut);
            }
        },
        else => {},
    }
}

/// Union a target block's live-in set into the block's live-out set.
unsafe fn unionBlockLiveIn(target: u32, liveIn: *unsafe [bitset::Bitset], liveOut: *unsafe mut bitset::Bitset) {
    bitset::union_(liveOut, &liveIn[target]);
fn unionBlockLiveIn(target: u32, liveIn: &[u32], words: u32, liveOut: &mut [u32]) {
    bitset::union_(liveOut, &liveIn[target * words..(target + 1) * words]);
}

/// Check if a register has any use after this instruction.
export unsafe fn hasLaterUse(info: *unsafe LiveInfo, func: *unsafe il::Fn, blockIdx: u32, instrIdx: u32, reg: il::Reg) -> bool {
export unsafe fn hasLaterUse 'scratch (info: &LiveInfo 'scratch, func: &il::Fn, blockIdx: u32, instrIdx: u32, reg: il::Reg) -> bool {
    let block = &func.blocks[blockIdx];

    if bitset::contains(&info.liveOut[blockIdx], reg.n) {
    if bitset::contains(liveOutRow(info, blockIdx), reg.n) {
        return true;
    }
    for i in (instrIdx + 1)..block.instrs.len {
        if instrUsesReg(block.instrs[i], reg) {
            return true;

    return false;
}

/// Check if an instruction uses a specific register.
unsafe fn instrUsesReg(instr: il::Instr, reg: il::Reg) -> bool {
    let mut ctx = FindCtx { target: reg.n, found: false };
    il::forEachReg(instr, findRegCallback, &mut ctx as &mut opaque);
    return ctx.found;
    let mut registers = il::registers(&instr);
    while let source = il::nextReg(&mut registers, &instr) {
        if source.n == reg.n {
            return true;
        }
    }
    return false;
}

/// Callback for [`il::forEachReg`]: sets found if register matches target.
unsafe fn findRegCallback(reg: il::Reg, ctx: &mut opaque) {
    findReg(reg, ctx as &mut FindCtx);
/// Borrow the live-in words for one block.
export fn liveInRow 'scratch (info: &LiveInfo 'scratch, block: u32) -> &'scratch [u32] {
    assert block < info.blockCount;
    return &info.liveIn[block * info.words..(block + 1) * info.words];
}

/// Set the match flag when the register equals the target.
fn findReg(reg: il::Reg, c: &mut FindCtx) {
    if reg.n == c.target {
        set c.found = true;
    }
/// Borrow the live-out words for one block.
export fn liveOutRow 'scratch (info: &LiveInfo 'scratch, block: u32) -> &'scratch [u32] {
    assert block < info.blockCount;
    return &info.liveOut[block * info.words..(block + 1) * info.words];
}

lib/std/lang/gen/regalloc/liveness/tests.rad added +69 -0

1	+	//! Tests for liveness analysis.
2	+
3	+	use std::testing;
4	+	use std::lang::alloc;
5	+	use std::lang::il;
6	+	use std::lang::gen::bitset;
7	+
8	+
9	+	/// Construct a block whose instruction storage belongs to the caller.
10	+	unsafe fn block(name: [u8], instructions: unsafe mut [il::Instr]) -> il::Block {
11	+	return il::Block { label: name, params: &[], instrs: instructions,
12	+	locs: &[], preds: &[], loopDepth: 0 };
13	+	}
14	+
15	+	/// Check one bit in each word of a three-word row.
16	+	fn check(words: &[u32], first: bool, second: bool, third: bool) throws (testing::TestError) {
17	+	try testing::expect(words.len == 3);
18	+	try testing::expect(bitset::contains(words, 0) == first);
19	+	try testing::expect(bitset::contains(words, 33) == second);
20	+	try testing::expect(bitset::contains(words, 66) == third);
21	+	}
22	+
23	+	@test unsafe fn testLoopLiveness() throws (testing::TestError) {
24	+	let r0 = il::Reg { n: 0 };
25	+	let r33 = il::Reg { n: 33 };
26	+	let r66 = il::Reg { n: 66 };
27	+	let mut entry = [
28	+	il::Instr::Copy { dst: r0, val: il::Val::Imm(7) },
29	+	il::Instr::Jmp { target: 1, args: &mut [] },
30	+	];
31	+	let mut head = [
32	+	il::Instr::Copy { dst: r33, val: il::Val::Reg(r0) },
33	+	il::Instr::Br { op: il::CmpOp::Eq, typ: il::Type::W64,
34	+	a: il::Val::Reg(r33), b: il::Val::Imm(0),
35	+	thenTarget: 2, thenArgs: &mut [], elseTarget: 3, elseArgs: &mut [] },
36	+	];
37	+	let mut body = [
38	+	il::Instr::BinOp { op: il::BinOp::Add, typ: il::Type::W64,
39	+	dst: r66, a: il::Val::Reg(r33), b: il::Val::Imm(1) },
40	+	il::Instr::Jmp { target: 1, args: &mut [] },
41	+	];
42	+	let mut exit = [il::Instr::Ret { val: il::Val::Reg(r33) }];
43	+	let blocks = [block("entry", &mut entry[..]), block("head", &mut head[..]),
44	+	block("body", &mut body[..]), block("exit", &mut exit[..])];
45	+	let function = il::Fn { name: "loop", params: &[], returnType: il::Type::W64,
46	+	isExtern: false, isLeaf: true, blocks: &blocks[..] };
47	+	static DATA: [u8; 8192] = [0; 8192];
48	+	let mut arena = alloc::new(&mut DATA[..]);
49	+	let mut answer: u32 = 0;
50	+	use arena as analysis in {
51	+	let live = try! super::analyze(&function, &analysis);
52	+	try testing::expect(live.blockCount == 4);
53	+	try testing::expect(live.maxReg == 67);
54	+	try testing::expect(live.words == 3);
55	+	try check(super::liveInRow(&live, 0), false, false, false);
56	+	try check(super::liveOutRow(&live, 0), true, false, false);
57	+	try check(super::liveInRow(&live, 1), true, false, false);
58	+	try check(super::liveOutRow(&live, 1), true, true, false);
59	+	try check(super::liveInRow(&live, 2), true, true, false);
60	+	try check(super::liveOutRow(&live, 2), true, false, false);
61	+	try check(super::liveInRow(&live, 3), false, true, false);
62	+	try check(super::liveOutRow(&live, 3), false, false, false);
63	+	try check(&live.defs[6..9], false, false, true);
64	+	try check(&live.uses[6..9], false, true, false);
65	+	set answer = 42;
66	+	}
67	+	alloc::reset(&mut arena);
68	+	try testing::expect(answer == 42);
69	+	}

lib/std/lang/gen/regalloc/spill.rad +66 -81

    /// Number of uses (weighted by loop depth).
    uses: u32,
}

/// Spill decision for a function.
export record SpillInfo: Copy {
export record SpillInfo: 'scratch + Copy {
    /// SSA register mapped to stack slot offset. `-1` means not spilled.
    slots: *[i32],
    slots: &'scratch [i32],
    /// Total spill frame size needed in bytes.
    frameSize: i32,
    /// Values that must be allocated in callee-saved registers.
    calleeClass: bitset::Bitset,
    calleeClass: &'scratch [u32],
    /// Maximum SSA register number.
    maxReg: u32,
}

/// Candidate buffer for spill decisions.
record Candidates: Copy {
    entries: [CostEntry; 256],
    entries: [CostEntry; MAX_CANDIDATES],
    n: u32,
}

/// Entry for cost sorting.
record CostEntry: Copy {
    reg: u32,
    cost: u32,
}

/// Context for counting register uses.
record CountCtx: Copy {
    costs: *unsafe mut [SpillCost],
    weight: u32,
}

/// Analyze a function and determine which values need spill slots.
export unsafe fn analyze(
    func: *unsafe il::Fn,
    live: &liveness::LiveInfo,
export unsafe fn analyze 'scratch (
    func: &il::Fn,
    live: &liveness::LiveInfo 'scratch,
    numRegs: u32,
    numCalleeSaved: u32,
    slotSize: u32,
    arena: &mut alloc::Arena
) -> SpillInfo throws (alloc::AllocError) {
    storage: &Session 'scratch
) -> SpillInfo 'scratch throws (alloc::AllocError) {
    let maxReg = live.maxReg;
    if maxReg == 0 {
        let calleeClass = try bitset::allocate(arena, 0);
        return SpillInfo {
            slots: &mut [],
        let calleeClass = try bitset::allocate(storage, 0);
        return SpillInfo 'scratch {
            slots: try storage.fill(-1 as i32, 0),
            frameSize: 0,
            calleeClass,
            calleeClass: &calleeClass[..],
            maxReg: 0,
        };
    }
    // Allocate spill slots array.
    let slots = try alloc::allocSlice(arena, @sizeOf(i32), @alignOf(i32), maxReg) as *mut [i32];
    for i in 0..maxReg {
        set slots[i] = -1;
    }
    let slots = try storage.fill(-1 as i32, maxReg);
    // Allocate cost array.
    let costs = try alloc::allocRawSlice(arena, @sizeOf(SpillCost), @alignOf(SpillCost), maxReg) as *unsafe mut [SpillCost];
    for i in 0..maxReg {
        set costs[i] = SpillCost { defs: 0, uses: 0 };
    }
    let costs = try storage.fill(SpillCost { defs: 0, uses: 0 }, maxReg);
    // Phase 1: Calculate spill costs.
    fillCosts(func, costs);

    // Phase 2: Find values that exceed register pressure.
    let mut spilled = try bitset::allocate(arena, maxReg);
    let mut calleeClass = try bitset::allocate(arena, maxReg);
    let mut scratch = try bitset::allocate(arena, maxReg);
    let spilled = try bitset::allocate(storage, maxReg);
    let calleeClass = try bitset::allocate(storage, maxReg);
    let scratch = try bitset::allocate(storage, maxReg);

    for b in 0..func.blocks.len {
        let block = &func.blocks[b];

        // Start with live-out set.
        bitset::copy(&mut scratch, &live.liveOut[b]);
        bitset::copy(scratch, liveness::liveOutRow(live, b));

        // Walk instructions backwards.
        let mut i = block.instrs.len;
        while i > 0 {
            set i -= 1;
            let instr = block.instrs[i];

            // Limit register pressure before processing this instruction.
            try limitPressure(&mut scratch, &mut spilled, costs, numRegs);
            try limitPressure(scratch, spilled, costs, numRegs);

            // Enforce cross-call pressure at call sites.
            if il::isCall(instr) {
                try limitCrossCallPressure(
                    &mut scratch, &mut spilled, costs,
                    &mut calleeClass, numCalleeSaved, il::instrDst(instr)
                    scratch, spilled, costs,
                    calleeClass, numCalleeSaved, il::instrDst(instr)
                );
            }
            // Remove definition from live set.
            if let dst = il::instrDst(instr) {
                bitset::clear(&mut scratch, dst.n);
                bitset::clear(scratch, dst.n);
            }
            // Add uses to live set.
            il::forEachReg(instr, addRegToSetCallback, &mut scratch as &mut opaque);
            let mut registers = il::registers(&instr);
            while let reg = il::nextReg(&mut registers, &instr) {
                bitset::put(scratch, reg.n);
            }
        }
        // Also limit pressure at block entry.
        try limitPressure(&mut scratch, &mut spilled, costs, numRegs);
        try limitPressure(scratch, spilled, costs, numRegs);
    }

    // Phase 3: Enforce global callee-class limit.
    // The per-call-site limit may leave the callee-class set larger than
    // `numCalleeSaved` when different call sites keep different subsets.
    // Spill excess values to guarantee the assignment phase always finds
    // a callee-saved register for cross-call values.
    let calleeCount = bitset::count(&calleeClass);
    let calleeCount = bitset::count(calleeClass);
    if calleeCount > numCalleeSaved {
        let mut it = bitset::iter(&calleeClass);
        let mut it = bitset::iter(calleeClass);
        for _ in 0..(calleeCount - numCalleeSaved) {
            if let reg = bitset::iterNext(&mut it) {
                bitset::clear(&mut calleeClass, reg);
                bitset::put(&mut spilled, reg);
            if let reg = bitset::iterNext(&mut it, calleeClass) {
                bitset::clear(calleeClass, reg);
                bitset::put(spilled, reg);
            } else {
                panic "spill: count > 0 but no set bits found";
            }
        }
    }

    // Phase 4: Assign stack slots to spilled values.
    let mut frameSize: i32 = 0;
    let mut it = bitset::iter(&spilled);
    let mut it = bitset::iter(spilled);

    while let n = bitset::iterNext(&mut it) {
    while let n = bitset::iterNext(&mut it, spilled) {
        set slots[n] = frameSize;
        set frameSize += slotSize as i32;
    }
    return SpillInfo { slots, frameSize, calleeClass, maxReg };
    return SpillInfo 'scratch { slots: &slots[..], frameSize, calleeClass: &calleeClass[..], maxReg };
}

/// Calculate spill costs for all registers, weighted by loop depth.
unsafe fn fillCosts(func: *unsafe il::Fn, costs: *unsafe mut [SpillCost]) {
unsafe fn fillCosts(func: &il::Fn, costs: &mut [SpillCost]) {
    for b in 0..func.blocks.len {
        let block = &func.blocks[b];

        // Exponential weight for loop depth, capped to avoid overflow.
        let depth = MAX_LOOP_WEIGHT if block.loopDepth > MAX_LOOP_WEIGHT else block.loopDepth;

            if p.value.n < costs.len {
                set costs[p.value.n].defs = costs[p.value.n].defs + weight;
            }
        }
        // Count instruction defs and uses.
        for i in 0..block.instrs.len {
            let instr = block.instrs[i];
        for instr in block.instrs {

            // Count definition.
            if let dst = il::instrDst(instr) {
                if dst.n < costs.len {
                    set costs[dst.n].defs = costs[dst.n].defs + weight;
                }
            }
            // Count uses.
            let mut ctx = CountCtx { costs, weight };
            il::forEachReg(instr, countRegUseCallback, &mut ctx as &mut opaque);
            let mut registers = il::registers(&instr);
            while let reg = il::nextReg(&mut registers, &instr) {
                countRegUse(reg, &mut costs[..], weight);
            }
        }
    }
}

/// Sort candidates by cost (ascending) using insertion sort, then spill
/// the cheapest `excess` values: set in `spilled`, clear in `source`.
unsafe fn spillCheapest(
fn spillCheapest(
    c: &mut Candidates,
    excess: u32,
    source: &mut bitset::Bitset,
    spilled: &mut bitset::Bitset
    source: &mut [u32],
    spilled: &mut [u32]
) {
    // Insertion sort ascending by cost.
    for i in 1..c.n {
        let key = c.entries[i];
        let mut j: u32 = i;

        bitset::clear(source, c.entries[i].reg);
    }
}

/// Collect all values from a bitset into a candidates buffer with their costs.
unsafe fn collectCandidates(bs: &bitset::Bitset, costs: *unsafe [SpillCost]) -> Candidates throws (alloc::AllocError) {
unsafe fn collectCandidates(bs: &[u32], costs: &[SpillCost]) -> Candidates throws (alloc::AllocError) {
    let mut c = Candidates { entries: undefined, n: 0 };
    let mut it = bitset::iter(bs);
    while let reg = bitset::iterNext(&mut it) {
        if c.n == MAX_CANDIDATES { throw alloc::AllocError::OutOfMemory; }
    while let reg = bitset::iterNext(&mut it, bs) {
        if c.n == MAX_CANDIDATES {
            throw alloc::AllocError::OutOfMemory;
        }
        if reg < costs.len {
            set c.entries[c.n] = CostEntry { reg, cost: costs[reg].defs + costs[reg].uses };
            set c.n += 1;
        }
    }
    return c;
}

/// Limit register pressure by marking low-cost values as spilled.
unsafe fn limitPressure(
    live: &mut bitset::Bitset,
    spilled: &mut bitset::Bitset,
    costs: *unsafe [SpillCost],
    live: &mut [u32],
    spilled: &mut [u32],
    costs: &[SpillCost],
    numRegs: u32
) throws (alloc::AllocError) {
    let liveCount = bitset::count(live);
    if liveCount <= numRegs {
        return;

///
/// At a call site, every live value must survive the call in a callee-saved
/// register. If the count exceeds `numCalleeSaved`, spill the cheapest
/// crossing values.
unsafe fn limitCrossCallPressure(
    live: &mut bitset::Bitset,
    spilled: &mut bitset::Bitset,
    costs: *unsafe [SpillCost],
    calleeClass: &mut bitset::Bitset,
    live: &mut [u32],
    spilled: &mut [u32],
    costs: &[SpillCost],
    calleeClass: &mut [u32],
    numCalleeSaved: u32,
    callDst: ?il::Reg
) throws (alloc::AllocError) {
    // Collect crossing candidates: live values excluding the call destination.
    let mut candidates: [CostEntry; 256] = undefined;
    let mut candidates: [CostEntry; MAX_CANDIDATES] = undefined;
    let mut numCandidates: u32 = 0;
    let mut it = bitset::iter(live);
    while let n = bitset::iterNext(&mut it) {
    while let n = bitset::iterNext(&mut it, live) {
        if not isCallDst(callDst, n) and n < costs.len {
            if numCandidates == MAX_CANDIDATES { throw alloc::AllocError::OutOfMemory; }
            if numCandidates == MAX_CANDIDATES {
                throw alloc::AllocError::OutOfMemory;
            }
            set candidates[numCandidates] = CostEntry {
                reg: n,
                cost: costs[n].defs + costs[n].uses,
            };
            set numCandidates += 1;

        let mut c = Candidates { entries: candidates, n: numCandidates };
        spillCheapest(&mut c, numCandidates - numCalleeSaved, live, spilled);
    }
    // Mark crossing values that remain after spilling as callee-saved class.
    let mut it2 = bitset::iter(live);
    while let n = bitset::iterNext(&mut it2) {
    while let n = bitset::iterNext(&mut it2, live) {
        if not isCallDst(callDst, n) {
            bitset::put(calleeClass, n);
        }
    }
}

/// Callback for [`il::forEachReg`]: increments use count for register.
unsafe fn countRegUseCallback(reg: il::Reg, ctxPtr: &mut opaque) {
    let weight = (ctxPtr as &mut CountCtx).weight;
    countRegUse(reg, &mut (ctxPtr as &mut CountCtx).costs[..], weight);
}

/// Add the block weight to the register use count.
fn countRegUse(reg: il::Reg, costs: &mut [SpillCost], weight: u32) {
    assert reg.n < costs.len, "countRegUseCallback: register out of bounds";
    assert reg.n < costs.len, "countRegUse: register out of bounds";
    set costs[reg.n].uses += weight;
}

/// Callback for [`il::forEachReg`]: adds register to live set.
unsafe fn addRegToSetCallback(reg: il::Reg, ctx: &mut opaque) {
    bitset::put(ctx as &mut bitset::Bitset, reg.n);
}

/// Check if a register is spilled.
export fn isSpilled(info: &SpillInfo, reg: il::Reg) -> bool {
export fn isSpilled 'scratch (info: &SpillInfo 'scratch, reg: il::Reg) -> bool {
    if reg.n >= info.maxReg {
        return false;
    }
    return info.slots[reg.n] >= 0;
}

/// Get spill slot offset for a register, or `nil` if not spilled.
export fn spillSlot(info: &SpillInfo, reg: il::Reg) -> ?i32 {
export fn spillSlot 'scratch (info: &SpillInfo 'scratch, reg: il::Reg) -> ?i32 {
    if isSpilled(info, reg) {
        return info.slots[reg.n];
    }
    return nil;
}

lib/std/lang/il.rad +170 -69

// TODO: Labels should have their own type.
// TODO: Blocks should have an instruction in `Instr`.

export mod printer;
export mod binary;
@test mod tests;

use std::mem;
use std::lang::alloc;

/// Source location for debug info.

    /// Environment break: `ebreak;`.
    /// Triggers a breakpoint exception for debugging.
    Ebreak,
    /// Full acquire/release memory fence.
    MemoryFence,
    /// Read one register through a live Device handle.
    DeviceRead {
        /// Register access width.
        typ: Type,
        /// Destination for the zero-extended register value.
        dst: Reg,
        /// Domain-relative Device capability.
        handle: Val,
        /// Byte offset within the device region.
        offset: Val,
    },
    /// Write one register through a live Device handle.
    DeviceWrite {
        /// Register access width.
        typ: Type,
        /// Domain-relative Device capability.
        handle: Val,
        /// Byte offset within the device region.
        offset: Val,
        /// Value whose low bits are written at the selected width.
        value: Val,
    },
}

//////////////////////////
// Blocks and Functions //
//////////////////////////


///////////////////////
// Utility Functions //
///////////////////////

/// Compiler-generated metadata call for one MMIO access.
/// a0 is the handle, a1 the offset, and a2 the byte width plus bit 8 for a write.
/// a3 holds a write value and is preserved. Success returns the address in a0.
/// Any failure terminates the caller before the user-mode register access.
export constant DEVICE_ACCESS: u32 = 74;

/// Get the destination register of an instruction, if any.
export fn instrDst(instr: Instr) -> ?Reg {
    match instr {
        case Instr::Reserve { dst, .. } => return dst,
        case Instr::Load { dst, .. } => return dst,

        case Instr::UnOp { dst, .. } => return dst,
        case Instr::Zext { dst, .. } => return dst,
        case Instr::Sext { dst, .. } => return dst,
        case Instr::Call { dst, .. } => return dst,
        case Instr::Ecall { dst, .. } => return dst,
        case Instr::DeviceRead { dst, .. } => return dst,
        else => return nil,
    }
}

/// Check if an instruction is a function call.
export fn isCall(instr: Instr) -> bool {
    match instr {
        case Instr::Call { .. },
             Instr::Ecall { .. } => return true,
             Instr::Ecall { .. }, Instr::DeviceRead { .. }, Instr::DeviceWrite { .. } => return true,
        else => return false,
    }
}

/// Call a function for each register used by an instruction.
/// This is called by the register allocator to analyze register usage.
export unsafe fn forEachReg(instr: Instr, f: unsafe fn(Reg, &mut opaque), ctx: &mut opaque) {
    match instr {
        case Instr::Reserve { size, .. } =>
            withReg(size, f, ctx),
        case Instr::Load { src, .. } => f(src, ctx),
        case Instr::Sload { src, .. } => f(src, ctx),
/// Position within an instruction's source operands.
export record RegCursor: Copy {
    /// Registers in the instruction's fixed operands, in operand order.
    fixed: [Reg; 5],
    /// Number of initialized fixed registers.
    count: u32,
    /// Next fixed register.
    next: u32,
    /// Next argument in the current argument group.
    argument: u32,
    /// Argument group: zero for the first group, then one per switch case.
    branch: u32,
    /// Whether the instruction has variable argument groups left to scan.
    arguments: bool,
}

/// Start a source-register scan in instruction operand order.
export unsafe fn registers(instr: &Instr) -> RegCursor {
    let mut cursor = RegCursor { fixed: undefined, count: 0, next: 0, argument: 0, branch: 0, arguments: false };
    match *instr {
        case Instr::Reserve { size, .. } => addOperand(&mut cursor, size),
        case Instr::Load { src, .. } => addOperand(&mut cursor, Val::Reg(src)),
        case Instr::Sload { src, .. } => addOperand(&mut cursor, Val::Reg(src)),
        case Instr::Store { src, dst, .. } => {
            withReg(src, f, ctx);
            f(dst, ctx);
        },
            addOperand(&mut cursor, src);
            addOperand(&mut cursor, Val::Reg(dst));
        }
        case Instr::Blit { dst, src, size } => {
            f(dst, ctx);
            f(src, ctx);
            withReg(size, f, ctx);
        },
        case Instr::Copy { val, .. } =>
            withReg(val, f, ctx),
            addOperand(&mut cursor, Val::Reg(dst));
            addOperand(&mut cursor, Val::Reg(src));
            addOperand(&mut cursor, size);
        }
        case Instr::Copy { val, .. } => addOperand(&mut cursor, val),
        case Instr::BinOp { a, b, .. } => {
            withReg(a, f, ctx);
            withReg(b, f, ctx);
        },
        case Instr::UnOp { a, .. } =>
            withReg(a, f, ctx),
        case Instr::Zext { val, .. } =>
            withReg(val, f, ctx),
        case Instr::Sext { val, .. } =>
            withReg(val, f, ctx),
        case Instr::Call { func, args, .. } => {
            withReg(func, f, ctx);
            for arg in args {
                withReg(arg, f, ctx);
            }
        },
            addOperand(&mut cursor, a);
            addOperand(&mut cursor, b);
        }
        case Instr::UnOp { a, .. } => addOperand(&mut cursor, a),
        case Instr::Zext { val, .. } => addOperand(&mut cursor, val),
        case Instr::Sext { val, .. } => addOperand(&mut cursor, val),
        case Instr::Call { func, .. } => {
            addOperand(&mut cursor, func);
            set cursor.arguments = true;
        }
        case Instr::Ret { val } => {
            if let v = val {
                withReg(v, f, ctx);
            if let value = val {
                addOperand(&mut cursor, value);
            }
        }
        case Instr::Jmp { .. } => set cursor.arguments = true,
        case Instr::Br { a, b, .. } => {
            addOperand(&mut cursor, a);
            addOperand(&mut cursor, b);
            set cursor.arguments = true;
        }
        case Instr::Switch { val, .. } => {
            addOperand(&mut cursor, val);
            set cursor.arguments = true;
        }
        case Instr::Ecall { num, a0, a1, a2, a3, .. } => {
            addOperand(&mut cursor, num);
            addOperand(&mut cursor, a0);
            addOperand(&mut cursor, a1);
            addOperand(&mut cursor, a2);
            addOperand(&mut cursor, a3);
        }
        case Instr::DeviceRead { handle, offset, .. } => {
            addOperand(&mut cursor, handle);
            addOperand(&mut cursor, offset);
        }
        case Instr::DeviceWrite { handle, offset, value, .. } => {
            addOperand(&mut cursor, handle);
            addOperand(&mut cursor, offset);
            addOperand(&mut cursor, value);
        }
        case Instr::Unreachable, Instr::Ebreak, Instr::MemoryFence => {
        }
    }
    return cursor;
}

/// Append a fixed register operand to the cursor.
fn addOperand(cursor: &mut RegCursor, value: Val) {
    if let case Val::Reg(reg) = value {
        set cursor.fixed[cursor.count] = reg;
        set cursor.count += 1;
    }
}

/// Return the next source register, including repeated uses.
/// Supply the unchanged instruction for every step of a scan.
export unsafe fn nextReg(cursor: &mut RegCursor, instr: &Instr) -> ?Reg {
    if cursor.next < cursor.count {
        let reg = cursor.fixed[cursor.next];
        set cursor.next += 1;
        return reg;
    }
    if not cursor.arguments {
        return nil;
    }
    match *instr {
        case Instr::Call { args, .. } => {
            if let reg = nextArgument(cursor, args) {
                return reg;
            }
        },
        }
        case Instr::Jmp { args, .. } => {
            for arg in args {
                withReg(arg, f, ctx);
            if let reg = nextArgument(cursor, args) {
                return reg;
            }
        },
        case Instr::Br { a, b, thenArgs, elseArgs, .. } => {
            withReg(a, f, ctx);
            withReg(b, f, ctx);
            for arg in thenArgs {
                withReg(arg, f, ctx);
        }
        case Instr::Br { thenArgs, elseArgs, .. } => {
            if cursor.branch == 0 {
                if let reg = nextArgument(cursor, thenArgs) {
                    return reg;
                }
                set cursor.branch = 1;
                set cursor.argument = 0;
            }
            for arg in elseArgs {
                withReg(arg, f, ctx);
            if let reg = nextArgument(cursor, elseArgs) {
                return reg;
            }
        },
        case Instr::Switch { val, defaultArgs, cases, .. } => {
            withReg(val, f, ctx);
            for arg in defaultArgs {
                withReg(arg, f, ctx);
        }
        case Instr::Switch { defaultArgs, cases, .. } => {
            if cursor.branch == 0 {
                if let reg = nextArgument(cursor, defaultArgs) {
                    return reg;
                }
                set cursor.branch = 1;
                set cursor.argument = 0;
            }
            for c in cases {
                for arg in c.args {
                    withReg(arg, f, ctx);
            while cursor.branch - 1 < cases.len {
                if let reg = nextArgument(cursor, cases[cursor.branch - 1].args) {
                    return reg;
                }
                set cursor.branch += 1;
                set cursor.argument = 0;
            }
        },
        case Instr::Ecall { num, a0, a1, a2, a3, .. } => {
            withReg(num, f, ctx);
            withReg(a0, f, ctx);
            withReg(a1, f, ctx);
            withReg(a2, f, ctx);
            withReg(a3, f, ctx);
        },
        case Instr::Unreachable,
             Instr::Ebreak,
             Instr::MemoryFence => {},
        }
        else => panic "nextReg: expected instruction argument groups",
    }
    set cursor.arguments = false;
    return nil;
}

/// Call callback if value is a register.
unsafe fn withReg(val: Val, callback: unsafe fn(Reg, &mut opaque), ctx: &mut opaque) {
    if let case Val::Reg(r) = val {
        callback(r, ctx);
/// Scan an argument group from the cursor's current position.
unsafe fn nextArgument(cursor: &mut RegCursor, args: *unsafe [Val]) -> ?Reg {
    while cursor.argument < args.len {
        let value = args[cursor.argument];
        set cursor.argument += 1;
        if let case Val::Reg(reg) = value {
            return reg;
        }
    }
    return nil;
}

lib/std/lang/il/binary.rad +4 -0

export constant INSTR_ECALL: u8 = 16;
/// Wire tag for instruction Ebreak.
export constant INSTR_EBREAK: u8 = 17;
/// Wire tag for instruction MemoryFence.
export constant INSTR_MEMORYFENCE: u8 = 18;
/// Wire tag for a checked device read.
export constant INSTR_DEVICE_READ: u8 = 19;
/// Wire tag for a checked device write.
export constant INSTR_DEVICE_WRITE: u8 = 20;

/// Wire tag for data Val.
export constant DATA_VAL: u8 = 0;
/// Wire tag for data Sym.
export constant DATA_SYM: u8 = 1;

lib/std/lang/il/binary/collect.rad +12 -3

/// Collect names referenced by one IL value.
unsafe fn value(names: &mut Names, owner: *[u8], item: il::Val) throws (binary::Error) {
    match item {
        case il::Val::DataSym(name) => try reference(names, owner, name),
        case il::Val::FnAddr(name) => try reference(names, owner, name),
        else => {},
        else => {
        },
    }
}

/// Collect names from an instruction's variable-length operand sequence.
unsafe fn values(names: &mut Names, owner: *[u8], items: &[il::Val]) throws (binary::Error) {

            try value(names, owner, a0);
            try value(names, owner, a1);
            try value(names, owner, a2);
            try value(names, owner, a3);
        },
        case il::Instr::DeviceRead { handle, offset, .. } => {
            try value(names, owner, handle); try value(names, owner, offset);
        },
        case il::Instr::DeviceWrite { handle, offset, value: source, .. } => {
            try value(names, owner, handle); try value(names, owner, offset); try value(names, owner, source);
        },
        case il::Instr::Load { .. }, il::Instr::Sload { .. }, il::Instr::Unreachable,
             il::Instr::Ebreak, il::Instr::MemoryFence => {},
             il::Instr::Ebreak, il::Instr::MemoryFence => {
             },
    }
}

/// Check that a definition belongs to the selected package.
unsafe fn definition(names: &mut Names, owner: *[u8], name: *[u8]) throws (binary::Error) {

        try definition(names, owner, item.name);
        for data in item.values {
            match data.item {
                case il::DataItem::Sym(name) => try reference(names, owner, name),
                case il::DataItem::Fn(name) => try reference(names, owner, name),
                else => {},
                else => {
                },
            }
        }
    }
    for func in program.fns {
        try definition(names, owner, func.name);

lib/std/lang/il/binary/decodeTests.rad +3 -1


/// Copy data fixtures into stable storage for the package descriptor.
unsafe fn retainData(items: &[il::Data]) -> *[il::Data] {
    unsafe static DATA: [il::Data; 2] = undefined;
    assert items.len <= DATA.len;
    for item, i in items { set DATA[i] = item; }
    for item, i in items {
        set DATA[i] = item;
    }
    return &DATA[..items.len];
}

lib/std/lang/il/binary/program.rad +12 -4

        let mut extent: u64 = 0;
        for j in 0..count {
            let value = try reader::dataValue(input);
            let mut width: u32 = 0;
            match value.item {
                case il::DataItem::Val { typ, .. } => { set width = il::typeSize(typ); },
                case il::DataItem::Sym(_), il::DataItem::Fn(_) => { set width = 8; },
                case il::DataItem::Str(text) => { set width = text.len; },
                case il::DataItem::Undef => { set width = 1; },
                case il::DataItem::Val { typ, .. } => {
                    set width = il::typeSize(typ);
                },
                case il::DataItem::Sym(_), il::DataItem::Fn(_) => {
                    set width = 8;
                },
                case il::DataItem::Str(text) => {
                    set width = text.len;
                },
                case il::DataItem::Undef => {
                    set width = 1;
                },
            }
            set extent += width as u64 * value.count as u64;
            if extent > size as u64 {
                throw binary::Error::Invalid;
            }

lib/std/lang/il/binary/reader.rad +23 -4

            let va1 = try val(input);
            let va2 = try val(input);
            let va3 = try val(input);
            return il::Instr::Ecall { dst: vdst, num: vnum, a0: va0, a1: va1, a2: va2, a3: va3 };
        },
        case super::INSTR_DEVICE_READ => {
            let t = try typ(input);
            let dst = try reg(input);
            let handle = try val(input); let offset = try val(input);
            return il::Instr::DeviceRead { typ: t, dst, handle, offset };
        },
        case super::INSTR_DEVICE_WRITE => {
            let t = try typ(input);
            let handle = try val(input); let offset = try val(input); let value = try val(input);
            return il::Instr::DeviceWrite { typ: t, handle, offset, value };
        },
        case super::INSTR_EBREAK => {
            return il::Instr::Ebreak;
        },
        case super::INSTR_MEMORYFENCE => {
            return il::Instr::MemoryFence;

        case super::DATA_VAL => {
            let t = try typ(input);
            let n = try integer(input, il::typeSize(t));
            set item = il::DataItem::Val { typ: t, val: n as i64 };
        },
        case super::DATA_SYM => { set item = il::DataItem::Sym(try symbol(input)); },
        case super::DATA_FN => { set item = il::DataItem::Fn(try symbol(input)); },
        case super::DATA_STR => { set item = il::DataItem::Str(try bytes(input)); },
        case super::DATA_UNDEF => { set item = il::DataItem::Undef; },
        case super::DATA_SYM => {
            set item = il::DataItem::Sym(try symbol(input));
        },
        case super::DATA_FN => {
            set item = il::DataItem::Fn(try symbol(input));
        },
        case super::DATA_STR => {
            set item = il::DataItem::Str(try bytes(input));
        },
        case super::DATA_UNDEF => {
            set item = il::DataItem::Undef;
        },
        else => throw binary::Error::Invalid,
    }
    let n = try integer(input, 4) as u32;
    return il::DataValue { item, count: n };
}

lib/std/lang/il/binary/tests.rad +78 -22


/// Check little-endian encoding for every integer width.
@test unsafe fn integers() throws (testing::TestError) {
    let mut buffer: [u8; 15] = [0; 15];
    let mut out = writer::new(&mut buffer[..], &[]);
    try writer::integer(&mut out, 0x12, 1) catch { throw testing::TestError::Failed; };
    try writer::integer(&mut out, 0x3456, 2) catch { throw testing::TestError::Failed; };
    try writer::integer(&mut out, 0x789abcde, 4) catch { throw testing::TestError::Failed; };
    try writer::integer(&mut out, 0x0123456789abcdef, 8) catch { throw testing::TestError::Failed; };
    try writer::integer(&mut out, 0x12, 1) catch {
        throw testing::TestError::Failed;
    };
    try writer::integer(&mut out, 0x3456, 2) catch {
        throw testing::TestError::Failed;
    };
    try writer::integer(&mut out, 0x789abcde, 4) catch {
        throw testing::TestError::Failed;
    };
    try writer::integer(&mut out, 0x0123456789abcdef, 8) catch {
        throw testing::TestError::Failed;
    };
    try testing::expectBytesEq(&buffer[..], &[0x12, 0x56, 0x34, 0xde, 0xbc, 0x9a, 0x78, 0xef, 0xcd,
        0xab, 0x89, 0x67, 0x45, 0x23, 0x01]);
}

/// Compare one instruction with its fixed wire representation.
unsafe fn instruction(item: il::Instr, expected: &[u8]) throws (testing::TestError) {
    let mut buffer: [u8; 256] = [0; 256];
    let mut out = writer::new(&mut buffer[..], &["data", "fn"]);
    try writer::instr(&mut out, item) catch { throw testing::TestError::Failed; };
    try writer::instr(&mut out, item) catch {
        throw testing::TestError::Failed;
    };
    try testing::expectBytesEq(&buffer[..out.offset], expected);
    for capacity in 0..expected.len {
        let mut short = writer::new(&mut buffer[..capacity], &["data", "fn"]);
        let mut failed = false;
        try writer::instr(&mut short, item) catch err {

    let memory = &mut MEMORY[..512];
    let mut arena = alloc::new(&mut memory[..]);
    let mut input = reader::new(expected, &mut arena, &["data", "fn"]);
    set input.registers = 16;
    set input.blocks = 4;
    let decoded = try reader::instr(&mut input) catch { throw testing::TestError::Failed; };
    let decoded = try reader::instr(&mut input) catch {
        throw testing::TestError::Failed;
    };
    try testing::expect(input.offset == expected.len);
    set out.offset = 0;
    try writer::instr(&mut out, decoded) catch { throw testing::TestError::Failed; };
    try writer::instr(&mut out, decoded) catch {
        throw testing::TestError::Failed;
    };
    try testing::expectBytesEq(&buffer[..out.offset], expected);
    for length in 0..expected.len {
        alloc::reset(&mut arena);
        set input = reader::new(&expected[..length], &mut arena, &["data", "fn"]);
        set input.registers = 16;

        dst: il::Reg { n: 1 }, num: il::Val::Undef, a0: il::Val::Undef, a1: il::Val::Undef,
        a2: il::Val::Undef, a3: il::Val::Undef,
    }, &[16, 1, 0, 0, 0, 4, 4, 4, 4, 4]);
    try instruction(il::Instr::Ebreak, &[17]);
    try instruction(il::Instr::MemoryFence, &[18]);
    for typ in [il::Type::W8, il::Type::W16, il::Type::W32, il::Type::W64] {
        let mut read: [u8; 8] = [19, 0, 1, 0, 0, 0, 4, 4];
        let mut write: [u8; 5] = [20, 0, 4, 4, 4];
        set read[1] = il::typeSize(typ) as u8;
        set write[1] = il::typeSize(typ) as u8;
        try instruction(il::Instr::DeviceRead {
            typ, dst: il::Reg { n: 1 }, handle: il::Val::Undef, offset: il::Val::Undef,
        }, &read[..]);
        try instruction(il::Instr::DeviceWrite {
            typ, handle: il::Val::Undef, offset: il::Val::Undef, value: il::Val::Undef,
        }, &write[..]);
    }
}

/// Check every value tag and empty and nonempty sequences.
@test unsafe fn values() throws (testing::TestError) {
    let mut buffer: [u8; 64] = [0; 64];
    let mut out = writer::new(&mut buffer[..], &["data", "fn"]);
    try writer::values(&mut out, &[]) catch { throw testing::TestError::Failed; };
    try writer::values(&mut out, &[]) catch {
        throw testing::TestError::Failed;
    };
    try writer::values(&mut out, &[
        il::Val::Reg(il::Reg { n: 0x12345678 }),
        il::Val::Imm(-2), il::Val::DataSym("data"),
        il::Val::FnAddr("fn"), il::Val::Undef,
    ]) catch { throw testing::TestError::Failed; };
    ]) catch {
        throw testing::TestError::Failed;
    };
    try testing::expectBytesEq(&buffer[..out.offset], &[
        0, 0, 0, 0, 5, 0, 0, 0,
        0, 0x78, 0x56, 0x34, 0x12,
        1, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        2, 0, 0, 0, 0, 3, 1, 0, 0, 0, 4,
    ]);
    let memory = &mut MEMORY[..256];
    let mut arena = alloc::new(&mut memory[..]);
    let mut input = reader::new(&buffer[..out.offset], &mut arena, &["data", "fn"]);
    set input.registers = 0x12345679;
    let empty = try reader::values(&mut input) catch { throw testing::TestError::Failed; };
    let decoded = try reader::values(&mut input) catch { throw testing::TestError::Failed; };
    let empty = try reader::values(&mut input) catch {
        throw testing::TestError::Failed;
    };
    let decoded = try reader::values(&mut input) catch {
        throw testing::TestError::Failed;
    };
    try testing::expect(empty.len == 0);
    try testing::expect(decoded.len == 5);
    try testing::expect(input.offset == out.offset);
    let mut repeated: [u8; 64] = [0; 64];
    let mut copy = writer::new(&mut repeated[..], &["data", "fn"]);
    try writer::values(&mut copy, empty) catch { throw testing::TestError::Failed; };
    try writer::values(&mut copy, decoded) catch { throw testing::TestError::Failed; };
    try writer::values(&mut copy, empty) catch {
        throw testing::TestError::Failed;
    };
    try writer::values(&mut copy, decoded) catch {
        throw testing::TestError::Failed;
    };
    try testing::expectBytesEq(&buffer[..out.offset], &repeated[..copy.offset]);

}

/// Check initializer bytes and repetition counts.
@test unsafe fn initializers() throws (testing::TestError) {
    let mut buffer: [u8; 128] = [0; 128];
    let mut out = writer::new(&mut buffer[..], &["data", "fn"]);
    try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Val { typ: il::Type::W8,
        val: -1 }, count: 0 }) catch { throw testing::TestError::Failed; };
        val: -1 }, count: 0 }) catch {
            throw testing::TestError::Failed;
        };
    try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Val { typ: il::Type::W16,
        val: -2 }, count: 1 }) catch { throw testing::TestError::Failed; };
        val: -2 }, count: 1 }) catch {
            throw testing::TestError::Failed;
        };
    try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Val { typ: il::Type::W32,
        val: -3 }, count: 2 }) catch { throw testing::TestError::Failed; };
        val: -3 }, count: 2 }) catch {
            throw testing::TestError::Failed;
        };
    try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Val { typ: il::Type::W64,
        val: -4 }, count: 3 }) catch { throw testing::TestError::Failed; };
        val: -4 }, count: 3 }) catch {
            throw testing::TestError::Failed;
        };
    try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Sym("data"), count: 4 })
        catch { throw testing::TestError::Failed; };
        catch {
            throw testing::TestError::Failed;
        };
    try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Fn("fn"), count: 5 }) catch
        { throw testing::TestError::Failed; };
        {
            throw testing::TestError::Failed;
        };
    try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Str("ab"), count: 6 }) catch
        { throw testing::TestError::Failed; };
        {
            throw testing::TestError::Failed;
        };
    try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Str(""), count: 7 }) catch {
        throw testing::TestError::Failed; };
    try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Undef, count: 8 }) catch {
        throw testing::TestError::Failed; };
    try testing::expectBytesEq(&buffer[..out.offset], &[0, 1, 255, 0, 0, 0, 0, 0, 2, 254, 255, 1, 0,

    try writer::symbol(&mut out, "absent") catch err {
        try testing::expect(err == binary::Error::Symbol);
        set failures += 1;
    };
    try testing::expect(out.offset == 0);
    try writer::integer(&mut out, 0, 8) catch { throw testing::TestError::Failed; };
    try writer::integer(&mut out, 0, 8) catch {
        throw testing::TestError::Failed;
    };
    try writer::integer(&mut out, 1, 1) catch err {
        try testing::expect(err == binary::Error::Capacity);
        set failures += 1;
    };
    try testing::expect(failures == 3);

        };
        try testing::expect(failed);
        try testing::expect(out.offset <= capacity);
    }
    let mut out = writer::new(&mut buffer[..], &[]);
    try writer::bytes(&mut out, "abc") catch { throw testing::TestError::Failed; };
    try writer::bytes(&mut out, "abc") catch {
        throw testing::TestError::Failed;
    };
    try testing::expectBytesEq(&buffer[..], &[3, 0, 0, 0, 97, 98, 99]);
}

lib/std/lang/il/binary/writer.rad +11 -0

            try val(out, va0);
            try val(out, va1);
            try val(out, va2);
            try val(out, va3);
        },
        case il::Instr::DeviceRead { typ: t, dst, handle, offset } => {
            try integer(out, super::INSTR_DEVICE_READ as u64, 1);
            try typ(out, t);
            try integer(out, dst.n as u64, 4);
            try val(out, handle); try val(out, offset);
        },
        case il::Instr::DeviceWrite { typ: t, handle, offset, value } => {
            try integer(out, super::INSTR_DEVICE_WRITE as u64, 1);
            try typ(out, t);
            try val(out, handle); try val(out, offset); try val(out, value);
        },
        case il::Instr::Ebreak => {
            try integer(out, super::INSTR_EBREAK as u64, 1);
        },
        case il::Instr::MemoryFence => {
            try integer(out, super::INSTR_MEMORYFENCE as u64, 1);

lib/std/lang/il/printer.rad +8 -0

            write(out, " ");
            writeVal(out, a2);
            write(out, " ");
            writeVal(out, a3);
        }
        case super::Instr::DeviceRead { typ, dst, handle, offset } => {
            write(out, "device-read "); write(out, typeStr(typ)); write(out, " ");
            writeReg(out, dst); write(out, " "); writeVal(out, handle); write(out, " "); writeVal(out, offset);
        }
        case super::Instr::DeviceWrite { typ, handle, offset, value } => {
            write(out, "device-write "); write(out, typeStr(typ)); write(out, " ");
            writeVal(out, handle); write(out, " "); writeVal(out, offset); write(out, " "); writeVal(out, value);
        }
        case super::Instr::Ebreak => {
            write(out, "ebreak");
        }
        case super::Instr::MemoryFence => {
            write(out, "memory-fence");

lib/std/lang/il/tests.rad added +64 -0

1	+	//! Tests for RIL source register iteration.
2	+
3	+	use std::testing;
4	+
5	+	/// Require exact source-register order and stable exhaustion.
6	+	unsafe fn check(instr: super::Instr, expected: &[u32]) throws (testing::TestError) {
7	+	let mut cursor = super::registers(&instr);
8	+	for value in expected {
9	+	let reg = super::nextReg(&mut cursor, &instr) else panic;
10	+	try testing::expect(reg.n == value);
11	+	}
12	+	try testing::expect(super::nextReg(&mut cursor, &instr) == nil);
13	+	try testing::expect(super::nextReg(&mut cursor, &instr) == nil);
14	+	}
15	+
16	+	@test unsafe fn testRegisterIteration() throws (testing::TestError) {
17	+	let dst = super::Reg { n: 99 };
18	+	let r1 = super::Reg { n: 1 };
19	+	let r2 = super::Reg { n: 2 };
20	+	let a = super::Val::Reg(r1);
21	+	let b = super::Val::Reg(r2);
22	+	let imm = super::Val::Imm(7);
23	+	try check(super::Instr::Reserve { dst, size: a, alignment: 8 }, &[1]);
24	+	try check(super::Instr::Reserve { dst, size: imm, alignment: 8 }, &[]);
25	+	try check(super::Instr::Load { typ: super::Type::W64, dst, src: r1, offset: 0 }, &[1]);
26	+	try check(super::Instr::Sload { typ: super::Type::W32, dst, src: r2, offset: 0 }, &[2]);
27	+	try check(super::Instr::Store { typ: super::Type::W64, src: a, dst: r2, offset: 0 }, &[1, 2]);
28	+	try check(super::Instr::Store { typ: super::Type::W64, src: imm, dst: r2, offset: 0 }, &[2]);
29	+	try check(super::Instr::Blit { dst: r1, src: r2, size: a }, &[1, 2, 1]);
30	+	try check(super::Instr::Blit { dst: r1, src: r2, size: imm }, &[1, 2]);
31	+	try check(super::Instr::Copy { dst, val: a }, &[1]);
32	+	try check(super::Instr::Copy { dst, val: imm }, &[]);
33	+	try check(super::Instr::Copy { dst, val: super::Val::DataSym("data") }, &[]);
34	+	try check(super::Instr::Copy { dst, val: super::Val::Undef }, &[]);
35	+	try check(super::Instr::BinOp { op: super::BinOp::Add, typ: super::Type::W64, dst, a: imm, b }, &[2]);
36	+	try check(super::Instr::BinOp { op: super::BinOp::Add, typ: super::Type::W64, dst, a, b: a }, &[1, 1]);
37	+	try check(super::Instr::UnOp { op: super::UnOp::Neg, typ: super::Type::W64, dst, a }, &[1]);
38	+	try check(super::Instr::Zext { typ: super::Type::W8, dst, val: a }, &[1]);
39	+	try check(super::Instr::Sext { typ: super::Type::W8, dst, val: b }, &[2]);
40	+	let mut args = [imm, a, b, a];
41	+	try check(super::Instr::Call { retTy: super::Type::W64, dst, func: b, args: &args[..] }, &[2, 1, 2, 1]);
42	+	try check(super::Instr::Call { retTy: super::Type::W64, dst: nil, func: super::Val::FnAddr("callee"), args: &[] }, &[]);
43	+	try check(super::Instr::Ret { val: a }, &[1]);
44	+	try check(super::Instr::Ret { val: nil }, &[]);
45	+	try check(super::Instr::Jmp { target: 0, args: &mut args[..] }, &[1, 2, 1]);
46	+	let mut other = [b, imm];
47	+	try check(super::Instr::Br { op: super::CmpOp::Eq, typ: super::Type::W64, a, b,
48	+	thenTarget: 0, thenArgs: &mut args[..], elseTarget: 1, elseArgs: &mut other[..] }, &[1, 2, 1, 2, 1, 2]);
49	+	let mut cases = [
50	+	super::SwitchCase { value: 0, target: 0, args: &mut [] },
51	+	super::SwitchCase { value: 1, target: 1, args: &mut args[..] },
52	+	super::SwitchCase { value: 2, target: 2, args: &mut [] },
53	+	super::SwitchCase { value: 3, target: 3, args: &mut other[..] },
54	+	];
55	+	try check(super::Instr::Switch { val: b, defaultTarget: 0, defaultArgs: &mut [], cases: &mut cases[..] }, &[2, 1, 2, 1, 2]);
56	+	try check(super::Instr::Switch { val: imm, defaultTarget: 0, defaultArgs: &mut args[..], cases: &mut [] }, &[1, 2, 1]);
57	+	try check(super::Instr::Switch { val: imm, defaultTarget: 0, defaultArgs: &mut [], cases: &mut [] }, &[]);
58	+	try check(super::Instr::Ecall { dst, num: a, a0: imm, a1: b, a2: a, a3: imm }, &[1, 2, 1]);
59	+	try check(super::Instr::Ecall { dst, num: a, a0: b, a1: a, a2: b, a3: a }, &[1, 2, 1, 2, 1]);
60	+	try check(super::Instr::Unreachable, &[]);
61	+	try check(super::Instr::Ebreak, &[]);
62	+	try check(super::Instr::MemoryFence, &[]);
63	+
64	+	}

lib/std/lang/lower.rad +922 -628

    Normal,
    /// Program entry function marked with `@default`.
    Default,
}

/// Function sink used by lowerers that consume functions as they are produced.
export record FnSink: Copy {
    /// Opaque context. It must remain valid for every sink callback.
    ctx: *unsafe mut opaque,
    /// Callback invoked for each lowered function.
    emitFn: unsafe fn(*unsafe mut opaque, *unsafe il::Fn, FnRole),
}

/// Destination for functions produced by the lowerer.
export union FnOutput: Copy {
    /// Store lowered functions in the provided slice.
    Accumulate(*unsafe mut [*unsafe il::Fn]),
    /// Send lowered functions to an external consumer immediately.
    Stream(FnSink),
/// One function ready for a caller to consume before lowering continues.
export record LoweredFunction: Copy {
    /// Function allocated in the current function arena.
    function: *unsafe il::Fn,
    /// Entry-point role of the source declaration.
    role: FnRole,
}

/// Position within one module's declarations and instance methods.
export record ModuleCursor {
    /// Top-level declaration nodes in source order.
    declarations: *[*ast::Node],
    /// Next declaration to process.
    next: u32,
    /// Whether default functions in this module are program entry points.
    isRoot: bool,
    /// Instance whose methods are currently being lowered.
    instanceState: InstanceCursor,
    /// Whether the instance cursor contains an active declaration.
    instanceActive: bool,
}

/// Persistent v-table names and position within an instance declaration.
export record InstanceCursor: Copy {
    /// Trait whose method slots define the v-table.
    traitInfo: *unsafe resolver::TraitType,
    /// Trait source name.
    traitName: *[u8],
    /// Concrete type source name.
    typeName: *[u8],
    /// Method declarations in source order.
    methods: *[*ast::Node],
    /// Next method to process.
    next: u32,
    /// Persistent qualified function names, indexed by trait method slot.
    methodNames: [*[u8]; ast::MAX_TRAIT_METHODS],
    /// Slots initialized by concrete methods.
    methodNameSet: [bool; ast::MAX_TRAIT_METHODS],
}

/// Module-level lowering context. Shared across all function lowerings.
/// Holds global state like the data section (strings, constants) and provides
/// access to the resolver for type queries.
export record Lowerer {
export record Lowerer: 'arena + 'phase where 'arena: 'phase {
    /// Arena for persistent lowering state, including data and symbol names.
    arena: *unsafe mut alloc::Arena,
    /// Arena for allocations owned by the function currently being lowered.
    fnArena: *unsafe mut alloc::Arena,
    /// Allocator backed by the arena.
    allocator: alloc::Allocator,
    /// Resolver for type information. Used to query types, symbols, and
    /// compile-time constant values during lowering.
    resolver: *unsafe resolver::Resolver,
    resolver: &'phase resolver::Resolver 'arena,
    /// Module graph for cross-module symbol resolution.
    moduleGraph: ?*unsafe module::ModuleGraph,
    moduleGraph: ?&'phase module::ModuleGraph,
    /// Package name for qualified symbol names.
    pkgName: *[u8],
    /// Current module being lowered.
    currentMod: ?u16,
    /// Global data items (string literals, constants, static arrays).
    /// These become the data sections in the final binary.
    data: *mut [il::Data],
    /// Destination for lowered functions.
    output: FnOutput,
    /// Map of function symbols to qualified names.
    fnSyms: *mut [FnSymEntry],
    /// First data entry owned by the package currently being lowered.
    packageDataStart: u32,
    /// Functions retained for accumulated output.
    functions: *unsafe mut [*unsafe il::Fn],
    /// Function and data symbols with their emitted names.
    symbolNames: *mut [SymbolNameEntry],
    /// Global error type tag table. Maps nominal types to unique tags.
    errTags: *mut [ErrTagEntry],
    /// Next error tag to assign (starts at 1; 0 = success).
    errTagCounter: u32,
    /// Lowering options.
    options: LowerOptions,
}

/// Entry mapping a function symbol to its qualified name.
record FnSymEntry: Copy {
/// Entry mapping a function or data symbol to its emitted name.
record SymbolNameEntry: Copy {
    /// Stable resolver symbol identity.
    sym: *unsafe resolver::Symbol,
    /// Qualified name in the emitted program.
    qualName: *[u8],
}

/// Entry in the global error tag table.
record ErrTagEntry: Copy {

    return maxSize;
}

/// Get or assign a globally unique error tag for the given error type.
/// Tag `0` is reserved for success; error tags start at `1`.
fn getOrAssignErrorTag(self: &mut Lowerer, errType: resolver::Type) -> u32 {
unsafe fn getOrAssignErrorTag 'arena 'phase (self: &mut Lowerer 'arena 'phase, errType: resolver::Type) -> u32 where 'arena: 'phase {
    for entry in &self.errTags[..] {
        if entry.ty == errType {
        if resolver::erasedTypesEqual(entry.ty, errType) {
            return entry.tag;
        }
    }
    let tag = self.errTagCounter;

    set self.errTagCounter += 1;
    self.errTags.append(ErrTagEntry { ty: errType, tag }, self.allocator);
    self.errTags.append(ErrTagEntry { ty: errType, tag }, alloc::arenaAllocator(self.arena));

    return tag;
}

/// Emit one function to the active output.
unsafe fn emitFunction(self: &mut Lowerer, func: *unsafe il::Fn, role: FnRole) {
    match self.output {
        case FnOutput::Accumulate(accumulated) => {
            let mut fns = accumulated;
            fns.append(func, self.allocator);
            set self.output = FnOutput::Accumulate(fns);
        }
        case FnOutput::Stream(sink) => {
            sink.emitFn(sink.ctx, func, role);
        }
    }
/// Retain a lowered function for accumulated IL output.
unsafe fn emitFunction 'arena 'phase (self: &mut Lowerer 'arena 'phase, func: *unsafe il::Fn) where 'arena: 'phase {
    self.functions.append(func, alloc::arenaAllocator(self.arena));
}

/// Get the function role for a top-level function declaration.
fn lowerFnRole(isRoot: bool, attrs: ?ast::Attributes) -> FnRole {
    if isRoot and checkAttr(attrs, ast::Attribute::Default) {

// Function Lowering State //
/////////////////////////////

/// Per-function lowering state. Created fresh for each function and contains
/// all the mutable state needed during function body lowering.
record FnLowerer: Copy {
record FnLowerer: 'arena + 'phase + 'function where 'arena: 'phase, 'phase: 'function {
    /// Reference to the module-level lowerer.
    low: *unsafe mut Lowerer,
    /// Allocator for IL allocations.
    allocator: alloc::Allocator,
    low: &'function mut Lowerer 'arena 'phase,
    /// Arena for allocations owned by this function.
    arena: &'function mut alloc::Arena,
    /// Type signature of the function being lowered.
    fnType: *resolver::FnType,
    /// Number of SSA variable slots required for each block.
    localCount: u32,
    /// Function name, used as prefix for generated data symbols.

    /// Metadata (name, type, mutability) for each variable. Indexed by variable
    /// id. Doesn't change after declaration. For the SSA value of a variable in
    /// a specific block, see [`BlockData::vars`].
    vars: *unsafe mut [VarData],
    /// Parameter-to-variable bindings, initialized in the entry block.
    params: *unsafe mut [FnParamBinding],
    params: [FnParamBinding; resolver::MAX_FN_PARAMS],
    /// Number of initialized parameter bindings.
    paramsLen: u32,

    // ~ Basic block management ~ //

    /// Block storage array, indexed by block id.
    blockData: *unsafe mut [BlockData],

    /// The block currently receiving new instructions.
    currentBlock: ?BlockId,

    // ~ Loop management ~ //

    /// Stack of loop contexts for break/continue resolution.
    loopStack: *unsafe mut [LoopCtx],
    /// Loop contexts indexed by nesting depth.
    /// The active prefix contains `loopDepth` entries.
    loopStack: [LoopCtx; MAX_LOOP_DEPTH],
    /// Current nesting depth (index into loopStack).
    loopDepth: u32,

    // ~ Counters ~ //


/// 2. Iterates over top-level declarations, lowering each.
/// 3. Returns the complete IL program with functions and data section.
///
/// The resolver must have already processed the AST -- we rely on its type
/// annotations, symbol table, and constant evaluations.
export unsafe fn lower(
    res: &resolver::Resolver,
export unsafe fn lower 'arena (
    res: &resolver::Resolver 'arena,
    root: *ast::Node,
    pkgName: *[u8],
    arena: &mut alloc::Arena
) -> il::Program throws (LowerError) {
    let mut low = Lowerer {
        arena: (&mut *arena) as *unsafe mut alloc::Arena,
        fnArena: (&mut *arena) as *unsafe mut alloc::Arena,
        allocator: alloc::arenaAllocator(arena),
        resolver: res as *unsafe resolver::Resolver,
        moduleGraph: nil,
        pkgName,
        currentMod: nil,
        data: &mut [],
        output: FnOutput::Accumulate(&mut []),
        fnSyms: &mut [],
        errTags: &mut [],
        errTagCounter: 1,
        options: LowerOptions { debug: false, buildTest: false },
    };
    try lowerDecls(&mut low, root, true);
    let functionArena = (&mut *arena) as *unsafe mut alloc::Arena;
    let resolved: 'phase = &*res where 'arena: 'phase in {
        let mut low = Lowerer 'arena 'phase {
            arena: (&mut *arena) as *unsafe mut alloc::Arena,
            resolver: resolved,
            moduleGraph: nil,
            pkgName,
            currentMod: nil,
            data: &mut [],
            packageDataStart: 0,
            functions: &mut [],
            symbolNames: &mut [],
            errTags: &mut [],
            errTagCounter: 1,
            options: LowerOptions { debug: false, buildTest: false },
        };
        try lowerDecls(&mut low, root, true, functionArena);

    return finalize(low);
        return finalize(low);
    }
}

/////////////////////////////////
// Multi-Module Lowering API   //
/////////////////////////////////

/// Create a lowerer for multi-module compilation.
/// The resolver, graph, and both arenas must outlive the returned lowerer.
export unsafe fn lowerer(
    res: *unsafe resolver::Resolver,
    graph: &module::ModuleGraph,
/// The resolver, graph, and persistent arena must outlive the returned lowerer.
export unsafe fn lowerer 'arena 'phase (
    res: &'phase resolver::Resolver 'arena,
    graph: &'phase module::ModuleGraph,
    pkgName: *[u8],
    arena: *unsafe mut alloc::Arena,
    fnArena: *unsafe mut alloc::Arena,
    options: LowerOptions
) -> Lowerer {
    return Lowerer {
) -> Lowerer 'arena 'phase where 'arena: 'phase {
    return Lowerer 'arena 'phase {
        arena,
        fnArena,
        allocator: alloc::arenaAllocator(arena),
        resolver: res,
        moduleGraph: graph as *unsafe module::ModuleGraph,
        moduleGraph: graph,
        pkgName,
        currentMod: nil,
        data: &mut [],
        output: FnOutput::Accumulate(&mut []),
        fnSyms: &mut [],
        packageDataStart: 0,
        functions: &mut [],
        symbolNames: &mut [],
        errTags: &mut [],
        errTagCounter: 1,
        options,
    };
}

/// Lower a module's AST into the lowerer.
/// Call this for each module in the package, then use `finalize` to get the program.
export unsafe fn lowerModule(
    low: &mut Lowerer,
export unsafe fn lowerModule 'arena 'phase (
    low: &mut Lowerer 'arena 'phase,
    moduleId: u16,
    root: *ast::Node,
    isRoot: bool
) throws (LowerError) {
    isRoot: bool,
    functionArena: &mut alloc::Arena
) throws (LowerError) where 'arena: 'phase {
    set low.currentMod = moduleId;
    try lowerDecls(low, root, isRoot);
    try lowerDecls(low, root, isRoot, functionArena);
}

/// Lower all top-level declarations in a block.
unsafe fn lowerDecls(low: &mut Lowerer, root: *ast::Node, isRoot: bool) throws (LowerError) {
/// Start lowering the declarations of one module.
export unsafe fn moduleCursor(root: *ast::Node, isRoot: bool) -> ModuleCursor throws (LowerError) {
    let case ast::NodeValue::Block(block) = root.value else {
        throw LowerError::ExpectedBlock(root);
    };
    let stmtsList = block.statements;

    for node in stmtsList {
    return ModuleCursor { declarations: block.statements, next: 0, isRoot, instanceState: undefined, instanceActive: false };
}

/// Lower declarations until one function is ready or the module is complete.
/// The caller must finish using a function before reclaiming its arena storage.
export unsafe fn lowerNext 'arena 'phase (
    low: &mut Lowerer 'arena 'phase,
    cursor: &mut ModuleCursor,
    functionArena: &mut alloc::Arena
) -> ?LoweredFunction throws (LowerError) where 'arena: 'phase {
    loop {
        if cursor.instanceActive {
            if let function = try lowerNextInstance(low, &mut cursor.instanceState, functionArena) {
                return LoweredFunction { function, role: FnRole::Normal };
            }
            set cursor.instanceActive = false;
        }
        if cursor.next >= cursor.declarations.len {
            return nil;
        }
        let node = cursor.declarations[cursor.next];
        set cursor.next += 1;
        match node.value {
            case ast::NodeValue::FnDecl(decl) => {
                if let f = try lowerFnDecl(low, node, decl) {
                    let role = lowerFnRole(isRoot, decl.attrs);
                    emitFunction(low, f, role);
                if let function = try lowerFnDecl(low, node, decl, functionArena) {
                    return LoweredFunction { function, role: lowerFnRole(cursor.isRoot, decl.attrs) };
                }
            }
            case ast::NodeValue::ConstDecl(decl) => {
                try lowerDataDecl(low, node, decl.value, true);
            }
            case ast::NodeValue::StaticDecl(decl) => {
                try lowerDataDecl(low, node, decl.value, false);
            }
            case ast::NodeValue::InstanceDecl { traitName, targetType, methods } => {
                try lowerInstanceDecl(low, node, traitName, targetType, methods);
            case ast::NodeValue::ConstDecl(decl) =>
                try lowerDataDecl(low, node, decl.value, true),
            case ast::NodeValue::StaticDecl(decl) =>
                try lowerDataDecl(low, node, decl.value, false),
            case ast::NodeValue::InstanceDecl { traitName, targetType, methods, .. } => {
                set cursor.instanceState = try instanceCursor(low, traitName, targetType, methods);
                set cursor.instanceActive = true;
            }
            case ast::NodeValue::MethodDecl { name, receiverName, receiverType, sig, body, .. } => {
                if let f = try lowerMethodDecl(low, node, name, receiverName, sig, body) {
                    emitFunction(low, f, FnRole::Normal);
            case ast::NodeValue::MethodDecl { name, receiverName, sig, body, .. } => {
                if let function = try lowerMethodDecl(
                    low, node, name, receiverName, sig, body, functionArena
                ) {
                    return LoweredFunction { function, role: FnRole::Normal };
                }
            }
            else => {},
        }
    }
}

/// Lower all top-level declarations in a block.
unsafe fn lowerDecls 'arena 'phase (
    low: &mut Lowerer 'arena 'phase,
    root: *ast::Node,
    isRoot: bool,
    functionArena: &mut alloc::Arena
) throws (LowerError) where 'arena: 'phase {
    let mut cursor = try moduleCursor(root, isRoot);
    while let result = try lowerNext(low, &mut cursor, functionArena) {
        emitFunction(low, result.function);
    }
}

/// Consume the lowerer and publish its global data as an immutable array.
export fn finalize(low: Lowerer) -> il::Program {
    let case Lowerer { data, output, .. } = low
export fn finalize 'arena 'phase (low: Lowerer 'arena 'phase) -> il::Program where 'arena: 'phase {
    let case Lowerer 'arena 'phase { data, functions, .. } = low
        else panic "expected lowerer";
    match output {
        case FnOutput::Accumulate(accumulated) => {
            return il::Program {
                data,
                fns: accumulated,
            };
        }
        case FnOutput::Stream(_) => {
            panic "finalize: cannot finalize streaming lowerer";
        }
    }
    return il::Program { data, fns: functions };
}

/////////////////////////////////
// Qualified Name Construction //
/////////////////////////////////

/// Get module path segments for the current or specified module.
/// Returns empty slice if no module graph or module not found.
unsafe fn getModulePath(self: &mut Lowerer, modId: ?u16) -> *[*[u8]] {
unsafe fn getModulePath 'arena 'phase (self: &mut Lowerer 'arena 'phase, modId: ?u16) -> *[*[u8]] where 'arena: 'phase {
    let graph = self.moduleGraph else {
        return &[];
    };
    let mut id = modId;
    if id == nil {

    return module::moduleQualifiedPath(entry);
}

/// Build a qualified name string for a symbol.
/// If `modId` is nil, uses current module.
unsafe fn qualifyName(self: &mut Lowerer, modId: ?u16, name: *[u8]) -> *[u8] {
unsafe fn qualifyName 'arena 'phase (self: &mut Lowerer 'arena 'phase, modId: ?u16, name: *[u8]) -> *[u8] where 'arena: 'phase {
    let path = getModulePath(self, modId);
    if path.len == 0 {
        return name;
    }
    return il::formatQualifiedName(self.arena, path, name);
}

/// Register a function symbol with its qualified name.
/// Called when lowering function declarations, so cross-package calls can find
/// the function by name.
fn registerFnSym(self: &mut Lowerer, sym: *unsafe resolver::Symbol, qualName: *[u8]) {
    self.fnSyms.append(FnSymEntry { sym, qualName }, self.allocator);
/// Register the emitted name for a function or data symbol.
/// Calls and address expressions use this name across package boundaries.
unsafe fn registerSymbolName 'arena 'phase (self: &mut Lowerer 'arena 'phase, sym: *unsafe resolver::Symbol, qualName: *[u8]) where 'arena: 'phase {
    self.symbolNames.append(SymbolNameEntry { sym, qualName }, alloc::arenaAllocator(self.arena));
}

/// Look up a function's qualified name by its symbol.
/// Returns `nil` if the symbol wasn't registered (e.g. callee's module is not yet lowered).
/// Look up the emitted name for a function or data symbol.
/// Return `nil` if its declaration has not been lowered.
// TODO: This is kind of dubious as an optimization, if it depends on the order
// in which modules are lowered.
// TODO: Use a hash table here?
unsafe fn lookupFnSym(self: &Lowerer, sym: *unsafe resolver::Symbol) -> ?*[u8] {
    for entry in &self.fnSyms[..] {
unsafe fn lookupSymbolName 'arena 'phase (self: &Lowerer 'arena 'phase, sym: *unsafe resolver::Symbol) -> ?*[u8] where 'arena: 'phase {
    for entry in &self.symbolNames[..] {
        if entry.sym == sym {
            return entry.qualName;
        }
    }
    return nil;
}

/// Set the package context for lowering.
/// Called before lowering each package.
/// The graph must outlive later uses of the lowerer.
export unsafe fn setPackage(self: &mut Lowerer, graph: &module::ModuleGraph, pkgName: *[u8]) {
    set self.moduleGraph = graph as *unsafe module::ModuleGraph;
export unsafe fn setPackage 'arena 'phase (self: &mut Lowerer 'arena 'phase, pkgName: *[u8]) where 'arena: 'phase {
    set self.pkgName = pkgName;
    set self.currentMod = nil;
    set self.packageDataStart = self.data.len;
}

/// Create a new function lowerer for a given function type and name.
unsafe fn fnLowerer(
    self: &mut Lowerer,
unsafe fn fnLowerer 'arena 'phase 'function (
    self: &'function mut Lowerer 'arena 'phase,
    node: *ast::Node,
    fnType: *resolver::FnType,
    qualName: *[u8]
) -> FnLowerer {
    let loopStack = try! alloc::allocRawSlice(self.fnArena, @sizeOf(LoopCtx), @alignOf(LoopCtx), MAX_LOOP_DEPTH) as *unsafe mut [LoopCtx];

    let mut fnLow = FnLowerer {
        low: (&mut *self) as *unsafe mut Lowerer,
        allocator: alloc::arenaAllocator(self.fnArena),
        fnType: fnType,
        localCount: resolver::nodeData(self.resolver, node).localCount,
    qualName: *[u8],
    functionArena: &'function mut alloc::Arena
) -> FnLowerer 'arena 'phase 'function where 'arena: 'phase, 'phase: 'function {
    let localCount = resolver::nodeData(self.resolver, node).localCount;
    let mut fnLow = FnLowerer 'arena 'phase 'function {
        low: self,
        arena: functionArena,
        fnType,
        localCount,
        fnName: qualName,
        vars: &mut [],
        params: &mut [],
        params: [FnParamBinding { var: Var(0), reg: il::Reg { n: 0 } }; resolver::MAX_FN_PARAMS],
        paramsLen: 0,
        blockData: &mut [],
        entryBlock: nil,
        currentBlock: nil,
        loopStack,
        loopStack: [LoopCtx { breakTarget: BlockId(0), continueTarget: nil }; MAX_LOOP_DEPTH],
        loopDepth: 0,
        labelCounter: 0,
        dataCounter: 0,
        regCounter: 0,
        returnReg: nil,
        isLeaf: true,
        srcLoc: undefined,
    };
    if self.options.debug {
        let modId = self.currentMod else {
    if fnLow.low.options.debug {
        let modId = fnLow.low.currentMod else {
            panic "fnLowerer: debug enabled but no current module";
        };
        set fnLow.srcLoc = il::SrcLoc {
            moduleId: modId,
            offset: node.span.offset,

/// This sets up the per-function lowering state, processes parameters,
/// then lowers the function body into a CFG of basic blocks.
///
/// For throwing functions, the return type is a result aggregate
/// rather than the declared return type.
unsafe fn lowerFnDecl(self: &mut Lowerer, node: *ast::Node, decl: ast::FnDecl) -> ?*unsafe il::Fn throws (LowerError) {
unsafe fn lowerFnDecl 'arena 'phase (
    self: &mut Lowerer 'arena 'phase,
    node: *ast::Node,
    decl: ast::FnDecl,
    functionArena: &mut alloc::Arena
) -> ?*unsafe il::Fn throws (LowerError) where 'arena: 'phase {
    if not shouldLowerFn(&decl, self.options.buildTest) {
        return nil;
    }
    let case ast::NodeValue::Ident(name) = decl.name.value else {
        throw LowerError::ExpectedIdentifier;

    // Build qualified function name for multi-module compilation.
    let qualName = qualifyName(self, nil, name);

    // Register function symbol for cross-package call resolution.
    if let sym = data.sym {
        registerFnSym(self, sym, qualName);
    }
    let mut fnLow = fnLowerer(self, node, fnType, qualName);

    // If the function returns an aggregate or is throwing, prepend a hidden
    // return parameter. The caller allocates the buffer and passes it
    // as the first argument; the callee writes the return value into it.
    if requiresReturnParam(fnType) and not isExtern {
        set fnLow.returnReg = nextReg(&mut fnLow);
    }
    let lowParams = try lowerParams(&mut fnLow, *fnType, decl.sig.params, nil);
    let func = try! alloc::allocRaw(self.fnArena, @sizeOf(il::Fn), @alignOf(il::Fn)) as *unsafe mut il::Fn;
        registerSymbolName(self, sym, qualName);
    }
    let parent: 'function = &mut *self, arena = &mut *functionArena where 'phase: 'function in {
        let mut fnLow = fnLowerer(parent, node, fnType, qualName, arena);

        // If the function returns an aggregate or is throwing, prepend a hidden
        // return parameter. The caller allocates the buffer and passes it
        // as the first argument; the callee writes the return value into it.
        if requiresReturnParam(fnType) and not isExtern {
            set fnLow.returnReg = nextReg(&mut fnLow);
        }
        let lowParams = try lowerParams(&mut fnLow, *fnType, decl.sig.params, nil);
        let func = try! alloc::allocRaw(fnLow.arena, @sizeOf(il::Fn), @alignOf(il::Fn)) as *unsafe mut il::Fn;

        // Throwing functions return a result aggregate (word-sized pointer).
        // TODO: The resolver should set an appropriate type that takes into account
        //       the throws list. It shouldn't set the return type to the "success"
        //       value only.
        let returnType = il::Type::W64 if fnType.throwList.len > 0
            else ilType(fnLow.low, *fnType.returnType);
        set *func = il::Fn {
            name: qualName,
            params: lowParams,
            returnType,
            isExtern,
            isLeaf: true,
            blocks: &[],
        };
        let body = decl.body else {
            // Extern functions have no body.
            assert isExtern;
            return func;
        };
        set func.blocks = try lowerFnBody(&mut fnLow, body);
        set func.isLeaf = fnLow.isLeaf;

    set *func = il::Fn {
        name: qualName,
        params: lowParams,
        returnType: undefined,
        isExtern,
        isLeaf: true,
        blocks: &[],
    };
    // Throwing functions return a result aggregate (word-sized pointer).
    // TODO: The resolver should set an appropriate type that takes into account
    //       the throws list. It shouldn't set the return type to the "success"
    //       value only.
    if fnType.throwList.len > 0 {
        set func.returnType = il::Type::W64;
    } else {
        set func.returnType = ilType(self, *fnType.returnType);
    }
    let body = decl.body else {
        // Extern functions have no body.
        assert isExtern;
        return func;
    };
    set func.blocks = try lowerFnBody(&mut fnLow, body);
    set func.isLeaf = fnLow.isLeaf;

    return func;
    }
}

/// Build a qualified name of the form "Type::method".
unsafe fn instanceMethodName(self: &mut Lowerer, modId: ?u16, typeName: *[u8], methodName: *[u8]) -> *[u8] {
unsafe fn instanceMethodName 'arena 'phase (self: &mut Lowerer 'arena 'phase, modId: ?u16, typeName: *[u8], methodName: *[u8]) -> *[u8] where 'arena: 'phase {
    let sepLen: u32 = 2; // "::"
    let totalLen = typeName.len + sepLen + methodName.len;
    let buf = try! alloc::allocSlice(self.arena, 1, 1, totalLen) as *mut [u8];
    let mut pos: u32 = 0;



    return qualifyName(self, modId, &buf[..totalLen]);
}

/// Build a v-table data name of the form "vtable::Type::Trait".
unsafe fn vtableName(self: &mut Lowerer, modId: ?u16, typeName: *[u8], traitName: *[u8]) -> *[u8] {
unsafe fn vtableName 'arena 'phase (self: &mut Lowerer 'arena 'phase, modId: ?u16, typeName: *[u8], traitName: *[u8]) -> *[u8] where 'arena: 'phase {
    let prefix = "vtable::";
    let sepLen: u32 = 2; // "::"
    let totalLen = prefix.len + typeName.len + sepLen + traitName.len;
    let buf = try! alloc::allocSlice(self.arena, 1, 1, totalLen) as *mut [u8];
    let mut pos: u32 = 0;

/// Each method in the instance block is lowered as a standalone function
/// with a qualified name of the form `Type::method`. A read-only v-table
/// data record is emitted containing pointers to these functions, ordered
/// by the trait's method indices. The v-table is later referenced when
/// constructing trait objects for dynamic dispatch.
unsafe fn lowerInstanceDecl(
    self: &mut Lowerer,
    node: *ast::Node,
unsafe fn instanceCursor 'arena 'phase (
    self: &mut Lowerer 'arena 'phase,
    traitNameNode: *ast::Node,
    targetTypeNode: *ast::Node,
    methods: *[*ast::Node]
) throws (LowerError) {
) -> InstanceCursor throws (LowerError) where 'arena: 'phase {
    // Look up the trait and type from the resolver.
    let traitSym = resolver::nodeData(self.resolver, traitNameNode).sym
        else throw LowerError::MissingSymbol(traitNameNode);
    let case resolver::SymbolData::Trait(traitInfo) = traitSym.data
        else throw LowerError::MissingMetadata;
    let typeSym = resolver::nodeData(self.resolver, targetTypeNode).sym
        else throw LowerError::MissingSymbol(targetTypeNode);

    let tName = traitSym.name;
    let typeName = typeSym.name;

    // Lower each instance method as a regular function.
    // Collect qualified names for the v-table. Empty entries are filled
    // later from inherited supertrait methods.
    let mut methodNames: [*[u8]; ast::MAX_TRAIT_METHODS] = undefined;
    let mut methodNameSet: [bool; ast::MAX_TRAIT_METHODS] = [false; ast::MAX_TRAIT_METHODS];
    return InstanceCursor {
        traitInfo, traitName: traitSym.name, typeName: typeSym.name, methods, next: 0,
        methodNames: undefined, methodNameSet: [false; ast::MAX_TRAIT_METHODS],
    };
}

    for methodNode in methods {
/// Lower the next concrete method, or finish the instance's v-table.
unsafe fn lowerNextInstance 'arena 'phase (
    self: &mut Lowerer 'arena 'phase,
    state: &mut InstanceCursor,
    functionArena: &mut alloc::Arena
) -> ?*unsafe il::Fn throws (LowerError) where 'arena: 'phase {
    let traitInfo = state.traitInfo;
    let typeName = state.typeName;
    let tName = state.traitName;
    while state.next < state.methods.len {
        let methodNode = state.methods[state.next];
        set state.next += 1;
        let case ast::NodeValue::MethodDecl {
            name, receiverName, receiverType, sig, body, ..
            name, receiverName, sig, body, ..
        } = methodNode.value else continue;

        let case ast::NodeValue::Ident(mName) = name.value else {
            throw LowerError::ExpectedIdentifier;
        };
        let qualName = instanceMethodName(self, nil, typeName, mName);
        let func = try lowerMethod(self, methodNode, qualName, receiverName, sig, body)
        let func = try lowerMethod(self, methodNode, qualName, receiverName, sig, body, functionArena)
            else continue;
        emitFunction(self, func, FnRole::Normal);

        let method = resolver::findTraitMethod(traitInfo, mName)
            else panic "lowerInstanceDecl: method not found in trait";

        set methodNames[method.index] = qualName;
        set methodNameSet[method.index] = true;
        set state.methodNames[method.index] = qualName;
        set state.methodNameSet[method.index] = true;
        return func;
    }

    // Fill inherited method slots from supertraits.
    // These methods were already lowered as part of the supertrait instance
    // declarations and use the same `Type::method` qualified name.
    for method, i in traitInfo.methods {
        if not methodNameSet[i] {
            set methodNames[i] = instanceMethodName(self, nil, typeName, method.name);
        if not state.methodNameSet[i] {
            set state.methodNames[i] = instanceMethodName(self, nil, typeName, method.name);
        }
    }

    // Create v-table in data section, used for dynamic dispatch.
    let vName = vtableName(self, nil, typeName, tName);

        self.arena, @sizeOf(il::DataValue), @alignOf(il::DataValue), traitInfo.methods.len as u32
    ) as *mut [il::DataValue];

    for i in 0..traitInfo.methods.len {
        set values[i] = il::DataValue {
            item: il::DataItem::Fn(methodNames[i]),
            item: il::DataItem::Fn(state.methodNames[i]),
            count: 1,
        };
    }
    self.data.append(il::Data {
        name: vName,
        size: traitInfo.methods.len as u32 * resolver::PTR_SIZE,
        alignment: resolver::PTR_SIZE,
        readOnly: true,
        isZeroInit: false,
        values: &values[..traitInfo.methods.len as u32],
    }, self.allocator);
    }, alloc::arenaAllocator(self.arena));
    return nil;
}

/// Lower a method node into an IL function with the given qualified name.
/// Shared by both instance methods and standalone methods.
unsafe fn lowerMethod(
    self: &mut Lowerer,
unsafe fn lowerMethod 'arena 'phase (
    self: &mut Lowerer 'arena 'phase,
    node: *ast::Node,
    qualName: *[u8],
    receiverName: *ast::Node,
    sig: ast::FnSig,
    body: *ast::Node,
) -> ?*unsafe il::Fn throws (LowerError) {
    functionArena: &mut alloc::Arena,
) -> ?*unsafe il::Fn throws (LowerError) where 'arena: 'phase {
    let data = resolver::nodeData(self.resolver, node);
    let case resolver::Type::Fn(fnType) = data.ty else {
        throw LowerError::ExpectedFunction;
    };
    let sym = data.sym else throw LowerError::MissingSymbol(node);
    registerFnSym(self, sym, qualName);

    let mut fnLow = fnLowerer(self, node, fnType, qualName);
    if requiresReturnParam(fnType) {
        set fnLow.returnReg = nextReg(&mut fnLow);
    }
    let lowParams = try lowerParams(&mut fnLow, *fnType, sig.params, receiverName);
    let func = try! alloc::allocRaw(self.fnArena, @sizeOf(il::Fn), @alignOf(il::Fn)) as *unsafe mut il::Fn;
    registerSymbolName(self, sym, qualName);

    let parent: 'function = &mut *self, arena = &mut *functionArena where 'phase: 'function in {
        let mut fnLow = fnLowerer(parent, node, fnType, qualName, arena);
        if requiresReturnParam(fnType) {
            set fnLow.returnReg = nextReg(&mut fnLow);
        }
        let lowParams = try lowerParams(&mut fnLow, *fnType, sig.params, receiverName);
        let func = try! alloc::allocRaw(fnLow.arena, @sizeOf(il::Fn), @alignOf(il::Fn)) as *unsafe mut il::Fn;

        let returnType = il::Type::W64 if fnType.throwList.len > 0
            else ilType(fnLow.low, *fnType.returnType);
        set *func = il::Fn {
            name: qualName,
            params: lowParams,
            returnType,
            isExtern: false,
            isLeaf: true,
            blocks: &[],
        };
        set func.blocks = try lowerFnBody(&mut fnLow, body);
        set func.isLeaf = fnLow.isLeaf;

    set *func = il::Fn {
        name: qualName,
        params: lowParams,
        returnType: ilType(self, *fnType.returnType),
        isExtern: false,
        isLeaf: true,
        blocks: &[],
    };
    if fnType.throwList.len > 0 {
        set func.returnType = il::Type::W64;
        return func;
    }
    set func.blocks = try lowerFnBody(&mut fnLow, body);
    set func.isLeaf = fnLow.isLeaf;

    return func;
}

/// Lower a standalone method declaration.
/// Produces a function with qualified name `Type::method`.
unsafe fn lowerMethodDecl(
    self: &mut Lowerer,
unsafe fn lowerMethodDecl 'arena 'phase (
    self: &mut Lowerer 'arena 'phase,
    node: *ast::Node,
    name: *ast::Node,
    receiverName: *ast::Node,
    sig: ast::FnSig,
    body: *ast::Node,
) -> ?*unsafe il::Fn throws (LowerError) {
    functionArena: &mut alloc::Arena,
) -> ?*unsafe il::Fn throws (LowerError) where 'arena: 'phase {
    let sym = resolver::nodeData(self.resolver, node).sym
        else throw LowerError::MissingSymbol(node);
    let case ast::NodeValue::Ident(mName) = name.value
        else throw LowerError::ExpectedIdentifier;
    let me = resolver::findMethodBySymbol(self.resolver, sym)
        else throw LowerError::MissingMetadata;
    let qualName = instanceMethodName(self, nil, me.concreteTypeName, mName);

    return try lowerMethod(self, node, qualName, receiverName, sig, body);
    return try lowerMethod(self, node, qualName, receiverName, sig, body, functionArena);
}

/// Check if a function should be lowered.
fn shouldLowerFn(decl: &ast::FnDecl, buildTest: bool) -> bool {
    if checkAttr(decl.attrs, ast::Attribute::Test) {

    return false;
}

/// Create a label with a numeric suffix, eg. `@base0`.
/// This ensures unique labels like `@then0`, `@then1`, etc.
unsafe fn labelWithSuffix(self: &mut FnLowerer, base: *[u8], suffix: u32) -> *[u8] throws (LowerError) {
unsafe fn labelWithSuffix 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, base: *[u8], suffix: u32) -> *[u8] throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let mut digits: [u8; fmt::U32_STR_LEN] = undefined;
    let start = fmt::formatU32(suffix, &mut digits[..]);
    let totalLen = base.len + digits.len - start;
    let buf = try! alloc::allocSlice(self.low.fnArena, 1, 1, totalLen) as *mut [u8];
    let buf = try! alloc::allocSlice(self.arena, 1, 1, totalLen) as *mut [u8];

    try! mem::copy(&mut buf[..base.len], base);
    try! mem::copy(&mut buf[base.len..totalLen], &digits[start..]);

    return &buf[..totalLen];
}

/// Generate a unique label by appending the global counter to the base.
unsafe fn nextLabel(self: &mut FnLowerer, base: *[u8]) -> *[u8] throws (LowerError) {
unsafe fn nextLabel 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, base: *[u8]) -> *[u8] throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let idx = self.labelCounter;
    set self.labelCounter += 1;

    return try labelWithSuffix(self, base, idx);
}

        else => panic,
    }
}

/// Convert a constant value to an IL value.
unsafe fn constValueToVal(self: &mut FnLowerer, val: resolver::ConstValue, node: *ast::Node) -> il::Val throws (LowerError) {
unsafe fn constValueToVal 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, val: resolver::ConstValue, node: *ast::Node) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    if let case resolver::ConstValue::String(s) = val {
        return try lowerStringLit(self, node, s);
    }
    return il::Val::Imm(constToScalar(val));
}

/// Convert a resolver constant value to an IL data initializer item.
unsafe fn constValueToDataItem(self: &mut Lowerer, val: resolver::ConstValue, typ: resolver::Type) -> il::DataItem {
unsafe fn constValueToDataItem 'arena 'phase (self: &mut Lowerer 'arena 'phase, val: resolver::ConstValue, typ: resolver::Type) -> il::DataItem where 'arena: 'phase {
    if let case resolver::ConstValue::String(s) = val {
        return il::DataItem::Str(s);
    }
    // Bool and char are byte-sized; integer uses the declared type.
    let mut irTyp = il::Type::W8;

    return il::DataItem::Val { typ: irTyp, val: constToScalar(val) };
}

/// Lower scalar-like constant nodes into data values, including fallback handling
/// for void-variant tags and slice string initializers.
unsafe fn lowerConstScalarDataInto(
    self: &mut Lowerer,
unsafe fn lowerConstScalarDataInto 'arena 'phase (
    self: &mut Lowerer 'arena 'phase,
    node: *ast::Node,
    ty: resolver::Type,
    dataPrefix: *[u8],
    b: &mut DataValueBuilder
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase {
    let val = resolver::constValueEntry(self.resolver, node) else {
        if let idx = voidVariantIndex(self.resolver, node) {
            dataBuilderPush(b, il::DataValue {
                item: il::DataItem::Val { typ: il::Type::W8, val: idx },
                count: 1

        count: 1
    });
}

/// Lower a constant or static declaration to the data section.
unsafe fn lowerDataDecl(
    self: &mut Lowerer,
unsafe fn lowerDataDecl 'arena 'phase (
    self: &mut Lowerer 'arena 'phase,
    node: *ast::Node,
    value: *ast::Node,
    readOnly: bool
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase {
    let data = resolver::nodeData(self.resolver, node);
    let sym = data.sym else {
        throw LowerError::MissingSymbol(node);
    };
    if data.ty == resolver::Type::Unknown {
        throw LowerError::MissingType(node);
    }
    let layout = resolver::getTypeLayout(data.ty);
    let qualName = qualifyName(self, nil, sym.name);
    let mut b = dataBuilder(self.allocator);
    let qualName = lookupSymbolName(self, sym) else qualifyName(self, nil, sym.name);
    let mut b = dataBuilder(alloc::arenaAllocator(self.arena));
    try lowerConstDataInto(self, value, data.ty, layout.size, qualName, &mut b);
    let result = dataBuilderFinish(b);

    self.data.append(il::Data {
        name: qualName,
        size: layout.size,
        alignment: layout.alignment,
        readOnly,
        isZeroInit: not readOnly and result.zeroInit,
        values: result.values,
    }, self.allocator);
    }, alloc::arenaAllocator(self.arena));
}

/// Emit the in-memory representation of a slice header: `{ ptr, len, cap }`.
fn dataSliceHeader(b: &mut DataValueBuilder, dataSym: *[u8], len: u32) {
    dataBuilderPush(b, il::DataValue {

        count: 1
    });
}

/// Lower a compile-time `&[...]` expression to a concrete slice header.
unsafe fn lowerConstAddressSliceInto(
    self: &mut Lowerer,
unsafe fn lowerConstAddressSliceInto 'arena 'phase (
    self: &mut Lowerer 'arena 'phase,
    addr: ast::AddressOf,
    ty: resolver::Type,
    dataPrefix: *[u8],
    b: &mut DataValueBuilder
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase {
    let case resolver::Type::Slice { mutable, .. } = ty
        else throw LowerError::ExpectedSliceOrArray;
    let targetTy = resolver::typeFor(self.resolver, addr.target)
        else throw LowerError::MissingType(addr.target);
    let case resolver::Type::Array(arrInfo) = targetTy
        else throw LowerError::ExpectedArray;

    let mut nested = dataBuilder(self.allocator);
    let mut nested = dataBuilder(alloc::arenaAllocator(self.arena));
    let layout = resolver::getTypeLayout(targetTy);
    try lowerConstDataInto(self, addr.target, targetTy, layout.size, dataPrefix, &mut nested);

    let backing = dataBuilderFinish(nested);
    let readOnly = not mutable;

    }
    dataSliceHeader(b, dataName, arrInfo.length);
}

/// Lower a constant expression payload into a builder without slot padding.
/// Compute the type layout only when undefined data needs a byte count.
unsafe fn lowerConstDataPayloadInto(
    self: &mut Lowerer,
/// Compute the type layout when nil or undefined data needs a byte count.
unsafe fn lowerConstDataPayloadInto 'arena 'phase (
    self: &mut Lowerer 'arena 'phase,
    node: *ast::Node,
    ty: resolver::Type,
    dataPrefix: *[u8],
    b: &mut DataValueBuilder
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase {
    // Optional coercions define the tag and payload layout of constant values.
    if let case resolver::Type::Optional(inner) = ty {
        if let coercion = resolver::coercionFor(self.resolver, node) {
            if let case resolver::Coercion::OptionalLift(target) = coercion {
                if resolver::typesEqual(target, ty) {
                    if resolver::isNullableType(*inner) {
                        try lowerConstDataPayloadInto(self, node, *inner, dataPrefix, b);
                    } else {
                        let layout = resolver::getTypeLayout(ty);
                        let offset = resolver::getOptionalValOffset(*inner);
                        dataBuilderPush(b, il::DataValue {
                            item: il::DataItem::Val { typ: il::Type::W8, val: 1 }, count: 1,
                        });
                        if offset > 1 {
                            dataBuilderPush(b, il::DataValue { item: il::DataItem::Undef, count: offset - 1 });
                        }
                        try lowerConstDataInto(self, node, *inner, layout.size - offset, dataPrefix, b);
                    }
                    return;
                }
            }
        }
    }
    // Function pointer references in constant data.
    if let case resolver::Type::Fn(_) = ty {
        let sym = resolver::nodeData(self.resolver, node).sym
            else throw LowerError::MissingSymbol(node);
        let modId = resolver::moduleIdForSymbol(self.resolver, sym);

                return;
            }
        }
    }
    match node.value {
        case ast::NodeValue::Nil => {
            let case resolver::Type::Optional(_) = ty else throw LowerError::NilInNonOptional;
            let layout = resolver::getTypeLayout(ty);
            dataBuilderPush(b, il::DataValue {
                item: il::DataItem::Val { typ: il::Type::W8, val: 0 }, count: layout.size,
            });
        },
        case ast::NodeValue::Undef => {
            let layout = resolver::getTypeLayout(ty);
            dataBuilderPush(b, il::DataValue {
                item: il::DataItem::Undef,
                count: layout.size

        }
    }
}

/// Lower a constant expression into a builder, padding to the given slot size.
unsafe fn lowerConstDataInto(
    self: &mut Lowerer,
unsafe fn lowerConstDataInto 'arena 'phase (
    self: &mut Lowerer 'arena 'phase,
    node: *ast::Node,
    ty: resolver::Type,
    slotSize: u32,
    dataPrefix: *[u8],
    b: &mut DataValueBuilder
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase {
    let layout = resolver::getTypeLayout(ty);
    try lowerConstDataPayloadInto(self, node, ty, dataPrefix, b);
    // Pad to fill the enclosing slot.
    let padding = slotSize - layout.size;
    if padding > 0 {

    }
}

/// Flatten a constant array literal `[a, b, c]` into a builder.
/// Each element payload fills its type size; no extra slot padding is needed.
unsafe fn lowerConstArrayLitInto(
    self: &mut Lowerer,
unsafe fn lowerConstArrayLitInto 'arena 'phase (
    self: &mut Lowerer 'arena 'phase,
    elems: *[*ast::Node],
    ty: resolver::Type,
    dataPrefix: *[u8],
    b: &mut DataValueBuilder
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase {
    let case resolver::Type::Array(arrInfo) = ty
        else throw LowerError::ExpectedArray;
    let elemTy = *arrInfo.item;

    for elem in elems {

}

/// Build data values for a constant array repeat literal `[item; count]`.
/// Repeat element payloads without extra slot padding. Undefined data uses
/// the element layout to compute the total byte count.
unsafe fn lowerConstArrayRepeatInto(
    self: &mut Lowerer,
unsafe fn lowerConstArrayRepeatInto 'arena 'phase (
    self: &mut Lowerer 'arena 'phase,
    repeat: ast::ArrayRepeatLit,
    ty: resolver::Type,
    dataPrefix: *[u8],
    b: &mut DataValueBuilder
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase {
    let case resolver::Type::Array(arrInfo) = ty
        else throw LowerError::ExpectedArray;
    let length = arrInfo.length;
    let elemTy = *arrInfo.item;

    if let case resolver::Type::Optional(_) = elemTy {
        for _ in 0..length {
            try lowerConstDataPayloadInto(self, repeat.item, elemTy, dataPrefix, b);
        }
        return;
    }

    if let case ast::NodeValue::Undef = repeat.item.value {
        let elemLayout = resolver::getTypeLayout(elemTy);
        dataBuilderPush(b, il::DataValue {
            item: il::DataItem::Undef,
            count: elemLayout.size * length

    }
}

/// Build data values for a constant record literal.
/// Each field is lowered with a slot size that includes trailing padding.
unsafe fn lowerConstRecordLitInto(
    self: &mut Lowerer,
unsafe fn lowerConstRecordLitInto 'arena 'phase (
    self: &mut Lowerer 'arena 'phase,
    node: *ast::Node,
    recLit: ast::RecordLit,
    ty: resolver::Type,
    dataPrefix: *[u8],
    b: &mut DataValueBuilder
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase {
    match ty {
        case resolver::Type::Nominal(resolver::NominalType::Record(recInfo)) => {
            try lowerConstRecordCtorInto(self, recLit.fields, recInfo, dataPrefix, b);
        }
        case resolver::Type::Nominal(resolver::NominalType::Union(_)) => {

        else => throw LowerError::ExpectedRecord,
    }
}

/// Build data values for record constants.
unsafe fn lowerConstRecordCtorInto(
    self: &mut Lowerer,
unsafe fn lowerConstRecordCtorInto 'arena 'phase (
    self: &mut Lowerer 'arena 'phase,
    args: *[*ast::Node],
    recInfo: resolver::RecordType,
    dataPrefix: *[u8],
    b: &mut DataValueBuilder
) throws (LowerError) {
    let layout = recInfo.layout;
) throws (LowerError) where 'arena: 'phase {
    let layout = *recInfo.layout;
    for argNode, i in args {
        let mut valueNode = argNode;
        if let case ast::NodeValue::RecordLitField(fieldLit) = argNode.value {
            set valueNode = fieldLit.value;
        }

        try lowerConstDataInto(self, valueNode, fieldInfo.fieldType, slotSize, dataPrefix, b);
    }
}

/// Build data values for a constant union variant value from payload fields/args.
unsafe fn lowerConstUnionVariantInto(
    self: &mut Lowerer,
unsafe fn lowerConstUnionVariantInto 'arena 'phase (
    self: &mut Lowerer 'arena 'phase,
    node: *ast::Node,
    variantSym: *unsafe mut resolver::Symbol,
    ty: resolver::Type,
    payloadArgs: *[*ast::Node],
    dataPrefix: *[u8],
    b: &mut DataValueBuilder
) throws (LowerError) {
    let case resolver::SymbolData::Variant { type: payloadType, index, .. } = variantSym.data
) throws (LowerError) where 'arena: 'phase {
    let case resolver::SymbolData::Variant { ordinal, index, .. } = variantSym.data
        else throw LowerError::UnexpectedNodeValue(node);

    let unionInfo = unionInfoFromType(ty) else {
        throw LowerError::MissingMetadata;
    };
    let payloadType = unionInfo.variants[ordinal].valueType;
    let unionLayout = resolver::getTypeLayout(ty);
    let payloadSlotSize = unionLayout.size - unionInfo.valOffset;

    // Tag byte.
    dataBuilderPush(b, il::DataValue {

    }

    let case resolver::Type::Nominal(resolver::NominalType::Record(payloadRec)) = payloadType else {
        throw LowerError::ExpectedRecord;
    };
    let payloadLayout = payloadRec.layout;
    let payloadLayout = *payloadRec.layout;
    try lowerConstRecordCtorInto(self, payloadArgs, payloadRec, dataPrefix, b);

    // Unused bytes in the union payload slot for smaller variants.
    if payloadSlotSize > payloadLayout.size {
        dataBuilderPush(b, il::DataValue {

    }
}

/// Find an existing string data entry with matching content.
// TODO: Optimize with hash table or remove?
fn findStringData(self: &Lowerer, s: *[u8]) -> ?*[u8] {
    for d in &self.data[..] {
fn findStringData 'arena 'phase (self: &Lowerer 'arena 'phase, s: *[u8]) -> ?*[u8] where 'arena: 'phase {
    for d in &self.data[self.packageDataStart..] {
        if d.values.len == 1 {
            if let case il::DataItem::Str(existing) = d.values[0].item {
                if mem::eq(existing, s) {
                    return d.name;
                }

    return nil;
}

/// Compose a segmented symbol name from a list of path segments.
/// Example: `["func", "nominal", "VALUE"]` -> `func$nominal$VALUE`.
unsafe fn buildSegmentedName(
    self: &mut Lowerer,
unsafe fn buildSegmentedName 'arena 'phase (
    self: &mut Lowerer 'arena 'phase,
    segments: &[*[u8]]
) -> *[u8] throws (LowerError) {
) -> *[u8] throws (LowerError) where 'arena: 'phase {
    assert segments.len > 0;

    let mut totalLen: u32 = 0;
    for segment in segments {
        set totalLen += segment.len;


    return &buf[..totalLen];
}

/// Generate a unique name for declaration-local backing data entries.
unsafe fn nextDeclDataName(
    self: &mut Lowerer,
unsafe fn nextDeclDataName 'arena 'phase (
    self: &mut Lowerer 'arena 'phase,
    prefix: *[u8],
    count: u32,
    namespace: *[u8]
) -> *[u8] throws (LowerError) {
) -> *[u8] throws (LowerError) where 'arena: 'phase {
    let mut digits: [u8; fmt::U32_STR_LEN] = undefined;
    let start = fmt::formatU32(count, &mut digits[..]);
    let suffix = try! alloc::allocSlice(self.arena, 1, 1, digits.len - start) as *mut [u8];
    try! mem::copy(suffix, &digits[start..]);
    let segments = [prefix, namespace, suffix];

    return try buildSegmentedName(self, &segments[..]);
}

/// Append a data entry using a function-local literal namespace (`prefix$literal$N`).
unsafe fn pushDeclData(
    self: &mut Lowerer,
unsafe fn pushDeclData 'arena 'phase (
    self: &mut Lowerer 'arena 'phase,
    size: u32,
    alignment: u32,
    readOnly: bool,
    values: *[il::DataValue],
    dataPrefix: *[u8]
) -> *[u8] throws (LowerError) {
) -> *[u8] throws (LowerError) where 'arena: 'phase {
    let dataCount = self.data.len;
    let name = try nextDeclDataName(self, dataPrefix, dataCount, "literal");
    self.data.append(il::Data {
        name,
        size,
        alignment,
        readOnly,
        isZeroInit: not readOnly and dataValuesAreZeroInit(values),
        values,
    }, self.allocator);
    }, alloc::arenaAllocator(self.arena));

    return name;
}

/// Find or create read-only string data and return its symbol name.
unsafe fn getOrCreateStringData(
    self: &mut Lowerer,
unsafe fn getOrCreateStringData 'arena 'phase (
    self: &mut Lowerer 'arena 'phase,
    s: *[u8],
    dataPrefix: *[u8]
) -> *[u8] throws (LowerError) {
) -> *[u8] throws (LowerError) where 'arena: 'phase {
    if let existing = findStringData(self, s) {
        return existing;
    }
    let values = try! alloc::allocSlice(
        self.arena, @sizeOf(il::DataValue), @alignOf(il::DataValue), 1

    return true;
}

/// Find an existing read-only slice data entry with matching values.
// TODO: Optimize with hash table or remove?
fn findSliceData(self: &Lowerer, values: *[il::DataValue], alignment: u32) -> ?*[u8] {
    for d in &self.data[..] {
fn findSliceData 'arena 'phase (self: &Lowerer 'arena 'phase, values: *[il::DataValue], alignment: u32) -> ?*[u8] where 'arena: 'phase {
    for d in &self.data[self.packageDataStart..] {
        if d.alignment == alignment and d.readOnly and dataValuesEq(d.values, values) {
            return d.name;
        }
    }
    return nil;
}

/// Find existing constant data entry with matching content.
/// Handles both string data and slice data.
fn findConstData(self: &Lowerer, values: *[il::DataValue], alignment: u32) -> ?*[u8] {
fn findConstData 'arena 'phase (self: &Lowerer 'arena 'phase, values: *[il::DataValue], alignment: u32) -> ?*[u8] where 'arena: 'phase {
    // Fast path for strings.
    if values.len == 1 and alignment == 1 {
        if let case il::DataItem::Str(s) = values[0].item {
            return findStringData(self, s);
        }

    return findSliceData(self, values, alignment);
}

/// Lower constant data to a slice value.
/// Creates or reuses a data section entry, then builds a slice header on the stack.
unsafe fn lowerConstDataAsSlice(
    self: &mut FnLowerer,
unsafe fn lowerConstDataAsSlice 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    result: &ConstDataResult,
    alignment: u32,
    readOnly: bool,
    elemTy: *resolver::Type,
    mutable: bool,
    length: u32
) -> il::Val throws (LowerError) {
) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let values = result.values;
    let elemLayout = resolver::getTypeLayout(*elemTy);
    let size = elemLayout.size * length;
    let mut dataName: *[u8] = undefined;
    let mut found: ?*[u8] = nil;

            size,
            alignment,
            readOnly,
            isZeroInit: not readOnly and result.zeroInit,
            values,
        }, self.low.allocator);
        }, alloc::arenaAllocator(self.low.arena));
    }

    // Get data address.
    let ptrReg = nextReg(self);
    emit(self, il::Instr::Copy { dst: ptrReg, val: il::Val::DataSym(dataName) });

        self, elemTy, mutable, il::Val::Reg(ptrReg), il::Val::Imm(length as i64), il::Val::Imm(length as i64)
    );
}

/// Generate a unique data name for inline literals, eg. `fnName$literal$N`.
unsafe fn nextDataName(self: &mut FnLowerer) -> *[u8] throws (LowerError) {
unsafe fn nextDataName 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function) -> *[u8] throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let counter = self.dataCounter;
    set self.dataCounter += 1;
    let fnName = self.fnName;
    return try nextDeclDataName(self.low, fnName, counter, "literal");
}

/// Assign a unique function-local data symbol name.
unsafe fn registerLocalDataDeclName(self: &mut FnLowerer, node: *ast::Node) throws (LowerError) {
unsafe fn registerLocalDataDeclName 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let sym = resolver::nodeData(self.low.resolver, node).sym
        else throw LowerError::MissingSymbol(node);

    let prefix = self.fnName;
    let segments = [prefix, "nominal", sym.name];
    let name = try buildSegmentedName(self.low, &segments[..]);

    set sym.name = name;
    let qualified = qualifyName(self.low, nil, name);
    registerSymbolName(self.low, sym, qualified);
}

/// Get the next available SSA register.
fn nextReg(self: &mut FnLowerer) -> il::Reg {
fn nextReg 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function) -> il::Reg where 'arena: 'phase, 'phase: 'function {
    let reg = il::Reg { n: self.regCounter };
    set self.regCounter += 1;
    return reg;
}

/// Look up the resolved type of an AST node, or throw `MissingType`.
unsafe fn typeOf(self: &mut FnLowerer, node: *ast::Node) -> resolver::Type throws (LowerError) {
unsafe fn typeOf 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node) -> resolver::Type throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let ty = resolver::typeFor(self.low.resolver, node)
        else throw LowerError::MissingType(node);
    return ty;
}

/// Look up the symbol for an AST node, or throw `MissingSymbol`.
unsafe fn symOf(self: &mut FnLowerer, node: *ast::Node) -> *unsafe mut resolver::Symbol throws (LowerError) {
unsafe fn symOf 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node) -> *unsafe mut resolver::Symbol throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let sym = resolver::nodeData(self.low.resolver, node).sym
        else throw LowerError::MissingSymbol(node);
    return sym;
}

/// Remove the last block parameter and its associated variable.
/// Used when detecting a trivial phi that can be eliminated.
unsafe fn removeLastBlockParam(self: &mut FnLowerer, block: BlockId) {
unsafe fn removeLastBlockParam 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, block: BlockId) where 'arena: 'phase, 'phase: 'function {
    let blk = getBlockMut(self, block);
    if blk.params.len > 0 {
        // TODO: Use `pop`?
        set blk.params = @sliceOf(blk.params.ptr, blk.params.len - 1, blk.params.cap);
    }

/// Rewrite cached SSA values for a variable across all blocks, and also
/// rewrite any terminator arguments that reference the provisional register.
/// The latter is necessary because recursive SSA resolution may have already
/// patched terminator arguments with the provisional value before it was
/// found to be trivial.
unsafe fn rewriteCachedVarValue(self: &mut FnLowerer, v: Var, from: il::Val, to: il::Val) {
unsafe fn rewriteCachedVarValue 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, v: Var, from: il::Val, to: il::Val) where 'arena: 'phase, 'phase: 'function {
    for i in 0..self.blockData.len {
        let blk = getBlockMut(self, BlockId(i));
        if blk.vars[*v] == from {
            set blk.vars[*v] = to;
        }

/// Create a new basic block with the given label base.
///
/// The block is initially unsealed (predecessors may be added later) and empty.
/// Returns a [`BlockId`] that can be used for jumps and branches. The block must
/// be switched to via [`switchToBlock`] before instructions can be emitted.
unsafe fn createBlock(self: &mut FnLowerer, labelBase: *[u8]) -> BlockId throws (LowerError) {
unsafe fn createBlock 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, labelBase: *[u8]) -> BlockId throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let label = try nextLabel(self, labelBase);
    let id = BlockId(self.blockData.len);
    let varCount = self.localCount;
    let vars = try! alloc::allocRawSlice(self.low.fnArena, @sizeOf(?il::Val), @alignOf(?il::Val), varCount) as *unsafe mut [?il::Val];
    let vars = try! alloc::allocRawSlice(self.arena, @sizeOf(?il::Val), @alignOf(?il::Val), varCount) as *unsafe mut [?il::Val];

    for i in 0..varCount {
        set vars[i] = nil;
    }
    self.blockData.append(BlockData {

        locs: &mut [],
        preds: &mut [],
        vars,
        sealState: Sealed::No,
        loopDepth: self.loopDepth,
    }, self.allocator);
    }, alloc::arenaAllocator(self.arena));

    return id;
}

/// Create a new block with a single parameter.
unsafe fn createBlockWithParam(
    self: &mut FnLowerer,
unsafe fn createBlockWithParam 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    labelBase: *[u8],
    param: il::Param
) -> BlockId throws (LowerError) {
) -> BlockId throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let block = try createBlock(self, labelBase);
    let blk = getBlockMut(self, block);
    blk.params.append(param, self.allocator);
    blk.params.append(param, alloc::arenaAllocator(self.arena));

    return block;
}

/// Switch to building a different block.
/// All subsequent `emit` calls will add instructions to this block.
fn switchToBlock(self: &mut FnLowerer, block: BlockId) {
fn switchToBlock 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, block: BlockId) where 'arena: 'phase, 'phase: 'function {
    set self.currentBlock = block;
}

/// Seal a block, indicating all predecessor edges are now known.
///
/// Sealing enables SSA construction to resolve variable uses by looking up
/// values from predecessors and inserting block parameters as needed. It
/// does not prevent instructions from being added to the block.
unsafe fn sealBlock(self: &mut FnLowerer, block: BlockId) throws (LowerError) {
unsafe fn sealBlock 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, block: BlockId) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let blk = getBlockMut(self, block);
    let case Sealed::No = blk.sealState else {
        return; // Already sealed.
    };
    // Keep the current parameter list. Resolution can add more parameters.

        try resolveBlockArgs(self, block, Var(varId), paramIdx);
    }
}

/// Seal a block and switch to it.
unsafe fn switchToAndSeal(self: &mut FnLowerer, block: BlockId) throws (LowerError) {
unsafe fn switchToAndSeal 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, block: BlockId) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    try sealBlock(self, block);
    switchToBlock(self, block);
}

/// Get block data by block id.
unsafe fn getBlock(self: &FnLowerer, block: BlockId) -> *unsafe BlockData {
unsafe fn getBlock 'arena 'phase 'function (self: &FnLowerer 'arena 'phase 'function, block: BlockId) -> *unsafe BlockData where 'arena: 'phase, 'phase: 'function {
    return &self.blockData[*block];
}

/// Get mutable block data by block id.
unsafe fn getBlockMut(self: &mut FnLowerer, block: BlockId) -> *unsafe mut BlockData {
unsafe fn getBlockMut 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, block: BlockId) -> *unsafe mut BlockData where 'arena: 'phase, 'phase: 'function {
    return &mut self.blockData[*block];
}

/// Get the current block being built.
fn currentBlock(self: &FnLowerer) -> BlockId {
fn currentBlock 'arena 'phase 'function (self: &FnLowerer 'arena 'phase 'function) -> BlockId where 'arena: 'phase, 'phase: 'function {
    let block = self.currentBlock else {
        panic "currentBlock: no current block";
    };
    return block;
}

//////////////////////////
// Instruction Emission //
//////////////////////////

/// Emit an instruction to the current block.
unsafe fn emit(self: &mut FnLowerer, instr: il::Instr) {
unsafe fn emit 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, instr: il::Instr) where 'arena: 'phase, 'phase: 'function {
    let blk = self.currentBlock else panic;
    let mut block = getBlockMut(self, blk);

    // Track whether this function is a leaf.
    if self.isLeaf {
        match instr {
            case il::Instr::Call { .. },
                 il::Instr::Ecall { .. } => set self.isLeaf = false,
            else => {},
        }
    if il::isCall(instr) {
        set self.isLeaf = false;
    }
    // Record source location alongside instruction when enabled.
    if self.low.options.debug {
        block.locs.append(self.srcLoc, self.allocator);
        block.locs.append(self.srcLoc, alloc::arenaAllocator(self.arena));
    }
    block.instrs.append(instr, self.allocator);
    block.instrs.append(instr, alloc::arenaAllocator(self.arena));
}

/// Emit an unconditional jump to `target`.
unsafe fn emitJmp(self: &mut FnLowerer, target: BlockId) throws (LowerError) {
unsafe fn emitJmp 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, target: BlockId) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    emit(self, il::Instr::Jmp { target: *target, args: &mut [] });
    addPredecessor(self, target, currentBlock(self));
}

/// Emit an unconditional jump to `target` with a single argument.
unsafe fn emitJmpWithArg(self: &mut FnLowerer, target: BlockId, arg: il::Val) throws (LowerError) {
unsafe fn emitJmpWithArg 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, target: BlockId, arg: il::Val) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let args = try allocVal(self, arg);
    emit(self, il::Instr::Jmp { target: *target, args });
    addPredecessor(self, target, currentBlock(self));
}

/// Emit an unconditional jump to `target` and switch to it.
unsafe fn switchAndJumpTo(self: &mut FnLowerer, target: BlockId) throws (LowerError) {
unsafe fn switchAndJumpTo 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, target: BlockId) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    try emitJmp(self, target);
    switchToBlock(self, target);
}

/// Emit a conditional branch based on `cond`.
unsafe fn emitBr(self: &mut FnLowerer, cond: il::Reg, thenBlock: BlockId, elseBlock: BlockId) throws (LowerError) {
unsafe fn emitBr 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, cond: il::Reg, thenBlock: BlockId, elseBlock: BlockId) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    assert thenBlock <> elseBlock;
    emit(self, il::Instr::Br {
        op: il::CmpOp::Ne,
        typ: il::Type::W32,
        a: il::Val::Reg(cond),

    addPredecessor(self, thenBlock, currentBlock(self));
    addPredecessor(self, elseBlock, currentBlock(self));
}

/// Emit a compare-and-branch instruction with the given comparison op.
unsafe fn emitBrCmp(
    self: &mut FnLowerer,
unsafe fn emitBrCmp 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    op: il::CmpOp,
    typ: il::Type,
    a: il::Val,
    b: il::Val,
    thenBlock: BlockId,
    elseBlock: BlockId
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    assert thenBlock <> elseBlock;
    emit(self, il::Instr::Br {
        op, typ, a, b,
        thenTarget: *thenBlock, thenArgs: &mut [],
        elseTarget: *elseBlock, elseArgs: &mut [],

    addPredecessor(self, thenBlock, currentBlock(self));
    addPredecessor(self, elseBlock, currentBlock(self));
}

/// Emit a guard that traps with `ebreak` when a comparison is false.
unsafe fn emitTrapUnlessCmp(
    self: &mut FnLowerer,
unsafe fn emitTrapUnlessCmp 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    op: il::CmpOp,
    typ: il::Type,
    a: il::Val,
    b: il::Val
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let passBlock = try createBlock(self, "guard#pass");
    let trapBlock = try createBlock(self, "guard#trap");

    try emitBrCmp(self, op, typ, a, b, passBlock, trapBlock);
    try switchToAndSeal(self, trapBlock);

    }
    return aa <= bb;
}

/// Emit an `ebreak` when `a < b` holds.
unsafe fn emitTrapIfLt(
    self: &mut FnLowerer,
unsafe fn emitTrapIfLt 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    typ: il::Type,
    a: il::Val,
    b: il::Val
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let trapBlock = try createBlock(self, "guard#trap");
    let passBlock = try createBlock(self, "guard#pass");

    try emitBrCmp(self, il::CmpOp::Ult, typ, a, b, trapBlock, passBlock);
    try switchToAndSeal(self, trapBlock);

    try switchToAndSeal(self, passBlock);
}

/// Emit a conditional branch. Uses fused compare-and-branch for simple scalar
/// comparisons, falls back to separate comparison plus branch otherwise.
unsafe fn emitCondBranch(
    self: &mut FnLowerer,
unsafe fn emitCondBranch 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    cond: *ast::Node,
    thenBlock: BlockId,
    elseBlock: BlockId
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    // Try fused compare-and-branch for simple scalar comparisons.
    if let case ast::NodeValue::BinOp(binop) = cond.value {
        let leftTy = try typeOf(self, binop.left);
        let rightTy = try typeOf(self, binop.right);
        if not isAggregateType(leftTy) and not isAggregateType(rightTy) {


    try emitBr(self, condReg, thenBlock, elseBlock);
}

/// Emit a 32-bit store instruction at the given offset.
unsafe fn emitStoreW32At(self: &mut FnLowerer, src: il::Val, dst: il::Reg, offset: i32) {
unsafe fn emitStoreW32At 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, src: il::Val, dst: il::Reg, offset: i32) where 'arena: 'phase, 'phase: 'function {
    emit(self, il::Instr::Store { typ: il::Type::W32, src, dst, offset });
}

/// Emit a 32-bit load instruction at the given offset.
unsafe fn emitLoadW32At(self: &mut FnLowerer, dst: il::Reg, src: il::Reg, offset: i32) {
unsafe fn emitLoadW32At 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, dst: il::Reg, src: il::Reg, offset: i32) where 'arena: 'phase, 'phase: 'function {
    emit(self, il::Instr::Load { typ: il::Type::W32, dst, src, offset });
}

/// Emit an 8-bit store instruction at the given offset.
unsafe fn emitStoreW8At(self: &mut FnLowerer, src: il::Val, dst: il::Reg, offset: i32) {
unsafe fn emitStoreW8At 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, src: il::Val, dst: il::Reg, offset: i32) where 'arena: 'phase, 'phase: 'function {
    emit(self, il::Instr::Store { typ: il::Type::W8, src, dst, offset });
}

/// Emit an 8-bit load instruction at the given offset.
unsafe fn emitLoadW8At(self: &mut FnLowerer, dst: il::Reg, src: il::Reg, offset: i32) {
unsafe fn emitLoadW8At 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, dst: il::Reg, src: il::Reg, offset: i32) where 'arena: 'phase, 'phase: 'function {
    emit(self, il::Instr::Load { typ: il::Type::W8, dst, src, offset });
}

/// Emit a 64-bit store instruction at the given offset.
unsafe fn emitStoreW64At(self: &mut FnLowerer, src: il::Val, dst: il::Reg, offset: i32) {
unsafe fn emitStoreW64At 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, src: il::Val, dst: il::Reg, offset: i32) where 'arena: 'phase, 'phase: 'function {
    emit(self, il::Instr::Store { typ: il::Type::W64, src, dst, offset });
}

/// Emit a 64-bit load instruction at the given offset.
unsafe fn emitLoadW64At(self: &mut FnLowerer, dst: il::Reg, src: il::Reg, offset: i32) {
unsafe fn emitLoadW64At 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, dst: il::Reg, src: il::Reg, offset: i32) where 'arena: 'phase, 'phase: 'function {
    emit(self, il::Instr::Load { typ: il::Type::W64, dst, src, offset });
}

/// Load a tag from memory at `src` plus `offset` with the given IL type.
unsafe fn loadTag(self: &mut FnLowerer, src: il::Reg, offset: i32, tagType: il::Type) -> il::Val {
unsafe fn loadTag 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, src: il::Reg, offset: i32, tagType: il::Type) -> il::Val where 'arena: 'phase, 'phase: 'function {
    let dst = nextReg(self);
    emit(self, il::Instr::Load { typ: tagType, dst, src, offset });
    return il::Val::Reg(dst);
}

/// Load the data pointer from a slice value.
unsafe fn loadSlicePtr(self: &mut FnLowerer, sliceReg: il::Reg) -> il::Reg {
unsafe fn loadSlicePtr 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, sliceReg: il::Reg) -> il::Reg where 'arena: 'phase, 'phase: 'function {
    let ptrReg = nextReg(self);
    emitLoadW64At(self, ptrReg, sliceReg, SLICE_PTR_OFFSET);
    return ptrReg;
}

/// Load the length from a slice value.
unsafe fn loadSliceLen(self: &mut FnLowerer, sliceReg: il::Reg) -> il::Val {
unsafe fn loadSliceLen 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, sliceReg: il::Reg) -> il::Val where 'arena: 'phase, 'phase: 'function {
    let lenReg = nextReg(self);
    emitLoadW32At(self, lenReg, sliceReg, SLICE_LEN_OFFSET);
    return il::Val::Reg(lenReg);
}

/// Load the capacity from a slice value.
unsafe fn loadSliceCap(self: &mut FnLowerer, sliceReg: il::Reg) -> il::Val {
unsafe fn loadSliceCap 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, sliceReg: il::Reg) -> il::Val where 'arena: 'phase, 'phase: 'function {
    let capReg = nextReg(self);
    emitLoadW32At(self, capReg, sliceReg, SLICE_CAP_OFFSET);
    return il::Val::Reg(capReg);
}

/// Emit a load instruction for a scalar value at `src` plus `offset`.
/// For reading values that may be aggregates, use `emitRead` instead.
unsafe fn emitLoad(self: &mut FnLowerer, src: il::Reg, offset: i32, typ: resolver::Type) -> il::Val {
unsafe fn emitLoad 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, src: il::Reg, offset: i32, typ: resolver::Type) -> il::Val where 'arena: 'phase, 'phase: 'function {
    let dst = nextReg(self);
    let ilTyp = ilType(self.low, typ);

    if isSignedType(typ) {
        emit(self, il::Instr::Sload { typ: ilTyp, dst, src, offset });

    return il::Val::Reg(dst);
}

/// Read a value from memory at `src` plus `offset`. Aggregates are represented
/// as pointers, so we return the address directly. Scalars are loaded via [`emitLoad`].
unsafe fn emitRead(self: &mut FnLowerer, src: il::Reg, offset: i32, typ: resolver::Type) -> il::Val {
unsafe fn emitRead 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, src: il::Reg, offset: i32, typ: resolver::Type) -> il::Val where 'arena: 'phase, 'phase: 'function {
    if isAggregateType(typ) {
        let ptr = emitPtrOffset(self, src, offset);
        return il::Val::Reg(ptr);
    }
    return emitLoad(self, src, offset, typ);
}

/// Emit a copy instruction that loads a data symbol's address into a register.
unsafe fn emitDataAddr(self: &mut FnLowerer, sym: *unsafe resolver::Symbol) -> il::Reg {
unsafe fn emitDataAddr 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, sym: *unsafe resolver::Symbol) -> il::Reg where 'arena: 'phase, 'phase: 'function {
    let dst = nextReg(self);
    let modId = resolver::moduleIdForSymbol(self.low.resolver, sym);
    let qualName = qualifyName(self.low, modId, sym.name);
    let qualName = lookupSymbolName(self.low, sym) else qualifyName(self.low, modId, sym.name);

    emit(self, il::Instr::Copy { dst, val: il::Val::DataSym(qualName) });

    return dst;
}

/// Emit a copy instruction that loads a function's address into a register.
unsafe fn emitFnAddr(self: &mut FnLowerer, sym: *unsafe resolver::Symbol) -> il::Reg {
unsafe fn emitFnAddr 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, sym: *unsafe resolver::Symbol) -> il::Reg where 'arena: 'phase, 'phase: 'function {
    let dst = nextReg(self);
    let modId = resolver::moduleIdForSymbol(self.low.resolver, sym);
    let qualName = qualifyName(self.low, modId, sym.name);

    emit(self, il::Instr::Copy { dst, val: il::Val::FnAddr(qualName) });

    return dst;
}

/// Emit pattern tests for a single pattern.
unsafe fn emitPatternMatch(
    self: &mut FnLowerer,
unsafe fn emitPatternMatch 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    subject: &MatchSubject,
    pattern: *ast::Node,
    matchBlock: BlockId,
    fallthrough: BlockId
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    // Wildcards always match; array patterns are tested element-by-element
    // during binding, so they also unconditionally enter the match block.
    if isWildcardPattern(pattern) {
        try emitJmp(self, matchBlock);
        return;

    if let case ast::NodeValue::ArrayLit(_) = pattern.value {
        try emitJmp(self, matchBlock);
        return;
    }
    if let case resolver::Type::Nominal(resolver::NominalType::Record(_)) = subject.type {
        if let case ast::NodeValue::RecordLit(_) = pattern.value {
            try emitJmp(self, matchBlock);
            return;
        match pattern.value {
            case ast::NodeValue::RecordLit(_), ast::NodeValue::Call(_) => {
                try emitJmp(self, matchBlock);
                return;
            }
            else => {
            },
        }
    }
    let isNil = pattern.value == ast::NodeValue::Nil;

    match subject.kind {

}

/// Emit branches for multiple patterns. The first pattern that matches
/// causes a jump to the match block. If no patterns match, we jump to the
/// fallthrough block.
unsafe fn emitPatternMatches(
    self: &mut FnLowerer,
unsafe fn emitPatternMatches 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    subject: &MatchSubject,
    patterns: &[*ast::Node],
    matchBlock: BlockId,
    fallthrough: BlockId
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    assert patterns.len > 0;

    for i in 0..(patterns.len - 1) {
        let pattern = patterns[i];
        let nextArm = try createBlock(self, "arm");


/// Emit a match binding pattern.
/// Binding patterns always match for regular values, but for optionals they
/// check for the presence of a value. Jumps to `valuePresent` on success,
/// `valueAbsent` on failure.
unsafe fn emitBindingTest(
    self: &mut FnLowerer,
unsafe fn emitBindingTest 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    subject: &MatchSubject,
    valuePresent: BlockId,
    valueAbsent: BlockId
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    match subject.kind {
        case MatchSubjectKind::OptionalPtr, MatchSubjectKind::OptionalAggregate => {
            let nilReg = try optionalNilReg(self, subject.val, subject.type);
            try emitBr(self, nilReg, valuePresent, valueAbsent);
        }

        }
    }
}

/// Emit a jump to target if the current block hasn't terminated, then seal the target block.
unsafe fn emitJmpAndSeal(self: &mut FnLowerer, target: BlockId) throws (LowerError) {
unsafe fn emitJmpAndSeal 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, target: BlockId) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    if not blockHasTerminator(self) {
        try emitJmp(self, target);
    }
    try sealBlock(self, target);
}

/// Check if the current block already has a terminator instruction.
unsafe fn blockHasTerminator(self: &FnLowerer) -> bool {
unsafe fn blockHasTerminator 'arena 'phase 'function (self: &FnLowerer 'arena 'phase 'function) -> bool where 'arena: 'phase, 'phase: 'function {
    let blk = getBlock(self, currentBlock(self));
    if blk.instrs.len == 0 {
        return false;
    }
    match blk.instrs[blk.instrs.len - 1] {

///         return 0;   // @else diverges, no jump to merge.
///     }
///
/// In the above example, the merge block stays `nil`, and no code is generated
/// after the `if`. The merge block is created on first use.
unsafe fn emitMergeIfUnterminated(self: &mut FnLowerer, mergeBlock: &mut ?BlockId) throws (LowerError) {
unsafe fn emitMergeIfUnterminated 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, mergeBlock: &mut ?BlockId) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    if not blockHasTerminator(self) {
        if *mergeBlock == nil {
            set *mergeBlock = try createBlock(self, "merge");
        }
        let target = *mergeBlock else { throw LowerError::MissingTarget; };

// Control Flow Edge Management //
//////////////////////////////////

/// Add a predecessor edge from `pred` to `target`.
/// Must be called before the target block is sealed. Duplicates are ignored.
unsafe fn addPredecessor(self: &mut FnLowerer, target: BlockId, pred: BlockId) {
unsafe fn addPredecessor 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, target: BlockId, pred: BlockId) where 'arena: 'phase, 'phase: 'function {
    let blk = getBlockMut(self, target);
    assert blk.sealState <> Sealed::Yes, "addPredecessor: adding predecessor to sealed block";
    let preds = &mut blk.preds;
    for i in 0..preds.len {
        if preds[i] == *pred { // Avoid duplicate predecessor entries.
            return;
        }
    }
    preds.append(*pred, self.allocator);
    preds.append(*pred, alloc::arenaAllocator(self.arena));
}

/// Finalize all blocks and return the block array.
unsafe fn finalizeBlocks(self: &mut FnLowerer) -> *unsafe [il::Block] throws (LowerError) {
unsafe fn finalizeBlocks 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function) -> *unsafe [il::Block] throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let blockCount = self.blockData.len;
    let blocks = try! alloc::allocRawSlice(
        self.low.fnArena, @sizeOf(il::Block), @alignOf(il::Block), blockCount
        self.arena, @sizeOf(il::Block), @alignOf(il::Block), blockCount
    ) as *unsafe mut [il::Block];

    for i in 0..self.blockData.len {
        let data = &self.blockData[i];


// Loop Management //
/////////////////////

/// Enter a loop context for break/continue handling.
/// `continueBlock` is `nil` when the continue target is created lazily.
unsafe fn enterLoop(self: &mut FnLowerer, breakBlock: BlockId, continueBlock: ?BlockId) {
fn enterLoop 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, breakBlock: BlockId, continueBlock: ?BlockId) where 'arena: 'phase, 'phase: 'function {
    assert self.loopDepth < self.loopStack.len, "enterLoop: loop depth overflow";
    let slot = &mut self.loopStack[self.loopDepth];

    set slot.breakTarget = breakBlock;
    set slot.continueTarget = continueBlock;
    set self.loopDepth += 1;
}

/// Exit the current loop context.
fn exitLoop(self: &mut FnLowerer) {
fn exitLoop 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function) where 'arena: 'phase, 'phase: 'function {
    assert self.loopDepth <> 0, "exitLoop: loopDepth is zero";
    set self.loopDepth -= 1;
}

/// Get the current loop context.
unsafe fn currentLoop(self: &mut FnLowerer) -> ?*unsafe mut LoopCtx {
/// Copy the current loop targets.
fn currentLoop 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function) -> ?LoopCtx where 'arena: 'phase, 'phase: 'function {
    if self.loopDepth == 0 {
        return nil;
    }
    return &mut self.loopStack[self.loopDepth - 1];
    return self.loopStack[self.loopDepth - 1];
}

/// Get or lazily create the continue target block for the current loop.
unsafe fn getOrCreateContinueBlock(self: &mut FnLowerer) -> BlockId throws (LowerError) {
unsafe fn getOrCreateContinueBlock 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function) -> BlockId throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let ctx = currentLoop(self) else {
        throw LowerError::OutsideOfLoop;
    };
    if let block = ctx.continueTarget {
        return block;
    }
    let block = try createBlock(self, "step");
    set ctx.continueTarget = block;
    set self.loopStack[self.loopDepth - 1].continueTarget = block;
    return block;
}

/// Allocate a slice of values in the lowering arena.
unsafe fn allocVals(self: &mut FnLowerer, len: u32) -> *unsafe mut [il::Val] throws (LowerError) {
    return try! alloc::allocRawSlice(self.low.fnArena, @sizeOf(il::Val), @alignOf(il::Val), len) as *unsafe mut [il::Val];
unsafe fn allocVals 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, len: u32) -> *unsafe mut [il::Val] throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    return try! alloc::allocRawSlice(self.arena, @sizeOf(il::Val), @alignOf(il::Val), len) as *unsafe mut [il::Val];
}

/// Allocate a single-value slice in the lowering arena.
unsafe fn allocVal(self: &mut FnLowerer, val: il::Val) -> *unsafe mut [il::Val] throws (LowerError) {
unsafe fn allocVal 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, val: il::Val) -> *unsafe mut [il::Val] throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let args = try allocVals(self, 1);
    set args[0] = val;
    return args;
}


// a block parameter, but defer filling in the terminator arguments. When the
// block is later sealed via [`sealBlock`], all incomplete block params are resolved.

/// Declare a new source-level variable and define its initial value.
/// If called before any block exists (e.g., for parameters), the definition is skipped.
unsafe fn newVar(
    self: &mut FnLowerer,
unsafe fn newVar 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    name: ?*[u8],
    type: il::Type,
    mutable: bool,
    val: il::Val
) -> Var {
) -> Var where 'arena: 'phase, 'phase: 'function {
    let id = self.vars.len;
    self.vars.append(VarData { name, type, mutable, addressTaken: false }, self.allocator);
    self.vars.append(
        VarData { name, type, mutable, addressTaken: false },
        alloc::arenaAllocator(self.arena)
    );

    let v = Var(id);
    if self.currentBlock <> nil {
        defVar(self, v, val);
    }


/// Define (write) a variable. Record the SSA value of a variable in the
/// current block. Called when a variable is assigned or initialized (`let`
/// bindings, assignments, loop updates). When [`useVar`] is later called,
/// it will retrieve this value.
unsafe fn defVar(self: &mut FnLowerer, v: Var, val: il::Val) {
unsafe fn defVar 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, v: Var, val: il::Val) where 'arena: 'phase, 'phase: 'function {
    assert *v < self.vars.len;
    set getBlockMut(self, currentBlock(self)).vars[*v] = val;
}

/// Use (read) the current value of a variable in the current block.
/// May insert block parameters if the value must come from predecessors.
unsafe fn useVar(self: &mut FnLowerer, v: Var) -> il::Val throws (LowerError) {
unsafe fn useVar 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, v: Var) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    return try useVarInBlock(self, currentBlock(self), v);
}

/// Resolve which SSA definition of a variable reaches a use point in a given block.
///
/// Given a variable and a block where it's used, this function finds the
/// correct [`il::Val`] that holds the variable's value at that program point.
/// When control flow merges from multiple predecessors with different
/// definitions, it creates a block parameter to unify them.
unsafe fn useVarInBlock(self: &mut FnLowerer, block: BlockId, v: Var) -> il::Val throws (LowerError) {
unsafe fn useVarInBlock 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, block: BlockId, v: Var) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    assert *v < self.vars.len;

    let blk = getBlockMut(self, block);
    if let val = blk.vars[*v] {
        return val;

    return try createBlockParam(self, block, v);
}

/// Look up a variable by name in the current scope.
/// Searches from most recently declared to first, enabling shadowing.
unsafe fn lookupVarByName(self: &FnLowerer, name: *[u8]) -> ?Var {
unsafe fn lookupVarByName 'arena 'phase 'function (self: &FnLowerer 'arena 'phase 'function, name: *[u8]) -> ?Var where 'arena: 'phase, 'phase: 'function {
    let mut id = self.vars.len;
    while id > 0 {
        set id -= 1;
        if let varName = self.vars[id].name {
            // Names are interned strings, so pointer comparison suffices.

    }
    return nil;
}

/// Look up a local variable bound to an identifier node.
unsafe fn lookupLocalVar(self: &FnLowerer, node: *ast::Node) -> ?Var {
unsafe fn lookupLocalVar 'arena 'phase 'function (self: &FnLowerer 'arena 'phase 'function, node: *ast::Node) -> ?Var where 'arena: 'phase, 'phase: 'function {
    let case ast::NodeValue::Ident(name) = node.value else {
        return nil;
    };
    return lookupVarByName(self, name);
}

/// Save current lexical variable scope depth.
unsafe fn enterVarScope(self: &FnLowerer) -> u32 {
unsafe fn enterVarScope 'arena 'phase 'function (self: &FnLowerer 'arena 'phase 'function) -> u32 where 'arena: 'phase, 'phase: 'function {
    return self.vars.len;
}

/// Restore lexical variable scope depth.
unsafe fn exitVarScope(self: &mut FnLowerer, savedVarsLen: u32) {
unsafe fn exitVarScope 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, savedVarsLen: u32) where 'arena: 'phase, 'phase: 'function {
    set self.vars = @sliceOf(self.vars.ptr, savedVarsLen, self.vars.cap);
}

/// Get the metadata for a variable.
unsafe fn getVar(self: &FnLowerer, v: Var) -> *unsafe VarData {
unsafe fn getVar 'arena 'phase 'function (self: &FnLowerer 'arena 'phase 'function, v: Var) -> *unsafe VarData where 'arena: 'phase, 'phase: 'function {
    assert *v < self.vars.len;
    return &self.vars[*v];
}

/// Create a block parameter to merge a variable's value from multiple

///     @end(w32 %1)              // x = %1, merged from predecessors
///       ret %1;
///
/// Create a register `%1` as a block parameter. In a sealed block, patch each
/// predecessor's jump to pass its value of `x`. Otherwise, defer until sealing.
unsafe fn createBlockParam(self: &mut FnLowerer, block: BlockId, v: Var) -> il::Val throws (LowerError) {
unsafe fn createBlockParam 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, block: BlockId, v: Var) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    // Entry block must not have block parameters.
    assert block <> self.entryBlock, "createBlockParam: entry block must not have block parameters";
    // Allocate a register to hold the merged value.
    let reg = nextReg(self);
    let type = getVar(self, v).type;

    // Create block parameter and add it to the block.
    let param = il::Param { value: reg, type };
    let blk = getBlockMut(self, block);
    let paramIdx = blk.paramVars.len;
    blk.params.append(param, self.allocator);
    blk.paramVars.append(*v, self.allocator); // Associate variable with parameter.
    blk.params.append(param, alloc::arenaAllocator(self.arena));
    blk.paramVars.append(*v, alloc::arenaAllocator(self.arena)); // Associate variable with parameter.

    // Record that this variable's value in this block is now the parameter register.
    // This must happen before the predecessor loop to handle self-referential loops.
    set blk.vars[*v] = il::Val::Reg(reg);


///     x3 = phi(x1, x2)
///
/// This representation avoids the need for phi nodes to reference their
/// predecessor blocks explicitly, since the control flow edges already encode
/// that information.
unsafe fn resolveBlockArgs(self: &mut FnLowerer, block: BlockId, v: Var, paramIdx: u32) throws (LowerError) {
unsafe fn resolveBlockArgs 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, block: BlockId, v: Var, paramIdx: u32) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let blk = getBlock(self, block);

    // For each predecessor, recursively look up the variable's reaching definition
    // in that block, then patch the predecessor's terminator to pass that value
    // as an argument to this block's parameter.

    }
}

/// Check if a block parameter is trivial, i.e. all predecessors provide
/// the same value. Returns the trivial value if so.
unsafe fn getTrivialPhiVal(self: &mut FnLowerer, block: BlockId, v: Var) -> ?il::Val throws (LowerError) {
unsafe fn getTrivialPhiVal 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, block: BlockId, v: Var) -> ?il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let blk = getBlock(self, block);
    // Get the block parameter register.
    let paramReg = blk.vars[*v];
    // Check if all predecessors provide the same value.
    let mut sameVal: ?il::Val = nil;

    return sameVal;
}

/// Patch a single terminator argument for a specific edge. This is used during
/// SSA construction to pass variable values along control flow edges.
unsafe fn patchTerminatorArg(
    self: &mut FnLowerer,
unsafe fn patchTerminatorArg 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    from: BlockId,         // The predecessor block containing the terminator to patch.
    target: u32,           // The index of the target block we're passing the value to.
    paramIdx: u32,         // The index of the block parameter to set.
    val: il::Val           // The value to pass as the argument.
) {
) where 'arena: 'phase, 'phase: 'function {
    let data = getBlockMut(self, from);
    let ix = data.instrs.len - 1; // The terminator is always the last instruction.

    // TODO: We shouldn't need to use a mutable subscript here, given that the
    // fields are already mutable.

        }
    }
}

/// Grow an args array to hold at least the given capacity.
unsafe fn growArgs(self: &mut FnLowerer, args: *unsafe mut [il::Val], capacity: u32) -> *unsafe mut [il::Val] {
unsafe fn growArgs 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, args: *unsafe mut [il::Val], capacity: u32) -> *unsafe mut [il::Val] where 'arena: 'phase, 'phase: 'function {
    if args.len >= capacity {
        return args;
    }
    let newArgs = try! alloc::allocRawSlice(
        self.low.fnArena, @sizeOf(il::Val), @alignOf(il::Val), capacity
        self.arena, @sizeOf(il::Val), @alignOf(il::Val), capacity
    ) as *unsafe mut [il::Val];

    for arg, i in args {
        set newArgs[i] = arg;
    }

    return name;
}

/// Lower function parameters. Declares variables for each parameter.
/// When a receiver name is passed, we're handling a trait method.
unsafe fn lowerParams(
    self: &mut FnLowerer,
unsafe fn lowerParams 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    fnType: resolver::FnType,
    astParams: *[*ast::Node],
    receiverName: ?*ast::Node
) -> *unsafe [il::Param] throws (LowerError) {
) -> *unsafe [il::Param] throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let offset: u32 = 1 if self.returnReg <> nil else 0;
    let totalLen = fnType.paramTypes.len as u32 + offset;
    if totalLen == 0 {
        return &[];
    }
    assert fnType.paramTypes.len as u32 <= resolver::MAX_FN_PARAMS;

    let params = try! alloc::allocRawSlice(
        self.low.fnArena, @sizeOf(il::Param), @alignOf(il::Param), totalLen
        self.arena, @sizeOf(il::Param), @alignOf(il::Param), totalLen
    ) as *unsafe mut [il::Param];

    if let reg = self.returnReg {
        set params[0] = il::Param { value: reg, type: il::Type::W64 };
    }

        } else {
            set name = try paramName(&astParams[i].value);
        }
        let v = newVar(self, name, type, false, il::Val::Undef);

        self.params.append(FnParamBinding { var: v, reg }, self.allocator);
        set self.params[i] = FnParamBinding { var: v, reg };
        set self.paramsLen += 1;
    }
    return params;
}

/// Resolve match subject.
unsafe fn lowerMatchSubject(self: &mut FnLowerer, subject: *ast::Node) -> MatchSubject throws (LowerError) {
unsafe fn lowerMatchSubject 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, subject: *ast::Node) -> MatchSubject throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let mut val = try lowerExpr(self, subject);
    let subjectType = try typeOf(self, subject);
    let unwrapped = resolver::unwrapMatchSubject(subjectType);

    // When matching an aggregate by value, copy it to a fresh stack slot so

        else => return false,
    }
}

/// Load the tag byte from a tagged value aggregate (optionals and unions).
unsafe fn tvalTagReg(self: &mut FnLowerer, base: il::Reg) -> il::Reg {
unsafe fn tvalTagReg 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, base: il::Reg) -> il::Reg where 'arena: 'phase, 'phase: 'function {
    let tagReg = nextReg(self);
    emitLoadW8At(self, tagReg, base, TVAL_TAG_OFFSET);
    return tagReg;
}

/// Load the tag word from a result aggregate.
unsafe fn resultTagReg(self: &mut FnLowerer, base: il::Reg) -> il::Reg {
unsafe fn resultTagReg 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, base: il::Reg) -> il::Reg where 'arena: 'phase, 'phase: 'function {
    let tagReg = nextReg(self);
    emitLoadW64At(self, tagReg, base, TVAL_TAG_OFFSET);
    return tagReg;
}

/// Get the register to compare against `0` for optional `nil` checking.
/// For null-ptr-optimized types, loads the data pointer, or returns it
/// directly for scalar pointers. For aggregates, returns the tag register.
unsafe fn optionalNilReg(self: &mut FnLowerer, val: il::Val, typ: resolver::Type) -> il::Reg throws (LowerError) {
unsafe fn optionalNilReg 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, val: il::Val, typ: resolver::Type) -> il::Reg throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let reg = emitValToReg(self, val);

    match typ {
        case resolver::Type::Optional(resolver::Type::Slice { .. }) => {
            let ptrReg = nextReg(self);

        else => return reg,
    }
}

/// Lower an optional nil check (`opt == nil` or `opt <> nil`).
unsafe fn lowerNilCheck(self: &mut FnLowerer, opt: *ast::Node, isEq: bool) -> il::Val throws (LowerError) {
unsafe fn lowerNilCheck 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, opt: *ast::Node, isEq: bool) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let optTy = try typeOf(self, opt);
    // Handle `nil == nil` or `nil <> nil`.
    if optTy == resolver::Type::Nil {
        return il::Val::Imm(1) if isEq else il::Val::Imm(0);
    }

    let op = il::BinOp::Eq if isEq else il::BinOp::Ne;
    return emitTypedBinOp(self, op, cmpType, il::Val::Reg(cmpReg), il::Val::Imm(0));
}

/// Load the payload value from a tagged value aggregate at the given offset.
unsafe fn tvalPayloadVal(self: &mut FnLowerer, base: il::Reg, payload: resolver::Type, valOffset: i32) -> il::Val {
unsafe fn tvalPayloadVal 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, base: il::Reg, payload: resolver::Type, valOffset: i32) -> il::Val where 'arena: 'phase, 'phase: 'function {
    if payload == resolver::Type::Void {
        return il::Val::Undef;
    }
    return emitRead(self, base, valOffset, payload);
}

/// Compute the address of the payload in a tagged value aggregate.
unsafe fn tvalPayloadAddr(self: &mut FnLowerer, base: il::Reg, valOffset: i32) -> il::Val {
unsafe fn tvalPayloadAddr 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, base: il::Reg, valOffset: i32) -> il::Val where 'arena: 'phase, 'phase: 'function {
    return il::Val::Reg(emitPtrOffset(self, base, valOffset));
}

/// Bind a variable to a tagged value's payload.
unsafe fn bindPayloadVariable(
    self: &mut FnLowerer,
unsafe fn bindPayloadVariable 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    name: *[u8],
    subjectVal: il::Val,
    bindType: resolver::Type,
    matchBy: resolver::MatchBy,
    valOffset: i32,
    mutable: bool
) -> Var throws (LowerError) {
) -> Var throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let base = emitValToReg(self, subjectVal);
    let mut payload: il::Val = undefined;

    match matchBy {
        case resolver::MatchBy::Value =>

    };
    return newVar(self, name, ilType(self.low, bindType), mutable, payload);
}

/// Bind an identifier from a matched subject.
unsafe fn bindMatchVariable(
    self: &mut FnLowerer,
unsafe fn bindMatchVariable 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    subject: &MatchSubject,
    binding: *ast::Node,
    mutable: bool
) -> ?Var throws (LowerError) {
) -> ?Var throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    // Only bind if the pattern is an identifier.
    let case ast::NodeValue::Ident(name) = binding.value else {
        return nil;
    };
    // For optional aggregates, extract the payload from the tagged value.

}

/// Bind variables from inside case patterns (union variants, records, slices).
/// `failBlock` is passed when nested patterns may require additional tests
/// that branch on mismatch (e.g. nested union variant tests).
unsafe fn bindPatternVariables(self: &mut FnLowerer, subject: &MatchSubject, patterns: &[*ast::Node], failBlock: BlockId) throws (LowerError) {
unsafe fn bindPatternVariables 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, subject: &MatchSubject, patterns: &[*ast::Node], failBlock: BlockId) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    for pattern in patterns {

        // Handle simple variant patterns like `Variant(x)`.
        if let arg = resolver::variantPatternBinding(self.low.resolver, pattern) {
            let case MatchSubjectKind::Union(unionInfo) = subject.kind

                    try bindFieldVariable(self, arg, payloadBase, fieldInfo, subject.by, failBlock);
                }
            }
        }
        match pattern.value {
            case ast::NodeValue::Call(call) => {
                if let body = resolver::getRecord(subject.type) {
                    let base = emitValToReg(self, subject.val);
                    for binding, i in call.args {
                        try bindFieldVariable(self, binding, base, body.fields[i], subject.by, failBlock);
                    }
                }
            }
            // Compound variant patterns like `Variant { a, b }`.
            case ast::NodeValue::RecordLit(lit) =>
                try bindRecordPatternFields(self, subject, pattern, lit, failBlock),
            // Array patterns like `[a, b, c]`.
            case ast::NodeValue::ArrayLit(items) =>

}

/// Bind variables from an array literal pattern (e.g., `[a, 1, c]`).
/// Each element is either bound as a variable, skipped (placeholder), or
/// tested against the subject element, branching to `failBlock` on mismatch.
unsafe fn bindArrayPatternElements(
    self: &mut FnLowerer,
unsafe fn bindArrayPatternElements 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    subject: &MatchSubject,
    items: *[*ast::Node],
    failBlock: BlockId
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let case resolver::Type::Array(arrInfo) = subject.type
        else throw LowerError::ExpectedSliceOrArray;

    let elemTy = *arrInfo.item;
    let elemLayout = resolver::getTypeLayout(elemTy);

        try bindFieldVariable(self, elem, base, fieldInfo, subject.by, failBlock);
    }
}

/// Bind fields from a record pattern.
unsafe fn bindRecordPatternFields(self: &mut FnLowerer, subject: &MatchSubject, pattern: *ast::Node, lit: ast::RecordLit, failBlock: BlockId) throws (LowerError) {
unsafe fn bindRecordPatternFields 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, subject: &MatchSubject, pattern: *ast::Node, lit: ast::RecordLit, failBlock: BlockId) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    // No fields to bind (e.g., `{ .. }`).
    if lit.fields.len == 0 {
        return;
    }
    // Optional value patterns were already compared structurally by

    try bindNestedRecordFields(self, payloadBase, lit, recInfo, subject.by, failBlock);
}

/// Bind a single record field to a pattern variable, with support for nested
/// pattern tests that branch to `failBlock` on mismatch.
unsafe fn bindFieldVariable(
    self: &mut FnLowerer,
unsafe fn bindFieldVariable 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    binding: *ast::Node,
    base: il::Reg,
    fieldInfo: resolver::RecordField,
    matchBy: resolver::MatchBy,
    failBlock: BlockId
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    match binding.value {
        case ast::NodeValue::Ident(name) => {
            let val = emitRead(self, base, fieldInfo.offset, fieldInfo.fieldType)
                if matchBy == resolver::MatchBy::Value
                else il::Val::Reg(emitPtrOffset(self, base, fieldInfo.offset));

}

/// Emit a nested pattern test for a record field value, branching to
/// `failBlock` if the pattern does not match. On success, continues in
/// a fresh block and binds any nested variables.
unsafe fn emitNestedFieldTest(
    self: &mut FnLowerer,
unsafe fn emitNestedFieldTest 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    pattern: *ast::Node,
    base: il::Reg,
    fieldInfo: resolver::RecordField,
    matchBy: resolver::MatchBy,
    failBlock: BlockId
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let mut fieldType = fieldInfo.fieldType;
    let fieldPtr = emitPtrOffset(self, base, fieldInfo.offset);

    // Auto-deref: when the field is a pointer and the pattern destructures
    // the pointed-to value, load the pointer and use the target type.

    let patterns = [pattern];
    try bindPatternVariables(self, &nestedSubject, &patterns[..], failBlock);
}

/// Bind variables from a nested record literal pattern.
unsafe fn bindNestedRecordFields(
    self: &mut FnLowerer,
unsafe fn bindNestedRecordFields 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    base: il::Reg,
    lit: ast::RecordLit,
    recInfo: resolver::RecordType,
    matchBy: resolver::MatchBy,
    failBlock: BlockId
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    for fieldNode in lit.fields {
        let case ast::NodeValue::RecordLitField(field) = fieldNode.value else {
            throw LowerError::UnexpectedNodeValue(fieldNode);
        };
        let fieldIdx = resolver::recordFieldIndexFor(self.low.resolver, fieldNode)

        try bindFieldVariable(self, field.value, base, fieldInfo, matchBy, failBlock);
    }
}

/// Lower function body to a list of basic blocks.
unsafe fn lowerFnBody(self: &mut FnLowerer, body: *ast::Node) -> *unsafe [il::Block] throws (LowerError) {
unsafe fn lowerFnBody 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, body: *ast::Node) -> *unsafe [il::Block] throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    // Create and switch to entry block.
    let entry = try createBlock(self, "entry");
    set self.entryBlock = entry;
    switchToBlock(self, entry);

    /// Bind parameter registers to variables in the entry block.
    for def in self.params {
    for i in 0..self.paramsLen {
        let def = self.params[i];
        defVar(self, def.var, il::Val::Reg(def.reg));
    }
    /// Lower function body.
    try lowerBlock(self, body);


    }
    return try finalizeBlocks(self);
}

/// Lower a scalar match as a switch instruction.
unsafe fn lowerMatchSwitch(self: &mut FnLowerer, prongs: *[*ast::Node], subject: &MatchSubject, mergeBlock: &mut ?BlockId) throws (LowerError) {
unsafe fn lowerMatchSwitch 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, prongs: *[*ast::Node], subject: &MatchSubject, mergeBlock: &mut ?BlockId) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let mut blocks: [BlockId; 32] = undefined;
    let mut cases: *unsafe mut [il::SwitchCase] = &mut [];
    let mut defaultIdx: u32 = 0;
    let entry = currentBlock(self);



                    cases.append(il::SwitchCase {
                        value: constToScalar(cv),
                        target: *blocks[i],
                        args: &mut []
                    }, self.allocator);
                    }, alloc::arenaAllocator(self.arena));
                }
            }
        }
        addPredecessor(self, blocks[i], entry);
    }

///   arm#1:
///       jmp else#0;                     // guard failed, fallthrough to `else`
///   else#0:
///       ret 0;                          // `else` body
///
unsafe fn lowerMatch(self: &mut FnLowerer, node: *ast::Node, m: ast::Match) throws (LowerError) {
unsafe fn lowerMatch 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, m: ast::Match) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    assert m.prongs.len > 0;

    let prongs = m.prongs;
    // Lower the subject expression once; reused across all arms.
    let subject = try lowerMatchSubject(self, m.subject);

        try switchToAndSeal(self, blk);
    }
}

/// Lower an `if let` statement.
unsafe fn lowerIfLet(self: &mut FnLowerer, cond: ast::IfLet) throws (LowerError) {
unsafe fn lowerIfLet 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, cond: ast::IfLet) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let savedVarsLen = enterVarScope(self);
    let subject = try lowerMatchSubject(self, cond.pattern.scrutinee);
    let mut thenBlock: BlockId = undefined;
    if cond.pattern.guard == nil {
        set thenBlock = try createBlock(self, "then");

/// Emit pattern match branch with optional guard, and bind variables.
/// Used by `if-let`, `let-else`, and `while-let` lowering.
///
/// When a guard is present, the guard block is created before `successBlock`
/// to ensure block indices are in RPO.
unsafe fn lowerPatternMatch(
    self: &mut FnLowerer,
unsafe fn lowerPatternMatch 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    subject: &MatchSubject,
    pat: &ast::PatternMatch,
    successBlock: &mut BlockId,
    successLabel: *[u8],
    failBlock: BlockId
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    // If guard present, pattern match jumps to @guard, then guard evaluation
    // jumps to `successBlock` or `failBlock`. Otherwise, jump directly to
    // `successBlock`.
    let mut targetBlock: BlockId = undefined;
    if pat.guard <> nil {

        try switchToAndSeal(self, *successBlock);
    }
}

/// Lower a `let-else` statement.
unsafe fn lowerLetElse(self: &mut FnLowerer, letElse: ast::LetElse) throws (LowerError) {
unsafe fn lowerLetElse 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, letElse: ast::LetElse) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let subject = try lowerMatchSubject(self, letElse.pattern.scrutinee);
    let mut successBlock: BlockId = undefined;
    if letElse.pattern.guard == nil {
        set successBlock = try createBlock(self, "success");
    }

    // Continue at @merge after a successful match or value-producing fallback.
    try switchToAndSeal(self, mergeBlock);
}

/// Lower a `while let` loop as a match-driven loop.
unsafe fn lowerWhileLet(self: &mut FnLowerer, w: ast::WhileLet) throws (LowerError) {
unsafe fn lowerWhileLet 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, w: ast::WhileLet) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let savedVarsLen = enterVarScope(self);
    // Create control flow blocks: loop header, body (created lazily when
    // there's a guard), and exit.
    let whileBlock = try createBlock(self, "while");
    let mut bodyBlock: BlockId = undefined;

///////////////////
// Node Lowering //
///////////////////

/// Lower an AST node.
unsafe fn lowerNode(self: &mut FnLowerer, node: *ast::Node) throws (LowerError) {
unsafe fn lowerNode 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    if self.low.options.debug {
        set self.srcLoc.offset = node.span.offset;
    }
    match node.value {
        case ast::NodeValue::RegionBlock { bindings, body, .. } => {
            let savedVarsLen = enterVarScope(self);
            let values = try allocVals(self, bindings.len);
            for bindingNode, i in bindings {
                let case ast::NodeValue::RegionBinding(binding) = bindingNode.value
                    else throw LowerError::ExpectedIdentifier;
                set values[i] = try lowerExpr(self, binding.value);
                if blockHasTerminator(self) {
                    exitVarScope(self, savedVarsLen);
                    return;
                }
            }
            for bindingNode, i in bindings {
                let case ast::NodeValue::RegionBinding(binding) = bindingNode.value
                    else throw LowerError::ExpectedIdentifier;
                try bindLetValue(self, bindingNode, ast::borrowBinding(binding), values[i]);
            }
            try lowerBlock(self, body);
            exitVarScope(self, savedVarsLen);
        }
        case ast::NodeValue::Block(_) => {
            try lowerBlock(self, node);
        }
        case ast::NodeValue::Return { value } => {
            try lowerReturnStmt(self, node, value);

        }
    }
}

/// Lower a code block.
unsafe fn lowerBlock(self: &mut FnLowerer, node: *ast::Node) throws (LowerError) {
unsafe fn lowerBlock 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let case ast::NodeValue::Block(blk) = node.value else {
        throw LowerError::ExpectedBlock(node);
    };
    let savedVarsLen = enterVarScope(self);
    for stmt in blk.statements {


/// Return the effective type of a node after any coercion applied by
/// the resolver. `lowerExpr` already materializes the coercion in the
/// IL value, so the lowerer must use the post-coercion type when
/// choosing how to compare or store that value.
unsafe fn effectiveType(self: &mut FnLowerer, node: *ast::Node) -> resolver::Type throws (LowerError) {
unsafe fn effectiveType 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node) -> resolver::Type throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let ty = try typeOf(self, node);
    if let coerce = resolver::coercionFor(self.low.resolver, node) {
        if let case resolver::Coercion::OptionalLift(optTy) = coerce {
            return optTy;
        }


/// Check if a resolver type lowers to an aggregate in memory.
unsafe fn isAggregateType(typ: resolver::Type) -> bool {
    match typ {
        case resolver::Type::Slice { .. },
             resolver::Type::TraitObject { .. } => return true,
             resolver::Type::TraitObject { .. },
             resolver::Type::Session(_) => return true,
        case resolver::Type::Optional(resolver::Type::Pointer { .. }) => {
            // Optional pointers are scalar due to NPO.
            return false;
        }
        case resolver::Type::Optional(_) => {

}

/// Check if a node is a void union variant literal (e.g. `Color::Red`).
/// If so, returns the variant's tag index. This enables optimized comparisons
/// that only check the tag instead of doing full aggregate comparison.
unsafe fn voidVariantIndex(res: &resolver::Resolver, node: *ast::Node) -> ?i64 {
unsafe fn voidVariantIndex 'arena (res: &resolver::Resolver 'arena, node: *ast::Node) -> ?i64 {
    let data = resolver::nodeData(res, node);
    // Optional equality checks both the presence tag and the union value.
    if let case resolver::Coercion::OptionalLift(_) = data.coercion {
        return nil;
    }

    }
    return index as i64;
}

/// Reserve stack storage for a value of the given type.
unsafe fn emitReserve(self: &mut FnLowerer, typ: resolver::Type) -> il::Reg throws (LowerError) {
unsafe fn emitReserve 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, typ: resolver::Type) -> il::Reg throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let layout = resolver::getTypeLayout(typ);
    return emitReserveLayout(self, layout);
}

/// Reserve stack storage with an explicit layout.
unsafe fn emitReserveLayout(self: &mut FnLowerer, layout: resolver::Layout) -> il::Reg {
unsafe fn emitReserveLayout 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, layout: resolver::Layout) -> il::Reg where 'arena: 'phase, 'phase: 'function {
    let dst = nextReg(self);

    emit(self, il::Instr::Reserve {
        dst,
        size: il::Val::Imm(layout.size as i64),

    });
    return dst;
}

/// Store a value into an address.
unsafe fn emitStore(self: &mut FnLowerer, base: il::Reg, offset: i32, typ: resolver::Type, src: il::Val) throws (LowerError) {
unsafe fn emitStore 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, base: il::Reg, offset: i32, typ: resolver::Type, src: il::Val) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    // `undefined` values need no store.
    if let case il::Val::Undef = src {
        return;
    }
    if isAggregateType(typ) {

        });
    }
}

/// Allocate stack space for a value and store it. Returns a pointer to the value.
unsafe fn emitStackVal(self: &mut FnLowerer, typ: resolver::Type, val: il::Val) -> il::Val throws (LowerError) {
unsafe fn emitStackVal 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, typ: resolver::Type, val: il::Val) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let ptr = try emitReserve(self, typ);
    try emitStore(self, ptr, 0, typ, val);
    return il::Val::Reg(ptr);
}

/// Generic helper to build any tagged aggregate.
/// Reserves space based on the provided layout, stores the tag, and optionally
/// stores the payload value at `valOffset`.
unsafe fn buildTagged(
    self: &mut FnLowerer,
unsafe fn buildTagged 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    layout: resolver::Layout,
    tag: i64,
    payload: ?il::Val,
    payloadType: resolver::Type,
    tagSize: u32,
    valOffset: i32
) -> il::Val throws (LowerError) {
) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let dst = nextReg(self);
    emit(self, il::Instr::Reserve {
        dst,
        size: il::Val::Imm(layout.size as i64),
        alignment: layout.alignment,

/// Wrap a value in an optional type.
///
/// For optional pointers (`?*T`), the value is returned as-is since pointers
/// use zero to represent `nil`. For other optionals, builds a tagged aggregate.
/// with the tag set to `1`, and the value as payload.
unsafe fn wrapInOptional(self: &mut FnLowerer, val: il::Val, optType: resolver::Type) -> il::Val throws (LowerError) {
unsafe fn wrapInOptional 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, val: il::Val, optType: resolver::Type) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let case resolver::Type::Optional(inner) = optType else {
        throw LowerError::ExpectedOptional;
    };
    // Null-pointer-optimized (NPO) types are used as-is -- valid values are never null.
    if resolver::isNullableType(*inner) {


/// Build a `nil` value for an optional type.
///
/// For optional pointers (`?*T`), returns an immediate `0` (null pointer).
/// For other optionals, builds a tagged aggregate with tag set to `0` (absent).
unsafe fn buildNilOptional(self: &mut FnLowerer, optType: resolver::Type) -> il::Val throws (LowerError) {
unsafe fn buildNilOptional 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, optType: resolver::Type) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let case resolver::Type::Optional(inner) = optType
        else throw LowerError::ExpectedOptional;
    if let case resolver::Type::Pointer { .. } = *inner {
        return il::Val::Imm(0);
    }

    let valOffset = resolver::getOptionalValOffset(*inner) as i32;
    return try buildTagged(self, resolver::getTypeLayout(optType), 0, nil, *inner, 1, valOffset);
}

/// Build a result value for throwing functions.
unsafe fn buildResult(
    self: &mut FnLowerer,
unsafe fn buildResult 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    tag: i64,
    payload: ?il::Val,
    payloadType: resolver::Type
) -> il::Val throws (LowerError) {
) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let successType = *self.fnType.returnType;
    let layout = resolver::getResultLayout(
        successType, self.fnType.throwList
    );
    return try buildTagged(self, layout, tag, payload, payloadType, resolver::PTR_SIZE as i32, RESULT_VAL_OFFSET);
}

/// Build a slice aggregate from a data pointer, length and capacity.
unsafe fn buildSliceValue(
    self: &mut FnLowerer,
unsafe fn buildSliceValue 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    elemTy: *resolver::Type,
    mutable: bool,
    ptrVal: il::Val,
    lenVal: il::Val,
    capVal: il::Val
) -> il::Val throws (LowerError) {
) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let sliceType = resolver::Type::Slice {
        class: types::PointerClass::Unsafe,
        item: elemTy,
        mutable,
    };


    return il::Val::Reg(dst);
}

/// Build a trait object fat pointer from a data pointer and a v-table.
unsafe fn buildTraitObject(
    self: &mut FnLowerer,
unsafe fn buildTraitObject 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    dataVal: il::Val,
    traitInfo: *unsafe resolver::TraitType,
    inst: &resolver::InstanceEntry
) -> il::Val throws (LowerError) {
) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let vName = vtableName(self.low, inst.moduleId, inst.concreteTypeName, traitInfo.name);

    // Reserve space for the trait object on the stack.
    let slot = emitReserveLayout(self, resolver::Layout {
        size: resolver::PTR_SIZE * 2,

    });
    return il::Val::Reg(slot);
}

/// Compute a field pointer by adding a byte offset to a base address.
unsafe fn emitPtrOffset(self: &mut FnLowerer, base: il::Reg, offset: i32) -> il::Reg {
unsafe fn emitPtrOffset 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, base: il::Reg, offset: i32) -> il::Reg where 'arena: 'phase, 'phase: 'function {
    if offset == 0 {
        return base;
    }
    let dst = nextReg(self);


    return dst;
}

/// Emit an element address computation for array/slice indexing.
/// Computes: `base + idx * stride`.
unsafe fn emitElem(self: &mut FnLowerer, stride: u32, base: il::Reg, idx: il::Val) -> il::Reg {
unsafe fn emitElem 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, stride: u32, base: il::Reg, idx: il::Val) -> il::Reg where 'arena: 'phase, 'phase: 'function {
    // If index is zero, return base directly.
    if idx == il::Val::Imm(0) {
        return base;
    }
    // If stride is `1`, skip the multiply.

    });
    return dst;
}

/// Emit a typed binary operation, returning the result as a value.
unsafe fn emitTypedBinOp(self: &mut FnLowerer, op: il::BinOp, typ: il::Type, a: il::Val, b: il::Val) -> il::Val {
unsafe fn emitTypedBinOp 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, op: il::BinOp, typ: il::Type, a: il::Val, b: il::Val) -> il::Val where 'arena: 'phase, 'phase: 'function {
    let dst = nextReg(self);
    emit(self, il::Instr::BinOp { op, typ, dst, a, b });
    return il::Val::Reg(dst);
}

/// Emit a tag comparison for void variant equality/inequality.
unsafe fn emitTagCmp(self: &mut FnLowerer, op: ast::BinaryOp, val: il::Val, tagIdx: i64, valType: resolver::Type) -> il::Val
    throws (LowerError)
unsafe fn emitTagCmp 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, op: ast::BinaryOp, val: il::Val, tagIdx: i64, valType: resolver::Type) -> il::Val
    throws (LowerError) where 'arena: 'phase, 'phase: 'function
{
    let reg = emitValToReg(self, val);

    // For all-void unions, the value *is* the tag, not a pointer.
    let mut tag: il::Val = undefined;

    let binOp = il::BinOp::Eq if op == ast::BinaryOp::Eq else il::BinOp::Ne;
    return emitTypedBinOp(self, binOp, il::Type::W8, tag, il::Val::Imm(tagIdx));
}

/// Logical "and" between two values. Returns the result in a register.
unsafe fn emitLogicalAnd(self: &mut FnLowerer, left: ?il::Val, right: il::Val) -> il::Val {
unsafe fn emitLogicalAnd 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, left: ?il::Val, right: il::Val) -> il::Val where 'arena: 'phase, 'phase: 'function {
    let prev = left else {
        return right;
    };
    return emitTypedBinOp(self, il::BinOp::And, il::Type::W32, prev, right);
}

//////////////////////////
// Aggregate Comparison //
//////////////////////////

/// Emit an equality test for values at an offset of the given base registers.
unsafe fn emitEqAtOffset(
    self: &mut FnLowerer,
unsafe fn emitEqAtOffset 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    left: il::Reg,
    right: il::Reg,
    offset: i32,
    fieldType: resolver::Type
) -> il::Val throws (LowerError) {
) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    // For aggregate types, pass offset through and compare recursively.
    if isAggregateType(fieldType) {
        return try lowerAggregateEq(self, fieldType, left, right, offset);
    }
    // For scalar types, load and compare directly.


    return il::Val::Reg(dst);
}

/// Compare two record values for equality.
unsafe fn lowerRecordEq(
    self: &mut FnLowerer,
unsafe fn lowerRecordEq 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    recInfo: resolver::RecordType,
    a: il::Reg,
    b: il::Reg,
    offset: i32
) -> il::Val throws (LowerError) {
) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let mut result: ?il::Val = nil;

    for field in recInfo.fields {
        let cmp = try emitEqAtOffset(self, a, b, offset + field.offset, field.fieldType);


    }
    return il::Val::Imm(1);
}

/// Compare two slice values for equality.
unsafe fn lowerSliceEq(
    self: &mut FnLowerer,
unsafe fn lowerSliceEq 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    elemTy: *resolver::Type,
    mutable: bool,
    a: il::Reg,
    b: il::Reg,
    offset: i32
) -> il::Val throws (LowerError) {
) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let ptrTy = resolver::Type::Pointer {
        class: types::PointerClass::Unsafe,
        target: elemTy,
        mutable,
    };

/// branchless formulation: `tagEq AND (tagNil OR payloadEq)`
///
/// For inner types that may contain uninitialized data when `nil` (unions,
/// nested optionals), the payload comparison is guarded behind a branch
/// so that `nil` payloads are never inspected.
unsafe fn lowerOptionalEq(
    self: &mut FnLowerer,
unsafe fn lowerOptionalEq 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    inner: resolver::Type,
    a: il::Reg,
    b: il::Reg,
    offset: i32
) -> il::Val throws (LowerError) {
) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let valOffset = resolver::getOptionalValOffset(inner) as i32;

    // Load tags.
    let tagA = loadTag(self, a, offset + TVAL_TAG_OFFSET, il::Type::W8);
    let tagB = loadTag(self, b, offset + TVAL_TAG_OFFSET, il::Type::W8);

/// For all-void unions, we skip the control flow entirely and just compare
/// the tags directly.
///
/// TODO: Could be optimized to branchless when all non-void variants share
/// the same payload type: `tagEq AND (isVoidVariant OR payloadEq)`.
unsafe fn lowerUnionEq(
    self: &mut FnLowerer,
unsafe fn lowerUnionEq 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    unionInfo: resolver::UnionType,
    a: il::Reg,
    b: il::Reg,
    offset: i32
) -> il::Val throws (LowerError) {
) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    // Compare tags.
    let tagA = loadTag(self, a, offset + TVAL_TAG_OFFSET, il::Type::W8);
    let tagB = loadTag(self, b, offset + TVAL_TAG_OFFSET, il::Type::W8);

    // Fast path: all-void union just needs tag comparison.


    // Create comparison blocks for each non-void variant and build switch cases.
    // Void variants jump directly to merge with `true`.
    let trueArgs = try allocVal(self, il::Val::Imm(1));
    let cases = try! alloc::allocRawSlice(
        self.low.fnArena, @sizeOf(il::SwitchCase), @alignOf(il::SwitchCase), unionInfo.variants.len as u32
        self.arena, @sizeOf(il::SwitchCase), @alignOf(il::SwitchCase), unionInfo.variants.len as u32
    ) as *unsafe mut [il::SwitchCase];

    let mut caseBlocks: [?BlockId; resolver::MAX_UNION_VARIANTS] = undefined;
    for variant, i in unionInfo.variants {
        if variant.valueType == resolver::Type::Void {

    try switchToAndSeal(self, mergeBlock);
    return il::Val::Reg(resultReg);
}

/// Compare two array values for equality, element by element.
unsafe fn lowerArrayEq(
    self: &mut FnLowerer,
unsafe fn lowerArrayEq 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    arr: resolver::ArrayType,
    a: il::Reg,
    b: il::Reg,
    offset: i32
) -> il::Val throws (LowerError) {
) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let elemLayout = resolver::getTypeLayout(*arr.item);
    let stride = elemLayout.size as i32;
    let mut result: ?il::Val = nil;

    for i in 0..arr.length {

    // Empty arrays are always equal.
    return il::Val::Imm(1);
}

/// Compare two aggregate values for equality.
unsafe fn lowerAggregateEq(
    self: &mut FnLowerer,
unsafe fn lowerAggregateEq 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    typ: resolver::Type,
    a: il::Reg,
    b: il::Reg,
    offset: i32
) -> il::Val throws (LowerError) {
) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    match typ {
        case resolver::Type::Slice { item, mutable, .. } =>
            return try lowerSliceEq(self, item, mutable, a, b, offset),
        case resolver::Type::Optional(inner) => {
            if let case resolver::Type::Slice { item, mutable, .. } = *inner {

    }
}

/// Lower a record literal expression. Handles both plain records and union variant
/// record literals like `Union::Variant { field: value }`.
unsafe fn lowerRecordLit(self: &mut FnLowerer, node: *ast::Node, lit: ast::RecordLit) -> il::Val throws (LowerError) {
unsafe fn lowerRecordLit 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, lit: ast::RecordLit) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let typ = try typeOf(self, node);
    match typ {
        case resolver::Type::Nominal(resolver::NominalType::Record(recInfo)) => {
            let dst = try emitReserve(self, typ);
            try lowerRecordFields(self, dst, &recInfo, lit.fields, 0);

    }
}

/// Lower fields of a record literal into a destination register.
/// The `offset` is added to each field's offset when storing.
unsafe fn lowerRecordFields(
    self: &mut FnLowerer,
unsafe fn lowerRecordFields 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    dst: il::Reg,
    recInfo: &resolver::RecordType,
    fields: *[*ast::Node],
    offset: i32
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    for fieldNode, i in fields {
        let case ast::NodeValue::RecordLitField(field) = fieldNode.value else {
            throw LowerError::UnexpectedNodeValue(fieldNode);
        };
        let mut fieldIdx: u32 = i;

        }
    }
}

/// Lower an unlabeled record constructor call.
unsafe fn lowerRecordCtor(self: &mut FnLowerer, nominal: *unsafe resolver::NominalType, args: *[*ast::Node]) -> il::Val throws (LowerError) {
unsafe fn lowerRecordCtor 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, nominal: *unsafe resolver::NominalType, args: *[*ast::Node]) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let case resolver::NominalType::Record(recInfo) = *nominal else {
        throw LowerError::ExpectedRecord;
    };
    let typ = resolver::Type::Nominal(nominal);
    let dst = try emitReserve(self, typ);

    }
    return il::Val::Reg(dst);
}

/// Lower an array literal expression like `[1, 2, 3]`.
unsafe fn lowerArrayLit(self: &mut FnLowerer, node: *ast::Node, elements: *[*ast::Node]) -> il::Val
    throws (LowerError)
unsafe fn lowerArrayLit 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, elements: *[*ast::Node]) -> il::Val
    throws (LowerError) where 'arena: 'phase, 'phase: 'function
{
    let typ = try typeOf(self, node);
    let case resolver::Type::Array(arrInfo) = typ else {
        throw LowerError::ExpectedArray;
    };

}

/// Lower an array repeat literal expression like `[42; 3]`.
/// Unrolls the initialization at compile time.
// TODO: Beyond a certain length, lower this to a loop.
unsafe fn lowerArrayRepeatLit(self: &mut FnLowerer, node: *ast::Node, repeat: ast::ArrayRepeatLit) -> il::Val
    throws (LowerError)
unsafe fn lowerArrayRepeatLit 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, repeat: ast::ArrayRepeatLit) -> il::Val
    throws (LowerError) where 'arena: 'phase, 'phase: 'function
{
    let typ = try typeOf(self, node);
    let case resolver::Type::Array(arrInfo) = typ else {
        throw LowerError::ExpectedArray;
    };

    }
    return il::Val::Reg(dst);
}

/// Lower a union constructor call like `Union::Variant(...)`.
unsafe fn lowerUnionCtor(self: &mut FnLowerer, node: *ast::Node, sym: *unsafe mut resolver::Symbol, call: ast::Call) -> il::Val
    throws (LowerError)
unsafe fn lowerUnionCtor 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, sym: *unsafe mut resolver::Symbol, call: ast::Call) -> il::Val
    throws (LowerError) where 'arena: 'phase, 'phase: 'function
{
    let unionTy = try typeOf(self, node);
    let case resolver::SymbolData::Variant { type: payloadType, index, .. } = sym.data else {
        throw LowerError::ExpectedVariant;
    };

    }
    return try buildTagged(self, resolver::getTypeLayout(unionTy), index as i64, payloadVal, payloadType, 1, valOffset);
}

/// Lower a field access into a pointer to the field.
unsafe fn lowerFieldRef(self: &mut FnLowerer, access: ast::Access) -> FieldRef throws (LowerError) {
unsafe fn lowerFieldRef 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, access: ast::Access) -> FieldRef throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let parentTy = try typeOf(self, access.parent);
    let subjectTy = resolver::autoDeref(parentTy);
    let fieldIdx = resolver::recordFieldIndexFor(self.low.resolver, access.child) else {
        throw LowerError::MissingMetadata;
    };

        fieldType: fieldInfo.fieldType,
    };
}

/// Lower a field access expression.
unsafe fn lowerFieldAccess(self: &mut FnLowerer, access: ast::Access) -> il::Val throws (LowerError) {
unsafe fn lowerFieldAccess 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, access: ast::Access) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let fieldRef = try lowerFieldRef(self, access);
    return emitRead(self, fieldRef.base, fieldRef.offset, fieldRef.fieldType);
}

/// Compute data pointer and element count for a range into a container.
/// Used by both slice range expressions (`&a[start..end]`) and slice
/// assignments (`a[start..end] = value`).
unsafe fn resolveSliceRangePtr(
    self: &mut FnLowerer,
unsafe fn resolveSliceRangePtr 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    container: *ast::Node,
    range: ast::Range,
    info: resolver::SliceRangeInfo
) -> SliceRangeResult throws (LowerError) {
) -> SliceRangeResult throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let baseVal = try lowerExpr(self, container);
    let baseReg = emitValToReg(self, baseVal);

    // Extract data pointer and container length.
    let mut dataReg = baseReg;

    }
    return SliceRangeResult { dataReg, count };
}

/// Lower a slice range expression into a slice header value.
unsafe fn lowerSliceRange(
    self: &mut FnLowerer,
unsafe fn lowerSliceRange 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    container: *ast::Node,
    range: ast::Range,
    sliceNode: *ast::Node
) -> il::Val throws (LowerError) {
) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let info = resolver::sliceRangeInfoFor(self.low.resolver, sliceNode) else {
        throw LowerError::MissingMetadata;
    };
    let r = try resolveSliceRangePtr(self, container, range, info);
    return try buildSliceValue(
        self, info.itemType, info.mutable, il::Val::Reg(r.dataReg), r.count, r.count
    );
}

/// Lower an address-of (`&x`) expression.
unsafe fn lowerAddressOf(self: &mut FnLowerer, node: *ast::Node, addr: ast::AddressOf) -> il::Val throws (LowerError) {
unsafe fn lowerAddressOf 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, addr: ast::AddressOf) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    // Handle subscript: `&ary[i]` or `&ary[start..end]`.
    if let case ast::NodeValue::Subscript { container, index } = addr.target.value {
        if let case ast::NodeValue::Range(range) = index.value {
            return try lowerSliceRange(self, container, range, node);
        }

        let fieldRef = try lowerFieldRef(self, access);
        let ptr = emitPtrOffset(self, fieldRef.base, fieldRef.offset);

        return il::Val::Reg(ptr);
    }
    // A qualified constant or static uses its resolved owner's data symbol.
    if let case ast::NodeValue::ScopeAccess(_) = addr.target.value {
        let sym = resolver::nodeData(self.low.resolver, addr.target).sym else {
            throw LowerError::MissingSymbol(addr.target);
        };
        return il::Val::Reg(emitDataAddr(self, sym));
    }
    // Handle variable address: `&x`
    if let case ast::NodeValue::Ident(_) = addr.target.value {
        if let v = lookupLocalVar(self, addr.target) {
            let val = try useVar(self, v);
            let typ = try typeOf(self, addr.target);

    }
    throw LowerError::UnexpectedNodeValue(addr.target);
}

/// Lower an addressed array literal as a slice.
unsafe fn lowerArrayLiteralSlice(
    self: &mut FnLowerer,
unsafe fn lowerArrayLiteralSlice 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    sliceNode: *ast::Node,
    arrayNode: *ast::Node
) -> il::Val throws (LowerError) {
) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let sliceTy = try typeOf(self, sliceNode);
    let case resolver::Type::Slice { item, mutable, .. } = sliceTy else {
        throw LowerError::UnexpectedType(sliceTy);
    };
    let arrayTy = try typeOf(self, arrayNode);

            self, item, mutable, il::Val::Imm(0), il::Val::Imm(0), il::Val::Imm(0)
        );
    }
    if resolver::isConstExpr(self.low.resolver, arrayNode) {
        let fnName = self.fnName;
        let mut b = dataBuilder(self.low.allocator);
        let mut b = dataBuilder(alloc::arenaAllocator(self.low.arena));
        match arrayNode.value {
            case ast::NodeValue::ArrayLit(elements) =>
                try lowerConstArrayLitInto(self.low, elements, arrayTy, fnName, &mut b),
            case ast::NodeValue::ArrayRepeatLit(repeat) =>
                try lowerConstArrayRepeatInto(self.low, repeat, arrayTy, fnName, &mut b),


/// Lower the common element pointer computation for subscript operations.
/// Handles both arrays and slices by resolving the container type, extracting
/// the data pointer (for slices), and emitting an [`il::Instr::Elem`] to compute
/// the element address.
unsafe fn lowerElemPtr(
    self: &mut FnLowerer, container: *ast::Node, index: *ast::Node
) -> ElemPtrResult throws (LowerError) {
unsafe fn lowerElemPtr 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function, container: *ast::Node, index: *ast::Node
) -> ElemPtrResult throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let containerTy = try typeOf(self, container);
    let subjectTy = resolver::autoDeref(containerTy);
    let baseVal = try lowerExpr(self, container);
    let indexVal = try lowerExpr(self, index);
    let baseReg = emitValToReg(self, baseVal);

}

/// Lower a dereference expression.
/// Handles both pointer deref (`*ptr`) and record deref (`*r` on single-field
/// unlabeled record). Both read at offset 0 using the resolver-assigned type.
unsafe fn lowerDeref(self: &mut FnLowerer, node: *ast::Node, target: *ast::Node) -> il::Val throws (LowerError) {
unsafe fn lowerDeref 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, target: *ast::Node) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let type = try typeOf(self, node);
    let ptrVal = try lowerExpr(self, target);
    let ptrReg = emitValToReg(self, ptrVal);

    return emitRead(self, ptrReg, 0, type);
    let value = emitRead(self, ptrReg, 0, type);
    if let case resolver::Type::Cell { .. } = try typeOf(self, target); isAggregateType(type) {
        return try emitStackVal(self, type, value);
    }
    return value;
}

/// Lower a subscript expression.
unsafe fn lowerSubscript(self: &mut FnLowerer, node: *ast::Node, container: *ast::Node, index: *ast::Node) -> il::Val
    throws (LowerError)
unsafe fn lowerSubscript 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, container: *ast::Node, index: *ast::Node) -> il::Val
    throws (LowerError) where 'arena: 'phase, 'phase: 'function
{
    if let case ast::NodeValue::Range(_) = index.value {
        panic "lowerSubscript: range subscript must use address-of (&)";
    }
    let result = try lowerElemPtr(self, container, index);

    return emitRead(self, result.elemReg, 0, result.elemType);
}

/// Lower a let binding.
unsafe fn lowerLet(self: &mut FnLowerer, node: *ast::Node, l: ast::Let) throws (LowerError) {
unsafe fn lowerLet 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, l: ast::Let) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    // Evaluate value.
    let val = try lowerExpr(self, l.value);
    if blockHasTerminator(self) {
        return;
    }
    try bindLetValue(self, node, l, val);
}

/// Bind an evaluated initializer in the current variable scope.
unsafe fn bindLetValue 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, l: ast::Let, val: il::Val)
    throws (LowerError) where 'arena: 'phase, 'phase: 'function
{
    // Handle placeholder pattern: `let _ = expr;`
    if let case ast::NodeValue::Placeholder = l.ident.value {
        return;
    }
    let case ast::NodeValue::Ident(name) = l.ident.value else {
        throw LowerError::ExpectedIdentifier;
    };
    let typ = try typeOf(self, l.value);
    let typ = try typeOf(self, l.ident);
    let ilType = ilType(self.low, typ);
    let mut varVal = val;

    // Aggregates with persistent storage need a local copy to avoid aliasing.
    // Temporaries such as literals or call results can be adopted directly.

    // Void variant literals (e.g. `Option::None`) use scope access syntax and
    // are flagged as place expressions, but they are freshly constructed
    // temporaries with no persistent storage.
    if isAggregateType(typ) and
        ast::isPlaceExpr(l.value) and
        not resolver::isCellDeref(self.low.resolver, l.value) and
        voidVariantIndex(self.low.resolver, l.value) == nil {
        set varVal = try emitStackVal(self, typ, val);
    }

    // If the resolver determined that this variable's address is taken

///
///     @entry -> (true)  @then ---> @end <--.
///         |                                 )
///         `---- (false) -------------------'
///
unsafe fn lowerIf(self: &mut FnLowerer, i: ast::If) throws (LowerError) {
unsafe fn lowerIf 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, i: ast::If) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let thenBlock = try createBlock(self, "then");

    if let elseNode = i.elseBranch { // If-else case.
        let elseBlock = try createBlock(self, "else");
        try emitCondBranch(self, i.condition, thenBlock, elseBlock);

}

/// Lower an assignment target that designates a memory location, and return
/// the address to store through. Returns `nil` without emitting anything for
/// targets that aren't memory-backed, such as locals tracked in SSA.
unsafe fn lowerPlace(self: &mut FnLowerer, target: *ast::Node) -> ?FieldRef throws (LowerError) {
unsafe fn lowerPlace 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, target: *ast::Node) -> ?FieldRef throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    match target.value {
        case ast::NodeValue::ScopeAccess(_) => {
            let sym = try symOf(self, target);
            let case resolver::SymbolData::Value { type, .. } = sym.data else {
                throw LowerError::ImmutableAssignment;

/// whether it was handled. Nothing is emitted when it isn't.
///
/// Compound assignments share their target node with the left operand of the
/// desugared binary expression. Resolve that place once so side effects in a
/// dereference, field parent, or subscript index are not repeated for the store.
unsafe fn lowerCompoundAssign(
    self: &mut FnLowerer, expr: *ast::Node, binop: ast::BinOp
) -> bool throws (LowerError) {
unsafe fn lowerCompoundAssign 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function, expr: *ast::Node, binop: ast::BinOp
) -> bool throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let place = try lowerPlace(self, binop.left) else return false;
    let current = emitRead(self, place.base, place.offset, place.fieldType);
    let left = try applyCoercion(self, binop.left, current);
    let right = try lowerExpr(self, binop.right);
    let exprType = try typeOf(self, expr);


    return true;
}

/// Lower an assignment statement.
unsafe fn lowerAssign(self: &mut FnLowerer, node: *ast::Node, a: ast::Assign) throws (LowerError) {
unsafe fn lowerAssign 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, a: ast::Assign) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    // Slice assignment: `slice[range] = value`.
    if let info = resolver::sliceRangeInfoFor(self.low.resolver, node) {
        let case ast::NodeValue::Subscript { container, index } = a.left.value
            else panic "lowerAssign: slice assign without subscript";
        let case ast::NodeValue::Range(range) = index.value

        }
    }
}

/// Lower `slice[range] = value`.
unsafe fn lowerSliceAssign(
    self: &mut FnLowerer,
unsafe fn lowerSliceAssign 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    rhs: *ast::Node,
    container: *ast::Node,
    range: ast::Range,
    info: resolver::SliceRangeInfo
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let r = try resolveSliceRangePtr(self, container, range, info);
    let elemSize = resolver::getTypeLayout(*info.itemType).size;
    let rhsTy = try typeOf(self, rhs);

    if let case resolver::Type::Slice { .. } = rhsTy {

        try emitFillLoop(self, r.dataReg, fillVal, r.count, *info.itemType, elemSize);
    }
}

/// Emit a typed fill loop: `for i in 0..count { dst[i * stride] = value; }`.
unsafe fn emitFillLoop(
    self: &mut FnLowerer,
unsafe fn emitFillLoop 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    dst: il::Reg,
    value: il::Val,
    count: il::Val,
    elemType: resolver::Type,
    elemSize: u32
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let iReg = nextReg(self);
    let header = try createBlockWithParam(
        self, "fill", il::Param { value: iReg, type: il::Type::W32 }
    );
    let body = try createBlock(self, "fill");

///
///   @entry -> @loop -> @loop
///               |
///               `----> @end
///
unsafe fn lowerLoop(self: &mut FnLowerer, body: *ast::Node) throws (LowerError) {
unsafe fn lowerLoop 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, body: *ast::Node) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let loopBlock = try createBlock(self, "loop");
    let endBlock = try createBlock(self, "merge");

    // Enter the loop with the given break and continue targets.
    // `break` jumps to `endBlock`,

///
///   @entry -> @loop -> (true)  @body -> @loop
///               |
///               `----> (false) @end
///
unsafe fn lowerWhile(self: &mut FnLowerer, w: ast::While) throws (LowerError) {
unsafe fn lowerWhile 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, w: ast::While) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let whileBlock = try createBlock(self, "while");
    let bodyBlock = try createBlock(self, "body");
    let endBlock = try createBlock(self, "merge");

    enterLoop(self, endBlock, whileBlock);

    try switchToAndSeal(self, endBlock);
    exitLoop(self);
}

/// Emit an increment of a variable by `1`.
unsafe fn emitIncrement(self: &mut FnLowerer, v: Var, typ: il::Type) throws (LowerError) {
unsafe fn emitIncrement 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, v: Var, typ: il::Type) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let cur = try useVar(self, v);
    let next = nextReg(self);

    emit(self, il::Instr::BinOp { op: il::BinOp::Add, typ, dst: next, a: cur, b: il::Val::Imm(1) });
    defVar(self, v, il::Val::Reg(next));

/// The step block is created lazily (after the loop body) so that it gets
/// a block index higher than all body blocks. This ensures the register
/// allocator processes definitions before uses in forward block order,
/// avoiding stale assignments when a value defined deep in the body flows
/// through the step block as a block argument.
unsafe fn lowerForLoop(self: &mut FnLowerer, iter: &ForIter, body: *ast::Node) throws (LowerError) {
unsafe fn lowerForLoop 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, iter: &ForIter, body: *ast::Node) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let loopBlock = try createBlock(self, "loop");
    let bodyBlock = try createBlock(self, "body");
    let endBlock = try createBlock(self, "merge");

    enterLoop(self, endBlock, nil);


    switchToBlock(self, endBlock);
}

/// Lower a `for` loop over a range, array, or slice.
unsafe fn lowerFor(self: &mut FnLowerer, node: *ast::Node, f: ast::For) throws (LowerError) {
unsafe fn lowerFor 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, f: ast::For) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let savedVarsLen = enterVarScope(self);
    let info = resolver::forLoopInfoFor(self.low.resolver, node) else {
        throw LowerError::MissingMetadata;
    };
    match info {

    }
    exitVarScope(self, savedVarsLen);
}

/// Lower a break statement.
unsafe fn lowerBreak(self: &mut FnLowerer) throws (LowerError) {
unsafe fn lowerBreak 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let ctx = currentLoop(self) else {
        throw LowerError::OutsideOfLoop;
    };
    try emitJmp(self, ctx.breakTarget);
}

/// Lower a continue statement.
unsafe fn lowerContinue(self: &mut FnLowerer) throws (LowerError) {
unsafe fn lowerContinue 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let block = try getOrCreateContinueBlock(self);
    try emitJmp(self, block);
}

/// Emit a return, blitting into the caller's return buffer if needed.
///
/// When the function has a return buffer parameter, the value is blitted
/// into the buffer and the buffer pointer is returned. Otherwise, the value is
/// returned directly.
unsafe fn emitRetVal(self: &mut FnLowerer, val: il::Val) throws (LowerError) {
unsafe fn emitRetVal 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, val: il::Val) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    if let retReg = self.returnReg {
        let src = emitValToReg(self, val);
        let size = resolver::getResultLayout(*self.fnType.returnType, self.fnType.throwList).size
            if self.fnType.throwList.len > 0
            else resolver::getTypeLayout(*self.fnType.returnType).size;

        emit(self, il::Instr::Blit { dst: retReg, src, size: il::Val::Imm(size as i64) });
        emit(self, il::Instr::Ret { val: il::Val::Reg(retReg) });
    } else if isSmallAggregate(*self.fnType.returnType) {
        let src = emitValToReg(self, val);
        let mut src = emitValToReg(self, val);
        let layout = resolver::getTypeLayout(*self.fnType.returnType);
        if layout.alignment < resolver::PTR_SIZE or layout.size < resolver::PTR_SIZE {
            // The return word must not read beyond the value or its alignment.
            let word = emitReserveLayout(self, resolver::Layout {
                size: resolver::PTR_SIZE, alignment: resolver::PTR_SIZE,
            });
            emitStoreW64At(self, il::Val::Imm(0), word, 0);
            emit(self, il::Instr::Blit { dst: word, src, size: il::Val::Imm(layout.size as i64) });
            set src = word;
        }
        let dst = nextReg(self);

        emit(self, il::Instr::Load { typ: il::Type::W64, dst, src, offset: 0 });
        emit(self, il::Instr::Ret { val: il::Val::Reg(dst) });
    } else {
        emit(self, il::Instr::Ret { val });
    }
}

/// Lower a return statement.
unsafe fn lowerReturnStmt(self: &mut FnLowerer, node: *ast::Node, value: ?*ast::Node) throws (LowerError) {
unsafe fn lowerReturnStmt 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, value: ?*ast::Node) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let mut val = il::Val::Undef;
    if let expr = value {
        set val = try lowerExpr(self, expr);
    }
    if blockHasTerminator(self) {

    set val = try applyCoercion(self, node, val);
    try emitRetVal(self, val);
}

/// Lower a throw statement.
unsafe fn lowerThrowStmt(self: &mut FnLowerer, expr: *ast::Node) throws (LowerError) {
unsafe fn lowerThrowStmt 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, expr: *ast::Node) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    assert self.fnType.throwList.len > 0;

    let errType = *self.fnType.throwList[0] if self.fnType.throwList.len == 1
        else try typeOf(self, expr);
    let tag = getOrAssignErrorTag(self.low, errType) as i64;


    try emitRetVal(self, resultVal);
}

/// Ensure a value is in a register (eg. for branch conditions).
unsafe fn emitValToReg(self: &mut FnLowerer, val: il::Val) -> il::Reg {
unsafe fn emitValToReg 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, val: il::Val) -> il::Reg where 'arena: 'phase, 'phase: 'function {
    match val {
        case il::Val::Reg(r) => return r,
        case il::Val::Imm(_), il::Val::DataSym(_), il::Val::FnAddr(_) => {
            let dst = nextReg(self);
            emit(self, il::Instr::Copy { dst, val });

///       // ...
///       jmp @end(%b);
///     @end(w8 %result)
///       ret %result;
///
unsafe fn lowerLogicalOp(
    self: &mut FnLowerer,
unsafe fn lowerLogicalOp 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    binop: ast::BinOp,
    thenLabel: *[u8],
    elseLabel: *[u8],
    mergeLabel: *[u8],
    op: LogicalOp
) -> il::Val throws (LowerError) {
) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let thenBlock = try createBlock(self, thenLabel);
    let elseBlock = try createBlock(self, elseLabel);

    let resultReg = nextReg(self);
    let mergeBlock = try createBlockWithParam(

    try switchToAndSeal(self, mergeBlock);
    return il::Val::Reg(resultReg);
}

/// Lower a conditional expression (`thenExpr if condition else elseExpr`).
unsafe fn lowerCondExpr(self: &mut FnLowerer, node: *ast::Node, cond: ast::CondExpr) -> il::Val
    throws (LowerError)
unsafe fn lowerCondExpr 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, cond: ast::CondExpr) -> il::Val
    throws (LowerError) where 'arena: 'phase, 'phase: 'function
{
    let typ = try typeOf(self, node);
    let thenBlock = try createBlock(self, "cond#then");
    let elseBlock = try createBlock(self, "cond#else");


        else => return nil,
    }
}

/// Lower a binary operation.
unsafe fn lowerBinOp(self: &mut FnLowerer, node: *ast::Node, binop: ast::BinOp) -> il::Val throws (LowerError) {
unsafe fn lowerBinOp 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, binop: ast::BinOp) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    // Short-circuit logical operators don't evaluate both operands eagerly.
    if binop.op == ast::BinaryOp::And {
        return try lowerLogicalOp(self, binop, "and#then", "and#else", "and#end", LogicalOp::And);
    } else if binop.op == ast::BinaryOp::Or {
        return try lowerLogicalOp(self, binop, "or#then", "or#else", "or#end", LogicalOp::Or);

    }
    return emitScalarBinOp(self, binop.op, ilType(self.low, resultTy), a, b, isUnsignedType(resultTy));
}

/// Emit an aggregate equality or inequality comparison.
unsafe fn emitAggregateEqOp(
    self: &mut FnLowerer,
unsafe fn emitAggregateEqOp 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    op: ast::BinaryOp,
    typ: resolver::Type,
    a: il::Val,
    b: il::Val
) -> il::Val throws (LowerError) {
) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let regA = emitValToReg(self, a);
    let regB = emitValToReg(self, b);
    let result = try lowerAggregateEq(self, typ, regA, regB, 0);

    if op == ast::BinaryOp::Ne {

    }
    return result;
}

/// Emit a scalar binary operation instruction.
unsafe fn emitScalarBinOp(
    self: &mut FnLowerer,
unsafe fn emitScalarBinOp 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    op: ast::BinaryOp,
    typ: il::Type,
    a: il::Val,
    b: il::Val,
    unsigned: bool
) -> il::Val {
) -> il::Val where 'arena: 'phase, 'phase: 'function {
    let dst = nextReg(self);
    let mut needsExt: bool = false;
    match op {
        case ast::BinaryOp::Add => {
            emit(self, il::Instr::BinOp { op: il::BinOp::Add, typ, dst, a, b });

    }
    return il::Val::Reg(dst);
}

/// Normalize sub-word values to well-defined high bits.
unsafe fn normalizeSubword(self: &mut FnLowerer, typ: il::Type, unsigned: bool, val: il::Val) -> il::Val {
unsafe fn normalizeSubword 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, typ: il::Type, unsigned: bool, val: il::Val) -> il::Val where 'arena: 'phase, 'phase: 'function {
    if typ == il::Type::W8 or typ == il::Type::W16 {
        let extDst: il::Reg = nextReg(self);
        if unsigned {
            emit(self, il::Instr::Zext { typ, dst: extDst, val });
        } else {

    }
    return val;
}

/// Lower a unary operation.
unsafe fn lowerUnOp(self: &mut FnLowerer, node: *ast::Node, unop: ast::UnOp) -> il::Val throws (LowerError) {
unsafe fn lowerUnOp 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, unop: ast::UnOp) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    if unop.op == ast::UnaryOp::Neg {
        if let case ast::NodeValue::Number(lit) = unop.value.value {
            return il::Val::Imm((0 - lit.magnitude) as i64);
        }
    }

    }
    return il::Val::Reg(dst);
}

/// Lower a cast expression (`x as T`).
unsafe fn lowerCast(self: &mut FnLowerer, node: *ast::Node, cast: ast::As) -> il::Val throws (LowerError) {
unsafe fn lowerCast 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, cast: ast::As) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let val = try lowerExpr(self, cast.value);

    let srcType = try typeOf(self, cast.value);
    let dstType = try typeOf(self, node);
    if resolver::typesEqual(srcType, dstType) {


/// Lower a string literal to a slice value.
///
/// String literals are stored as global data and the result is a slice
/// pointing to the data with the appropriate length.
unsafe fn lowerStringLit(self: &mut FnLowerer, node: *ast::Node, s: *[u8]) -> il::Val throws (LowerError) {
unsafe fn lowerStringLit 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, s: *[u8]) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    // Get the slice type from the node.
    let sliceTy = try typeOf(self, node);
    let case resolver::Type::Slice { item, mutable, .. } = sliceTy
        else throw LowerError::ExpectedSliceOrArray;
    // Build the string data value.

        self, &result, 1, true, item, mutable, s.len
    );
}

/// Lower a builtin call expression.
unsafe fn lowerBuiltinCall(self: &mut FnLowerer, node: *ast::Node, kind: ast::Builtin, args: *[*ast::Node]) -> il::Val throws (LowerError) {
unsafe fn lowerBuiltinCall 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, kind: ast::Builtin, args: *[*ast::Node]) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    match kind {
        case ast::Builtin::SliceOf => return try lowerSliceOf(self, node, args),
        case ast::Builtin::SizeOf, ast::Builtin::AlignOf => {
            let constVal = resolver::constValueEntry(self.low.resolver, node) else {
                throw LowerError::MissingConst(node);

        }
    }
}

/// Lower a `@sliceOf(ptr, len)` or `@sliceOf(ptr, len, cap)` builtin call.
unsafe fn lowerSliceOf(self: &mut FnLowerer, node: *ast::Node, args: *[*ast::Node]) -> il::Val throws (LowerError) {
unsafe fn lowerSliceOf 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, args: *[*ast::Node]) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    if args.len <> 2 and args.len <> 3 {
        throw LowerError::InvalidArgCount;
    }
    let sliceTy = try typeOf(self, node);
    let case resolver::Type::Slice { item, mutable, .. } = sliceTy

    }
    return try buildSliceValue(self, item, mutable, ptrVal, lenVal, capVal);
}

/// Lower a `try` expression.
unsafe fn lowerTry(self: &mut FnLowerer, node: *ast::Node, t: ast::Try) -> il::Val throws (LowerError) {
unsafe fn lowerTry 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, t: ast::Try) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let case ast::NodeValue::Call(callExpr) = t.expr.value else {
        throw LowerError::ExpectedCall;
    };
    let calleeTy = try typeOf(self, callExpr.callee);
    let case resolver::Type::Fn(calleeInfo) = calleeTy else {

    // Type of the try expression, which is either the return type of the function
    // if successful, or an optional of it, if using `try?`.
    let tryExprTy = try typeOf(self, node);
    // Check for trait method dispatch or standalone method call.
    let mut resVal: il::Val = undefined;
    let mut initialization: ?SessionInitialization = nil;
    let callNodeExtra = resolver::nodeData(self.low.resolver, t.expr).extra;
    if let case resolver::NodeExtra::TraitMethodCall {
    if let case resolver::NodeExtra::SessionAllocation(allocation) = callNodeExtra {
        let prepared = try prepareSessionAllocation(self, callExpr, allocation);
        set initialization = prepared;
        set resVal = prepared.result;
    } else if let case resolver::NodeExtra::TraitMethodCall {
        traitInfo, methodIndex
    } = callNodeExtra {
        set resVal = try lowerTraitMethodCall(self, t.expr, callExpr, traitInfo, methodIndex);
    } else if let case resolver::NodeExtra::MethodCall { method } = callNodeExtra {
        set resVal = try lowerMethodCall(self, t.expr, callExpr, method);
    } else {
        set resVal = try lowerCall(self, t.expr, callExpr);
    }
    if blockHasTerminator(self) {
        return il::Val::Undef;
    }
    let base = emitValToReg(self, resVal); // The result value.
    let tagReg = resultTagReg(self, base); // The result tag.

    let okBlock = try createBlock(self, "ok"); // Block if success.
    let errBlock = try createBlock(self, "err"); // Block if failure.

    try sealBlock(self, errBlock);

    // Success path: extract the successful value from the result and store it
    // in the result slot for later use after the merge point.
    switchToBlock(self, okBlock);
    if let prepared = initialization {
        try initializeSessionAllocation(self, prepared);
    }

    if okValueTy == resolver::Type::Never {
        emit(self, il::Instr::Unreachable);
    } else if let slot = resultSlot {
        // Extract the success payload. If the result type differs from the payload

/// Lower typed multi-catch clauses.
///
/// Emits a switch on the global error tag to dispatch to the correct catch
/// clause. Each typed clause extracts the error payload for its specific type
/// and binds it to the clause's identifier.
unsafe fn lowerMultiCatch(
    self: &mut FnLowerer,
unsafe fn lowerMultiCatch 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    catches: *[*ast::Node],
    calleeInfo: *resolver::FnType,
    base: il::Reg,
    tagReg: il::Reg,
    mergeBlock: &mut ?BlockId
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let entry = currentBlock(self);

    // First pass: create blocks, resolve error types, and build switch cases.
    let mut blocks: [BlockId; MAX_CATCH_CLAUSES] = undefined;
    let mut errTypes: [?resolver::Type; MAX_CATCH_CLAUSES] = undefined;


            cases.append(il::SwitchCase {
                value: getOrAssignErrorTag(self.low, errTy) as i64,
                target: *blocks[i],
                args: &mut []
            }, self.allocator);
            }, alloc::arenaAllocator(self.arena));
        } else {
            set errTypes[i] = nil;
            set defaultIdx = i;
        }
    }

/// Emit a byte-copy loop: `for i in 0..size { dst[i] = src[i]; }`.
///
/// Used when `blit` cannot be used because the copy size is dynamic.
/// Terminates the current block and leaves the builder positioned
/// after the loop.
unsafe fn emitByteCopyLoop(
    self: &mut FnLowerer,
unsafe fn emitByteCopyLoop 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    dst: il::Reg,
    src: il::Reg,
    size: il::Val,
    label: *[u8]
) throws (LowerError) {
) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let iReg = nextReg(self);
    let header = try createBlockWithParam(
        self, label, il::Param { value: iReg, type: il::Type::W32 }
    );
    let body = try createBlock(self, label);

///
///     @store:
///       store element at ptr + len * stride
///       increment len
///
unsafe fn lowerSliceAppend(self: &mut FnLowerer, call: ast::Call, elemType: *resolver::Type) -> il::Val throws (LowerError) {
unsafe fn lowerSliceAppend 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, call: ast::Call, elemType: *resolver::Type) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let case ast::NodeValue::FieldAccess(access) = call.callee.value
        else throw LowerError::MissingMetadata;

    // Get the address of the slice header.
    let sliceVal = try lowerExpr(self, access.parent);


/// Lower `slice.delete(index)`.
///
/// Bounds-check the index, shift elements after it by one stride
/// via a byte-copy loop, and decrement `len`.
unsafe fn lowerSliceDelete(self: &mut FnLowerer, call: ast::Call, elemType: *resolver::Type) throws (LowerError) {
unsafe fn lowerSliceDelete 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, call: ast::Call, elemType: *resolver::Type) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let case ast::NodeValue::FieldAccess(access) = call.callee.value
        else throw LowerError::MissingMetadata;

    let elemLayout = resolver::getTypeLayout(*elemType);
    let stride = elemLayout.size;

    let newLen = emitTypedBinOp(self, il::BinOp::Sub, il::Type::W32, lenVal, il::Val::Imm(1));

    emitStoreW32At(self, newLen, sliceReg, SLICE_LEN_OFFSET);
}

/// Initializer values retained across a fallible session reservation.
record SessionInitialization: Copy {
    /// Resolved allocation operation and element type.
    allocation: resolver::SessionAllocation,
    /// Runtime reservation result.
    result: il::Val,
    /// Evaluated object, fill value, or source slice.
    value: il::Val,
    /// Evaluated number of elements.
    count: il::Val,
}

/// Evaluate initializer values and reserve their session storage.
unsafe fn prepareSessionAllocation 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function, call: ast::Call, allocation: resolver::SessionAllocation
) -> SessionInitialization throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let case ast::NodeValue::FieldAccess(access) = call.callee.value else throw LowerError::ExpectedCall;
    let receiver = try lowerExpr(self, access.parent);
    let sessionReg = emitValToReg(self, receiver);
    let dataReg = nextReg(self);
    emitLoadW64At(self, dataReg, sessionReg, TRAIT_OBJ_DATA_OFFSET);
    let vtableReg = nextReg(self);
    emitLoadW64At(self, vtableReg, sessionReg, TRAIT_OBJ_VTABLE_OFFSET);
    let functionReg = nextReg(self);
    emitLoadW64At(
        self, functionReg, vtableReg,
        (allocation.methodIndex * resolver::PTR_SIZE) as i32,
    );
    let value = try lowerCallArg(self, call.args[0], true);
    if blockHasTerminator(self) {
        return SessionInitialization { allocation, result: il::Val::Undef, value, count: il::Val::Undef };
    }
    let slice = allocation.kind <> resolver::SessionAllocationKind::New;
    let mut count = il::Val::Imm(1);
    if allocation.kind == resolver::SessionAllocationKind::Copy {
        set count = loadSliceLen(self, emitValToReg(self, value));
    } else if allocation.kind == resolver::SessionAllocationKind::Fill {
        set count = try lowerExpr(self, call.args[1]);
        if blockHasTerminator(self) {
            return SessionInitialization { allocation, result: il::Val::Undef, value, count: il::Val::Undef };
        }
    }
    let layout = resolver::getTypeLayout(*allocation.item);
    let size = layout.size if layout.size > 0 else 1;
    let alignment = layout.alignment if layout.alignment > 0 else 1;
    let runtime = allocation.traitInfo.methods[allocation.methodIndex].fnType;
    let argOffset: u32 = 1 if requiresReturnParam(runtime) else 0;
    let args = try allocVals(self, (4 if slice else 3) + argOffset);
    set args[argOffset] = il::Val::Reg(dataReg);
    set args[argOffset + 1] = il::Val::Imm(size as i64);
    set args[argOffset + 2] = il::Val::Imm(alignment as i64);
    if slice {
        set args[argOffset + 3] = count;
    }
    let result = try emitCallValue(self, il::Val::Reg(functionReg), runtime, args);
    return SessionInitialization { allocation, result, value, count };
}

/// Initialize successful reservation storage before its reference is published.
unsafe fn initializeSessionAllocation 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, prepared: SessionInitialization)
    throws (LowerError) where 'arena: 'phase, 'phase: 'function
{
    let allocation = prepared.allocation;
    let base = emitValToReg(self, prepared.result);
    let value = prepared.value;
    let count = prepared.count;
    let layout = resolver::getTypeLayout(*allocation.item);
    let destination = nextReg(self);
    emitLoadW64At(self, destination, base, RESULT_VAL_OFFSET);
    match allocation.kind {
        case resolver::SessionAllocationKind::New =>
            try emitStore(self, destination, 0, *allocation.item, value),
        case resolver::SessionAllocationKind::Copy => {
            let source = loadSlicePtr(self, emitValToReg(self, value));
            let bytes = emitTypedBinOp(self, il::BinOp::Mul, il::Type::W32, count, il::Val::Imm(layout.size as i64));
            try emitByteCopyLoop(self, destination, source, bytes, "allocate.copy");
        }
        case resolver::SessionAllocationKind::Fill =>
            try emitFillLoop(self, destination, value, count, *allocation.item, layout.size),
    }
}

/// Lower a call expression, which may be a function call or type constructor.
unsafe fn lowerCallOrCtor(self: &mut FnLowerer, node: *ast::Node, call: ast::Call) -> il::Val throws (LowerError) {
unsafe fn lowerCallOrCtor 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, call: ast::Call) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let nodeData = resolver::nodeData(self.low.resolver, node).extra;

    // Check for slice method dispatch.
    if let case resolver::NodeExtra::SliceAppend { elemType } = nodeData {
        return try lowerSliceAppend(self, call, elemType);

    // Check for standalone method call.
    if let case resolver::NodeExtra::MethodCall { method } = nodeData {
        return try lowerMethodCall(self, node, call, method);
    }
    if let sym = resolver::nodeData(self.low.resolver, call.callee).sym {
        if let case resolver::SymbolData::Type(nominal) = sym.data {
            let case resolver::NominalType::Record(_) = *nominal else {
                throw LowerError::ExpectedRecord;
            };
        if let case resolver::SymbolData::Type(_) = sym.data {
            let ty = try typeOf(self, node);
            let case resolver::Type::Nominal(nominal) = ty else throw LowerError::ExpectedRecord;
            return try lowerRecordCtor(self, nominal, call.args);
        }
        if let case resolver::SymbolData::Variant { .. } = sym.data {
            return try lowerUnionCtor(self, node, sym, call);
        }

///     load w64 %data %obj 0          // data pointer
///     load w64 %vtable %obj 8        // v-table pointer
///     load w64 %fn %vtable <slot>    // function pointer
///     call <retTy> %ret %fn(%data, args...)
///
unsafe fn lowerTraitMethodCall(
    self: &mut FnLowerer,
unsafe fn lowerTraitMethodCall 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    node: *ast::Node,
    call: ast::Call,
    traitInfo: *unsafe resolver::TraitType,
    methodIndex: u32
) -> il::Val throws (LowerError) {
) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    // Method calls look like field accesses.
    let case ast::NodeValue::FieldAccess(access) = call.callee.value
        else throw LowerError::MissingMetadata;

    // Lower the trait object expression.


/// Lower a call argument, snapshotting aggregate place expressions before
/// evaluating later arguments. Aggregates are represented by addresses in the
/// IL, so retaining the original address would let a later argument mutation
/// change the value already supplied for this argument.
unsafe fn lowerCallArg(self: &mut FnLowerer, arg: *ast::Node, hasLater: bool) -> il::Val
    throws (LowerError)
unsafe fn lowerCallArg 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, arg: *ast::Node, hasLater: bool) -> il::Val
    throws (LowerError) where 'arena: 'phase, 'phase: 'function
{
    let val = try lowerExpr(self, arg);

    if hasLater and ast::isPlaceExpr(arg) {
        let argType = try effectiveType(self, arg);

///
/// All call lowering paths (regular, trait method, standalone method) converge
/// here after preparing the callee value, function type, and argument array.
/// The `args` slice must already include a slot at index zero for the hidden
/// return parameter; that slot is filled by this function.
unsafe fn emitCallValue(
    self: &mut FnLowerer,
unsafe fn emitCallValue 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    callee: il::Val,
    fnInfo: *resolver::FnType,
    args: *unsafe mut [il::Val],
) -> il::Val throws (LowerError) {
) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let retTy = *fnInfo.returnType;

    if requiresReturnParam(fnInfo) {
        if fnInfo.throwList.len > 0 {
            let layout = resolver::getResultLayout(retTy, fnInfo.throwList);


/// Lower a method receiver expression to a pointer value.
///
/// If the parent is already a pointer type, the value is used directly.
/// If the parent is a value type (eg. a local record), its address is taken.
unsafe fn lowerReceiver(self: &mut FnLowerer, parent: *ast::Node, parentTy: resolver::Type) -> il::Val
    throws (LowerError)
unsafe fn lowerReceiver 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, parent: *ast::Node, parentTy: resolver::Type) -> il::Val
    throws (LowerError) where 'arena: 'phase, 'phase: 'function
{
    if let case resolver::Type::Pointer { .. } = parentTy {
        // Already a pointer: lower and use directly.
        return try lowerExpr(self, parent);
    }

/// Given `obj.method(args)` where `method` is a standalone method on a concrete type,
/// emits a direct call with the receiver address as the first argument:
///
///     call <retTy> %ret @Type::method(&obj, args...)
///
unsafe fn lowerMethodCall(
    self: &mut FnLowerer,
unsafe fn lowerMethodCall 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    node: *ast::Node,
    call: ast::Call,
    method: &resolver::MethodEntry,
) -> il::Val throws (LowerError) {
) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let case ast::NodeValue::FieldAccess(access) = call.callee.value
        else throw LowerError::MissingMetadata;

    // Get the receiver as a pointer.
    let parentTy = try typeOf(self, access.parent);

    }
    return try emitCallValue(self, il::Val::FnAddr(qualName), fnInfo, args);
}

/// Check if a call is to a compiler intrinsic and lower it directly.
unsafe fn lowerIntrinsicCall(self: &mut FnLowerer, call: ast::Call) -> ?il::Val throws (LowerError) {
unsafe fn lowerIntrinsicCall 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, call: ast::Call) -> ?il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    // Get the callee symbol and check if it's marked as an intrinsic.
    let sym = resolver::nodeData(self.low.resolver, call.callee).sym else {
        // Expressions or function pointers may not have an associated symbol.
        return nil;
    };

        return nil;
    }
    // Check for known intrinsic names.
    if mem::eq(sym.name, "ecall") {
        return try lowerEcall(self, call);
    } else if mem::eq(sym.name, "deviceRead8") {
        return try lowerDevice(self, call, il::Type::W8, false);
    } else if mem::eq(sym.name, "deviceWrite8") {
        return try lowerDevice(self, call, il::Type::W8, true);
    } else if mem::eq(sym.name, "deviceRead16") {
        return try lowerDevice(self, call, il::Type::W16, false);
    } else if mem::eq(sym.name, "deviceWrite16") {
        return try lowerDevice(self, call, il::Type::W16, true);
    } else if mem::eq(sym.name, "deviceRead32") {
        return try lowerDevice(self, call, il::Type::W32, false);
    } else if mem::eq(sym.name, "deviceWrite32") {
        return try lowerDevice(self, call, il::Type::W32, true);
    } else if mem::eq(sym.name, "deviceRead64") {
        return try lowerDevice(self, call, il::Type::W64, false);
    } else if mem::eq(sym.name, "deviceWrite64") {
        return try lowerDevice(self, call, il::Type::W64, true);
    } else if mem::eq(sym.name, "ebreak") {
        return try lowerEbreak(self, call);
    } else if mem::eq(sym.name, "memoryFence") {
        return try lowerMemoryFence(self, call);
    } else {
        throw LowerError::UnknownIntrinsic;
    }
}

/// Lower an ecall intrinsic: `ecall(num, a0, a1, a2, a3) -> i32`.
unsafe fn lowerEcall(self: &mut FnLowerer, call: ast::Call) -> il::Val throws (LowerError) {
unsafe fn lowerEcall 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, call: ast::Call) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    if call.args.len <> 5 {
        throw LowerError::InvalidArgCount;
    }
    let num = try lowerExpr(self, call.args[0]);
    let a0 = try lowerExpr(self, call.args[1]);


    return il::Val::Reg(dst);
}

/// Lower an ebreak intrinsic: `ebreak()`.
unsafe fn lowerEbreak(self: &mut FnLowerer, call: ast::Call) -> il::Val throws (LowerError) {
unsafe fn lowerEbreak 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, call: ast::Call) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    if call.args.len <> 0 {
        throw LowerError::InvalidArgCount;
    }
    emit(self, il::Instr::Ebreak);

    return il::Val::Undef;
}

/// Lower `memoryFence()`.
unsafe fn lowerMemoryFence(self: &mut FnLowerer, call: ast::Call) -> il::Val throws (LowerError) {
unsafe fn lowerMemoryFence 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, call: ast::Call) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    if call.args.len <> 0 {
        throw LowerError::InvalidArgCount;
    }
    emit(self, il::Instr::MemoryFence);
    return il::Val::Undef;
}

/// Resolve callee to an IL value. For direct function calls, use the symbol name.
/// For variables holding function pointers or complex expressions (eg. `array[i]()`),
/// lower the callee expression.
unsafe fn lowerCallee(self: &mut FnLowerer, callee: *ast::Node) -> il::Val throws (LowerError) {
unsafe fn lowerCallee 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, callee: *ast::Node) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    if let sym = resolver::nodeData(self.low.resolver, callee).sym {
        if let case ast::NodeValue::FnDecl(_) = sym.node.value {
            // First try to look up the symbol in our registered functions.
            // This handles cross-package calls correctly, since packages are
            // lowered in dependency order.
            if let qualName = lookupFnSym(self.low, sym) {
            if let qualName = lookupSymbolName(self.low, sym) {
                return il::Val::FnAddr(qualName);
            }
            // Fall back to computing the qualified name from the module graph.
            // This works for functions in the current package.
            let modId = resolver::moduleIdForSymbol(self.low.resolver, sym) else {
                throw LowerError::MissingMetadata;
            };
            let modId = resolver::moduleIdForSymbol(self.low.resolver, sym);
            return il::Val::FnAddr(qualifyName(self.low, modId, sym.name));
        }
    }
    return try lowerExpr(self, callee);
}

/// Lower a function call expression.
unsafe fn lowerCall(self: &mut FnLowerer, node: *ast::Node, call: ast::Call) -> il::Val throws (LowerError) {
unsafe fn lowerCall 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, call: ast::Call) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    // Check for intrinsic calls before normal call lowering.
    if let intrinsicVal = try lowerIntrinsicCall(self, call) {
        return intrinsicVal;
    }
    let calleeTy = try typeOf(self, call.callee);


    return try emitCallValue(self, callee, fnInfo, args);
}

/// Apply coercions requested by the resolver.
unsafe fn applyCoercion(self: &mut FnLowerer, node: *ast::Node, val: il::Val) -> il::Val throws (LowerError) {
unsafe fn applyCoercion 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, val: il::Val) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let coerce = resolver::coercionFor(self.low.resolver, node) else {
        return val;
    };
    match coerce {
        case resolver::Coercion::OptionalLift(optType) => {


/// Lower an implicit numeric cast coercion.
///
/// Handles widening conversions between integer types. Uses sign-extension
/// for signed source types and zero-extension for unsigned source types.
unsafe fn lowerNumericCast(self: &mut FnLowerer, val: il::Val, srcType: resolver::Type, dstType: resolver::Type) -> il::Val {
unsafe fn lowerNumericCast 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, val: il::Val, srcType: resolver::Type, dstType: resolver::Type) -> il::Val where 'arena: 'phase, 'phase: 'function {
    let srcLayout = resolver::getTypeLayout(srcType);
    let dstLayout = resolver::getTypeLayout(dstType);

    if srcLayout.size == dstLayout.size {
        // Same size: bit pattern is unchanged, value is returned as-is.

    }
    return il::Val::Reg(dst);
}

/// Lower a global value symbol.
unsafe fn lowerGlobalValue(self: &mut FnLowerer, sym: *unsafe resolver::Symbol, ty: resolver::Type) -> il::Val {
unsafe fn lowerGlobalValue 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, sym: *unsafe resolver::Symbol, ty: resolver::Type) -> il::Val where 'arena: 'phase, 'phase: 'function {
    // Function pointer reference: return the function's address directly.
    // Functions have no separate storage cell in the data section.
    if let case resolver::Type::Fn(_) = ty {
        return il::Val::Reg(emitFnAddr(self, sym));
    }


    return emitRead(self, src, 0, ty);
}

/// Lower an identifier that refers to a global symbol.
unsafe fn lowerGlobalSymbol(self: &mut FnLowerer, node: *ast::Node) -> il::Val throws (LowerError) {
unsafe fn lowerGlobalSymbol 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    // First try to get a compile-time constant value.
    if let constVal = resolver::constValueEntry(self.low.resolver, node) {
        return try constValueToVal(self, constVal, node);
    }
    // Otherwise get the symbol.

        else => throw LowerError::UnexpectedNodeValue(node),
    }
}

/// Lower an assignment to a static variable.
unsafe fn lowerStaticAssign(self: &mut FnLowerer, target: *ast::Node, val: il::Val) throws (LowerError) {
unsafe fn lowerStaticAssign 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, target: *ast::Node, val: il::Val) throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let sym = try symOf(self, target);
    let case resolver::SymbolData::Value { type, .. } = sym.data else {
        throw LowerError::ImmutableAssignment;
    };
    let dst = emitDataAddr(self, sym);

    try emitStore(self, dst, 0, type, val);
}

/// Lower a scope access expression like `Module::Const` or `Union::Variant`.
/// This doesn't handle record literal variants.
unsafe fn lowerScopeAccess(self: &mut FnLowerer, node: *ast::Node) -> il::Val throws (LowerError) {
unsafe fn lowerScopeAccess 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    // First try to get a compile-time constant value.
    if let constVal = resolver::constValueEntry(self.low.resolver, node) {
        return try constValueToVal(self, constVal, node);
    }
    // Otherwise get the associated symbol.

    }
}

/// Lower an expression AST node to an IL value.
/// This is the main expression dispatch, all expression nodes go through here.
unsafe fn lowerExpr(self: &mut FnLowerer, node: *ast::Node) -> il::Val throws (LowerError) {
unsafe fn lowerExpr 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    if self.low.options.debug {
        set self.srcLoc.offset = node.span.offset;
    }
    let mut val: il::Val = undefined;


            set val = try lowerArrayLit(self, node, elements);
        }
        case ast::NodeValue::ArrayRepeatLit(repeat) => {
            set val = try lowerArrayRepeatLit(self, node, repeat);
        }
        case ast::NodeValue::RegionApply { value, .. } => {
            set val = try lowerExpr(self, value);
        }
        case ast::NodeValue::As(cast) => {
            set val = try lowerCast(self, node, cast);
        }
        case ast::NodeValue::CondExpr(cond) => {
            set val = try lowerCondExpr(self, node, cond);

/// are used. If a Radiance type doesn't fit in a machine word, it is passed
/// by reference.
///
/// The IL doesn't track signedness - that's encoded in the instructions
/// (e.g., Slt vs Ult).
unsafe fn ilType(self: &mut Lowerer, typ: resolver::Type) -> il::Type {
unsafe fn ilType 'arena 'phase (self: &mut Lowerer 'arena 'phase, typ: resolver::Type) -> il::Type where 'arena: 'phase {
    match typ {
        case resolver::Type::Bool,
             resolver::Type::I8,
             resolver::Type::U8 => return il::Type::W8,
        case resolver::Type::I16,

             resolver::Type::Pointer { .. },
             resolver::Type::Slice { .. },
             resolver::Type::TraitObject { .. },
             resolver::Type::Array(_),
             resolver::Type::Optional(_),
             resolver::Type::Fn(_) => return il::Type::W64,
             resolver::Type::Fn(_),
             resolver::Type::Session(_),
             resolver::Type::Cell { .. } => return il::Type::W64,
        case resolver::Type::Nominal(_) => {
            if resolver::isVoidUnion(typ) {
                return il::Type::W8;
            }
            return il::Type::W64;

        case resolver::Type::Int => return il::Type::W64,
        case resolver::Type::Opaque => panic "ilType: opaque type must be behind a pointer",
        else => panic "ilType: type cannot be lowered",
    }
}

/// Lower one fixed-width MMIO operation without exposing a pointer value.
unsafe fn lowerDevice 'arena 'phase 'function (
    self: &mut FnLowerer 'arena 'phase 'function,
    call: ast::Call,
    typ: il::Type,
    writing: bool
) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {
    let count: u32 = 3 if writing else 2;
    if call.args.len <> count {
        throw LowerError::InvalidArgCount;
    }
    let handle = try lowerExpr(self, call.args[0]);
    let offset = try lowerExpr(self, call.args[1]);
    if writing {
        let value = try lowerExpr(self, call.args[2]);
        emit(self, il::Instr::DeviceWrite { typ, handle, offset, value });
        return il::Val::Undef;
    }
    let dst = nextReg(self);
    emit(self, il::Instr::DeviceRead { typ, dst, handle, offset });
    return il::Val::Reg(dst);
}

lib/std/lang/module.rad +90 -53

use std::lang::alloc;
use std::lang::ast;
use std::lang::strings;

/// Maximum number of modules tracked in a single compilation graph.
export constant MAX_MODULES: u32 = 128;
export constant MAX_MODULES: u32 = 192;
/// Maximum number of characters for a module path.
constant MAX_PATH_LEN: u32 = 256;
/// Maximum number of components that make up a logical module path.
constant MAX_MODULE_PATH_DEPTH: u32 = 16;
/// Filesystem separator used when constructing child paths.

    name: *[u8],
    /// Logical path from the root module to this module.
    path: [*[u8]; MAX_MODULE_PATH_DEPTH],
    /// Number of segments inside `path`.
    pathDepth: u32,
    /// Mutable module state shared by all entry views.
    updates: *cell ModuleUpdates,
}

/// Copyable state stored in a module entry's cell.
export record ModuleUpdates: Copy {
    /// Current lifecycle state.
    state: ModuleState,
    /// Child module identifiers declared directly inside this module.
    children: [u16; MAX_MODULES],
    /// Number of entries stored in `children`.

    source: ?*[u8],
}

/// Dense storage for all modules referenced by the compilation unit.
export record ModuleGraph {
    /// Permanent storage for module entries.
    entries: *mut [ModuleEntry],
    /// Entry identities indexed by module identifier.
    entries: *mut [?*ModuleEntry],
    /// Number of initialized entries.
    entriesLen: u32,
    /// AST arena. It must outlive the graph.
    arena: ?*unsafe ast::NodeArena,
    /// Arena for AST nodes and stable entry allocations.
    arena: ?*unsafe mut ast::NodeArena,
}

/// Initialize an empty module graph backed by the provided storage.
/// The AST arena must outlive the returned graph.
/// The AST arena must outlive the graph and all retained entry views.
/// Entry allocation must occur outside speculative parser allocations.
export unsafe fn moduleGraph(
    storage: *mut [ModuleEntry],
    storage: *mut [?*ModuleEntry],
    arena: &mut ast::NodeArena
) -> ModuleGraph {
    for i in 0..storage.len {
        set storage[i] = nil;
    }
    return ModuleGraph {
        entries: storage,
        entriesLen: 0,
        arena: arena as *unsafe ast::NodeArena,
        arena: arena as *unsafe mut ast::NodeArena,
    };
}

/// Register a root module residing at `path` for a package.
export fn registerRoot(graph: &mut ModuleGraph, pool: &mut strings::Pool, packageId: u16, filePath: *[u8]) -> u16 throws (ModuleError) {
export unsafe fn registerRoot(graph: &mut ModuleGraph, pool: &mut strings::Pool, packageId: u16, filePath: *[u8]) -> u16 throws (ModuleError) {
    let name = try basenameSlice(filePath);
    return try registerRootWithName(graph, pool, packageId, name, filePath);
}

/// Register a root module with an explicit name and file path for a package.
export fn registerRootWithName(
export unsafe fn registerRootWithName(
    graph: &mut ModuleGraph, pool: &mut strings::Pool,
    packageId: u16,
    name: *[u8],
    filePath: *[u8]
) -> u16 throws (ModuleError) {
    let m = try allocModule(graph, pool, packageId, name, filePath);
    try appendPathSegment(m, name);

    set m.state = ModuleState::Registered;

    return m.id;
    let id = m.id;
    publish(graph, m);
    return id;
}

/// Register a child module.
/// Returns the module identifier.
export fn registerChild(
export unsafe fn registerChild(
    graph: &mut ModuleGraph, pool: &mut strings::Pool,
    parentId: u16,
    name: *[u8],
    filePath: *[u8]
) -> u16 throws (ModuleError) {
    assert name.len > 0, "registerChild: name must not be empty";
    assert filePath.len > 0, "registerChild: file path must not be empty";

    let parent = getMut(graph, parentId)
    let parent = get(graph, parentId)
        else throw ModuleError::NotFound(parentId);

    // If the child already exists under this parent, return it.
    if let child = findChild(graph, name, parentId) {
        return child.id;
    }
    // Inherit packageId from parent.
    let m = try allocModule(graph, pool, parent.packageId, name, filePath);

    set m.state = ModuleState::Registered;
    set m.parent = parentId;

    // Inherit path prefix from parent.
    for p in moduleQualifiedPath(parent) {
        try appendPathSegment(m, p);
    }
    try appendPathSegment(m, name);

    return try addChild(parent, m.id);
    let id = try addChild(parent, m.id);
    publish(graph, m);
    return id;
}

/// Fetch a read-only view of the module identified by `id`.
export fn get(graph: &ModuleGraph, id: u16) -> ?*ModuleEntry {
    if not isValidId(graph, id) {
        return nil;
    }
    return &graph.entries[id as u32];
}

/// Access a mutable entry by identifier.
fn getMut(graph: &mut ModuleGraph, id: u16) -> ?*mut ModuleEntry {
    if not isValidId(graph, id) {
        return nil;
    }
    return &mut graph.entries[id as u32];
    return graph.entries[id as u32];
}

/// Return the identifier of the child stored at `index`.
export fn childAt(m: *ModuleEntry, index: u32) -> u16 {
    assert index < m.childrenLen, "childAt: index must be valid";
    return m.children[index];
    let updates = *m.updates;
    assert index < updates.childrenLen, "childAt: index must be valid";
    return updates.children[index];
}

/// Public accessor for a module's directory prefix.
export fn moduleDir(m: *ModuleEntry) -> *[u8] {
    return &m.filePath[..m.dirLen];

/// Retrieve the lifecycle state for `id`.
export fn state(graph: &ModuleGraph, id: u16) -> ModuleState throws (ModuleError) {
    let m = get(graph, id) else {
        throw ModuleError::NotFound(id);
    };
    return m.state;
    return (*m.updates).state;
}

/// Record the parsed AST root for `id`.
export fn setAst(graph: &mut ModuleGraph, id: u16, root: *ast::Node) throws (ModuleError) {
    let m = getMut(graph, id) else throw ModuleError::NotFound(id);
    set m.ast = root;
    set m.state = ModuleState::Parsed;
    let m = get(graph, id) else throw ModuleError::NotFound(id);
    let mut updates = *m.updates;
    set updates.ast = root;
    set updates.state = ModuleState::Parsed;
    set *m.updates = updates;
}

/// Set the source text for a module.
export fn setSource(graph: &mut ModuleGraph, id: u16, source: *[u8]) throws (ModuleError) {
    let m = getMut(graph, id) else throw ModuleError::NotFound(id);
    set m.source = source;
    let m = get(graph, id) else throw ModuleError::NotFound(id);
    let mut updates = *m.updates;
    set updates.source = source;
    set *m.updates = updates;
}

/// Look up a child module by name under the given parent.
export fn findChild(graph: &ModuleGraph, name: *[u8], parentId: u16) -> ?*ModuleEntry {
    assert isValidId(graph, parentId), "findChild: parent identifier is valid";

    let parent = &graph.entries[parentId as u32];
    for i in 0..parent.childrenLen {
        let childId = parent.children[i];
        let child = &graph.entries[childId as u32];
    let parent = get(graph, parentId) else panic;
    let updates = *parent.updates;
    for i in 0..updates.childrenLen {
        let childId = updates.children[i];
        let child = get(graph, childId) else panic;
        if mem::eq(child.name, name) {
            return child;
        }
    }
    return nil;


/// Register a module from a file path, creating the full hierarchy as needed.
/// The path is split into components and the module hierarchy is built accordingly.
/// If `rootId` is `nil`, registers a new root for the given package.
/// Returns the module ID of the last component.
export fn registerFromPath(graph: &mut ModuleGraph, pool: &mut strings::Pool, packageId: u16, rootId: ?u16, filePath: *[u8]) -> u16 throws (ModuleError) {
export unsafe fn registerFromPath(graph: &mut ModuleGraph, pool: &mut strings::Pool, packageId: u16, rootId: ?u16, filePath: *[u8]) -> u16 throws (ModuleError) {
    let root = rootId else {
        return try registerRoot(graph, pool, packageId, filePath);
    };
    let rootEntry = get(graph, root) else {
        panic "registerFromPath: root is missing from storage";

    }
    return try registerChild(graph, pool, parentId, childName, filePath);
}

/// Allocate a fresh entry in the graph.
fn allocModule(graph: &mut ModuleGraph, pool: &mut strings::Pool, packageId: u16, name: *[u8], filePath: *[u8]) -> *mut ModuleEntry throws (ModuleError) {
unsafe fn allocModule(graph: &mut ModuleGraph, pool: &mut strings::Pool, packageId: u16, name: *[u8], filePath: *[u8]) -> *mut ModuleEntry throws (ModuleError) {
    if graph.entriesLen >= graph.entries.len {
        throw ModuleError::CapacityExceeded;
    }
    let idx = graph.entriesLen;
    set graph.entriesLen += 1;
    let arena = graph.arena else panic;
    let state = try! alloc::alloc(&mut arena.arena, @sizeOf(ModuleUpdates), @alignOf(ModuleUpdates)) as *mut ModuleUpdates;
    set *state = ModuleUpdates {
        state: ModuleState::Registered,
        children: [0; MAX_MODULES],
        childrenLen: 0,
        ast: nil,
        source: nil,
    };
    let updates = state as *cell ModuleUpdates;

    // TODO: This is a common pattern that needs better syntax.
    let m = &mut graph.entries[idx];
    let m = try! alloc::alloc(&mut arena.arena, @sizeOf(ModuleEntry), @alignOf(ModuleEntry)) as *mut ModuleEntry;
    set *m = ModuleEntry {
        id: idx as u16,
        packageId,
        parent: nil,
        filePath,
        dirLen: 0,
        dirLen: dirLength(filePath),
        name: strings::intern(pool, name),
        path: [""; MAX_MODULE_PATH_DEPTH],
        pathDepth: 0,
        state: ModuleState::Vacant,
        children: [0; MAX_MODULES],
        childrenLen: 0,
        ast: nil,
        source: nil,
        updates,
    };
    set m.dirLen = dirLength(m.filePath);

    return m;
}

/// Append a logical path segment (module identifier) to the entry.

    set entry.path[entry.pathDepth] = segment;
    set entry.pathDepth += 1;
}

/// Append a child identifier to the parent's child list.
fn addChild(parent: &mut ModuleEntry, childId: u16) -> u16 throws (ModuleError) {
    if parent.childrenLen >= parent.children.len {
fn addChild(parent: *ModuleEntry, childId: u16) -> u16 throws (ModuleError) {
    let mut updates = *parent.updates;
    if updates.childrenLen >= updates.children.len {
        throw ModuleError::CapacityExceeded;
    }
    set parent.children[parent.childrenLen] = childId;
    set parent.childrenLen += 1;
    set updates.children[updates.childrenLen] = childId;
    set updates.childrenLen += 1;
    set *parent.updates = updates;

    return childId;
}

/// Publish a fully initialized module entry in identifier order.
fn publish(graph: &mut ModuleGraph, entry: *ModuleEntry) {
    assert entry.id as u32 == graph.entriesLen;
    set graph.entries[graph.entriesLen] = entry;
    set graph.entriesLen += 1;
}

/// Return the number of registered children.
export fn childCount(entry: *ModuleEntry) -> u32 {
    return (*entry.updates).childrenLen;
}

/// Return the current parsed root for an entry.
export fn astFor(entry: *ModuleEntry) -> ?*ast::Node {
    return (*entry.updates).ast;
}

/// Return the current source text for an entry.
export fn sourceFor(entry: *ModuleEntry) -> ?*[u8] {
    return (*entry.updates).source;
}

/// Check if `id` points at an allocated entry.
fn isValidId(graph: &ModuleGraph, id: u16) -> bool {
    return (id as u32) < graph.entriesLen;
}


lib/std/lang/module/printer.rad +7 -6

        for seg, i in path { set buf[i] = sexpr::sym(seg); }
        set pathBuf = buf;
    }

    let mut childBuf: *[sexpr::Expr] = &[];
    if entry.childrenLen > 0 {
        let buf = try! sexpr::allocExprs(a, entry.childrenLen);
        for i in 0..entry.childrenLen {
            if let child = super::get(graph, entry.children[i]) {
    let childCount = super::childCount(entry);
    if childCount > 0 {
        let buf = try! sexpr::allocExprs(a, childCount);
        for i in 0..childCount {
            if let child = super::get(graph, super::childAt(entry, i)) {
                set buf[i] = subtreeToExpr(a, graph, child);
            }
        }
        set childBuf = buf;
    }

    return sexpr::block(a, "module", &[
        sexpr::sym(entry.name),
        sexpr::list(a, "id", &[sexpr::sym(idText)]),
        sexpr::list(a, "state", &[stateToExpr(entry.state)]),
        sexpr::list(a, "state", &[stateToExpr((*entry.updates).state)]),
        sexpr::Expr::Str(entry.filePath),
        sexpr::Expr::List { head: "::", tail: pathBuf, multiline: false }
    ], childBuf);
}

/// Print the entire module graph in S-expression format.
export unsafe fn printGraph(graph: &super::ModuleGraph, arena: &mut alloc::Arena) {
    // Print all root modules.
    for i in 0..graph.entriesLen {
        let entry = &graph.entries[i];
        let entry = super::get(graph, i as u16) else panic;
        if entry.parent == nil {
            sexpr::print(subtreeToExpr(arena, graph, entry), 0);
            io::print("\n");
        }
    }

lib/std/lang/module/tests.rad +58 -13

//! Tests for the module loader.

use std::mem;
use std::testing;
use std::lang::ast;
use std::lang::alloc;
use std::lang::parser;
use std::lang::scanner;
use std::lang::strings;

/// Test arena backing storage.
static TEST_ARENA: [u8; 4096] = [0; 4096];
static TEST_ARENA: [u8; 16384] = [0; 16384];
/// Interned string pool.
unsafe static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };

fn expectSliceEq(actual: *[u8], expected: *[u8])
    throws (testing::TestError)

        try expectSliceEq(actual[i], expected[i]);
    }
}

@test unsafe fn testRegisterChildren() throws (testing::TestError) {
    static storage: [super::ModuleEntry; 4] = undefined;
    static storage: [?*super::ModuleEntry; 4] = [nil; 4];
    let mut arena = ast::nodeArena(&mut TEST_ARENA[..]);
    let mut graph = super::moduleGraph(&mut storage[..], &mut arena);

    let rootId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, nil, "src/root.rad") catch {
        throw testing::TestError::Failed;


    let parent = super::get(&graph, rootId) else {
        throw testing::TestError::Failed;
    };
    try testing::expect(graph.entriesLen == 3);
    try testing::expect(parent.childrenLen == 2);
    try testing::expect(super::childCount(parent) == 2);
    try testing::expect(super::childAt(parent, 0) == firstId);
    try testing::expect(super::childAt(parent, 1) == secondId);
}

@test unsafe fn testRegisterChildReusesExisting() throws (testing::TestError) {
    static storage: [super::ModuleEntry; 4] = undefined;
    static storage: [?*super::ModuleEntry; 4] = [nil; 4];
    let mut arena = ast::nodeArena(&mut TEST_ARENA[..]);
    let mut graph = super::moduleGraph(&mut storage[..], &mut arena);

    let rootId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, nil, "src/main.rad") catch {
        throw testing::TestError::Failed;


    let parent = super::get(&graph, rootId) else {
        throw testing::TestError::Failed;
    };
    try testing::expect(graph.entriesLen == 2);
    try testing::expect(parent.childrenLen == 1);
    try testing::expect(super::childCount(parent) == 1);
}

@test fn testTrimExtensionWithRadExtension() throws (testing::TestError) {
    let input = "parser.rad";
    let result = super::trimExtension(input)

    let result = super::parsePath(path, &mut components[..]);
    try testing::expect(result == nil);
}

@test unsafe fn testRegisterFromPathHierarchy() throws (testing::TestError) {
    static storage: [super::ModuleEntry; 8] = undefined;
    static storage: [?*super::ModuleEntry; 8] = [nil; 8];
    let mut arena = ast::nodeArena(&mut TEST_ARENA[..]);
    let mut graph = super::moduleGraph(&mut storage[..], &mut arena);

    // Register root module.
    let stdId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, nil, "lib/std.rad") catch {

    try expectSliceEq(super::moduleDir(parser), "lib/std/lang/");
    try expectPathSegments(parser, &["std", "lang", "parser"]);

    // Verify parent-child relationships.
    try testing::expect(graph.entriesLen == 3);
    try testing::expect(std.childrenLen == 1);
    try testing::expect(super::childCount(std) == 1);
    try testing::expect(super::childAt(std, 0) == langId);
    try testing::expect(lang.childrenLen == 1);
    try testing::expect(super::childCount(lang) == 1);
    try testing::expect(super::childAt(lang, 0) == parserId);
    try testing::expect(parser.childrenLen == 0);
    try testing::expect(super::childCount(parser) == 0);
}

@test unsafe fn testRegisterFromPathMissingParent() throws (testing::TestError) {
    static storage: [super::ModuleEntry; 8] = undefined;
    static storage: [?*super::ModuleEntry; 8] = [nil; 8];
    let mut arena = ast::nodeArena(&mut TEST_ARENA[..]);
    let mut graph = super::moduleGraph(&mut storage[..], &mut arena);

    let rootId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, nil, "std.rad") catch {
        throw testing::TestError::Failed;

    };
    throw testing::TestError::Failed;
}

@test unsafe fn testRegisterFromPathDuplicateRoot() throws (testing::TestError) {
    static storage: [super::ModuleEntry; 8] = undefined;
    static storage: [?*super::ModuleEntry; 8] = [nil; 8];
    let mut arena = ast::nodeArena(&mut TEST_ARENA[..]);
    let mut graph = super::moduleGraph(&mut storage[..], &mut arena);

    let rootId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, nil, "std.rad") catch {
        throw testing::TestError::Failed;

    };
    throw testing::TestError::Failed;
}

@test unsafe fn testRegisterFromPathRegistersRoot() throws (testing::TestError) {
    static storage: [super::ModuleEntry; 8] = undefined;
    static storage: [?*super::ModuleEntry; 8] = [nil; 8];
    let mut arena = ast::nodeArena(&mut TEST_ARENA[..]);
    let mut graph = super::moduleGraph(&mut storage[..], &mut arena);

    let rootId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, nil, "lib/std.rad") catch {
        throw testing::TestError::Failed;

    try expectSliceEq(root.filePath, "lib/std.rad");
    try expectPathSegments(root, &["std"]);
}

@test unsafe fn testRegisterFromPathIgnoresLeadingDirectories() throws (testing::TestError) {
    static storage: [super::ModuleEntry; 8] = undefined;
    static storage: [?*super::ModuleEntry; 8] = [nil; 8];
    let mut arena = ast::nodeArena(&mut TEST_ARENA[..]);
    let mut graph = super::moduleGraph(&mut storage[..], &mut arena);

    let rootId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, nil, "src/pkg/root.rad") catch {
        throw testing::TestError::Failed;

        throw testing::TestError::Failed;
    };
    try expectSliceEq(parser.name, "parser");
    try expectPathSegments(parser, &["root", "lang", "parser"]);
}
/// Move the graph owner while its published entries retain their identities.
fn relocate(graph: super::ModuleGraph) -> super::ModuleGraph {
    return graph;
}
@test unsafe fn testGraphRelocation() throws (testing::TestError) {
    static DATA: [u8; 16384] = [0; 16384];
    static ENTRIES: [?*super::ModuleEntry; 2] = [nil; 2];
    static POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
    let mut arena = ast::nodeArena(&mut DATA[..]);
    let mut original = super::moduleGraph(&mut ENTRIES[..], &mut arena);
    let rootId = try! super::registerRoot(&mut original, &mut POOL, 0, "root.rad");
    let root = super::get(&original, rootId) else panic;
    let alias = root;
    let mut graph = relocate(original);
    let child = try! super::registerChild(&mut graph, &mut POOL, rootId, "child", "root/child.rad");
    try testing::expect(super::childCount(root) == 1);
    try testing::expect(super::childAt(alias, 0) == child);
    let published = super::get(&graph, rootId) else panic;
    try testing::expect(published as u64 == root as u64);
    let saved = alloc::used(&arena.arena);
    let reused = try! super::registerChild(&mut graph, &mut POOL, rootId, "child", "root/child.rad");
    try testing::expect(reused == child);
    try testing::expect(alloc::used(&arena.arena) == saved);
    let mut failed = false;
    try super::registerChild(&mut graph, &mut POOL, rootId, "full", "root/full.rad") catch {
        set failed = true;
    };
    try testing::expect(failed);
    try testing::expect(graph.entriesLen == 2);
    try testing::expect(super::childCount(alias) == 1);
    try testing::expect(alloc::used(&arena.arena) == saved);
    let source = "fn answer() -> u32 { return 42; }";
    let parsed: *ast::Node = try! parser::parse(scanner::SourceLoc::String, source, &mut arena, &mut POOL);
    try! super::setAst(&mut graph, rootId, parsed);
    try! super::setSource(&mut graph, rootId, source);
    let retainedAst = super::astFor(alias) else panic;
    try testing::expect(retainedAst as u64 == parsed as u64);
    let retainedSource = super::sourceFor(root) else panic;
    try testing::expect(mem::eq(retainedSource, source));
    try testing::expect(try! super::state(&graph, rootId) == super::ModuleState::Parsed);

}

lib/std/lang/package.rad +1 -1

    set pkg.rootModuleId = nil;

}

/// Register a module described by the file path.
export fn registerModule(pkg: &mut Package, graph: &mut module::ModuleGraph, pool: &mut strings::Pool, filePath: *[u8]) -> u16
export unsafe fn registerModule(pkg: &mut Package, graph: &mut module::ModuleGraph, pool: &mut strings::Pool, filePath: *[u8]) -> u16
    throws (module::ModuleError)
{
    let modId = try module::registerFromPath(graph, pool, pkg.id, pkg.rootModuleId, filePath);
    // First registered module becomes the root.
    if pkg.rootModuleId == nil {

lib/std/lang/parser.rad +246 -25


use std::mem;
use std::io;
use std::fmt;
use std::lang::alloc;
use std::lang::types;
use std::lang::ast;
use std::lang::strings;
use std::lang::scanner;

/// Maximum `u32` value.

    count: u32,
}

/// Snapshot of parser state for speculative parsing.
record SavedState: Copy {
    /// Scanner position, tokens, diagnostics, and expression context.
    parser: Parser,
    /// First byte available for tentative allocations.
    arena: u32,
    /// First node identifier available to the tentative parse.
    nextId: u32,
}

/// Operator metadata for precedence climbing.
record OpInfo: Copy {

    loop {
        match p.current.kind {
            case scanner::TokenKind::Dot => {
                advance(p);

                let field = try parseIdent(p, "expected field name after `.`");
                let mut field: *ast::Node = undefined;
                if consume(p, scanner::TokenKind::Set) {
                    set field = node(p, ast::NodeValue::Ident(p.previous.source));
                } else {
                    set field = try parseIdent(p, "expected field name after `.`");
                }
                set result = node(p, ast::NodeValue::FieldAccess(
                    ast::Access { parent: result, child: field }
                ));
            }
            case scanner::TokenKind::ColonColon => {

                let ident = try parseIdent(p, "expected identifier after `::`");
                set result = node(p, ast::NodeValue::ScopeAccess(
                    ast::Access { parent: result, child: ident }
                ));
            }
            case scanner::TokenKind::Region => {
                let regions = try parseRegions(p);
                set result = node(p, ast::NodeValue::RegionApply { value: result, regions });
            }
            case scanner::TokenKind::LBracket => {
                set result = try parseSubscriptOrSlice(p, result);
            }
            case scanner::TokenKind::LParen => {
                set result = try parseCall(p, result);

             ast::NodeValue::WhileLet(_),
             ast::NodeValue::For(_),
             ast::NodeValue::Loop { .. },
             ast::NodeValue::Match(_),
             ast::NodeValue::Block(_),
             ast::NodeValue::RegionBlock { .. },
             ast::NodeValue::FnDecl(_),
             ast::NodeValue::RecordDecl(_),
             ast::NodeValue::UnionDecl(_),
             ast::NodeValue::TraitDecl { .. },
             ast::NodeValue::InstanceDecl { .. },

        }
        case scanner::TokenKind::Match => {
            return try parseMatch(p);
        }
        case scanner::TokenKind::Let => {
            if isRegionBlock(p) {
                return try parseRegionBlock(p);
            }
            advance(p);
            if consume(p, scanner::TokenKind::Case) {
                return try parseLetCase(p);
            }
            if consume(p, scanner::TokenKind::Mut) {

        }
        case scanner::TokenKind::Record => {
            return try parseRecordDecl(p, attrs);
        }
        case scanner::TokenKind::Use => {
            if isSessionBlock(p) {
                return try parseSessionBlock(p);
            }
            return try parseUse(p, attrs);
        }
        case scanner::TokenKind::Mod => {
            return try parseMod(p, attrs);
        }

            return try parseExprStmt(p);
        }
    }
}

/// Return whether the current `let` statement starts a regional block.
unsafe fn isRegionBlock(p: &Parser) -> bool {
    let mut lookahead = p.scanner;
    return scanner::next(&mut lookahead).kind == scanner::TokenKind::Ident
        and scanner::next(&mut lookahead).kind == scanner::TokenKind::Colon
        and scanner::next(&mut lookahead).kind == scanner::TokenKind::Region;
}

/// Return whether the current `use` statement has an allocation-session header.
unsafe fn isSessionBlock(p: &mut Parser) -> bool {
    let saved = saveState(p);
    advance(p);
    let source: ?*ast::Node = try? parseUnaryExpr(p);
    let result = source <> nil
        and consume(p, scanner::TokenKind::As)
        and consume(p, scanner::TokenKind::Ident)
        and check(p, scanner::TokenKind::In);
    restoreState(p, &saved);
    return result;
}

/// Parse statements until the specified ending token is encountered.
///
/// Returns the completed immutable statement list.
export unsafe fn parseStmtsUntil(p: &mut Parser, end: scanner::TokenKind, capacity: u32) -> *[*ast::Node]
    throws (ParseError)

        arena: alloc::save(&p.arena.arena),
        nextId: p.arena.nextId,
    };
}

/// Restore parser state from a snapshot, fully undoing any
/// side effects of a failed speculative parse.
/// Restore scanner state, diagnostics, arena storage, and node identifiers.
/// Tentative nodes must be unreachable from all state retained by the caller.
/// Interned tokens retain source storage, which must outlive the string pool.
unsafe fn restoreState(p: &mut Parser, s: &SavedState) {
    set *p = s.parser;
    alloc::restore(&mut p.arena.arena, s.arena);
    set p.arena.nextId = s.nextId;
}

    set p.context = saved;

    return pattern;
}

/// Parse a region name.
unsafe fn parseRegion(p: &mut Parser) -> *ast::Node throws (ParseError) {
    let name = try expect(p, scanner::TokenKind::Region, "expected region name");
    return node(p, ast::NodeValue::Region { name, parent: nil });
}

/// Parse consecutive region names.
unsafe fn parseRegions(p: &mut Parser) -> *mut [*ast::Node] throws (ParseError) {
    let mut regions = ast::nodeSlice(p.arena, 4);
    while check(p, scanner::TokenKind::Region) {
        regions.append(try parseRegion(p), p.allocator);
    }
    return regions;
}

/// Parse region bounds for a declaration.
unsafe fn parseRegionBounds(p: &mut Parser, regions: &mut [*ast::Node])
    throws (ParseError)
{
    if not consume(p, scanner::TokenKind::Where) {
        return;
    }
    loop {
        let parent = try parseRegion(p);
        try expect(p, scanner::TokenKind::Colon, "expected `:` in region bound");
        let childName = try expect(p, scanner::TokenKind::Region, "expected region name");
        let mut matched = false;
        for i in 0..regions.len {
            let region = regions[i];
            if let case ast::NodeValue::Region { name, parent: declaredParent } = region.value;
                mem::eq(name, childName)
            {
                if declaredParent <> nil {
                    throw failParsing(p, "region parameter already has a bound");
                }
                set regions[i] = node(p, ast::NodeValue::Region { name, parent });
                set matched = true;
                break;
            }
        }
        if not matched {
            throw failParsing(p, "expected declared region parameter in bound");
        }
        if not consume(p, scanner::TokenKind::Comma) {
            break;
        }
    }
}

/// Parse scoped borrow bindings.
unsafe fn parseRegionBlock(p: &mut Parser) -> *ast::Node throws (ParseError) {
    advance(p);
    let mut binding = try parseIdent(p, "expected region binding name");
    try expect(p, scanner::TokenKind::Colon, "expected `:` after region binding");
    let regionName = try expect(p, scanner::TokenKind::Region, "expected region name after `:`");
    let mut region = node(p, ast::NodeValue::Region { name: regionName, parent: nil });
    let mut bindings = ast::nodeSlice(p.arena, 4);
    loop {
        try expect(p, scanner::TokenKind::Equal, "expected `=` after region binding");
        try expect(p, scanner::TokenKind::Amp, "expected `&` before borrowed place");
        let mutable = consume(p, scanner::TokenKind::Mut);
        let target = try parseUnaryExpr(p);
        let value = node(p, ast::NodeValue::AddressOf({ target, mutable }));
        bindings.append(node(p, ast::NodeValue::RegionBinding({ label: binding, value })), p.allocator);
        if not consume(p, scanner::TokenKind::Comma) {
            break;
        }
        set binding = try parseIdent(p, "expected region binding name");
    }
    if consume(p, scanner::TokenKind::Where) {
        let parent = try parseRegion(p);
        try expect(p, scanner::TokenKind::Colon, "expected `:` in region bound");
        let childName = try expect(p, scanner::TokenKind::Region, "expected child region in bound");
        if not mem::eq(regionName, childName) {
            throw failParsing(p, "region bound must name the declared region");
        }
        set region = node(p, ast::NodeValue::Region { name: regionName, parent });
    }
    try expect(p, scanner::TokenKind::In, "expected `in` after region bindings");
    let body = try parseBlock(p);
    return node(p, ast::NodeValue::RegionBlock { region, bindings, body, isSession: false });
}

/// Create a region name from an allocation-session binding name.
unsafe fn sessionRegion(p: &mut Parser, binding: *ast::Node) -> *ast::Node {
    let case ast::NodeValue::Ident(name) = binding.value
        else panic "sessionRegion: invalid binding";
    let len = name.len + 1;
    let buf = alloc::remainingBuf(&mut p.arena.arena);
    assert buf.len >= len, "sessionRegion: node arena is full";
    set buf[0] = 39;
    try! mem::copy(&mut buf[1..len], name);
    alloc::commit(&mut p.arena.arena, len);
    return node(p, ast::NodeValue::Region { name: &buf[..len], parent: nil });
}

/// Parse an allocation session with an implicit exclusive source borrow.
unsafe fn parseSessionBlock(p: &mut Parser) -> *ast::Node throws (ParseError) {
    try expect(p, scanner::TokenKind::Use, "expected `use`");
    let target = try parseUnaryExpr(p);
    let value = node(p, ast::NodeValue::AddressOf({ target, mutable: true }));
    try expect(p, scanner::TokenKind::As, "expected `as` after allocation source");
    let binding = try parseIdent(p, "expected allocation binding after `as`");
    let region = sessionRegion(p, binding);
    try expect(p, scanner::TokenKind::In, "expected `in` after allocation binding");
    let bindings = ast::nodeSlice(p.arena, 1).append(
        node(p, ast::NodeValue::RegionBinding({ label: binding, value })),
        p.allocator,
    );
    let body = try parseBlock(p);
    return node(p, ast::NodeValue::RegionBlock { region, bindings, body, isSession: true });
}

/// Parse an identifier.
unsafe fn parseIdent(p: &mut Parser, err: *[u8]) -> *ast::Node
    throws (ParseError)
{
    let source = try expect(p, scanner::TokenKind::Ident, err);

    try expect(p, terminator, "expected closing delimiter after record fields");

    return fields;
}

/// Parse an optional derives list (`: Trait + Trait`).
unsafe fn parseDerives(p: &mut Parser) -> *mut [*ast::Node] throws (ParseError) {
    let mut derives = ast::nodeSlice(p.arena, 4);

/// Parse an optional declaration list and separate regions from derives.
unsafe fn parseNominalClauses(
    p: &mut Parser,
    regions: &mut *mut [*ast::Node],
    derives: &mut *mut [*ast::Node],
) throws (ParseError) {
    if not consume(p, scanner::TokenKind::Colon) {
        return derives;
        return;
    }
    set *regions = ast::nodeSlice(p.arena, 4);
    set *derives = ast::nodeSlice(p.arena, 4);
    loop {
        let t = try parseIdent(p, "expected trait name in derive list");
        derives.append(t, p.allocator);
        if check(p, scanner::TokenKind::Region) {
            regions.append(try parseRegion(p), p.allocator);
        } else {
            derives.append(
                try parseIdent(p, "expected region or trait name in declaration list"),
                p.allocator,
            );
        }

        if not consume(p, scanner::TokenKind::Plus) {
            break;
        }
    }
}

/// Parse an optional list of trait names.
unsafe fn parseDerives(p: &mut Parser) -> *mut [*ast::Node] throws (ParseError) {
    if not consume(p, scanner::TokenKind::Colon) {
        return &mut [];
    }
    let mut derives = ast::nodeSlice(p.arena, 4);
    loop {
        derives.append(try parseIdent(p, "expected trait name"), p.allocator);
        if not consume(p, scanner::TokenKind::Plus) {
            break;
        }
    }
    return derives;
}

/// Parse a single record literal field.
/// Can be either labeled, or shorthand.

    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Record, "expected `record`");

    let name = try parseIdent(p, "expected record name");
    let derives = try parseDerives(p);
    let mut regions: *mut [*ast::Node] = &mut [];
    let mut derives: *mut [*ast::Node] = &mut [];
    try parseNominalClauses(p, &mut regions, &mut derives);
    try parseRegionBounds(p, &mut regions[..]);

    if consume(p, scanner::TokenKind::LParen) {
        let fields = try parseRecordFields(p, RecordFieldMode::Unlabeled);
        try expect(p, scanner::TokenKind::Semicolon, "expected `;` after record");
        return node(p, ast::NodeValue::RecordDecl(
            ast::RecordDecl { name, fields, attrs, derives, labeled: false }
            ast::RecordDecl {
                name, fields, attrs, regions, derives, labeled: false,
            }
        ));
    } else {
        try expect(p, scanner::TokenKind::LBrace, "expected `{` before record body");
        let fields = try parseRecordFields(p, RecordFieldMode::Labeled);
        return node(p, ast::NodeValue::RecordDecl(
            ast::RecordDecl { name, fields, attrs, derives, labeled: true }
            ast::RecordDecl {
                name, fields, attrs, regions, derives, labeled: true,
            }
        ));
    }
}

/// Parse a union declaration.

    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Union, "expected `union`");

    let name = try parseIdent(p, "expected union name");
    let derives = try parseDerives(p);
    let mut regions: *mut [*ast::Node] = &mut [];
    let mut derives: *mut [*ast::Node] = &mut [];
    try parseNominalClauses(p, &mut regions, &mut derives);
    try parseRegionBounds(p, &mut regions[..]);

    try expect(p, scanner::TokenKind::LBrace, "expected `{` before union body");

    let mut variants = ast::nodeSlice(p.arena, 128);
    while not check(p, scanner::TokenKind::RBrace) {

        }
    }
    try expect(p, scanner::TokenKind::RBrace, "expected `}`");

    return node(p, ast::NodeValue::UnionDecl(
        ast::UnionDecl { name, variants, attrs, derives }
        ast::UnionDecl {
            name, variants, attrs, regions, derives,
        }
    ));
}

/// Parse a function parameter.
unsafe fn parseFnParam(p: &mut Parser) -> *ast::Node

    // Method syntax: `fn (recv: *Type) name(params) { body }`.
    if check(p, scanner::TokenKind::LParen) {
        return try parseMethodDecl(p, attrs);
    }
    let name = try parseIdent(p, "expected function name");
    let regions = try parseRegions(p);
    let sig = try parseFnTypeSig(p);
    try parseRegionBounds(p, &mut regions[..]);
    let mut body: ?*ast::Node = nil;
    let mut fnAttrs = attrs;

    if consume(p, scanner::TokenKind::Semicolon) {
        if let a = attrs; ast::attributesContains(&a, ast::Attribute::Extern) {

        }
    } else {
        set body = try parseBlock(p);
    }
    return node(p, ast::NodeValue::FnDecl(
        ast::FnDecl { name, sig, body, attrs: fnAttrs }
        ast::FnDecl { name, regions, sig, body, attrs: fnAttrs }
    ));
}

/// Parse a pointer-like type after its ownership prefix.
unsafe fn parsePointerLikeType(
    p: &mut Parser,
    class: types::PointerClass,
    class: ast::PointerClass,
) -> *ast::Node throws (ParseError) {
    if check(p, scanner::TokenKind::Ident) and mem::eq(p.current.source, "cell") {
        advance(p);
        let payload = try parseType(p);
        return node(p, ast::NodeValue::TypeSig(ast::TypeSig::Cell { class, payload }));
    }
    let mutable = consume(p, scanner::TokenKind::Mut);

    if consume(p, scanner::TokenKind::LBracket) {
        let itemType = try parseType(p);
        try expect(p, scanner::TokenKind::RBracket, "expected `]` after slice element type");

                ast::TypeSig::Optional { valueType }
            ));
        }
        case scanner::TokenKind::Star => {
            advance(p);
            let class = types::PointerClass::Unsafe
            let class = ast::PointerClass::Unsafe
                if consume(p, scanner::TokenKind::Unsafe)
                else types::PointerClass::Owned;
                else ast::PointerClass::Owned;
            return try parsePointerLikeType(p, class);
        }
        case scanner::TokenKind::Amp => {
            advance(p);
            return try parsePointerLikeType(p, types::PointerClass::Ref);
            let mut region: ?*ast::Node = nil;
            if check(p, scanner::TokenKind::Region) {
                set region = try parseRegion(p);
            }
            let type = try parsePointerLikeType(p, ast::PointerClass::Ref);
            if let r = region {
                return node(p, ast::NodeValue::TypeSig(ast::TypeSig::RegionRef { region: r, type }));
            }
            return type;
        }
        case scanner::TokenKind::LBracket => {
            return try parseArrayType(p);
        }
        case scanner::TokenKind::Super, scanner::TokenKind::Ident => {
            let path = try parseTypePath(p);

            if check(p, scanner::TokenKind::Region) {
                let regions = try parseRegions(p);
                return node(p, ast::NodeValue::TypeSig(ast::TypeSig::Applied { name: path, regions }));
            }
            return node(p, ast::NodeValue::TypeSig(
                ast::TypeSig::Nominal(path)
            ));
        }
        case scanner::TokenKind::U8 => {

    let receiver = try parseType(p);

    try expect(p, scanner::TokenKind::RParen, "expected `)` after receiver");

    let name = try parseIdent(p, "expected method name");
    let mut regions = try parseRegions(p);
    let sig = try parseFnTypeSig(p);
    try parseRegionBounds(p, &mut regions[..]);
    try expect(p, scanner::TokenKind::Semicolon, "expected `;` after method signature");

    return node(p, ast::NodeValue::TraitMethodSig { name, receiver, sig, attrs });
    let modifiers = try! alloc::alloc(
        &mut p.arena.arena, @sizeOf(ast::MethodModifiers), @alignOf(ast::MethodModifiers)
    ) as *mut ast::MethodModifiers;
    set *modifiers = ast::MethodModifiers { regions, attrs };
    return node(p, ast::NodeValue::TraitMethodSig { name, modifiers, receiver, sig });
}

/// Parse an instance block.
/// Syntax: `instance Trait for Type { fn (t: *mut Type) fnord(..) {..} }`
///

{
    try expect(p, scanner::TokenKind::Instance, "expected `instance`");
    let traitName = try parseTypePath(p);
    try expect(p, scanner::TokenKind::For, "expected `for` after trait name");
    let targetType = try parseTypePath(p);
    let mut regions = try parseRegions(p);
    try parseRegionBounds(p, &mut regions[..]);
    try expect(p, scanner::TokenKind::LBrace, "expected `{` after target type");

    let mut methods = ast::nodeSlice(p.arena, ast::MAX_TRAIT_METHODS);

    while not check(p, scanner::TokenKind::RBrace) and


        methods.append(method, p.allocator);
    }
    try expect(p, scanner::TokenKind::RBrace, "expected `}` after instance methods");

    return node(p, ast::NodeValue::InstanceDecl { traitName, targetType, methods });
    return node(p, ast::NodeValue::InstanceDecl { traitName, targetType, regions, methods });
}

/// Parse a method declaration with a receiver.
/// Syntax: `fn (t: *mut Type) fnord(<params>) -> ReturnType { body }`
///

    let receiverType = try parseType(p);

    try expect(p, scanner::TokenKind::RParen, "expected `)` after receiver type");

    let name = try parseIdent(p, "expected method name");
    let mut regions = try parseRegions(p);
    let sig = try parseFnTypeSig(p);
    try parseRegionBounds(p, &mut regions[..]);
    let body = try parseBlock(p);

    let modifiers = try! alloc::alloc(
        &mut p.arena.arena, @sizeOf(ast::MethodModifiers), @alignOf(ast::MethodModifiers)
    ) as *mut ast::MethodModifiers;
    set *modifiers = ast::MethodModifiers { regions, attrs };
    return node(p, ast::NodeValue::MethodDecl {
        name, receiverName, receiverType, sig, body, attrs,
        name, modifiers, receiverName, receiverType, sig, body,
    });
}

/// Parse a comma-separated list enclosed by the given delimiters.
unsafe fn parseList(

lib/std/lang/parser/tests.rad +303 -17


use std::mem;
use std::fmt;
use std::testing;
use std::lang::ast;
use std::lang::types;
use std::lang::alloc;
use std::lang::sexpr;
use std::lang::ast::printer;
use std::lang::scanner;
use std::lang::strings;

}

/// Parse an `i32` pointer type and verify its class and mutability.
unsafe fn expectI32Pointer(
    source: *[u8],
    class: types::PointerClass,
    class: ast::PointerClass,
    mutable: bool,
) throws (testing::TestError) {
    let node = try! parseTypeStr(source);
    let case ast::NodeValue::TypeSig(sig) = node.value
        else throw testing::TestError::Failed;

    assert actualMutable == mutable;
}

/// Test parsing a mutable owned pointer.
@test unsafe fn testParseTypePointer() throws (testing::TestError) {
    try expectI32Pointer("*mut i32", types::PointerClass::Owned, true);
    try expectI32Pointer("*mut i32", ast::PointerClass::Owned, true);
}

/// Test parsing an immutable owned pointer.
@test unsafe fn testParseTypePointerImmutable() throws (testing::TestError) {
    try expectI32Pointer("*i32", types::PointerClass::Owned, false);
    try expectI32Pointer("*i32", ast::PointerClass::Owned, false);
}

/// Test parsing immutable and mutable references.
@test unsafe fn testParseTypeRef() throws (testing::TestError) {
    try expectI32Pointer("&i32", types::PointerClass::Ref, false);
    try expectI32Pointer("&mut i32", types::PointerClass::Ref, true);
    try expectI32Pointer("&i32", ast::PointerClass::Ref, false);
    try expectI32Pointer("&mut i32", ast::PointerClass::Ref, true);
}

/// Test parsing immutable and mutable unsafe pointers.
@test unsafe fn testParseTypeUnsafePointer() throws (testing::TestError) {
    try expectI32Pointer("*unsafe i32", types::PointerClass::Unsafe, false);
    try expectI32Pointer("*unsafe mut i32", types::PointerClass::Unsafe, true);
    try expectI32Pointer("*unsafe i32", ast::PointerClass::Unsafe, false);
    try expectI32Pointer("*unsafe mut i32", ast::PointerClass::Unsafe, true);
}

/// Test parsing a slice type.
@test unsafe fn testParseTypeSlice() throws (testing::TestError) {
    let node = try! parseTypeStr("*[u8]");
    let case ast::NodeValue::TypeSig(sig) = node.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Slice { class, itemType, mutable } = sig
        else throw testing::TestError::Failed;

    assert class == types::PointerClass::Owned;
    assert class == ast::PointerClass::Owned;
    try expectIntType(itemType, 1, ast::Signedness::Unsigned);
    assert not mutable;
}

/// Test parsing a mutable slice type.

    let case ast::NodeValue::TypeSig(sig) = node.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Slice { class, itemType, mutable } = sig
        else throw testing::TestError::Failed;

    assert class == types::PointerClass::Owned;
    assert class == ast::PointerClass::Owned;
    try expectIntType(itemType, 1, ast::Signedness::Unsigned);
    assert mutable;
}

/// Test parsing reference and unsafe slice classes.
@test unsafe fn testParseTypeSliceClasses() throws (testing::TestError) {
    let refNode = try! parseTypeStr("&[u8]");
    let case ast::NodeValue::TypeSig(ast::TypeSig::Slice {
        class: refClass, ..
    }) = refNode.value else throw testing::TestError::Failed;
    assert refClass == types::PointerClass::Ref;
    assert refClass == ast::PointerClass::Ref;

    let unsafeNode = try! parseTypeStr("*unsafe [u8]");
    let case ast::NodeValue::TypeSig(ast::TypeSig::Slice {
        class: unsafeClass, ..
    }) = unsafeNode.value else throw testing::TestError::Failed;
    assert unsafeClass == types::PointerClass::Unsafe;
    assert unsafeClass == ast::PointerClass::Unsafe;
}

/// Test parsing trait object pointer classes.
@test unsafe fn testParseTypeTraitObjectClasses() throws (testing::TestError) {
    let ownedNode = try! parseTypeStr("*opaque Read");
    let case ast::NodeValue::TypeSig(ast::TypeSig::TraitObject {
        class: ownedClass, ..
    }) = ownedNode.value else throw testing::TestError::Failed;
    assert ownedClass == types::PointerClass::Owned;
    assert ownedClass == ast::PointerClass::Owned;

    let refNode = try! parseTypeStr("&opaque Read");
    let case ast::NodeValue::TypeSig(ast::TypeSig::TraitObject {
        class: refClass, ..
    }) = refNode.value else throw testing::TestError::Failed;
    assert refClass == types::PointerClass::Ref;
    assert refClass == ast::PointerClass::Ref;

    let unsafeNode = try! parseTypeStr("*unsafe opaque Read");
    let case ast::NodeValue::TypeSig(ast::TypeSig::TraitObject {
        class: unsafeClass, ..
    }) = unsafeNode.value else throw testing::TestError::Failed;
    assert unsafeClass == types::PointerClass::Unsafe;
    assert unsafeClass == ast::PointerClass::Unsafe;
}

/// Test parsing an array type.
@test unsafe fn testParseTypeArray() throws (testing::TestError) {
    let node = try! parseTypeStr("[i32; 4]");

        "instance Read for Value { unsafe fn (value: &Value) get() {} }"
    );
    let case ast::NodeValue::InstanceDecl { methods, .. } = instanceNode.value
        else throw testing::TestError::Failed;
    try testing::expect(methods.len == 1);
    let case ast::NodeValue::MethodDecl { attrs, .. } = methods[0].value
    let case ast::NodeValue::MethodDecl { modifiers, .. } = methods[0].value
        else throw testing::TestError::Failed;
    let attrs = modifiers.attrs;
    let methodAttrs = attrs else throw testing::TestError::Failed;
    assert ast::attributesContains(&methodAttrs, ast::Attribute::Unsafe);

    static printStorage: [u8; 4096] = undefined;
    let mut printArena = alloc::new(&mut printStorage[..]);

        "trait Read { unsafe fn (&Read) get(); }"
    );
    let case ast::NodeValue::TraitDecl { methods: traitMethods, .. } = traitNode.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::TraitMethodSig {
        attrs: traitAttrs, ..
        modifiers: traitModifiers, ..
    } = traitMethods[0].value else throw testing::TestError::Failed;
    let traitAttrs = traitModifiers.attrs;
    let traitMethodAttrs = traitAttrs else throw testing::TestError::Failed;
    assert ast::attributesContains(&traitMethodAttrs, ast::Attribute::Unsafe);

    let traitMethodExpr = printer::toExpr(&mut printArena, traitMethods[0]);
    let case sexpr::Expr::List { tail: traitMethodItems, .. } = traitMethodExpr

    let case sexpr::Expr::Sym(traitAttr) = printedTraitAttrs[0]
        else throw testing::TestError::Failed;
    assert mem::eq(traitAttr, "@unsafe");
}

/// Test region parameters on methods, trait methods, and instances.
@test unsafe fn testParseRegionalMethods() throws (testing::TestError) {
    let instanceNode = try! parseStmtStr(
        "instance Read for View 'view { fn (view: &View 'view) get 'method () -> &'method u32 { panic; } }"
    );
    let case ast::NodeValue::InstanceDecl { regions, methods, .. } = instanceNode.value
        else throw testing::TestError::Failed;
    try testing::expect(regions.len == 1 and methods.len == 1);
    let case ast::NodeValue::MethodDecl { modifiers, .. } = methods[0].value
        else throw testing::TestError::Failed;
    try testing::expect(modifiers.regions.len == 1);

    let traitNode = try! parseStmtStr(
        "trait Read { fn (&Read) get 'method () -> &'method u32; }"
    );
    let case ast::NodeValue::TraitDecl { methods: traitMethods, .. } = traitNode.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::TraitMethodSig { modifiers: traitModifiers, .. } = traitMethods[0].value
        else throw testing::TestError::Failed;
    try testing::expect(traitModifiers.regions.len == 1);
}

/// Test parsing a function declaration with attributes.
@test unsafe fn testParseFnDeclAttributes() throws (testing::TestError) {
    let node = try! parseStmtStr("export fn run();");
    let case ast::NodeValue::FnDecl(decl) = node.value
        else throw testing::TestError::Failed;

    assert isUnsafe;
    assert sig.params.len == 1;
    assert sig.returnType <> nil;
    assert sig.throwList.len == 1;
}

/// Region arguments on an inner type remain distinct from a reference region.
@test unsafe fn testRegionReferenceTypes() throws (testing::TestError) {
    let root = try! parseTypeStr("&'short mut Node 'arena");
    let case ast::NodeValue::TypeSig(ast::TypeSig::RegionRef { region, type }) = root.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Region { name, parent: nil } = region.value
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(name, "'short"));
    let case ast::NodeValue::TypeSig(ast::TypeSig::Pointer { class, valueType, mutable }) = type.value
        else throw testing::TestError::Failed;
    try testing::expect(class == ast::PointerClass::Ref and mutable);
    let case ast::NodeValue::TypeSig(ast::TypeSig::Applied { name: nominal, regions }) = valueType.value
        else throw testing::TestError::Failed;
    try expectIdent(nominal, "Node");
    try testing::expect(regions.len == 1);
    let case ast::NodeValue::Region { name: argument, .. } = regions[0].value
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(argument, "'arena"));
    let slice = try! parseTypeStr("&'r [View 'a 'b]");
    let case ast::NodeValue::TypeSig(ast::TypeSig::RegionRef { type: sliceType, .. }) = slice.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::TypeSig(ast::TypeSig::Slice { .. }) = sliceType.value
        else throw testing::TestError::Failed;
}

/// Declaration lists accept regions, parent relations, and ownership derives.
@test unsafe fn testRegionDeclarations() throws (testing::TestError) {
    let parsedRecord = try! parseStmtStr("record View: 'a + 'b + Copy where 'a: 'b { item: &'b u8 }");
    let case ast::NodeValue::RecordDecl(decl) = parsedRecord.value
        else throw testing::TestError::Failed;
    try testing::expect(decl.regions.len == 2 and decl.derives.len == 1);
    let case ast::NodeValue::Region { parent: parent, .. } = decl.regions[1].value
        else throw testing::TestError::Failed;
    try testing::expect(parent <> nil);
    let func = try! parseStmtStr(
        "fn read 'long 'short (input: &'short u8) -> &'short u8 throws (ReadError) where 'long: 'short { return input; }"
    );
    let case ast::NodeValue::FnDecl(f) = func.value else throw testing::TestError::Failed;
    try testing::expect(f.regions.len == 2 and f.sig.throwList.len == 1);
    let case ast::NodeValue::Region { name: shortName, parent: shortParent } = f.regions[1].value
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(shortName, "'short") and shortParent <> nil);
    let parentNode = shortParent else throw testing::TestError::Failed;
    let case ast::NodeValue::Region { name: parentName, parent: nil } = parentNode.value
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(parentName, "'long"));
    let parsedUnion = try! parseStmtStr("union Result: 'x { Value(&'x u8), Empty }");
    let case ast::NodeValue::UnionDecl(u) = parsedUnion.value else throw testing::TestError::Failed;
    try testing::expect(u.regions.len == 1 and u.derives.len == 0);
}

/// Regional blocks retain their source bindings and derived session region.
@test unsafe fn testRegionBlocks() throws (testing::TestError) {
    let root = try! parseStmtStr("let left: 'r = &mut state.left, right = &state.right in { useView(left); }");
    let case ast::NodeValue::RegionBlock { bindings, isSession, .. } = root.value
        else throw testing::TestError::Failed;
    try testing::expect(not isSession and bindings.len == 2);
    let nested = try! parseStmtStr("let view: 'inner = &value where 'outer: 'inner in {}");
    let case ast::NodeValue::RegionBlock { region: nestedRegion, .. } = nested.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Region { name: nestedName, parent: nestedParent } = nestedRegion.value
        else throw testing::TestError::Failed;
    let parent = nestedParent else throw testing::TestError::Failed;
    let case ast::NodeValue::Region { name: parentName, parent: nil } = parent.value
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(nestedName, "'inner") and mem::eq(parentName, "'outer"));
    let arena = try! parseStmtStr("use arena as objects in { make(objects); }");
    let case ast::NodeValue::RegionBlock {
        region: arenaRegion, bindings: arenaBindings, isSession: arenaSession, ..
    } = arena.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Region { name: arenaRegionName, parent: nil } = arenaRegion.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::RegionBinding(arenaBinding) = arenaBindings[0].value
        else throw testing::TestError::Failed;
    let arenaLabel = arenaBinding.label else throw testing::TestError::Failed;
    let case ast::NodeValue::Ident(arenaLabelName) = arenaLabel.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::AddressOf({ target: arenaTarget, mutable: true }) = arenaBinding.value.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Ident(arenaTargetName) = arenaTarget.value
        else throw testing::TestError::Failed;
    try testing::expect(
        arenaSession and arenaBindings.len == 1
        and mem::eq(arenaRegionName, "'objects")
        and mem::eq(arenaLabelName, "objects")
        and mem::eq(arenaTargetName, "arena")
    );
}

/// Region grammar rejects incomplete lists and invalid allocation headers.
@test unsafe fn testMalformedRegionSyntax() throws (testing::TestError) {
    for source in [
        "fn bad: Copy () {}",
        "record Bad: 'r + {}",
        "let 'r  in {}",
        "let p: 'r = value in {}",
        "let 'r p = &value in {}",
        "let 'child < 'parent p = &value in {}",
        "let 'parent as p = &value in {}",
        "let value: 'child = &source where 'parent: 'other in {}",
        "use arena in {}",
        "use arena as in {}",
        "use arena as first, second in {}",
        "use 'r a = &mut arena in {}",
        "use 'r a as &mut arena in {}",
    ] {
        let parsed = try? parseStmtStr(source);
        try testing::expect(parsed == nil);
    }
    for source in ["&'x' u8", "&mut 'x u8", "View '", "&'r"] {
        let parsed = try? parseTypeStr(source);
        try testing::expect(parsed == nil);
    }
}

/// Ordinary identifiers remain available beside regional block syntax.
@test unsafe fn testRegionContextualKeywords() throws (testing::TestError) {
    for source in [
        "let borrow = 1;",
        "let session = 2;",
        "borrow(value);",
        "session(value);",
        "record Context { borrow: u32, session: u32 }",
    ] {
        let parsed = try? parseStmtStr(source);
        try testing::expect(parsed <> nil);
    }
}

/// The AST printer retains region parameters and qualified reference types.
@test unsafe fn testPrintRegionSignature() throws (testing::TestError) {
    let root = try! parseStmtStr("fn read 'r (input: &'r u8) -> &'r u8 { return input; }");
    static PRINT_STORAGE: [u8; 4096] = [0; 4096];
    let mut arena = alloc::new(&mut PRINT_STORAGE[..]);
    let printed = printer::toExpr(&mut arena, root);
    let case sexpr::Expr::Block { items, .. } = printed
        else throw testing::TestError::Failed;
    try testing::expect(items.len == 4);
    let case sexpr::Expr::List { head, tail, .. } = items[1]
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(head, "regions") and tail.len == 1);
    let case sexpr::Expr::Sym(name) = tail[0] else throw testing::TestError::Failed;
    try testing::expect(mem::eq(name, "'r"));
    let case sexpr::Expr::List { head: refHead, tail: refTail, .. } = items[3]
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(refHead, "region-ref") and refTail.len == 2);
}

/// Explicit function region arguments precede ordinary call arguments.
@test unsafe fn testFunctionRegionApplication() throws (testing::TestError) {
    let expr = try! parseExprStr("read 'a 'b (p)");
    let case ast::NodeValue::Call(call) = expr.value else throw testing::TestError::Failed;
    let case ast::NodeValue::RegionApply { value, regions } = call.callee.value
        else throw testing::TestError::Failed;
    try expectIdent(value, "read");
    try testing::expect(regions.len == 2 and call.args.len == 1);
}

/// Concrete region headers can name a parent and end without a semicolon.
@test unsafe fn testRegionParentSyntax() throws (testing::TestError) {
    let parsed = try? parseStmtsStr("fn f 'a (p: &'a u32) { let q: 'b = &*p where 'a: 'b in {} return; }");
    try testing::expect(parsed <> nil);
}

/// Cell qualifiers retain pointer ownership and payload syntax.
@test unsafe fn testCellPointerType() throws (testing::TestError) {
    let root = try! parseTypeStr("*cell u32");
    let case ast::NodeValue::TypeSig(ast::TypeSig::Cell { class, payload }) = root.value
        else throw testing::TestError::Failed;
    try testing::expect(class == ast::PointerClass::Owned);
    let case ast::NodeValue::TypeSig(ast::TypeSig::Integer { width: 4, .. }) = payload.value
        else throw testing::TestError::Failed;
    let borrowed = try! parseTypeStr("&'r cell Pair 's");
    let case ast::NodeValue::TypeSig(ast::TypeSig::RegionRef { type, .. }) = borrowed.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::TypeSig(ast::TypeSig::Cell { class: refClass, payload: inner }) = type.value
        else throw testing::TestError::Failed;
    try testing::expect(refClass == ast::PointerClass::Ref);
    let case ast::NodeValue::TypeSig(ast::TypeSig::Applied { regions, .. }) = inner.value
        else throw testing::TestError::Failed;
    try testing::expect(regions.len == 1);
}


/// Measure committed storage for a statement after an existing node.
unsafe fn statementStorageUsed(source: *[u8]) -> u32 {
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    ast::allocNode(&mut arena, ast::Span { offset: 0, length: 0 }, ast::NodeValue::Bool(true));
    let start = alloc::used(&arena.arena);
    let mut parser = super::mkParser(scanner::SourceLoc::String, source, &mut arena, &mut STRING_POOL);
    super::advance(&mut parser);
    try! super::parseStmt(&mut parser);
    return alloc::used(&arena.arena) - start;
}

/// Rewinding a failed expression preserves published nodes and source tokens.
@test unsafe fn testSpeculativeRestoreStorage() throws (testing::TestError) {
    let expectedBytes = statementStorageUsed("return");
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let retained = ast::allocNode(&mut arena, ast::Span { offset: 3, length: 1 }, ast::NodeValue::Bool(true));
    let mut parser = super::mkParser(scanner::SourceLoc::String,
        "return [speculativeRestoreIdentifier, 1 +", &mut arena, &mut STRING_POOL);
    super::advance(&mut parser);
    try super::expect(&mut parser, scanner::TokenKind::Eof, "retained diagnostic") catch {
    };
    let mut expected = parser;
    super::advance(&mut expected);
    let startOffset = alloc::used(&arena.arena);
    let startId = arena.nextId;
    let statement = try! super::parseStmt(&mut parser);
    let case ast::NodeValue::Return { value } = statement.value else throw testing::TestError::Failed;
    try testing::expect(value == nil);
    try testing::expect(statement.id == startId);
    try testing::expect(alloc::used(&arena.arena) == startOffset + expectedBytes);
    try testing::expect(arena.nextId == startId + 1);
    try testing::expect(parser.scanner.cursor == expected.scanner.cursor);
    try testing::expect(parser.scanner.token == expected.scanner.token);
    try testing::expect(parser.current.kind == expected.current.kind);
    try testing::expect(parser.current.offset == expected.current.offset);
    try testing::expect(parser.previous.kind == expected.previous.kind);
    try testing::expect(parser.previous.offset == expected.previous.offset);
    try testing::expect(parser.context == expected.context);
    try testing::expect(parser.errors.count == 1);
    for i in alloc::used(&arena.arena)..ARENA_STORAGE.len {
        set ARENA_STORAGE[i] = 0xA5;
    }
    let case ast::NodeValue::Bool(true) = retained.value else throw testing::TestError::Failed;
    try testing::expect(retained.span.offset == 3);
    try testing::expect(retained.span.length == 1);
    try testing::expect(mem::eq(parser.errors.list[0].message, "retained diagnostic"));
    try testing::expect(mem::eq(parser.errors.list[0].token.source, "return"));
    let interned = strings::find(&STRING_POOL, "speculativeRestoreIdentifier") else throw testing::TestError::Failed;
    try testing::expect(mem::eq(interned, "speculativeRestoreIdentifier"));
    let replacement = ast::allocNode(&mut arena, ast::Span { offset: 0, length: 0 }, ast::NodeValue::Bool(false));
    try testing::expect(replacement.id == startId + 1);
    let case ast::NodeValue::Bool(true) = retained.value else throw testing::TestError::Failed;
}

/// Optional return and panic expressions publish only their wrapper after failure.
@test unsafe fn testSpeculativeStatementPublication() throws (testing::TestError) {
    let expectedBytes = statementStorageUsed("return");
    for source in ["return (speculativeReturnIdentifier +", "panic (speculativePanicIdentifier +"] {
        let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
        ast::allocNode(&mut arena, ast::Span { offset: 0, length: 0 }, ast::NodeValue::Bool(true));
        let startOffset = alloc::used(&arena.arena);
        let mut parser = super::mkParser(scanner::SourceLoc::String, source, &mut arena, &mut STRING_POOL);
        super::advance(&mut parser);
        let startId = arena.nextId;
        let statement = try! super::parseStmt(&mut parser);
        try testing::expect(statement.id == startId);
        try testing::expect(arena.nextId == startId + 1);
        try testing::expect(alloc::used(&arena.arena) == startOffset + expectedBytes);
        try testing::expect(parser.errors.count == 0);
        try testing::expect(parser.current.kind == scanner::TokenKind::LParen);
        match statement.value {
            case ast::NodeValue::Return { value } => try testing::expect(value == nil),
            case ast::NodeValue::Panic { message } => try testing::expect(message == nil),
            else => throw testing::TestError::Failed,
        }
    }
}

lib/std/lang/resolver.rad +3240 -824

export constant MAX_INSTANCES: u32 = 128;
/// Maximum standalone methods (across all types).
export constant MAX_METHODS: u32 = 256;
/// Maximum number of linear bindings active in one function.
constant MAX_LINEAR_BINDINGS: u32 = 32;
/// Maximum full-region projections active in nested lexical regions.
constant MAX_REGIONAL_LOANS: u32 = 32;
/// Maximum inline field depth used to prove borrow separation.
constant MAX_BORROW_FIELDS: u32 = 16;
/// Maximum nesting depth tracked for loops.
constant MAX_LINEAR_LOOP_DEPTH: u32 = 16;

/// Trait definition stored in the resolver.
export record TraitType: Copy {
    /// Trait name.
    name: *[u8],
    /// Module that declares the trait.
    moduleId: u16,
    /// Method signatures, including from supertraits.
    methods: *unsafe mut [TraitMethod],
    /// Supertraits that must also be implemented.
    supertraits: *unsafe mut [*unsafe TraitType],
}

    length: u32,
}

/// Record nominal type.
export record RecordType: Copy {
    /// Region parameters of the source declaration.
    regions: ?*RegionScope,
    /// Exact region arguments, if this is an applied type.
    application: ?*unsafe NominalApplication,
    fields: *unsafe [RecordField],
    labeled: bool,
    /// Cached layout.
    layout: Layout,
    /// Shared layout of the source declaration.
    layout: *Layout,
    /// Whether the declaration explicitly carries the `Once` marker.
    declaredLinear: bool,
    /// Whether the declaration explicitly carries the `Copy` marker.
    declaredCopy: bool,
}

/// Union nominal type.
export record UnionType: Copy {
    /// Region parameters of the source declaration.
    regions: ?*RegionScope,
    /// Exact region arguments, if this is an applied type.
    application: ?*unsafe NominalApplication,
    variants: *unsafe [UnionVariant],
    /// Cached layout.
    layout: Layout,
    /// Shared layout of the source declaration.
    layout: *Layout,
    /// Cached payload offset within the union aggregate.
    valOffset: u32,
    /// If all variants have void payloads.
    isAllVoid: bool,
    /// Whether the declaration explicitly carries the `Once` marker.

/// Metadata for user-defined types.
export union NominalType: Copy {
    /// Placeholder for a type that hasn't been fully resolved yet.
    /// Stores the declaration node for lazy resolution.
    Placeholder(*ast::Node),
    /// Declaration whose value layout is under analysis.
    Resolving(*ast::Node),
    /// Applied type whose field or variant view is not yet resolved.
    Application(*unsafe NominalApplication),
    Record(RecordType),
    Union(UnionType),
}

/// Coercion plan, when coercion from one type to another.

    },
}

/// Resolved function signature details.
export record FnType: Copy {
    /// Symbolic regions declared by the source function.
    regions: ?*RegionScope,
    /// Parameter types in call order.
    paramTypes: *[*Type],
    /// Return value type.
    returnType: *Type,
    /// Error types that the function can throw.

    Nil, Undefined, Int,
    /// Primitive types.
    Void, Opaque, Never, Bool,
    /// Integer types.
    U8, U16, U32, U64, I8, I16, I32, I64,
    /// Shared cell pointer with value access to a Copy payload.
    Cell {
        /// Storage lifetime and ownership class.
        class: types::PointerClass,
        /// Payload type, preserved by all writes.
        payload: *Type,
    },
    /// Affine allocation interface retained by a lexical region.
    Session(*unsafe types::Region),
    /// Range types, eg. `start..end`.
    Range {
        start: ?*Type,
        end: ?*Type,
    },

    TryNonThrowing,
    /// Inferred catch binding used with multi-error callee.
    TryCatchMultiError,
    /// Duplicate error type in typed catch clauses.
    TryCatchDuplicateType,
    /// Distinct error types have the same tag after region erasure.
    AmbiguousRegionalError,
    /// Typed catch clauses do not cover all error types.
    TryCatchNonExhaustive,
    /// Called a fallible function without using `try`.
    MissingTry,
    /// Cannot use opaque type in this context.

    LinearUndefined,
    /// A `Copy` declaration contains a non-copy field or variant.
    CopyContainsNonCopy,
    /// A declaration carries both `Copy` and `Once`.
    ConflictingOwnershipMarkers,
    /// A region name is not visible in this declaration or block.
    UnknownRegion(*[u8]),
    /// A region application has the wrong argument count.
    RegionArgumentCount(CountMismatch),
    /// A region parameter has no consistent argument from checked references.
    RegionInference(*[u8]),
    /// A region argument does not satisfy its declared parent relation.
    RegionParent(*[u8]),
    /// A region parent relation contains a cycle.
    RegionCycle(*[u8]),
    /// A value retains a region that has left lexical scope.
    RegionEscape(*[u8]),
    /// A session requires one exclusive borrow of an allocation trait implementer.
    InvalidSessionSource,
    /// Allocation requires a value that can be discarded without destruction.
    InvalidAllocationValue,
    /// Cell payload is not a storable plain Copy value.
    InvalidCellPayload,
    /// The allocated value has an invalid or overflowing layout.
    InvalidAllocationLayout,
    /// A compiler-known allocation trait method has an invalid signature.
    InvalidAllocationRuntime,
    /// The function has too many distinct full-region projections.
    RegionalLoanOverflow,
    /// A nominal value layout contains itself.
    RecursiveType,
    /// A reference appears in a storable or escaping position.
    InvalidRefPosition,
    /// A reference local requires a fixed binding to existing storage.
    RefBinding,
    /// Call arguments contain overlapping incompatible loans.

record SuperAccessResult: Copy {
    scope: *unsafe mut Scope,
    child: *ast::Node,
}

/// Initialization operation performed after session storage reservation.
export union SessionAllocationKind: Copy {
    /// Initialize one object from a value.
    New,
    /// Copy plain Copy elements from a slice.
    Copy,
    /// Fill a slice with a plain Copy value.
    Fill,
}

/// Typed session allocation and its checked runtime reservation function.
export record SessionAllocation: Copy {
    /// Initialization operation.
    kind: SessionAllocationKind,
    /// Initialized element type.
    item: *Type,
    /// Allocation trait used by the session source.
    traitInfo: *unsafe TraitType,
    /// Reservation method slot in the allocation trait.
    methodIndex: u32,
}

/// Node-specific resolver metadata.
export union NodeExtra: Copy {
    /// No extra data for this node.
    None,
    /// Region identities owned by a source declaration.
    Regions(*RegionScope),
    /// Resolved field index for record literal fields.
    RecordField { index: u32 },
    /// Slice range metadata for subscript expressions with ranges.
    SliceRange(SliceRangeInfo),
    /// Cached union variant metadata for patterns/constructors.

        /// Method index in the v-table.
        methodIndex: u32,
    },
    /// Standalone method call metadata.
    MethodCall { method: *unsafe MethodEntry },
    /// Typed allocation through a session interface.
    SessionAllocation(SessionAllocation),
    /// Slice `.append(val, allocator)` method call.
    SliceAppend { elemType: *Type },
    /// Slice `.delete(index)` method call.
    SliceDelete { elemType: *Type },
}

}

/// Per-control-flow-path ownership state.
/// Read only the initialized symbol prefix below `len`.
record LinearEnv: Copy {
    /// Active full-region loans, indexed by the checker's regional loan table.
    regionalLoans: u64,
    /// Symbol pointers. Entries below `len` are initialized and not optional.
    symbols: [*unsafe mut Symbol; MAX_LINEAR_BINDINGS],
    /// Bit set for each binding that remains available.
    available: u64,
    /// Number of initialized entries in `symbols`.

}

/// Function-local exact-use checker state.
/// Read loop arrays only at indices below `loopDepth`.
/// `enterLinearLoop` initializes each slot before it increases `loopDepth`.
record LinearChecker: Copy {
record LinearChecker: 'arena + 'checking where 'arena: 'checking {
    /// Resolver that owns the symbols and diagnostics.
    resolver: *unsafe mut Resolver,
    resolver: &'checking mut Resolver 'arena,
    /// Regional projections discovered in this function.
    regional: [RegionalLoan; MAX_REGIONAL_LOANS],
    /// Number of initialized regional loan entries.
    regionalLen: u32,
    /// Named regions active at the current source location.
    regions: ?*RegionScope,
    /// Regional loans carried to each loop's next iteration.
    loopBackLoans: [u64; MAX_LINEAR_LOOP_DEPTH],
    /// Regional loans carried to each loop's exits.
    loopExitLoans: [u64; MAX_LINEAR_LOOP_DEPTH],
    /// Regions active at each loop's entry and exit.
    loopRegions: [?*RegionScope; MAX_LINEAR_LOOP_DEPTH],
    /// Source places protected by active pattern references.
    loans: [BorrowPlace; MAX_LINEAR_BINDINGS],
    /// Number of initialized entries in `loans`.
    loanLen: u32,
    /// Reference locals in active lexical scopes.

        return MatchSubject { effectiveTy: *target, by };
    }
    return MatchSubject { effectiveTy: ty, by: MatchBy::Value };
}

/// Region names introduced by a declaration or lexical block.
export record RegionScope: Copy {
    /// Entries in declaration order.
    entries: *unsafe [*unsafe mut types::Region],
    /// Enclosing lexical region environment.
    parent: ?*RegionScope,
}

/// Region arguments for one source declaration.
record RegionSubstitution: Copy {
    /// Declared parameters in source order.
    parameters: *RegionScope,
    /// Inferred or explicit arguments. Every entry must be set before substitution.
    arguments: *unsafe mut [?*unsafe types::Region],
}

/// One interned application of a nominal declaration to exact region arguments.
export record NominalApplication: Copy {
    /// Canonical source declaration identity.
    base: *unsafe NominalType,
    /// Source parameters in declaration order.
    parameters: *RegionScope,
    /// Region arguments in parameter order.
    arguments: *unsafe [*unsafe types::Region],
    /// Stable descriptor for the substituted field or variant view.
    view: *unsafe mut NominalType,
    /// Next application in the resolver cache.
    next: ?*unsafe NominalApplication,
}

/// Global resolver state.
export record Resolver {
export record Resolver: 'arena {
    /// Active region names for source type checking.
    regionScope: ?*RegionScope,
    /// Interned applications of nominal region parameters.
    applications: ?*unsafe NominalApplication,
    /// Current scope.
    scope: *unsafe mut Scope,
    /// Package scope containing package roots and top-level symbols.
    pkgScope: *unsafe mut Scope,
    /// Stack of loop contexts for nested loops.

    currentMod: u16,
    /// Whether the current lexical context permits unsafe operations.
    inUnsafeContext: bool,
    /// Configuration for semantic analysis.
    config: Config,
    /// Unified arena for symbols, scopes, and nominal type.
    arena: alloc::Arena,
    /// Caller-owned arena, valid for this resolver and all emitted metadata.
    arena: &'arena mut alloc::Arena,
    /// Combined semantic metadata table indexed by node ID.
    nodeData: NodeDataTable,
    /// Linked list of interned types.
    types: ?*TypeNode,
    /// Diagnostics recorded so far.

record TypeNode: Copy {
    ty: Type,
    next: ?*TypeNode,
}

/// Look up a region name in a lexical environment.
unsafe fn findRegion(scope: ?*RegionScope, name: *[u8]) -> ?*unsafe mut types::Region {
    let mut current = scope;
    while let env = current {
        for region in env.entries {
            if mem::eq(region.name, name) {
                return region;
            }
        }
        set current = env.parent;
    }
    return nil;
}

/// Resolve a source region name without using its spelling as an identity.
unsafe fn resolveRegion 'arena (self: &mut Resolver 'arena, node: *ast::Node) -> *unsafe types::Region
    throws (ResolveError)
{
    let case ast::NodeValue::Region { name, .. } = node.value
        else panic "resolveRegion: invalid region node";
    let region = findRegion(self.regionScope, name)
        else throw emitError(self, node, ErrorKind::UnknownRegion(name));
    return region;
}

/// Bind all region parameters before resolving their parent relations.
unsafe fn bindRegions 'arena (self: &mut Resolver 'arena, owner: *ast::Node, nodes: *[*ast::Node]) -> ?*RegionScope
    throws (ResolveError)
{
    if let case NodeExtra::Regions(scope) = self.nodeData.entries[owner.id].extra {
        return scope;
    }
    let mut count: u32 = 0;
    for node in nodes {
        if let case ast::NodeValue::Region { .. } = node.value {
            set count += 1;
        }
    }
    if count == 0 {
        return nil;
    }
    let entries = try! alloc::allocRawSlice(
        self.arena, @sizeOf(*unsafe mut types::Region), @alignOf(*unsafe mut types::Region), count
    ) as *unsafe mut [*unsafe mut types::Region];
    let mut index: u32 = 0;
    for node in nodes {
        let case ast::NodeValue::Region { name, .. } = node.value else continue;
        for i in 0..index {
            if mem::eq(entries[i].name, name) {
                throw emitError(self, node, ErrorKind::DuplicateBinding(name));
            }
        }
        let region = try! alloc::allocRaw(self.arena, @sizeOf(types::Region), @alignOf(types::Region))
            as *unsafe mut types::Region;
        set *region = types::Region { id: node.id, origin: types::RegionOrigin::Parameter, name, parent: nil };
        set entries[index] = region;
        set index += 1;
    }
    let scope = try! alloc::alloc(&mut *self.arena, @sizeOf(RegionScope), @alignOf(RegionScope)) as *mut RegionScope;
    set *scope = RegionScope { entries, parent: nil };
    let frozen: *RegionScope = scope;
    set index = 0;
    for node in nodes {
        let case ast::NodeValue::Region { parent, .. } = node.value else continue;
        if let parentNode = parent {
            let case ast::NodeValue::Region { name, .. } = parentNode.value
                else panic "bindRegions: invalid parent node";
            let target = findRegion(frozen, name)
                else throw emitError(self, parentNode, ErrorKind::UnknownRegion(name));
            if types::regionContains(entries[index], target) {
                throw emitError(self, parentNode, ErrorKind::RegionCycle(entries[index].name));
            }
            set entries[index].parent = target;
        }
        set index += 1;
    }
    set self.nodeData.entries[owner.id].extra = NodeExtra::Regions(frozen);
    return frozen;
}

/// Allocate and intern a type in the arena, returning a pointer for deduplication.
export unsafe fn allocType(self: &mut Resolver, ty: Type) -> *Type {
export unsafe fn allocType 'arena (self: &mut Resolver 'arena, ty: Type) -> *Type {
    // Search existing types for a match.
    let mut cursor = self.types;
    while let node = cursor {
        if node.ty == ty {
            return &node.ty;
        }
        set cursor = node.next;
    }
    // Allocate a new type node from the arena.
    let node = try! alloc::alloc(
        &mut self.arena, @sizeOf(TypeNode), @alignOf(TypeNode)
        &mut *self.arena, @sizeOf(TypeNode), @alignOf(TypeNode)
    ) as *mut TypeNode;

    set *node = TypeNode { ty, next: self.types };
    let frozen: *TypeNode = node;
    set self.types = frozen;

    return &frozen.ty;
}

/// Allocate a nominal type descriptor and return a pointer to it.
unsafe fn allocNominalType(self: &mut Resolver, info: NominalType) -> *unsafe mut NominalType {
unsafe fn allocNominalType 'arena (self: &mut Resolver 'arena, info: NominalType) -> *unsafe mut NominalType {
    // Nb. We don't attempt to de-duplicate nominal type entries,
    // since they don't carry node information and we create
    // placeholder entries when binding symbols.
    let entry = try! alloc::allocRaw(
        &mut self.arena, @sizeOf(NominalType), @alignOf(NominalType)
        self.arena, @sizeOf(NominalType), @alignOf(NominalType)
    ) as *unsafe mut NominalType;

    set *entry = info;

    return entry;
}

/// Allocate the single runtime layout for a nominal declaration.
unsafe fn allocLayout 'arena (self: &mut Resolver 'arena, value: Layout) -> *Layout {
    let layout = try! alloc::alloc(&mut *self.arena, @sizeOf(Layout), @alignOf(Layout)) as *mut Layout;
    set *layout = value;
    return layout;
}

/// Get the exact arguments of an applied nominal descriptor.
export unsafe fn nominalApplication(info: *unsafe NominalType) -> ?*unsafe NominalApplication {
    match *info {
        case NominalType::Application(applied) => return applied,
        case NominalType::Record(body) => return body.application,
        case NominalType::Union(body) => return body.application,
        else => return nil,
    }
}

/// Get source region parameters without forcing a recursive type's layout.
unsafe fn nominalParameters 'arena (self: &mut Resolver 'arena, info: *unsafe NominalType) -> ?*RegionScope
    throws (ResolveError)
{
    match *info {
        case NominalType::Placeholder(node) => return try declarationRegions(self, node),
        case NominalType::Resolving(node) => return try declarationRegions(self, node),
        case NominalType::Application(applied) => return applied.parameters,
        case NominalType::Record(body) => return body.regions,
        case NominalType::Union(body) => return body.regions,
    }
}

/// Bind the regions declared by a nominal source node.
unsafe fn declarationRegions 'arena (self: &mut Resolver 'arena, node: *ast::Node) -> ?*RegionScope
    throws (ResolveError)
{
    match node.value {
        case ast::NodeValue::RecordDecl(decl) => return try bindRegions(self, node, decl.regions),
        case ast::NodeValue::UnionDecl(decl) => return try bindRegions(self, node, decl.regions),
        else => panic "declarationRegions: expected nominal declaration",
    }
}

/// Use a hinted application only for the same unapplied nominal declaration.
unsafe fn hintedNominal(info: *unsafe NominalType, hint: Type) -> *unsafe NominalType {
    if nominalApplication(info) <> nil {
        return info;
    }
    let mut target = hint;
    if let case Type::Optional(inner) = target {
        set target = *inner;
    }
    if let case Type::Nominal(other) = target {
        if let applied = nominalApplication(other); applied.base == info {
            return other;
        }
    }
    return info;
}

/// Require explicit arguments for a parameterized nominal type.
unsafe fn requireNominalArguments 'arena (self: &mut Resolver 'arena, info: *unsafe NominalType, site: *ast::Node)
    throws (ResolveError)
{
    if nominalApplication(info) <> nil {
        return;
    }
    if let parameters = try nominalParameters(self, info) {
        throw emitError(self, site, ErrorKind::RegionArgumentCount(CountMismatch {
            expected: parameters.entries.len, actual: 0,
        }));
    }
}

/// Intern an exact nominal application before resolving its recursive members.
unsafe fn internNominalApplication 'arena (
    self: &mut Resolver 'arena, base: *unsafe NominalType, map: &RegionSubstitution
) -> *unsafe mut NominalType {
    let mut cursor = self.applications;
    while let applied = cursor {
        if applied.base == base {
            let mut same = true;
            for argument, i in applied.arguments {
                let other = map.arguments[i] else panic "internNominalApplication: missing argument";
                if argument.id <> other.id {
                    set same = false;
                    break;
                }
            }
            if same {
                return applied.view;
            }
        }
        set cursor = applied.next;
    }
    let arguments = try! alloc::allocRawSlice(
        self.arena, @sizeOf(*unsafe types::Region), @alignOf(*unsafe types::Region), map.arguments.len
    ) as *unsafe mut [*unsafe types::Region];
    for argument, i in map.arguments {
        let region = argument else panic "internNominalApplication: incomplete map";
        set arguments[i] = region;
    }
    let entry = try! alloc::allocRaw(
        self.arena, @sizeOf(NominalApplication), @alignOf(NominalApplication)
    ) as *unsafe mut NominalApplication;
    let view = allocNominalType(self, NominalType::Application(entry));
    set *entry = NominalApplication { base, parameters: map.parameters, arguments, view, next: self.applications };
    set self.applications = entry;
    return view;
}

/// Check explicit region arguments and intern the applied nominal type.
unsafe fn applyNominalRegions 'arena (
    self: &mut Resolver 'arena, base: *unsafe NominalType, regions: *[*ast::Node], site: *ast::Node
) -> *unsafe mut NominalType throws (ResolveError) {
    if nominalApplication(base) <> nil {
        throw emitError(self, site, ErrorKind::RegionArgumentCount(CountMismatch { expected: 0, actual: regions.len }));
    }
    let parameters = try nominalParameters(self, base);
    let mut count: u32 = 0;
    if let scope = parameters {
        set count = scope.entries.len;
    }
    if count <> regions.len {
        throw emitError(self, site, ErrorKind::RegionArgumentCount(CountMismatch { expected: count, actual: regions.len }));
    }
    let scope = parameters else panic "applyNominalRegions: empty application";
    let map = regionSubstitution(self, scope);
    for region, i in regions {
        set map.arguments[i] = try resolveRegion(self, region);
    }
    try validateRegionArguments(self, &map, site);
    return internNominalApplication(self, base, &map);
}

/// Complete nominal views stored inline within an applied type.
/// Pointer, slice, and cell targets have independent storage layouts.
unsafe fn resolveInlineTypeViews 'arena (self: &mut Resolver 'arena, ty: Type, site: *ast::Node)
    throws (ResolveError)
{
    match ty {
        case Type::Nominal(info) => try ensureNominalResolved(self, info, site),
        case Type::Array(array) => try resolveInlineTypeViews(self, *array.item, site),
        case Type::Optional(inner) => try resolveInlineTypeViews(self, *inner, site),
        else => {
        },
    }
}

/// Resolve a substituted member view with the source declaration's shared layout.
unsafe fn resolveNominalApplication 'arena (self: &mut Resolver 'arena, applied: *unsafe NominalApplication, site: *ast::Node)
    throws (ResolveError)
{
    try ensureNominalResolved(self, applied.base, site);
    let map = regionSubstitution(self, applied.parameters);
    for argument, i in applied.arguments {
        set map.arguments[i] = argument;
    }
    let allocator = alloc::arenaAllocator(self.arena);
    match *applied.base {
        case NominalType::Record(body) => {
            let mut fields: *unsafe mut [RecordField] = &mut [];
            for field in body.fields {
                let fieldType = substituteRegions(self, &map, field.fieldType);
                try resolveInlineTypeViews(self, fieldType, site);
                fields.append(RecordField {
                    name: field.name,
                    fieldType,
                    offset: field.offset,
                }, allocator);
            }
            set *applied.view = NominalType::Record(RecordType {
                regions: body.regions,
                application: applied,
                fields,
                labeled: body.labeled,
                layout: body.layout,
                declaredLinear: body.declaredLinear,
                declaredCopy: body.declaredCopy,
            });
        }
        case NominalType::Union(body) => {
            let mut variants: *unsafe mut [UnionVariant] = &mut [];
            for variant in body.variants {
                let valueType = substituteRegions(self, &map, variant.valueType);
                try resolveInlineTypeViews(self, valueType, site);
                variants.append(UnionVariant {
                    name: variant.name,
                    valueType,
                    symbol: variant.symbol,
                }, allocator);
            }
            set *applied.view = NominalType::Union(UnionType {
                regions: body.regions,
                application: applied,
                variants,
                layout: body.layout,
                valOffset: body.valOffset,
                isAllVoid: body.isAllVoid,
                declaredLinear: body.declaredLinear,
                declaredCopy: body.declaredCopy,
            });
        }
        else => panic "resolveNominalApplication: unresolved base",
    }
}

/// Complete all applied member views before semantic metadata reaches lowering.
unsafe fn resolveNominalApplications 'arena (self: &mut Resolver 'arena, site: *ast::Node) throws (ResolveError) {
    let mut end: ?*unsafe NominalApplication = nil;
    loop {
        let first = self.applications;
        let mut cursor = first;
        while cursor <> end {
            let applied = cursor else panic "resolveNominalApplications: invalid frontier";
            try ensureNominalResolved(self, applied.view, site);
            set cursor = applied.next;
        }
        if self.applications == first {
            return;
        }
        set end = first;
    }
}

/// Allocate a function type descriptor and return a pointer to it.
unsafe fn allocFnType(self: &mut Resolver, info: FnType) -> *FnType {
unsafe fn allocFnType 'arena (self: &mut Resolver 'arena, info: FnType) -> *FnType {
    let entry = try! alloc::alloc(
        &mut self.arena, @sizeOf(FnType), @alignOf(FnType)
        &mut *self.arena, @sizeOf(FnType), @alignOf(FnType)
    ) as *mut FnType;

    set *entry = info;

    return entry;
}

/// Returns an error, if any, associated with the given node.
fn errorForNode(self: &Resolver, node: *ast::Node) -> ?Error {
fn errorForNode 'arena (self: &Resolver 'arena, node: *ast::Node) -> ?Error {
    for i in 0..self.errors.len {
        let err = self.errors.entries[i];
        if err.node == node {
            return err;
        }

    return nil;
}

/// Storage buffers used by the analyzer.
export record ResolverStorage {
    /// Unified arena for symbols, scopes, and nominal type.
    arena: alloc::Arena,
    /// Node semantic metadata indexed by node ID.
    nodeData: *mut [NodeData],
    /// Package scope.
    pkgScope: *unsafe mut Scope,
    /// Error storage.

    /// Root AST node.
    rootAst: *ast::Node,
}

/// Construct a resolver with module context and backing storage.
export unsafe fn resolver(
/// The arena owner and backing bytes must retain stable addresses during use.
/// Arena reclamation can occur only after all metadata uses end.
export unsafe fn resolver 'arena (
    arena: &'arena mut alloc::Arena,
    storage: ResolverStorage,
    config: Config
) -> Resolver {
    let case ResolverStorage { arena: initialArena, nodeData, pkgScope, errors } = storage else panic "expected resolver storage";
    let mut arena = initialArena;
) -> Resolver 'arena {
    let case ResolverStorage { nodeData, pkgScope, errors } = storage else panic "expected resolver storage";
    let symbols = try! alloc::allocRawSlice(
        &mut arena, @sizeOf(*unsafe mut Symbol), @alignOf(*unsafe mut Symbol), MAX_MODULE_SYMBOLS
        arena, @sizeOf(*unsafe mut Symbol), @alignOf(*unsafe mut Symbol), MAX_MODULE_SYMBOLS
    ) as *unsafe mut [*unsafe mut Symbol];

    // Initialize the root scope.
    // TODO: Set this up when declaring `PKG_SCOPE`, not here.
    set *pkgScope = Scope {

    let mut moduleScopes: [?*unsafe mut Scope; module::MAX_MODULES] = undefined;
    // TODO: Simplify.
    for i in 0..moduleScopes.len {
        set moduleScopes[i] = nil;
    }
    return Resolver {
    return Resolver 'arena {
        regionScope: nil,
        applications: nil,
        scope: pkgScope,
        pkgScope: pkgScope,
        loopStack: undefined,
        loopDepth: 0,
        currentFn: nil,

    };
}

/// Capture the current errors in an immutable arena allocation.
/// The allocation must remain valid while the diagnostics are used.
export unsafe fn diagnostics(self: &mut Resolver) -> Diagnostics {
export unsafe fn diagnostics 'arena (self: &mut Resolver 'arena) -> Diagnostics {
    let count = self.errors.len;
    let entries = try! alloc::allocSlice(
        &mut self.arena, @sizeOf(Error), @alignOf(Error), count
        self.arena, @sizeOf(Error), @alignOf(Error), count
    ) as *mut [Error];
    for i in 0..self.errors.len {
        set entries[i] = self.errors.entries[i];
    }
    return Diagnostics { errors: entries };

    }
    return errs[index];
}

/// Record an error diagnostic and return an error sentinel suitable for throwing.
fn emitError(self: &mut Resolver, node: ?*ast::Node, kind: ErrorKind) -> ResolveError {
fn emitError 'arena (self: &mut Resolver 'arena, node: ?*ast::Node, kind: ErrorKind) -> ResolveError {
    // If our error list is full, just return an error without recording it.
    if self.errors.len >= self.errors.entries.len {
        return ResolveError::Failure;
    }
    // Don't record more than one error per node.


    return ResolveError::Failure;
}

/// Like [`emitError`], but for type mismatches specifically.
unsafe fn emitTypeMismatch(self: &mut Resolver, node: ?*ast::Node, mismatch: TypeMismatch) -> ResolveError {
unsafe fn emitTypeMismatch 'arena (self: &mut Resolver 'arena, node: ?*ast::Node, mismatch: TypeMismatch) -> ResolveError {
    return emitError(self, node, ErrorKind::TypeMismatch(mismatch));
}

/// Allocate a scope object with the given symbol capacity.
unsafe fn allocScope(self: &mut Resolver, owner: *ast::Node, capacity: u32) -> *unsafe mut Scope {
unsafe fn allocScope 'arena (self: &mut Resolver 'arena, owner: *ast::Node, capacity: u32) -> *unsafe mut Scope {
    // Check for an existing scope for this node, and don't allocate a new
    // one in that case.
    if let scope = scopeFor(self, owner) {
        return scope;
    }
    assert owner.id < self.nodeData.entries.len, "allocScope: node ID out of bounds";
    let p = try! alloc::allocRaw(&mut self.arena, @sizeOf(Scope), @alignOf(Scope));
    let p = try! alloc::allocRaw(self.arena, @sizeOf(Scope), @alignOf(Scope));
    let entry = p as *unsafe mut Scope;

    // Allocate symbols from the arena.
    let symbols = try! alloc::allocRawSlice(
        &mut self.arena, @sizeOf(*unsafe mut Symbol), @alignOf(*unsafe mut Symbol), capacity
        self.arena, @sizeOf(*unsafe mut Symbol), @alignOf(*unsafe mut Symbol), capacity
    ) as *unsafe mut [*unsafe mut Symbol];

    set *entry = Scope { owner, parent: nil, moduleId: nil, symbols, symbolsLen: 0 };
    set self.nodeData.entries[owner.id].scope = entry;


}

/// Enter a new local scope that is the child of the current scope.
/// This creates a parent/child relationship that means that lookups in the
/// child scope can recurse upwards.
export unsafe fn enterScope(self: &mut Resolver, owner: *ast::Node) -> *unsafe Scope {
export unsafe fn enterScope 'arena (self: &mut Resolver 'arena, owner: *ast::Node) -> *unsafe Scope {
    let scope = allocScope(self, owner, MAX_LOCAL_SYMBOLS);
    set scope.parent = self.scope;
    set self.scope = scope;
    return scope;
}

/// Enter a module scope. Returns an object that can be used to exit the scope.
export unsafe fn enterModuleScope(self: &mut Resolver, owner: *ast::Node, module: *module::ModuleEntry) -> ModuleScope {
export unsafe fn enterModuleScope 'arena (self: &mut Resolver 'arena, owner: *ast::Node, module: *module::ModuleEntry) -> ModuleScope {
    let prevScope = self.scope;
    let prevMod = self.currentMod;
    let scope = allocScope(self, owner, MAX_MODULE_SYMBOLS);

    set self.scope = scope;


    return ModuleScope { root: owner, entry: module, newScope: scope, prevScope, prevMod };
}

/// Enter a sub-module. Changes the current scope into that of the sub-module.
unsafe fn enterSubModule(self: &mut Resolver, name: *[u8], node: *ast::Node) -> ModuleScope throws (ResolveError) {
unsafe fn enterSubModule 'arena (self: &mut Resolver 'arena, name: *[u8], node: *ast::Node) -> ModuleScope throws (ResolveError) {
    let modEntry = module::findChild(self.moduleGraph, name, self.currentMod)
        else throw emitError(self, node, ErrorKind::UnresolvedSymbol(name));
    let modRoot = modEntry.ast
    let modRoot = module::astFor(modEntry)
        else panic "enterSubModule: analyzing module that wasn't parsed";

    return enterModuleScope(self, modRoot, modEntry);
}

/// Exit a module scope, given the object returned by `enterModuleScope`.
export fn exitModuleScope(self: &mut Resolver, entry: ModuleScope) {
export fn exitModuleScope 'arena (self: &mut Resolver 'arena, entry: ModuleScope) {
    set self.scope = entry.prevScope;
    set self.currentMod = entry.prevMod;
}

/// Exit the most recent scope.
export unsafe fn exitScope(self: &mut Resolver) {
export unsafe fn exitScope 'arena (self: &mut Resolver 'arena) {
    let parent = self.scope.parent else {
        // TODO: This should be a panic, but one of the tests hits this
        // clause, which might be a bug in the generator.
        return;
    };
    set self.scope = parent;
}

/// Visit the body of a loop while tracking nesting depth.
unsafe fn visitLoop(self: &mut Resolver, body: *ast::Node) -> Type
unsafe fn visitLoop 'arena (self: &mut Resolver 'arena, body: *ast::Node) -> Type
    throws (ResolveError)
{
    assert self.loopDepth < MAX_LOOP_DEPTH, "visitLoop: loop nesting depth exceeded";
    set self.loopStack[self.loopDepth] = LoopCtx { hasBreak: false };
    set self.loopDepth += 1;

    }
    return Type::Never;
}

/// Require that loop control statements appear inside a loop.
unsafe fn ensureInsideLoop(self: &mut Resolver, node: *ast::Node) throws (ResolveError) {
unsafe fn ensureInsideLoop 'arena (self: &mut Resolver 'arena, node: *ast::Node) throws (ResolveError) {
    if self.loopDepth == 0 {
        throw emitError(self, node, ErrorKind::InvalidLoopControl);
    }
}

/// Bind a loop pattern to the provided type.
unsafe fn bindForLoopPattern(self: &mut Resolver, pattern: *ast::Node, ty: Type, mutable: bool)
unsafe fn bindForLoopPattern 'arena (self: &mut Resolver 'arena, pattern: *ast::Node, ty: Type, mutable: bool)
    throws (ResolveError)
{
    match pattern.value {
        case ast::NodeValue::Placeholder, ast::NodeValue::Ident(_) => {
            let _ = try bindValueIdent(self, pattern, pattern, ty, mutable, 0, 0);

        }
    }
}

/// Set the expected return type for a new function body.
unsafe fn enterFn(self: &mut Resolver, node: *ast::Node, ty: &FnType) {
unsafe fn enterFn 'arena (self: &mut Resolver 'arena, node: *ast::Node, ty: &FnType) {
    assert self.currentFn == nil, "enterFn: already in a function";
    set self.currentFn = *ty;
    set self.currentFnNode = node;
    enterScope(self, node);
}

/// Clear the expected return type when leaving a function body.
unsafe fn exitFn(self: &mut Resolver) {
unsafe fn exitFn 'arena (self: &mut Resolver 'arena) {
    if self.currentFn == nil {
        // TODO: This should be a panic, but one of the tests hits this
        // clause, which might be a bug in the generator.
        return;
    }

    set self.currentFnNode = nil;
    exitScope(self);
}

/// Extract the identifier text from a node.
unsafe fn nodeName(self: &mut Resolver, node: *ast::Node) -> *[u8]
unsafe fn nodeName 'arena (self: &mut Resolver 'arena, node: *ast::Node) -> *[u8]
    throws (ResolveError)
{
    let case ast::NodeValue::Ident(name) = node.value
        else throw emitError(self, node, ErrorKind::ExpectedIdentifier);
    return name;
}

/// Associate a resolved symbol with an AST node.
fn setNodeSymbol(self: &mut Resolver, node: *ast::Node, symbol: *unsafe mut Symbol) {
fn setNodeSymbol 'arena (self: &mut Resolver 'arena, node: *ast::Node, symbol: *unsafe mut Symbol) {
    if let existingSym = self.nodeData.entries[node.id].sym {
        panic "setNodeSymbol: a symbol is already associated with this node";
    }
    set self.nodeData.entries[node.id].sym = symbol;
}

/// Associate a resolved type with an AST node and return it.
fn setNodeType(self: &mut Resolver, node: *ast::Node, ty: Type) -> Type {
fn setNodeType 'arena (self: &mut Resolver 'arena, node: *ast::Node, ty: Type) -> Type {
    if ty == Type::Unknown {
        // In this case, we simply don't associate a type.
        return ty;
    }
    set self.nodeData.entries[node.id].ty = ty;

    }
    return Type::Void;
}

/// Associate a coercion plan with an AST node.
fn setNodeCoercion(self: &mut Resolver, node: *ast::Node, coercion: Coercion) -> Coercion {
fn setNodeCoercion 'arena (self: &mut Resolver 'arena, node: *ast::Node, coercion: Coercion) -> Coercion {
    if coercion == Coercion::Identity {
        return coercion;
    }
    set self.nodeData.entries[node.id].coercion = coercion;

    return coercion;
}

/// Associate a constant value with an AST node.
fn setNodeConstValue(self: &mut Resolver, node: *ast::Node, value: ConstValue) {
fn setNodeConstValue 'arena (self: &mut Resolver 'arena, node: *ast::Node, value: ConstValue) {
    set self.nodeData.entries[node.id].constValue = value;
}

/// Associate a record field index with a record literal field node.
fn setRecordFieldIndex(self: &mut Resolver, node: *ast::Node, index: u32) {
fn setRecordFieldIndex 'arena (self: &mut Resolver 'arena, node: *ast::Node, index: u32) {
    set self.nodeData.entries[node.id].extra = NodeExtra::RecordField { index };
}

/// Associate slice range metadata with a subscript expression.
fn setSliceRangeInfo(self: &mut Resolver, node: *ast::Node, info: SliceRangeInfo) {
fn setSliceRangeInfo 'arena (self: &mut Resolver 'arena, node: *ast::Node, info: SliceRangeInfo) {
    set self.nodeData.entries[node.id].extra = NodeExtra::SliceRange(info);
}

/// Associate union variant metadata with a pattern or constructor node.
fn setVariantInfo(self: &mut Resolver, node: *ast::Node, ordinal: u32, tag: u32) {
fn setVariantInfo 'arena (self: &mut Resolver 'arena, node: *ast::Node, ordinal: u32, tag: u32) {
    set self.nodeData.entries[node.id].extra = NodeExtra::UnionVariant { ordinal, tag };
}

/// Associate trait method call metadata with a call node.
fn setTraitMethodCall(self: &mut Resolver, node: *ast::Node, traitInfo: *unsafe TraitType, methodIndex: u32) {
fn setTraitMethodCall 'arena (self: &mut Resolver 'arena, node: *ast::Node, traitInfo: *unsafe TraitType, methodIndex: u32) {
    set self.nodeData.entries[node.id].extra = NodeExtra::TraitMethodCall { traitInfo, methodIndex };
}

/// Associate for-loop metadata with a for-loop node.
fn setForLoopInfo(self: &mut Resolver, node: *ast::Node, info: ForLoopInfo) {
fn setForLoopInfo 'arena (self: &mut Resolver 'arena, node: *ast::Node, info: ForLoopInfo) {
    set self.nodeData.entries[node.id].extra = NodeExtra::ForLoop(info);
}

/// Retrieve the constant value associated with a node, if any.
export fn constValueEntry(self: &Resolver, node: *ast::Node) -> ?ConstValue {
export fn constValueEntry 'arena (self: &Resolver 'arena, node: *ast::Node) -> ?ConstValue {
    return self.nodeData.entries[node.id].constValue;
}

/// Get the resolved record field index for a record literal field node.
export fn recordFieldIndexFor(self: &Resolver, node: *ast::Node) -> ?u32 {
export fn recordFieldIndexFor 'arena (self: &Resolver 'arena, node: *ast::Node) -> ?u32 {
    if let case NodeExtra::RecordField { index } = self.nodeData.entries[node.id].extra {
        return index;
    }
    return nil;
}

/// Get the slice range metadata for a subscript expression with a range index.
export fn sliceRangeInfoFor(self: &Resolver, node: *ast::Node) -> ?SliceRangeInfo {
export fn sliceRangeInfoFor 'arena (self: &Resolver 'arena, node: *ast::Node) -> ?SliceRangeInfo {
    if let case NodeExtra::SliceRange(info) = self.nodeData.entries[node.id].extra {
        return info;
    }
    return nil;
}

/// Get the for-loop metadata for a for-loop node.
export fn forLoopInfoFor(self: &Resolver, node: *ast::Node) -> ?ForLoopInfo {
export fn forLoopInfoFor 'arena (self: &Resolver 'arena, node: *ast::Node) -> ?ForLoopInfo {
    if let case NodeExtra::ForLoop(info) = self.nodeData.entries[node.id].extra {
        return info;
    }
    return nil;
}

/// Associate match prong metadata with a match prong node.
fn setProngCatchAll(self: &mut Resolver, node: *ast::Node, catchAll: bool) {
fn setProngCatchAll 'arena (self: &mut Resolver 'arena, node: *ast::Node, catchAll: bool) {
    set self.nodeData.entries[node.id].extra = NodeExtra::MatchProng { catchAll };
}

/// Check if a prong is catch-all.
export fn isProngCatchAll(self: &Resolver, node: *ast::Node) -> bool {
export fn isProngCatchAll 'arena (self: &Resolver 'arena, node: *ast::Node) -> bool {
    if let case NodeExtra::MatchProng { catchAll } = self.nodeData.entries[node.id].extra {
        return catchAll;
    }
    return false;
}

/// Set match metadata.
fn setMatchConst(self: &mut Resolver, node: *ast::Node, isConst: bool) {
fn setMatchConst 'arena (self: &mut Resolver 'arena, node: *ast::Node, isConst: bool) {
    set self.nodeData.entries[node.id].extra = NodeExtra::Match { isConst };
}

/// Check if a match has all constant patterns.
export fn isMatchConst(self: &Resolver, node: *ast::Node) -> bool {
export fn isMatchConst 'arena (self: &Resolver 'arena, node: *ast::Node) -> bool {
    if let case NodeExtra::Match { isConst } = self.nodeData.entries[node.id].extra {
        return isConst;
    }
    return false;
}

/// Get the resolver metadata for a node.
export fn nodeData(self: &Resolver, node: *ast::Node) -> NodeData {
export fn nodeData 'arena (self: &Resolver 'arena, node: *ast::Node) -> NodeData {
    return self.nodeData.entries[node.id];
}

/// Get the type for a node, or `nil` if unknown.
export fn typeFor(self: &Resolver, node: *ast::Node) -> ?Type {
export fn typeFor 'arena (self: &Resolver 'arena, node: *ast::Node) -> ?Type {
    let ty = self.nodeData.entries[node.id].ty;
    if ty == Type::Unknown {
        return nil;
    }
    return ty;
}

/// Get the scope associated with a node.
export fn scopeFor(self: &Resolver, node: *ast::Node) -> ?*unsafe mut Scope {
export fn scopeFor 'arena (self: &Resolver 'arena, node: *ast::Node) -> ?*unsafe mut Scope {
    return self.nodeData.entries[node.id].scope;
}

/// Get the symbol bound to a node.
export fn symbolFor(self: &Resolver, node: *ast::Node) -> ?*unsafe mut Symbol {
export fn symbolFor 'arena (self: &Resolver 'arena, node: *ast::Node) -> ?*unsafe mut Symbol {
    return self.nodeData.entries[node.id].sym;
}

/// Get the coercion plan associated with a node, if any.
export fn coercionFor(self: &Resolver, node: *ast::Node) -> ?Coercion {
export fn coercionFor 'arena (self: &Resolver 'arena, node: *ast::Node) -> ?Coercion {
    let c = self.nodeData.entries[node.id].coercion;
    if c == Coercion::Identity {
        return nil;
    }
    return c;
}

/// Get the module ID for a symbol by walking up its scope chain.
export unsafe fn moduleIdForSymbol(self: &Resolver, sym: *unsafe Symbol) -> ?u16 {
export unsafe fn moduleIdForSymbol 'arena (self: &Resolver 'arena, sym: *unsafe Symbol) -> ?u16 {
    // For module-level symbols, return the cached module ID.
    if let id = sym.moduleId {
        return id;
    }
    // For module symbols, return the module ID directly.

    return nil;
}

/// Get the binding node for a variant pattern.
/// Returns the argument node if this is a variant constructor with a non-placeholder binding.
export unsafe fn variantPatternBinding(self: &Resolver, pattern: *ast::Node) -> ?*ast::Node {
export unsafe fn variantPatternBinding 'arena (self: &Resolver 'arena, pattern: *ast::Node) -> ?*ast::Node {
    let case ast::NodeValue::Call(call) = pattern.value
        else return nil;
    let sym = symbolFor(self, call.callee)
        else return nil;
    let case SymbolData::Variant { .. } = sym.data

    }
    return arg;
}

/// Allocate a new symbol, and return a reference to it.
unsafe fn allocSymbol(self: &mut Resolver, data: SymbolData, name: *[u8], node: *ast::Node, attrs: u32) -> *unsafe mut Symbol {
    let sym = try! alloc::allocRaw(&mut self.arena, @sizeOf(Symbol), @alignOf(Symbol)) as *unsafe mut Symbol;
unsafe fn allocSymbol 'arena (self: &mut Resolver 'arena, data: SymbolData, name: *[u8], node: *ast::Node, attrs: u32) -> *unsafe mut Symbol {
    let sym = try! alloc::allocRaw(self.arena, @sizeOf(Symbol), @alignOf(Symbol)) as *unsafe mut Symbol;
    set *sym = Symbol { name, data, attrs, node, moduleId: nil };

    return sym;
}

/// Check that a type is boolean, otherwise throw an error.
unsafe fn checkBoolean(self: &mut Resolver, node: *ast::Node) -> Type throws (ResolveError) {
unsafe fn checkBoolean 'arena (self: &mut Resolver 'arena, node: *ast::Node) -> Type throws (ResolveError) {
    return try checkEqual(self, node, Type::Bool);
}

/// Check that a type is numeric, otherwise throw an error.
unsafe fn checkNumeric(self: &mut Resolver, node: *ast::Node) -> Type throws (ResolveError) {
unsafe fn checkNumeric 'arena (self: &mut Resolver 'arena, node: *ast::Node) -> Type throws (ResolveError) {
    let ty = try infer(self, node);
    if not isNumericType(ty) {
        throw emitError(self, node, ErrorKind::ExpectedNumeric);
    }
    return ty;

}

/// Get the layout of a type.
export unsafe fn getTypeLayout(ty: Type) -> Layout {
    match ty {
        case Type::Pointer { .. } => return Layout { size: PTR_SIZE, alignment: PTR_SIZE },
        case Type::Slice { .. }, Type::TraitObject { .. } =>
        case Type::Pointer { .. } => return Layout {
            size: PTR_SIZE, alignment: PTR_SIZE
        },
        case Type::Slice { .. }, Type::TraitObject { .. }, Type::Session(_) =>
            return Layout { size: PTR_SIZE * 2, alignment: PTR_SIZE },
        case Type::Void, Type::Never => return Layout { size: 0, alignment: 0 },
        case Type::Bool, Type::U8, Type::I8 => return Layout { size: 1, alignment: 1 },
        case Type::U16, Type::I16 => return Layout { size: 2, alignment: 2 },
        case Type::U32, Type::I32 => return Layout { size: 4, alignment: 4 },
        case Type::Int => return Layout { size: 8, alignment: 8 },
        case Type::U64, Type::I64 => return Layout { size: 8, alignment: 8 },
        case Type::Fn(_) => return Layout { size: PTR_SIZE, alignment: PTR_SIZE },
        case Type::Cell { .. } => return Layout {
            size: PTR_SIZE, alignment: PTR_SIZE
        },
        case Type::Array(arr) => return getArrayLayout(arr),
        case Type::Optional(inner) => return getOptionalLayout(*inner),
        case Type::Nominal(info) => return getNominalLayout(*info),
        else => {
            panic "getTypeLayout: the given type cannot be layed out";
        }
    }
}

/// Get the layout of a type or value.
export unsafe fn getLayout(self: &Resolver, node: *ast::Node, ty: Type) -> Layout {
export unsafe fn getLayout 'arena (self: &Resolver 'arena, node: *ast::Node, ty: Type) -> Layout {
    let mut layout = getTypeLayout(ty);
    // Check for symbol-specific alignment override.
    if let sym = symbolFor(self, node) {
        if let case SymbolData::Value { alignment, .. } = sym.data {
            if alignment > 0 {

}

/// Get the layout of a nominal type.
export fn getNominalLayout(info: NominalType) -> Layout {
    match info {
        case NominalType::Placeholder(_) => {
            panic "getNominalLayout: placeholder type";
        case NominalType::Placeholder(_), NominalType::Resolving(_), NominalType::Application(_) => {
            panic "getNominalLayout: unresolved type";
        }
        case NominalType::Record(recordType) => {
            return recordType.layout;
            return *recordType.layout;
        }
        case NominalType::Union(unionType) => {
            return unionType.layout;
            return *unionType.layout;
        }
    }
}

/// Get the layout of a result aggregate with a tag and the larger payload.

        }
    }
}

/// Ensure all nested nominal types in a type are resolved.
unsafe fn ensureTypeResolved(self: &mut Resolver, ty: Type, site: *ast::Node) throws (ResolveError) {
unsafe fn ensureTypeResolved 'arena (self: &mut Resolver 'arena, ty: Type, site: *ast::Node) throws (ResolveError) {
    match ty {
        case Type::Nominal(info) => try ensureNominalResolved(self, info, site),
        case Type::Slice { item, .. } => try ensureTypeResolved(self, *item, site),
        case Type::Pointer { .. } => {}, // Pointers have fixed layout, don't recurse.
        // Pointer and slice layouts do not depend on their element layout.
        case Type::Pointer { .. }, Type::Slice { .. } => {
        },
        case Type::Cell { payload, .. } => try validateCellPayload(self, site, *payload),
        case Type::Array(arr) => try ensureTypeResolved(self, *arr.item, site),
        case Type::Optional(inner) => try ensureTypeResolved(self, *inner, site),
        else => {},
    }
}

/// Ensure a nominal type has its body resolved.
unsafe fn ensureNominalResolved(self: &mut Resolver, tyInfo: *unsafe NominalType, site: *ast::Node)
unsafe fn ensureNominalResolved 'arena (self: &mut Resolver 'arena, tyInfo: *unsafe NominalType, site: *ast::Node)
    throws (ResolveError)
{
    if let case NominalType::Application(applied) = *tyInfo {
        try resolveNominalApplication(self, applied, site);
        return;
    }
    if let case NominalType::Resolving(_) = *tyInfo {
        throw emitError(self, site, ErrorKind::RecursiveType);
    }
    if let case NominalType::Placeholder(declNode) = *tyInfo {
        // When resolving on-demand (e.g. from a child module), switch to the
        // declaring module's scope so field type lookups find the right symbols.
        let prevScope = self.scope;
        let prevMod = self.currentMod;

            }
        }

        match declNode.value {
            case ast::NodeValue::RecordDecl(decl) => {
                try resolveRecordBody(self, declNode, decl);
                try resolveRecordBody(self, declNode, decl) catch error {
                    set self.scope = prevScope;
                    set self.currentMod = prevMod;
                    throw error;
                };
            }
            case ast::NodeValue::UnionDecl(decl) => {
                try resolveUnionBody(self, declNode, decl);
                try resolveUnionBody(self, declNode, decl) catch error {
                    set self.scope = prevScope;
                    set self.currentMod = prevMod;
                    throw error;
                };
            }
            else => {},
        }
        set self.scope = prevScope;
        set self.currentMod = prevMod;
    }
}

/// Check if all elements in a node list are assignable to the target type.
unsafe fn isListAssignable(self: &mut Resolver, targetType: Type, items: *[*ast::Node]) -> bool {
unsafe fn isListAssignable 'arena (self: &mut Resolver 'arena, targetType: Type, items: *[*ast::Node]) -> bool {
    for itemNode in items {
        let elemTy = typeFor(self, itemNode)
            else return false;
        if let _ = isAssignable(self, targetType, elemTy, itemNode) {
            // Do nothing.

    from: types::PointerClass,
    inUnsafeContext: bool,
) -> bool {
    return to == from or (
        to == types::PointerClass::Ref
        and (from == types::PointerClass::Owned
        and (types::isReference(from) or from == types::PointerClass::Owned
            or (from == types::PointerClass::Unsafe and inUnsafeContext))
    );
}

/// Limit an exclusive value's implicit borrow to its owner's borrow.
unsafe fn assignableValueType 'arena (self: &mut Resolver 'arena, node: *ast::Node, source: Type) -> Type {
    match source {
        case Type::Pointer { class, target, mutable: true } => {
            let usable = pointerAddressClass(self, node, class, true);
            return Type::Pointer { class: usable, target, mutable: true };
        }
        case Type::Slice { class, item, mutable: true } => {
            let usable = pointerAddressClass(self, node, class, true);
            return Type::Slice { class: usable, item, mutable: true };
        }
        case Type::TraitObject { class, traitInfo, mutable: true } => {
            let usable = pointerAddressClass(self, node, class, true);
            return Type::TraitObject { class: usable, traitInfo, mutable: true };
        }
        case Type::Optional(inner) => {
            let value = assignableValueType(self, node, *inner);
            if typesEqual(value, *inner) {
                return source;
            }
            return Type::Optional(allocType(self, value));
        }
        else => return source,
    }
}

/// Check if the `from` type is assignable to the `to` type, and return a
/// coercion plan if so.
/// Referenced storage requires equal element types. Function values may gain
/// an unsafe call requirement.
unsafe fn isAssignable(self: &mut Resolver, to: Type, from: Type, rval: *ast::Node) -> ?Coercion {
unsafe fn isAssignable 'arena (self: &mut Resolver 'arena, to: Type, source: Type, rval: *ast::Node) -> ?Coercion {
    let from = assignableValueType(self, rval, source);
    if to == Type::Unknown or from == Type::Unknown {
        return nil;
    }
    if from == Type::Undefined {
        if containsRegion(to) {
            return nil;
        }
        if to == Type::Never {
            return nil;
        }
        // TODO: Don't let `undefined` be used in place of functions and other
        // non-data types.

        return Coercion::Identity;
    }
    if to == from {
        return Coercion::Identity;
    }
    if let case Type::Cell { class, payload } = to {
        let case Type::Cell { class: sourceClass, payload: sourcePayload } = from else return nil;
        if pointerClassesAssignable(class, sourceClass, self.inUnsafeContext) and typesEqual(*payload, *sourcePayload) {
            return Coercion::Identity;
        }
        return nil;
    }
    if let case Type::Pointer { class: lhsClass, target: lhsTarget, mutable: lhsMutable } = to {
        let case Type::Pointer { class: rhsClass, target: rhsTarget, mutable: rhsMutable } = from
            else return nil;
        if not pointerClassesAssignable(lhsClass, rhsClass, self.inUnsafeContext) {
            return nil;

    return fnSignatureEqual(a, b);
}

/// Compare parameter, return, and error types of functions.
fn fnSignatureEqual(a: &FnType, b: &FnType) -> bool {
    if a.regions <> b.regions {
        return false;
    }
    if a.paramTypes.len <> b.paramTypes.len {
        return false;
    }
    if a.throwList.len <> b.throwList.len {
        return false;

            else return false;
        return aClass == bClass and aMutable == bMutable
            and typesEqual(*aItem, *bItem);
    }
    match a {
        case Type::Cell { class, payload } => {
            let case Type::Cell { class: otherClass, payload: other } = b else return false;
            return class == otherClass and typesEqual(*payload, *other);
        }
        case Type::Array(aa) => {
            let case Type::Array(ab) = b else return false;
            return aa.length == ab.length and typesEqual(*aa.item, *ab.item);
        }
        case Type::Optional(oa) => {

        }
        else => return false,
    }
}

/// Compare types after lexical region arguments are erased.
/// Nominal types retain their source declaration identity.
export unsafe fn erasedTypesEqual(a: Type, b: Type) -> bool {
    if typesEqual(a, b) {
        return true;
    }
    match a {
        case Type::Cell { class, payload } => {
            let case Type::Cell { class: otherClass, payload: other } = b else return false;
            return erasedClassesEqual(class, otherClass) and erasedTypesEqual(*payload, *other);
        }
        case Type::Session(_) => {
            let case Type::Session(_) = b else return false;
            return true;
        }
        case Type::Nominal(left) => {
            let case Type::Nominal(right) = b else return false;
            let mut leftBase = left;
            let mut rightBase = right;
            if let app = nominalApplication(left) {
                set leftBase = app.base;
            }
            if let app = nominalApplication(right) {
                set rightBase = app.base;
            }
            return leftBase == rightBase;
        }
        case Type::Pointer { class, target, mutable } => {
            let case Type::Pointer { class: otherClass, target: other, mutable: otherMutable } = b
                else return false;
            return erasedClassesEqual(class, otherClass) and mutable == otherMutable
                and erasedTypesEqual(*target, *other);
        }
        case Type::Slice { class, item, mutable } => {
            let case Type::Slice { class: otherClass, item: other, mutable: otherMutable } = b
                else return false;
            return erasedClassesEqual(class, otherClass) and mutable == otherMutable
                and erasedTypesEqual(*item, *other);
        }
        case Type::TraitObject { class, traitInfo, mutable } => {
            let case Type::TraitObject { class: otherClass, traitInfo: other, mutable: otherMutable } = b
                else return false;
            return erasedClassesEqual(class, otherClass) and mutable == otherMutable and traitInfo == other;
        }
        case Type::Array(left) => {
            let case Type::Array(right) = b else return false;
            return left.length == right.length and erasedTypesEqual(*left.item, *right.item);
        }
        case Type::Optional(left) => {
            let case Type::Optional(right) = b else return false;
            return erasedTypesEqual(*left, *right);
        }
        case Type::Fn(left) => {
            let case Type::Fn(right) = b else return false;
            if left.isUnsafe <> right.isUnsafe or left.paramTypes.len <> right.paramTypes.len
                or left.throwList.len <> right.throwList.len {
                return false;
            }
            for ty, i in left.paramTypes {
                if not erasedTypesEqual(*ty, *right.paramTypes[i]) {
                    return false;
                }
            }
            for ty, i in left.throwList {
                if not erasedTypesEqual(*ty, *right.throwList[i]) {
                    return false;
                }
            }
            return erasedTypesEqual(*left.returnType, *right.returnType);
        }
        else => return false,
    }
}

/// Compare pointer classes without lexical region identities.
fn erasedClassesEqual(a: types::PointerClass, b: types::PointerClass) -> bool {
    return a == b or (types::isReference(a) and types::isReference(b));
}

/// Require distinct runtime tags for errors with different source types.
unsafe fn validateErrorTag 'arena (self: &mut Resolver 'arena, node: *ast::Node, ty: Type, errors: *[*Type]) throws (ResolveError) {
    for other in errors {
        if not typesEqual(ty, *other) and erasedTypesEqual(ty, *other) {
            throw emitError(self, node, ErrorKind::AmbiguousRegionalError);
        }
    }
}

/// Return whether `ty` is a direct reference.
export fn isRefType(ty: Type) -> bool {
    match ty {
        case Type::Pointer { class: types::PointerClass::Ref, .. },
             Type::Slice { class: types::PointerClass::Ref, .. },
             Type::TraitObject { class: types::PointerClass::Ref, .. } => return true,
        case Type::Cell { class, .. } => return types::isReference(class),
        case Type::Pointer { class, .. } => return types::isReference(class),
        case Type::Slice { class, .. } => return types::isReference(class),
        case Type::TraitObject { class, .. } => return types::isReference(class),
        else => return false,
    }
}

/// Return whether a type contains a reference.
fn containsRef(ty: Type) -> bool {
    if isRefType(ty) {
/// Get the region of a direct named reference.
fn referenceRegion(ty: Type) -> ?*unsafe types::Region {
    let mut class = types::PointerClass::Ref;
    match ty {
        case Type::Cell { class: cellClass, .. } => set class = cellClass,
        case Type::Pointer { class: pointerClass, .. } => set class = pointerClass,
        case Type::Slice { class: sliceClass, .. } => set class = sliceClass,
        case Type::TraitObject { class: objectClass, .. } => set class = objectClass,
        else => return nil,
    }
    if let case types::PointerClass::Region(region) = class {
        return region;
    }
    return nil;
}

/// Require every free region in a value type to remain in lexical scope.
unsafe fn validateRegionDependencies 'arena (self: &mut Resolver 'arena, node: *ast::Node, ty: Type)
    throws (ResolveError)
{
    try validateRegionStorage(self, node, ty, nil);
}

/// Check a dependency against storage lifetime or current lexical visibility.
unsafe fn regionCoversStorage(
    scope: ?*RegionScope, dependency: *unsafe types::Region, destination: ?*unsafe types::Region
) -> bool {
    if let region = destination {
        return types::regionContains(dependency, region);
    }
    return regionInScope(scope, dependency);
}

/// Require stored references to cover the lifetime of checked destination storage.
unsafe fn validateRegionalStore 'arena (self: &mut Resolver 'arena, place: *ast::Node, value: *ast::Node, ty: Type)
    throws (ResolveError)
{
    if let case types::PointerClass::Region(region) = addressStorageClass(self, place) {
        try validateRegionStorage(self, value, ty, region);
    }
}

/// Require all type dependencies to cover the destination or active lexical scope.
unsafe fn validateRegionStorage 'arena (
    self: &mut Resolver 'arena, node: *ast::Node, ty: Type, destination: ?*unsafe types::Region
)
    throws (ResolveError)
{
    if let case Type::Session(region) = ty {
        if not regionCoversStorage(self.regionScope, region, destination) {
            throw emitError(self, node, ErrorKind::RegionEscape(region.name));
        }
    }
    if let region = referenceRegion(ty) {
        if not regionCoversStorage(self.regionScope, region, destination) {
            throw emitError(self, node, ErrorKind::RegionEscape(region.name));
        }
    }
    match ty {
        case Type::Pointer { target, .. } => try validateRegionStorage(self, node, *target, destination),
        case Type::Slice { item, .. } => try validateRegionStorage(self, node, *item, destination),
        case Type::Cell { payload, .. } => try validateRegionStorage(self, node, *payload, destination),
        case Type::Array(array) => try validateRegionStorage(self, node, *array.item, destination),
        case Type::Optional(inner) => try validateRegionStorage(self, node, *inner, destination),
        case Type::Nominal(info) => {
            if let applied = nominalApplication(info) {
                for region in applied.arguments {
                    if not regionCoversStorage(self.regionScope, region, destination) {
                        throw emitError(self, node, ErrorKind::RegionEscape(region.name));
                    }
                }
            }
        }
        case Type::Fn(info) => {
            if info.regions <> nil {
                return;
            }
            for parameter in info.paramTypes {
                try validateRegionStorage(self, node, *parameter, destination);
            }
            for error in info.throwList {
                try validateRegionStorage(self, node, *error, destination);
            }
            try validateRegionStorage(self, node, *info.returnType, destination);
        }
        else => {
        },
    }
}

/// Return whether a type has an explicit region dependency.
unsafe fn containsRegion(ty: Type) -> bool {
    match ty {
        case Type::Cell { class, payload } => {
            if let case types::PointerClass::Region(_) = class {
                return true;
            }
            return containsRegion(*payload);
        }
        case Type::Session(_) => return true,
        case Type::Pointer { class, target, .. } => {
            if let case types::PointerClass::Region(_) = class {
                return true;
            }
            return containsRegion(*target);
        }
        case Type::Slice { class, item, .. } => {
            if let case types::PointerClass::Region(_) = class {
                return true;
            }
            return containsRegion(*item);
        }
        case Type::TraitObject { class, .. } => {
            if let case types::PointerClass::Region(_) = class {
                return true;
            }
            return false;
        }
        case Type::Array(array) => return containsRegion(*array.item),
        case Type::Optional(inner) => return containsRegion(*inner),
        case Type::Fn(info) => {
            if info.regions <> nil or containsRegion(*info.returnType) {
                return true;
            }
            for param in info.paramTypes {
                if containsRegion(*param) {
                    return true;
                }
            }
            for error in info.throwList {
                if containsRegion(*error) {
                    return true;
                }
            }
            return false;
        }
        case Type::Nominal(info) => return nominalApplication(info) <> nil,
        else => return false,
    }
}

/// Return whether a stored type contains a reference without a named region.
unsafe fn containsUnscopedRef(ty: Type) -> bool {
    if isRefType(ty) and referenceRegion(ty) == nil {
        return true;
    }
    if let case Type::Pointer { target, .. } = ty {
        return containsRef(*target);
        return containsUnscopedRef(*target);
    }
    if let case Type::Slice { item, .. } = ty {
        return containsRef(*item);
        return containsUnscopedRef(*item);
    }
    match ty {
        case Type::Array(array) => return containsRef(*array.item),
        case Type::Optional(inner) => return containsRef(*inner),
        case Type::Cell { payload, .. } => return containsUnscopedRef(*payload),
        case Type::Array(array) => return containsUnscopedRef(*array.item),
        case Type::Optional(inner) => return containsUnscopedRef(*inner),
        case Type::Fn(info) => return info.regions <> nil,
        // Nominal declarations validate their own fields and variants.
        // Treating them as leaves also terminates recursive pointer types.
        case Type::Nominal(_) => return false,
        else => return false,
    }
}

/// Return whether `ty` may be duplicated implicitly.
export unsafe fn isCopy(ty: Type) -> bool {
    match ty {
        case Type::Session(_) => return false,
        case Type::Pointer { class, mutable, .. } =>
            return class == types::PointerClass::Unsafe or not mutable,
        case Type::Slice { class, mutable, .. } =>
            return class == types::PointerClass::Unsafe or not mutable,
        case Type::TraitObject { class, mutable, .. } =>
            return class == types::PointerClass::Unsafe or not mutable,
        case Type::Array(array) => return isCopy(*array.item),
        case Type::Optional(inner) => return isCopy(*inner),
        case Type::Nominal(NominalType::Record(recInfo)) => return recInfo.declaredCopy,
        case Type::Nominal(NominalType::Union(unionType)) => return unionType.declaredCopy,
        case Type::Nominal(NominalType::Placeholder(_)) => return false,
        case Type::Nominal(NominalType::Application(applied)) => return isCopy(Type::Nominal(applied.base)),
        case Type::Nominal(NominalType::Placeholder(_)), Type::Nominal(NominalType::Resolving(_)) => return false,
        else => return true,
    }
}

/// Return whether a type must be consumed exactly once.
export unsafe fn isLinear(ty: Type) -> bool {
    match ty {
        case Type::Nominal(NominalType::Application(applied)) => return isLinear(Type::Nominal(applied.base)),
        case Type::Array(array) => return isLinear(*array.item),
        case Type::Optional(inner) => return isLinear(*inner),
        case Type::Nominal(NominalType::Record(recInfo)) => {
            if recInfo.declaredLinear {
                return true;

}

/// Return whether `ty` is a direct unsafe pointer-like value.
fn isUnsafePointerType(ty: Type) -> bool {
    match ty {
        case Type::Pointer { class: types::PointerClass::Unsafe, .. },
        case Type::Cell { class: types::PointerClass::Unsafe, .. },
             Type::Pointer { class: types::PointerClass::Unsafe, .. },
             Type::Slice { class: types::PointerClass::Unsafe, .. },
             Type::TraitObject { class: types::PointerClass::Unsafe, .. } => return true,
        else => return false,
    }
}

    return false;
}

/// Check if the `from` type is assignable to the `to` type, and return a
/// coercion plan if so, or throw an error if not.
unsafe fn expectAssignable(self: &mut Resolver, to: Type, from: Type, site: *ast::Node) -> Coercion throws (ResolveError) {
unsafe fn expectAssignable 'arena (self: &mut Resolver 'arena, to: Type, source: Type, site: *ast::Node) -> Coercion throws (ResolveError) {
    let from = assignableValueType(self, site, source);
    if isRefType(to) and isUnsafePointerType(from) {
        try requireUnsafe(self, site);
    }
    // Ensure any nested nominal types are resolved before checking assignability.
    try ensureTypeResolved(self, to, site);

        actual: from,
    });
}

/// Check that a type is optional, otherwise throw an error.
unsafe fn checkOptional(self: &mut Resolver, node: *ast::Node) -> *Type
unsafe fn checkOptional 'arena (self: &mut Resolver 'arena, node: *ast::Node) -> *Type
    throws (ResolveError)
{
    if let case Type::Optional(inner) = try infer(self, node) {
        return inner;
    }
    throw emitError(self, node, ErrorKind::ExpectedOptional);
}

/// Check that a node's type is equal to the expected type.
unsafe fn checkEqual(self: &mut Resolver, node: *ast::Node, expected: Type) -> Type
unsafe fn checkEqual 'arena (self: &mut Resolver 'arena, node: *ast::Node, expected: Type) -> Type
    throws (ResolveError)
{
    let actualTy = try visit(self, node, expected);
    if actualTy <> expected {
        throw emitTypeMismatch(self, node, TypeMismatch { expected, actual: actualTy });
    }
    return actualTy;
}

/// Bind an identifier in the given scope.
unsafe fn bindIdent(
    self: &mut Resolver,
unsafe fn bindIdent 'arena (
    self: &mut Resolver 'arena,
    name: *[u8],
    owner: *ast::Node,
    data: SymbolData,
    attrs: u32,
    scope: *unsafe mut Scope


    return sym;
}

/// Add a symbol to the given scope.
unsafe fn addSymbolToScope(self: &mut Resolver, sym: *unsafe mut Symbol, scope: *unsafe mut Scope, site: *ast::Node) throws (ResolveError) {
unsafe fn addSymbolToScope 'arena (self: &mut Resolver 'arena, sym: *unsafe mut Symbol, scope: *unsafe mut Scope, site: *ast::Node) throws (ResolveError) {
    for i in 0..scope.symbolsLen {
        if scope.symbols[i].name == sym.name {
            throw emitError(self, site, ErrorKind::DuplicateBinding(sym.name));
        }
    }

    set scope.symbolsLen += 1;
}

/// Bind a value identifier in the current scope.
/// Returns `nil` if the identifier is a placeholder (`_`).
unsafe fn bindValueIdent(
    self: &mut Resolver,
unsafe fn bindValueIdent 'arena (
    self: &mut Resolver 'arena,
    ident: *ast::Node,
    owner: *ast::Node,
    type: Type,
    mutable: bool,
    alignment: u32,

    }
    return sym;
}

/// Bind a constant identifier in the current scope.
unsafe fn bindConstIdent(
    self: &mut Resolver,
unsafe fn bindConstIdent 'arena (
    self: &mut Resolver 'arena,
    ident: *ast::Node,
    owner: *ast::Node,
    type: Type,
    val: ?ConstValue,
    attrs: u32

}

/// Bind a module identifier in the given scope.
/// This is used when declaring modules with `mod` or
/// importing modules with `use`.
unsafe fn bindModuleIdent(
    self: &mut Resolver,
unsafe fn bindModuleIdent 'arena (
    self: &mut Resolver 'arena,
    entry: *module::ModuleEntry,
    scope: *unsafe mut Scope,
    owner: *ast::Node,
    attrs: u32,
    bindingScope: *unsafe mut Scope


    return try bindIdent(self, name, owner, data, attrs, bindingScope);
}

/// Bind a type identifier in the current scope.
unsafe fn bindTypeIdent(
    self: &mut Resolver,
unsafe fn bindTypeIdent 'arena (
    self: &mut Resolver 'arena,
    ident: *ast::Node,
    owner: *ast::Node,
    type: *unsafe mut NominalType,
    attrs: u32
) -> *unsafe mut Symbol throws (ResolveError) {

}

/// Flatten an identifier or scope access chain into an array of name segments.
/// Examples: `fnord` -> `&["fnord"]`, `a::b::c` -> `&["a", "b", "c"]`.
/// Return the number of segments written to the buffer.
unsafe fn flattenPath(
    self: &mut Resolver,
unsafe fn flattenPath 'arena (
    self: &mut Resolver 'arena,
    node: *ast::Node,
    buf: &mut [*[u8]]
) -> u32 throws (ResolveError) {
    let mut out: u32 = 0;


    }
}

/// Get the parent module scope for the current module.
/// Returns the scope of the parent module, or `nil` if this is a root module.
unsafe fn getParentModuleScope(self: &mut Resolver, node: *ast::Node) -> ?*unsafe mut Scope throws (ResolveError) {
unsafe fn getParentModuleScope 'arena (self: &mut Resolver 'arena, node: *ast::Node) -> ?*unsafe mut Scope throws (ResolveError) {
    let currentMod = module::get(self.moduleGraph, self.currentMod)
        else throw emitError(self, node, ErrorKind::Internal);
    let parentId = currentMod.parent
        else return nil; // No parent module.

    return self.moduleScopes[parentId as u32];
}

/// Check if a node has `super` at its root (e.g. `super::x` or `super::Union::Variant`).
/// Returns the parent scope and the original node so `flattenPath` can strip `super`.
unsafe fn checkSuperAccess(
    self: &mut Resolver,
unsafe fn checkSuperAccess 'arena (
    self: &mut Resolver 'arena,
    node: *ast::Node
) -> ?SuperAccessResult throws (ResolveError) {
    // TODO: Maybe we should deal with `super` after the path is flattened.
    if let case ast::NodeValue::ScopeAccess(access) = node.value {
        // Direct super access: `super::x`.

    return symModuleId == currentModuleId;
}

/// Resolve an access node (eg. `lang::resolver::MAX_ERRORS`) to a symbol,
/// starting from the given scope.
unsafe fn resolveAccess(
    self: &mut Resolver,
unsafe fn resolveAccess 'arena (
    self: &mut Resolver 'arena,
    node: *ast::Node,
    access: ast::Access,
    scope: *unsafe Scope
) -> *unsafe mut Symbol throws (ResolveError) {
    if let case ast::NodeValue::RegionApply { .. } = access.parent.value {
        let ty = try infer(self, access.parent);
        let case Type::Nominal(info) = ty else throw emitError(self, node, ErrorKind::InvalidScopeAccess);
        try ensureNominalResolved(self, info, access.parent);
        let case NominalType::Union(body) = *info else throw emitError(self, node, ErrorKind::InvalidScopeAccess);
        let name = try nodeName(self, access.child);
        let symbol = try resolveUnionVariantAccess(self, node, access, body, name);
        setNodeType(self, node, ty);
        return symbol;
    }
    // Handle `super` access by adjusting scope and node.
    let mut startScope = scope;
    let mut pathNode = node;
    if let superAccess = try checkSuperAccess(self, node) {
        set startScope = superAccess.scope;

    return try resolvePath(self, node, access, &buffer[..pathLen], startScope);
}

/// Resolve a path (eg. ["lang", "resolver", "MAX_ERRORS"]) to a symbol,
/// starting from the given scope.
unsafe fn resolvePath(
    self: &mut Resolver,
unsafe fn resolvePath 'arena (
    self: &mut Resolver 'arena,
    node: *ast::Node,
    access: ast::Access,
    path: &[*[u8]],
    scope: *unsafe Scope
) -> *unsafe mut Symbol throws (ResolveError) {

    throw emitError(self, node, ErrorKind::InvalidScopeAccess);
}

/// Resolve a module path (e.g., `foo::bar::baz`) to a module entry and scope.
/// This traverses the module hierarchy, checking visibility at each step.
unsafe fn resolveModulePath(
    self: &mut Resolver,
unsafe fn resolveModulePath 'arena (
    self: &mut Resolver 'arena,
    module: *ast::Node
) -> ResolvedModule throws (ResolveError) {
    let mut startScope = self.scope;
    let mut pathNode = module;



    return try resolveModulePathRecursive(self, module, &pathBuf[1..pathLen], sym);
}

/// Recursively resolve the remaining path segments by traversing child modules.
unsafe fn resolveModulePathRecursive(
    self: &mut Resolver,
unsafe fn resolveModulePathRecursive 'arena (
    self: &mut Resolver 'arena,
    node: *ast::Node,
    path: &[*[u8]],
    sym: *unsafe Symbol
) -> ResolvedModule throws (ResolveError) {
    let case SymbolData::Module { entry, scope } = sym.data

        childSym
    );
}

/// Resolve a type name, which could be an identifier or scoped path.
unsafe fn resolveTypeName(self: &mut Resolver, node: *ast::Node) -> *unsafe NominalType throws (ResolveError) {
unsafe fn resolveTypeName 'arena (self: &mut Resolver 'arena, node: *ast::Node) -> *unsafe NominalType throws (ResolveError) {
    match node.value {
        case ast::NodeValue::Ident(name) => {
            let sym = findTypeSymbol(self.scope, name)
                else throw emitError(self, node, ErrorKind::UnresolvedSymbol(name));
            let case SymbolData::Type(ty) = sym.data

/// Visit a top-level declaration in the declaration phase.
/// This binds all names and analyzes signatures, types, and initializers.
/// Function bodies are deferred to the definition phase.
///
/// Nb. User-defined types are already handled by this point.
unsafe fn visitDecl(self: &mut Resolver, node: *ast::Node) throws (ResolveError) {
unsafe fn visitDecl 'arena (self: &mut Resolver 'arena, node: *ast::Node) throws (ResolveError) {
    match node.value {
        case ast::NodeValue::FnDecl(_),
             ast::NodeValue::ConstDecl(_),
             ast::NodeValue::Mod(_),
             ast::NodeValue::Use(_) => {
            // Handled in previous passes.
        }
        case ast::NodeValue::StaticDecl(_) => {
            try infer(self, node);
        }
        case ast::NodeValue::InstanceDecl { traitName, targetType, methods } => {
            try resolveInstanceDecl(self, node, traitName, targetType, methods);
        case ast::NodeValue::InstanceDecl { traitName, targetType, regions, methods } => {
            try resolveInstanceDecl(self, node, traitName, targetType, regions, methods);
        }
        case ast::NodeValue::MethodDecl { name, receiverName, receiverType, sig, body, attrs } => {
            try resolveMethodDecl(self, node, name, receiverName, receiverType, sig, attrs);
        case ast::NodeValue::MethodDecl {
            ..
        } => {
            try resolveMethodDecl(self, node);
        }
        else => {
            // Ignore non-declaration nodes.
        }
    }
}

/// Require an unsafe function or block.
unsafe fn requireUnsafe(self: &mut Resolver, node: *ast::Node) throws (ResolveError) {
unsafe fn requireUnsafe 'arena (self: &mut Resolver 'arena, node: *ast::Node) throws (ResolveError) {
    if not self.inUnsafeContext {
        throw emitError(self, node, ErrorKind::UnsafeOperation);
    }
}

/// Require an unsafe context for any access to an unsafe static.
unsafe fn checkStaticAccess(self: &mut Resolver, node: *ast::Node, sym: &Symbol)
unsafe fn checkStaticAccess 'arena (self: &mut Resolver 'arena, node: *ast::Node, sym: &Symbol)
    throws (ResolveError)
{
    if let case ast::NodeValue::StaticDecl(_) = sym.node.value {
        if ast::hasAttribute(sym.attrs, ast::Attribute::Unsafe) {
            try requireUnsafe(self, node);
        }
    }
}

/// Reject calls from safe code through unsafe function types.
unsafe fn checkUnsafeCall(self: &mut Resolver, node: *ast::Node, info: *FnType)
unsafe fn checkUnsafeCall 'arena (self: &mut Resolver 'arena, node: *ast::Node, info: *FnType)
    throws (ResolveError)
{
    if info.isUnsafe and not self.inUnsafeContext {
        throw emitError(self, node, ErrorKind::UnsafeCall);
    }
}

/// Visit a top-level definition, recursing into sub-modules.
unsafe fn visitDef(self: &mut Resolver, node: *ast::Node) throws (ResolveError) {
unsafe fn visitDef 'arena (self: &mut Resolver 'arena, node: *ast::Node) throws (ResolveError) {
    match node.value {
        case ast::NodeValue::FnDecl(decl) => {
            try resolveFnDeclBody(self, node, decl) catch {
                return;
            };
        }
        case ast::NodeValue::Mod(decl) => {
            if not shouldAnalyzeModule(self, decl.attrs) {
            let modName = try nodeName(self, decl.name);
            if not shouldAnalyzeModule(self, decl.attrs, modName) {
                return;
            }
            let modName = try nodeName(self, decl.name);
            let submod = try enterSubModule(self, modName, node);
            let case ast::NodeValue::Block(block) = submod.root.value
                else panic "visitDef: expected block for module root";
            try resolveModuleDefs(self, &block) catch e {
                exitModuleScope(self, submod);

            // Skip: already analyzed in declaration phase.
        }
        case ast::NodeValue::InstanceDecl { methods, .. } => {
            try resolveInstanceMethodBodies(self, methods);
        }
        case ast::NodeValue::MethodDecl { receiverName, sig, body, .. } => {
            try resolveMethodBody(self, node, receiverName, sig, body);
        case ast::NodeValue::MethodDecl {
            ..
        } => {
            try resolveMethodBody(self, node);
        }
        else => {
            // FIXME: This allows module-level statements that should
            // normally only be valid inside function bodies. We currently
            // need this because of how tests are written, but it should

        }
    }
}

/// Try to infer a node's type.
unsafe fn infer(self: &mut Resolver, node: *ast::Node) -> Type throws (ResolveError) {
unsafe fn infer 'arena (self: &mut Resolver 'arena, node: *ast::Node) -> Type throws (ResolveError) {
    return try visit(self, node, Type::Unknown);
}

/// Reject nested references while allowing a direct parameter or local reference.
unsafe fn validateValueTypeReferences(self: &mut Resolver, node: *ast::Node, ty: Type)
/// Permit named reference dependencies and direct call-scoped or local references.
unsafe fn validateValueTypeReferences 'arena (self: &mut Resolver 'arena, node: *ast::Node, ty: Type)
    throws (ResolveError)
{
    try validateRegionDependencies(self, node, ty);
    if let case Type::Fn(info) = ty; info.regions == nil {
        return;
    }
    if isRefType(ty) {
        if let case Type::Pointer { target, .. } = ty {
            if containsRef(*target) {
            if containsUnscopedRef(*target) {
                throw emitError(self, node, ErrorKind::InvalidRefPosition);
            }
        } else if let case Type::Slice { item, .. } = ty {
            if containsRef(*item) {
            if containsUnscopedRef(*item) {
                throw emitError(self, node, ErrorKind::InvalidRefPosition);
            }
        }
    } else if containsRef(ty) {
    } else if containsUnscopedRef(ty) {
        throw emitError(self, node, ErrorKind::InvalidRefPosition);
    }
}

/// Require a type that may be stored or escape a call.
unsafe fn ensureStorableType(self: &mut Resolver, node: *ast::Node, ty: Type)
unsafe fn ensureStorableType 'arena (self: &mut Resolver 'arena, node: *ast::Node, ty: Type)
    throws (ResolveError)
{
    if containsRef(ty) {
    try validateRegionDependencies(self, node, ty);
    if containsUnscopedRef(ty) {
        throw emitError(self, node, ErrorKind::InvalidRefPosition);
    }
}

/// Resolve a type signature node.
unsafe fn resolveValueType(self: &mut Resolver, node: *ast::Node) -> Type throws (ResolveError) {
unsafe fn resolveValueType 'arena (self: &mut Resolver 'arena, node: *ast::Node) -> Type throws (ResolveError) {
    let ty = try visit(self, node, Type::Unknown);
    if let case Type::Nominal(info) = ty {
        try requireNominalArguments(self, info, node);
    }
    // Opaque value types are not allowed.
    if ty == Type::Opaque {
        throw emitError(self, node, ErrorKind::OpaqueTypeNotAllowed);
    }
    try validateValueTypeReferences(self, node, ty);
    return ty;
}

/// Analyze a node's type and check that it can be assigned to the expected type.
unsafe fn checkAssignable(self: &mut Resolver, node: *ast::Node, expected: Type) -> Type throws (ResolveError) {
unsafe fn checkAssignable 'arena (self: &mut Resolver 'arena, node: *ast::Node, expected: Type) -> Type throws (ResolveError) {
    let actual = try visit(self, node, expected);
    let _ = try expectAssignable(self, expected, actual, node);
    if isRefType(expected) and isMutablePointerLike(expected) and isMutablePointerLike(actual) {
        if not try canMutateThrough(self, node) {
            throw emitError(self, node, ErrorKind::ImmutableBinding);
        }
    }
    return actual;
}

/// Analyze a node and propagate the resolved type.
/// The `hint` parameter provides type context for inference and validation.
/// When `nil`, the type must be inferred from the expression itself.
unsafe fn visit(self: &mut Resolver, node: *ast::Node, hint: Type) -> Type
unsafe fn visit 'arena (self: &mut Resolver 'arena, node: *ast::Node, hint: Type) -> Type
    throws (ResolveError)
{
    if let ty = typeFor(self, node) {
        return ty;
        // An optional context completes a nil expression's storage type.
        if ty <> Type::Nil or not isOptionalType(hint) {
            return ty;
        }
    }
    match node.value {
        case ast::NodeValue::Ident(name) => {
            let sym = findAnySymbol(self.scope, name)
                else throw emitError(self, node, ErrorKind::UnresolvedSymbol(name));

                        setNodeConstValue(self, node, val);
                    }
                    return setNodeType(self, node, type);
                },
                case SymbolData::Type(t) =>
                    return setNodeType(self, node, Type::Nominal(t)),
                    return setNodeType(self, node, Type::Nominal(hintedNominal(t, hint))),
                case SymbolData::Variant { .. } =>
                    return Type::Void,
                case SymbolData::Module { .. } =>
                    throw emitError(self, node, ErrorKind::UnexpectedModuleName),
                case SymbolData::Trait(_) =>
                    throw emitError(self, node, ErrorKind::UnexpectedTraitName),
            }
        },
        case ast::NodeValue::Call(call) => return try resolveCall(self, node, call, CallCtx::Normal),
        case ast::NodeValue::Call(call) => return try resolveCall(self, node, call, CallCtx::Normal, hint),
        case ast::NodeValue::FieldAccess(access) => return try resolveFieldAccess(self, node, access),
        case ast::NodeValue::BinOp(binop) => return try resolveBinOp(self, node, binop),
        case ast::NodeValue::RegionBlock { region, bindings, body, isSession } => {
            if isSession {
                return try resolveSessionBlock(self, node, region, bindings, body);
            }
            return try resolveBorrowBlock(self, node, region, bindings, body);
        }
        case ast::NodeValue::Block(block) => return try resolveBlock(self, node, block),
        case ast::NodeValue::Let(decl) => return try resolveLet(self, node, decl),
        case ast::NodeValue::ConstDecl(decl) => return try resolveConstOrStatic(
            self, node, decl.ident, decl.type, decl.value, decl.attrs, true
        ),
        case ast::NodeValue::StaticDecl(decl) => return try resolveConstOrStatic(
            self, node, decl.ident, decl.type, decl.value, decl.attrs, false
        ),
        case ast::NodeValue::FnParam(param) => return try resolveFnParam(self, node, param),
        case ast::NodeValue::If(cond) => return try resolveIf(self, node, cond),
        case ast::NodeValue::CondExpr(cond) => return try resolveCondExpr(self, node, cond),
        case ast::NodeValue::CondExpr(cond) => return try resolveCondExpr(self, node, cond, hint),
        case ast::NodeValue::IfLet(cond) => return try resolveIfLet(self, node, cond),
        case ast::NodeValue::While(loopNode) => return try resolveWhile(self, node, loopNode),
        case ast::NodeValue::WhileLet(loopNode) => return try resolveWhileLet(self, node, loopNode),
        case ast::NodeValue::For(loopNode) => return try resolveFor(self, node, loopNode),
        case ast::NodeValue::Loop { body } => {

        case ast::NodeValue::Assign(assign) => return try resolveAssign(self, node, assign),
        case ast::NodeValue::RecordLit(lit) => return try resolveRecordLit(self, node, lit, hint),
        case ast::NodeValue::ArrayLit(items) => return try resolveArrayLit(self, node, items, hint),
        case ast::NodeValue::ArrayRepeatLit(lit) => return try resolveArrayRepeat(self, node, lit, hint),
        case ast::NodeValue::Subscript { container, index } => return try resolveSubscript(self, node, container, index),
        case ast::NodeValue::ScopeAccess(access) => return try resolveScopeAccess(self, node, access),
        case ast::NodeValue::ScopeAccess(access) => return try resolveScopeAccess(self, node, access, hint),
        case ast::NodeValue::AddressOf(addr) => return try resolveAddressOf(self, node, addr, hint),
        case ast::NodeValue::Deref(target) => return try resolveDeref(self, node, target, hint),
        case ast::NodeValue::As(expr) => return try resolveAs(self, node, expr),
        case ast::NodeValue::Range(range) => return try resolveRange(self, node, range),
        case ast::NodeValue::Try(expr) => return try resolveTry(self, node, expr, hint),

        case ast::NodeValue::ExprStmt(expr) => {
            // Pass `Void` as expected type to indicate value is discarded.
            let exprTy = try visit(self, expr, Type::Void);
            return setNodeType(self, node, Type::Never if exprTy == Type::Never else Type::Void);
        },
        case ast::NodeValue::RegionApply { value, regions } =>
            return try resolveRegionApply(self, node, value, regions),
        case ast::NodeValue::TypeSig(sig) => return try inferTypeSig(self, node, sig),
        case ast::NodeValue::Super => {
            // `super` by itself is invalid, must be used in scope access.
            throw emitError(self, node, ErrorKind::InvalidModulePath);
        },

        }
    }
}

/// Visit an optional node when present.
unsafe fn visitOptional(self: &mut Resolver, node: ?*ast::Node, hint: Type) -> ?Type
unsafe fn visitOptional 'arena (self: &mut Resolver 'arena, node: ?*ast::Node, hint: Type) -> ?Type
    throws (ResolveError)
{
    if let n = node {
        return try visit(self, n, hint);
    }
    return nil;
}

/// Visit every node contained in a list, returning the last resolved type.
unsafe fn visitList(self: &mut Resolver, list: *[*ast::Node]) -> Type
unsafe fn visitList 'arena (self: &mut Resolver 'arena, list: *[*ast::Node]) -> Type
    throws (ResolveError)
{
    let mut diverges = false;
    for item in list {
        if try infer(self, item) == Type::Never {

    }
    return Type::Void;
}

/// Collect attribute flags applied to a declaration.
fn resolveAttributes(self: &mut Resolver, attrs: ?ast::Attributes) -> u32 {
fn resolveAttributes(attrs: ?ast::Attributes) -> u32 {
    let list = attrs else return 0;
    let attrNodes = list.list;
    let mut mask: u32 = 0;

    for node in attrNodes {
    for node in list.list {
        let case ast::NodeValue::Attribute(attr) = node.value
            else panic "resolveAttributes: invalid attribute node";
        set mask |= (attr as u32);
    }
    return mask;
}

/// Ensure the `default` attribute is only applied to functions.
unsafe fn ensureDefaultAttrNotAllowed(self: &mut Resolver, node: *ast::Node, attrs: u32)
unsafe fn ensureDefaultAttrNotAllowed 'arena (self: &mut Resolver 'arena, node: *ast::Node, attrs: u32)
    throws (ResolveError)
{
    let defaultBit = ast::Attribute::Default as u32;
    if (attrs & defaultBit) <> 0 {
        throw emitError(self, node, ErrorKind::DefaultAttrOnlyOnFn);
    }
}

/// Analyze a block node, allocating a nested lexical scope.
unsafe fn resolveBlock(self: &mut Resolver, node: *ast::Node, block: ast::Block) -> Type
unsafe fn resolveBlock 'arena (self: &mut Resolver 'arena, node: *ast::Node, block: ast::Block) -> Type
    throws (ResolveError)
{
    enterScope(self, node);
    let wasUnsafe = self.inUnsafeContext;
    set self.inUnsafeContext = wasUnsafe or block.isUnsafe;

    set self.inUnsafeContext = wasUnsafe;

    return setNodeType(self, node, blockTy);
}

/// Analyze a `let` declaration and bind its identifier.
unsafe fn resolveLet(self: &mut Resolver, node: *ast::Node, decl: ast::Let) -> Type
/// Introduce a concrete region under an explicit parent or enclosing region block.
unsafe fn borrowRegion 'arena (self: &mut Resolver 'arena, node: *ast::Node) -> *RegionScope throws (ResolveError) {
    let case ast::NodeValue::Region { name, parent } = node.value
        else panic "borrowRegion: invalid region node";
    if findRegion(self.regionScope, name) <> nil {
        throw emitError(self, node, ErrorKind::DuplicateBinding(name));
    }
    let mut enclosing: ?*unsafe types::Region = nil;
    let mut current = self.regionScope;
    while let scope = current {
        for region in scope.entries {
            if region.origin == types::RegionOrigin::Block {
                set enclosing = region;
                break;
            }
        }
        if enclosing <> nil {
            break;
        }
        set current = scope.parent;
    }
    if let parentNode = parent {
        set enclosing = try resolveRegion(self, parentNode);
    }
    let region = try! alloc::allocRaw(self.arena, @sizeOf(types::Region), @alignOf(types::Region))
        as *unsafe mut types::Region;
    set *region = types::Region { id: node.id, origin: types::RegionOrigin::Block, name, parent: enclosing };
    let entries = try! alloc::allocRawSlice(
        self.arena, @sizeOf(*unsafe mut types::Region), @alignOf(*unsafe mut types::Region), 1
    ) as *unsafe mut [*unsafe mut types::Region];
    set entries[0] = region;
    let scope = try! alloc::alloc(&mut *self.arena, @sizeOf(RegionScope), @alignOf(RegionScope)) as *mut RegionScope;
    set *scope = RegionScope { entries, parent: self.regionScope };
    return scope;
}

/// Qualify an existing-place borrow with its block's region.
unsafe fn qualifyBlockBorrow 'arena (
    self: &mut Resolver 'arena, node: *ast::Node, ty: Type, region: *unsafe types::Region
) -> Type throws (ResolveError) {
    let mut class = types::PointerClass::Ref;
    match ty {
        case Type::Cell { class: cellClass, .. } => set class = cellClass,
        case Type::Pointer { class: pointerClass, .. } => set class = pointerClass,
        case Type::Slice { class: sliceClass, .. } => set class = sliceClass,
        else => throw emitError(self, node, ErrorKind::RefBinding),
    }
    if let case types::PointerClass::Region(source) = class {
        if not types::regionContains(source, region) {
            throw emitError(self, node, ErrorKind::RegionParent(region.name));
        }
    }
    match ty {
        case Type::Pointer { target, mutable, .. } =>
            return Type::Pointer { class: types::PointerClass::Region(region), target, mutable },
        case Type::Slice { item, mutable, .. } =>
            return Type::Slice { class: types::PointerClass::Region(region), item, mutable },
        else => throw emitError(self, node, ErrorKind::RefBinding),
    }
}

/// Check source places before publishing the region's bindings to its body.
unsafe fn resolveBorrowBlock 'arena (
    self: &mut Resolver 'arena, node: *ast::Node, regionNode: *ast::Node,
    bindings: *[*ast::Node], body: *ast::Node
) -> Type throws (ResolveError) {
    if self.currentFn == nil {
        throw emitError(self, node, ErrorKind::InvalidRefPosition);
    }
    let scope = try borrowRegion(self, regionNode);
    let region = scope.entries[0];
    for bindingNode in bindings {
        let case ast::NodeValue::RegionBinding(binding) = bindingNode.value
            else panic "resolveBorrowBlock: invalid binding node";
        let case ast::NodeValue::AddressOf(address) = binding.value.value
            else panic "resolveBorrowBlock: invalid source node";
        let ty = try infer(self, binding.value);
        if not ast::isPlaceExpr(address.target) or borrowPlace(self, address.target).root == nil {
            throw emitError(self, binding.value, ErrorKind::RefBinding);
        }
        let qualified = try qualifyBlockBorrow(self, binding.value, ty, region);
        setNodeType(self, binding.value, qualified);
    }
    let previous = self.regionScope;
    set self.regionScope = scope;
    set self.nodeData.entries[node.id].extra = NodeExtra::Regions(scope);
    enterScope(self, node);
    let result = try resolveBorrowBody(self, bindings, body) catch error {
        exitScope(self);
        set self.regionScope = previous;
        throw error;
    };
    exitScope(self);
    set self.regionScope = previous;
    return setNodeType(self, node, result);
}

/// Bind a checked region's source references and resolve its statement body.
unsafe fn resolveBorrowBody 'arena (self: &mut Resolver 'arena, bindings: *[*ast::Node], body: *ast::Node) -> Type
    throws (ResolveError)
{
    for bindingNode in bindings {
        let case ast::NodeValue::RegionBinding(binding) = bindingNode.value
            else panic "resolveBorrowBody: invalid binding node";
        try resolveLet(self, bindingNode, ast::borrowBinding(binding));
    }
    return try infer(self, body);
}

/// Find a declaration by spelling when the name is not interned.
unsafe fn findSpelledSymbol(scope: *unsafe Scope, name: *[u8]) -> ?*unsafe mut Symbol {
    for i in 0..scope.symbolsLen {
        let symbol = scope.symbols[i];
        if mem::eq(symbol.name, name) {
            return symbol;
        }
    }
    return nil;
}

/// Look up a compiler-known declaration in the standard allocation module.
unsafe fn allocationSymbol 'arena (self: &Resolver 'arena, name: *[u8]) -> ?*unsafe mut Symbol {
    let mut scope = self.pkgScope;
    for segment in ["std", "lang", "alloc"] {
        let symbol = findSpelledSymbol(scope, segment) else return nil;
        let case SymbolData::Module { scope: child, .. } = symbol.data else return nil;
        set scope = child;
    }
    return findSpelledSymbol(scope, name);
}

/// Bind an allocation interface while retaining the source arena until region exit.
unsafe fn resolveSessionBlock 'arena (
    self: &mut Resolver 'arena, node: *ast::Node, regionNode: *ast::Node,
    bindings: *[*ast::Node], body: *ast::Node
) -> Type throws (ResolveError) {
    if self.currentFn == nil or bindings.len <> 1 {
        throw emitError(self, node, ErrorKind::InvalidSessionSource);
    }
    let bindingNode = bindings[0];
    let case ast::NodeValue::RegionBinding(binding) = bindingNode.value
        else panic "resolveSessionBlock: invalid binding";
    let case ast::NodeValue::AddressOf(address) = binding.value.value
        else throw emitError(self, binding.value, ErrorKind::InvalidSessionSource);
    let ty = try infer(self, binding.value);
    let case Type::Pointer { target, .. } = ty
        else throw emitError(self, binding.value, ErrorKind::InvalidSessionSource);
    let allocTrait = allocationSymbol(self, "Alloc")
        else throw emitError(self, node, ErrorKind::InvalidSessionSource);
    let case SymbolData::Trait(allocInfo) = allocTrait.data
        else throw emitError(self, node, ErrorKind::InvalidSessionSource);
    let allocModule = moduleIdForSymbol(self, allocTrait)
        else throw emitError(self, node, ErrorKind::InvalidSessionSource);
    let mut allocInstance: ?*unsafe InstanceEntry = nil;
    for i in 0..self.instancesLen {
        let candidate: *unsafe InstanceEntry = &self.instances[i];
        if candidate.traitType.moduleId == allocModule and mem::eq(candidate.traitType.name, allocInfo.name)
            and erasedTypesEqual(candidate.concreteType, *target)
        {
            set allocInstance = candidate;
            break;
        }
    }
    let selected = allocInstance
        else throw emitError(self, node, ErrorKind::InvalidSessionSource);
    if not address.mutable or not ast::isPlaceExpr(address.target)
        or borrowPlace(self, address.target).root == nil
    {
        throw emitError(self, binding.value, ErrorKind::InvalidSessionSource);
    }
    let _ = setNodeCoercion(self, binding.value, Coercion::TraitObject {
        traitInfo: allocInfo, inst: selected,
    });
    let scope = try borrowRegion(self, regionNode);
    let region = scope.entries[0];
    if let sourceRegion = referenceRegion(ty) {
        set region.parent = sourceRegion;
    }
    setNodeType(self, binding.value, try qualifyBlockBorrow(self, binding.value, ty, region));
    let previous = self.regionScope;
    set self.regionScope = scope;
    set self.nodeData.entries[node.id].extra = NodeExtra::Regions(scope);
    enterScope(self, node);
    let result = try resolveSessionBody(self, bindingNode, binding, region, body) catch error {
        exitScope(self);
        set self.regionScope = previous;
        throw error;
    };
    exitScope(self);
    set self.regionScope = previous;
    return setNodeType(self, node, result);
}

/// Introduce the opaque session value and check its body.
unsafe fn resolveSessionBody 'arena (
    self: &mut Resolver 'arena, node: *ast::Node, binding: ast::Arg,
    region: *unsafe types::Region, body: *ast::Node
) -> Type throws (ResolveError) {
    let ident = binding.label else panic "resolveSessionBody: missing binding name";
    let _ = try bindValueIdent(self, ident, node, Type::Session(region), false, 0, 0);
    return try infer(self, body);
}

/// Analyze a `let` declaration and bind its identifier.
unsafe fn resolveLet 'arena (self: &mut Resolver 'arena, node: *ast::Node, decl: ast::Let) -> Type
    throws (ResolveError)
{
    let mut alignment: u32 = 0; // Zero is default.
    let mut bindingTy = Type::Unknown;
    let mut valueTy = Type::Unknown;

    try validateValueTypeReferences(self, node, bindingTy);
    if isRefType(bindingTy) {
        if self.currentFn == nil {
            throw emitError(self, node, ErrorKind::InvalidRefPosition);
        }
        if decl.mutable {
        if decl.mutable and (referenceRegion(bindingTy) == nil or not isCopy(bindingTy)) {
            throw emitError(self, node, ErrorKind::RefBinding);
        }
    }
    // Variables cannot have void type.
    if bindingTy == Type::Void {

    // Alignment must be zero or a power of two.
    if alignment <> 0 and (alignment & (alignment - 1)) <> 0 {
        throw emitError(self, decl.value, ErrorKind::InvalidAlignmentValue(alignment));
    }
    let _ = try bindValueIdent(self, decl.ident, node, bindingTy, decl.mutable, alignment, 0);
    setNodeType(self, decl.value, bindingTy);

    // Untyped initializers use the declared storage type.
    if not isTypeInferrable(valueTy) {
        setNodeType(self, decl.value, bindingTy);
    }

    return Type::Never if valueTy == Type::Never else Type::Void;
}

/// Check whether a node is an integer literal, optionally under unary negation.

        else => return false,
    }
}

/// Determine whether a node represents a compile-time constant expression.
export unsafe fn isConstExpr(self: &Resolver, node: *ast::Node) -> bool {
export unsafe fn isConstExpr 'arena (self: &Resolver 'arena, node: *ast::Node) -> bool {
    match node.value {
        case ast::NodeValue::Bool(_),
             ast::NodeValue::Char(_),
             ast::NodeValue::Number(_),
             ast::NodeValue::String(_),

            return ConstValue::Int(constIntFromBits(raw, bits, true)),
    }
}

/// Return the constant `u32` value for a slice bound when known.
fn constSliceIndex(self: &mut Resolver, node: *ast::Node) -> ?u32 {
fn constSliceIndex 'arena (self: &mut Resolver 'arena, node: *ast::Node) -> ?u32 {
    let value = constValueEntry(self, node)
        else return nil;
    let case ConstValue::Int(int) = value
        else return nil;
    if int.negative {

/// This function ensures that a node represents a valid, non-negative integer constant
/// that fits within a machine word. It is used for contexts requiring compile-time
/// non-negative integers, such as array sizes and alignment specifications.
///
/// Returns the unsigned magnitude of the constant as `u32`.
unsafe fn checkSizeInt(self: &mut Resolver, node: *ast::Node) -> u32
unsafe fn checkSizeInt 'arena (self: &mut Resolver 'arena, node: *ast::Node) -> u32
    throws (ResolveError)
{
    // First traverse the node expect a numeric type.
    let _ = try checkNumeric(self, node);



/// Check that constructor arguments match record fields.
///
/// Verifies argument count matches field count, and that each argument is
/// assignable to its corresponding field type.
unsafe fn checkRecordConstructorArgs(self: &mut Resolver, node: *ast::Node, args: *[*ast::Node], recInfo: RecordType)
unsafe fn checkRecordConstructorArgs 'arena (self: &mut Resolver 'arena, node: *ast::Node, args: *[*ast::Node], recInfo: RecordType)
    throws (ResolveError)
{
    try checkRecordArity(self, args, recInfo, node);
    for arg, i in args {
        let fieldType = recInfo.fields[i].fieldType;
        try checkAssignable(self, arg, fieldType);
    }
}

/// Check that the argument count of a constructor pattern or call matches the record field count.
unsafe fn checkRecordArity(self: &mut Resolver, args: *[*ast::Node], recInfo: RecordType, pattern: *ast::Node) throws (ResolveError) {
unsafe fn checkRecordArity 'arena (self: &mut Resolver 'arena, args: *[*ast::Node], recInfo: RecordType, pattern: *ast::Node) throws (ResolveError) {
    if args.len <> recInfo.fields.len {
        throw emitError(self, pattern, ErrorKind::RecordFieldCountMismatch(CountMismatch {
            expected: recInfo.fields.len as u32,
            actual: args.len,
        }));
    }
}

/// Helper for analyzing `constant` and `static` declarations.
unsafe fn resolveConstOrStatic(
    self: &mut Resolver,
unsafe fn resolveConstOrStatic 'arena (
    self: &mut Resolver 'arena,
    node: *ast::Node,
    ident: *ast::Node,
    typeNode: *ast::Node,
    valueNode: *ast::Node,
    attrList: ?ast::Attributes,
    isConst: bool
) -> Type throws (ResolveError) {
    let attrs = resolveAttributes(self, attrList);
    let attrs = resolveAttributes(attrList);
    let bindingTy = try infer(self, typeNode);
    if containsRegion(bindingTy) {
        throw emitError(self, typeNode, ErrorKind::InvalidRefPosition);
    }
    try ensureStorableType(self, typeNode, bindingTy);
    let wasUnsafe = self.inUnsafeContext;
    set self.inUnsafeContext = wasUnsafe or (
        not isConst and ast::hasAttribute(attrs, ast::Attribute::Unsafe)
    );


    return Type::Void;
}

/// Analyze a function declaration signature and bind the function name.
unsafe fn resolveFnDecl(self: &mut Resolver, node: *ast::Node, decl: ast::FnDecl) -> Type
unsafe fn resolveFnDecl 'arena (self: &mut Resolver 'arena, node: *ast::Node, decl: ast::FnDecl) -> Type
    throws (ResolveError)
{
    let previous = self.regionScope;
    set self.regionScope = try bindRegions(self, node, decl.regions);
    let result = try resolveFnSignature(self, node, decl) catch error {
        set self.regionScope = previous;
        throw error;
    };
    set self.regionScope = previous;
    return result;
}

/// Resolve a function signature in its declared region environment.
unsafe fn resolveFnSignature 'arena (self: &mut Resolver 'arena, node: *ast::Node, decl: ast::FnDecl) -> Type
    throws (ResolveError)
{
    let attrMask = resolveAttributes(self, decl.attrs);
    let attrMask = resolveAttributes(decl.attrs);
    let mut retTy = Type::Void;
    if let retNode = decl.sig.returnType {
        set retTy = try infer(self, retNode);
        try ensureStorableType(self, retNode, retTy);
    }
    let a = alloc::arenaAllocator(&mut self.arena);
    let a = alloc::arenaAllocator(self.arena);
    let mut paramTypes: *mut [*Type] = &mut [];
    let mut throwList: *mut [*Type] = &mut [];
    let mut fnType = FnType {
        regions: self.regionScope,
        paramTypes: &[],
        returnType: allocType(self, retTy),
        throwList: &[],
        isUnsafe: ast::hasAttribute(attrMask, ast::Attribute::Unsafe),
    };

    for throwNode in decl.sig.throwList {
        let throwTy = try infer(self, throwNode) catch e {
            exitFn(self);
            throw e;
        };
        try validateErrorTag(self, throwNode, throwTy, &throwList[..]);
        throwList.append(allocType(self, throwTy), a);
        try ensureStorableType(self, throwNode, throwTy);
    }
    exitFn(self);
    set fnType.paramTypes = &paramTypes[..];


    return ty;
}

/// Analyze a function body.
unsafe fn resolveFnDeclBody(self: &mut Resolver, node: *ast::Node, decl: ast::FnDecl) throws (ResolveError) {
unsafe fn resolveFnDeclBody 'arena (self: &mut Resolver 'arena, node: *ast::Node, decl: ast::FnDecl) throws (ResolveError) {
    let sym = symbolFor(self, node) else {
        // The function declaration failed to type check, therefore
        // no symbol was associated with it.
        return;
    };

            throw emitError(self, node, ErrorKind::IntrinsicUnexpectedBody);
        }
        if isExtern {
            throw emitError(self, node, ErrorKind::FnUnexpectedBody);
        }
        try resolveExecutableBody(self, node, fnType, nil, decl.sig.params, body);
        let previous = self.regionScope;
        set self.regionScope = try bindRegions(self, node, decl.regions);
        try resolveExecutableBody(self, node, fnType, nil, decl.sig.params, body) catch error {
            set self.regionScope = previous;
            throw error;
        };
        set self.regionScope = previous;
    } else if not isExtern {
        throw emitError(self, node, ErrorKind::FnMissingBody);
    }
}

/// Resolve a function or method body and restore the enclosing context.
unsafe fn resolveExecutableBody(
    self: &mut Resolver,
unsafe fn resolveExecutableBody 'arena (
    self: &mut Resolver 'arena,
    node: *ast::Node,
    fnType: *FnType,
    receiverName: ?*ast::Node,
    params: *[*ast::Node],
    body: *ast::Node,

    }
}

/// Check parameters, body types, and ownership.
/// Return whether a required return is missing.
unsafe fn checkExecutableBody(
    self: &mut Resolver,
unsafe fn checkExecutableBody 'arena (
    self: &mut Resolver 'arena,
    fnType: *FnType,
    receiverName: ?*ast::Node,
    params: *[*ast::Node],
    body: *ast::Node,
) -> bool throws (ResolveError) {

    try checkLinearFn(self, receiverName, params, body);
    return false;
}

/// Analyze a function parameter and bind its identifier.
unsafe fn resolveFnParam(self: &mut Resolver, node: *ast::Node, param: ast::FnParam) -> Type
unsafe fn resolveFnParam 'arena (self: &mut Resolver 'arena, node: *ast::Node, param: ast::FnParam) -> Type
    throws (ResolveError)
{
    let ty = try resolveValueType(self, param.type);
    let _ = try bindValueIdent(self, param.name, node, ty, false, 0, 0);


    /// The declaration permits implicit copies.
    copy: bool,
}

/// Resolve compiler-known ownership markers from a derive list.
unsafe fn resolveOwnershipMarkers(self: &mut Resolver, derives: *[*ast::Node]) -> OwnershipMarkers
unsafe fn resolveOwnershipMarkers 'arena (self: &mut Resolver 'arena, derives: *[*ast::Node]) -> OwnershipMarkers
    throws (ResolveError)
{
    let mut result = OwnershipMarkers { linear: false, copy: false };
    for derive in derives {
        if let case ast::NodeValue::Region { .. } = derive.value {
            continue;
        }
        let name = try nodeName(self, derive);
        if mem::eq(name, "Once") {
            if result.linear {
                throw emitError(self, derive, ErrorKind::DuplicateBinding(name));
            }

    }
    return result;
}

/// Resolve record fields from a node list.
unsafe fn resolveRecordFields(self: &mut Resolver, node: *ast::Node, fields: *[*ast::Node], labeled: bool) -> RecordType
unsafe fn resolveRecordFields 'arena (self: &mut Resolver 'arena, node: *ast::Node, fields: *[*ast::Node], labeled: bool) -> RecordType
    throws (ResolveError)
{
    let a = alloc::arenaAllocator(&mut self.arena);
    let a = alloc::arenaAllocator(self.arena);
    let mut result: *unsafe mut [RecordField] = &mut [];
    let mut currentOffset: u32 = 0;
    let mut maxAlignment: u32 = 1;

    if fields.len > parser::MAX_RECORD_FIELDS {
        throw emitError(self, node, ErrorKind::Internal);
    }
    // TODO: Add cycle detection to catch invalid recursive types like `record A { a: A }`.
    for field in fields {
        let case ast::NodeValue::RecordField {
            field: fieldNode,
            type: typeNode,
            value: valueNode

    let recordLayout = Layout {
        size: mem::alignUp(currentOffset, maxAlignment),
        alignment: maxAlignment
    };
    return RecordType {
        regions: nil,
        application: nil,
        fields: &result[..],
        labeled,
        layout: recordLayout,
        layout: allocLayout(self, recordLayout),
        declaredLinear: false,
        declaredCopy: false,
    };
}

/// Resolve record field types for a named record declaration.
unsafe fn resolveRecordBody(self: &mut Resolver, node: *ast::Node, decl: ast::RecordDecl)
unsafe fn resolveRecordBody 'arena (self: &mut Resolver 'arena, node: *ast::Node, decl: ast::RecordDecl)
    throws (ResolveError)
{
    let previous = self.regionScope;
    set self.regionScope = try bindRegions(self, node, decl.regions);
    try resolveRecordContents(self, node, decl) catch error {
        set self.regionScope = previous;
        throw error;
    };
    set self.regionScope = previous;
}

/// Resolve record contents in the declaration's region environment.
unsafe fn resolveRecordContents 'arena (self: &mut Resolver 'arena, node: *ast::Node, decl: ast::RecordDecl)
    throws (ResolveError)
{
    // Get the type symbol that was bound to this declaration node.
    // If there's no symbol, it's because an earlier phase failed.
    let sym = symbolFor(self, node)

    // Skip if already resolved.
    if let case NominalType::Record(_) = *nominalTy {
        return;
    }
    let markers = try resolveOwnershipMarkers(self, decl.derives);
    let mut recordType = try resolveRecordFields(self, node, decl.fields, decl.labeled);
    set *nominalTy = NominalType::Resolving(node);
    let mut recordType = try resolveRecordFields(self, node, decl.fields, decl.labeled) catch error {
        set *nominalTy = NominalType::Placeholder(node);
        throw error;
    };
    set recordType.regions = self.regionScope;
    if markers.copy {
        for field in recordType.fields {
            if not isCopy(field.fieldType) {
                throw emitError(self, node, ErrorKind::CopyContainsNonCopy);
            }


    set *nominalTy = NominalType::Record(recordType);
}

/// Bind a type name.
unsafe fn bindTypeName(self: &mut Resolver, node: *ast::Node, name: *ast::Node, attrs: ?ast::Attributes) -> *unsafe mut Symbol
unsafe fn bindTypeName 'arena (self: &mut Resolver 'arena, node: *ast::Node, name: *ast::Node, attrs: ?ast::Attributes) -> *unsafe mut Symbol
    throws (ResolveError)
{
    let attrMask = resolveAttributes(self, attrs);
    let attrMask = resolveAttributes(attrs);
    try ensureDefaultAttrNotAllowed(self, node, attrMask);

    // Create a placeholder nominal type that will be replaced in
    // the next phase.
    let nominalTy = allocNominalType(self, NominalType::Placeholder(node));

    return try bindTypeIdent(self, name, node, nominalTy, attrMask);
}

/// Allocate a trait type descriptor and return a pointer to it.
unsafe fn allocTraitType(self: &mut Resolver, name: *[u8]) -> *unsafe mut TraitType {
    let p = try! alloc::allocRaw(&mut self.arena, @sizeOf(TraitType), @alignOf(TraitType));
unsafe fn allocTraitType 'arena (self: &mut Resolver 'arena, name: *[u8]) -> *unsafe mut TraitType {
    let p = try! alloc::allocRaw(self.arena, @sizeOf(TraitType), @alignOf(TraitType));
    let entry = p as *unsafe mut TraitType;
    set *entry = TraitType { name, methods: &mut [], supertraits: &mut [] };
    set *entry = TraitType { name, moduleId: self.currentMod, methods: &mut [], supertraits: &mut [] };

    return entry;
}

/// Bind a trait name in the current scope.
unsafe fn bindTraitName(self: &mut Resolver, node: *ast::Node, name: *ast::Node, attrs: ?ast::Attributes) -> *unsafe mut Symbol
unsafe fn bindTraitName 'arena (self: &mut Resolver 'arena, node: *ast::Node, name: *ast::Node, attrs: ?ast::Attributes) -> *unsafe mut Symbol
    throws (ResolveError)
{
    let attrMask = resolveAttributes(self, attrs);
    let attrMask = resolveAttributes(attrs);
    try ensureDefaultAttrNotAllowed(self, node, attrMask);

    let traitName = try nodeName(self, name);
    let traitType = allocTraitType(self, traitName);
    let data = SymbolData::Trait(traitType);

}

/// Find a trait method by name.
export unsafe fn findTraitMethod(traitType: *unsafe TraitType, name: *[u8]) -> ?*unsafe TraitMethod {
    for i in 0..traitType.methods.len {
        if traitType.methods[i].name == name {
        if mem::eq(traitType.methods[i].name, name) {
            return &traitType.methods[i];
        }
    }
    return nil;
}

/// Resolve a trait declaration body: supertrait methods, then own methods.
unsafe fn resolveTraitBody(self: &mut Resolver, node: *ast::Node, supertraits: *[*ast::Node], methods: *[*ast::Node])
unsafe fn resolveTraitBody 'arena (self: &mut Resolver 'arena, node: *ast::Node, supertraits: *[*ast::Node], methods: *[*ast::Node])
    throws (ResolveError)
{
    let sym = symbolFor(self, node)
        else return;
    let case SymbolData::Trait(traitType) = sym.data

            try resolveTraitBody(self, superSym.node, inheritedTraits, inheritedMethods);
        }

        setNodeSymbol(self, superNode, superSym);

        let a = alloc::arenaAllocator(&mut self.arena);
        let a = alloc::arenaAllocator(self.arena);
        if traitType.methods.len + superTrait.methods.len > ast::MAX_TRAIT_METHODS {
            throw emitError(self, node, ErrorKind::TraitMethodOverflow(CountMismatch {
                expected: ast::MAX_TRAIT_METHODS,
                actual: traitType.methods.len as u32 + superTrait.methods.len as u32,
            }));

            actual: traitType.methods.len as u32 + methods.len as u32,
        }));
    }

    for methodNode in methods {
        let case ast::NodeValue::TraitMethodSig { name, receiver, sig, attrs } = methodNode.value
        let case ast::NodeValue::TraitMethodSig { name, modifiers, receiver, sig } = methodNode.value
            else continue;
        let attrs = modifiers.attrs;
        let methodName = try nodeName(self, name);
        let attrMask = resolveAttributes(self, attrs);
        let attrMask = resolveAttributes(attrs);
        let previousRegions = self.regionScope;
        set self.regionScope = try bindRegions(self, methodNode, modifiers.regions);

        // Reject duplicate method names.
        if let _ = findTraitMethod(traitType, methodName) {
            throw emitError(self, name, ErrorKind::DuplicateBinding(methodName));
        }
        // Determine the receiver class and mutability, and validate that it
        // points to the declaring trait.
        let case ast::NodeValue::TypeSig(typeSig) = receiver.value
            else throw emitError(self, receiver, ErrorKind::TraitReceiverMismatch);
        let case ast::TypeSig::Pointer {
            class: receiverClass, valueType: receiverValueType, mutable,
            class: receiverSyntax, valueType: receiverValueType, mutable,
        } = typeSig
            else throw emitError(self, receiver, ErrorKind::TraitReceiverMismatch);
        let receiverClass = resolvePointerClass(receiverSyntax);
        let case ast::NodeValue::TypeSig(innerSig) = receiverValueType.value
            else throw emitError(self, receiver, ErrorKind::TraitReceiverMismatch);
        let case ast::TypeSig::Nominal(nameNode) = innerSig
            else throw emitError(self, receiver, ErrorKind::TraitReceiverMismatch);
        let receiverTargetName = try nodeName(self, nameNode);

        if receiverTargetName <> traitType.name {
            throw emitError(self, receiver, ErrorKind::TraitReceiverMismatch);
        }
        // Resolve parameter types and return type.
        let a = alloc::arenaAllocator(&mut self.arena);
        let a = alloc::arenaAllocator(self.arena);
        let mut paramTypes: *mut [*Type] = &mut [];
        let mut throwList: *mut [*Type] = &mut [];
        let mut retType = allocType(self, Type::Void);

        if sig.params.len > MAX_FN_PARAMS {

                expected: MAX_FN_PARAMS,
                actual: sig.params.len,
            }));
        }
        for paramNode in sig.params {
            let paramTy = try infer(self, paramNode);
            let case ast::NodeValue::FnParam(param) = paramNode.value
                else throw emitError(self, paramNode, ErrorKind::ExpectedIdentifier);
            let paramTy = try resolveValueType(self, param.type);
            paramTypes.append(allocType(self, paramTy), a);
        }
        if let ret = sig.returnType {
            set retType = allocType(self, try infer(self, ret));
        }

                actual: sig.throwList.len,
            }));
        }
        for throwNode in sig.throwList {
            let throwTy = try infer(self, throwNode);
            try validateErrorTag(self, throwNode, throwTy, &throwList[..]);
            throwList.append(allocType(self, throwTy), a);
        }
        let fnType = FnType {
            regions: self.regionScope,
            paramTypes: &paramTypes[..],
            returnType: retType,
            throwList: &throwList[..],
            isUnsafe: ast::hasAttribute(attrMask, ast::Attribute::Unsafe),
        };

            receiverClass,
            index: traitType.methods.len as u32,
        }, a);

        setNodeType(self, methodNode, Type::Void);
        set self.regionScope = previousRegions;
    }
}

/// Resolve a name path node to a symbol.
/// Used for trait and type references in instance declarations and trait objects.
unsafe fn resolveNamePath(self: &mut Resolver, node: *ast::Node) -> *unsafe mut Symbol
unsafe fn resolveNamePath 'arena (self: &mut Resolver 'arena, node: *ast::Node) -> *unsafe mut Symbol
    throws (ResolveError)
{
    match node.value {
        case ast::NodeValue::Ident(name) => {
            let sym = findAnySymbol(self.scope, name)

            throw emitError(self, node, ErrorKind::ExpectedIdentifier);
        }
    }
}

/// Join instance and method region parameters into one function binder.
unsafe fn instanceMethodRegions 'arena (
    self: &mut Resolver 'arena, instanceRegions: *[*ast::Node], methodRegions: *[*ast::Node]
) -> *[*ast::Node] {
    let count = instanceRegions.len + methodRegions.len;
    if count == 0 {
        return &[];
    }
    let allocator = alloc::arenaAllocator(self.arena);
    let mut nodes: *mut [*ast::Node] = &mut [];
    for region in instanceRegions {
        nodes.append(region, allocator);
    }
    for region in methodRegions {
        nodes.append(region, allocator);
    }
    return &nodes[..];
}

/// Map one region binder to a contiguous part of another binder.
unsafe fn mapRegionScopes 'arena (
    self: &mut Resolver 'arena, source: ?*RegionScope, target: ?*RegionScope,
    offset: u32, site: *ast::Node
) -> ?RegionSubstitution throws (ResolveError) {
    let sourceScope = source else return nil;
    let targetScope = target else throw emitError(self, site, ErrorKind::Internal);
    if offset + sourceScope.entries.len > targetScope.entries.len {
        throw emitError(self, site, ErrorKind::RegionArgumentCount(CountMismatch {
            expected: sourceScope.entries.len,
            actual: targetScope.entries.len - offset,
        }));
    }
    let map = regionSubstitution(self, sourceScope);
    for _, i in sourceScope.entries {
        set map.arguments[i] = targetScope.entries[offset + i];
    }
    try validateRegionArguments(self, &map, site);
    return map;
}

/// Resolved implementation of one trait method.
record ResolvedInstanceMethod: Copy {
    /// Canonical trait method.
    method: *unsafe TraitMethod,
    /// Concrete function symbol.
    symbol: *unsafe mut Symbol,
}

/// Shared declaration state for instance method resolution.
record InstanceMethodContext: Copy {
    /// Implemented trait.
    traitInfo: *unsafe TraitType,
    /// Instance target with declaration regions applied.
    concreteType: Type,
    /// Instance region nodes in declaration order.
    regions: *[*ast::Node],
    /// Bound instance region scope.
    scope: ?*RegionScope,
}

/// Resolve one instance method in its combined region environment.
unsafe fn resolveInstanceMethod 'arena (
    self: &mut Resolver 'arena, methodNode: *ast::Node,
    context: &InstanceMethodContext
) -> ResolvedInstanceMethod throws (ResolveError) {
    let case ast::NodeValue::MethodDecl {
        name, modifiers, receiverType, sig, ..
    } = methodNode.value else panic "resolveInstanceMethod: invalid method";
    let combinedRegions = instanceMethodRegions(self, context.regions, modifiers.regions);
    let methodScope = try bindRegions(self, methodNode, combinedRegions);
    set self.regionScope = methodScope;

    let methodName = try nodeName(self, name);
    let attrMask = resolveAttributes(modifiers.attrs);
    let tm = findTraitMethod(context.traitInfo, methodName)
        else throw emitError(self, name, ErrorKind::UnresolvedSymbol(methodName));
    if ast::hasAttribute(attrMask, ast::Attribute::Unsafe) <> tm.fnType.isUnsafe {
        throw emitError(self, methodNode, ErrorKind::TraitMethodSafetyMismatch);
    }

    let case ast::NodeValue::TypeSig(ast::TypeSig::Pointer {
        class: receiverSyntax, valueType, mutable: receiverMut,
    }) = receiverType.value else throw emitError(self, receiverType, ErrorKind::TraitReceiverMismatch);
    let receiverClass = resolvePointerClass(receiverSyntax);
    if receiverClass <> tm.receiverClass {
        throw emitError(self, receiverType, ErrorKind::TraitReceiverMismatch);
    }
    let annotatedTy = try infer(self, valueType);
    let mut expectedConcrete = context.concreteType;
    if let map = try mapRegionScopes(self, context.scope, methodScope, 0, methodNode) {
        set expectedConcrete = substituteRegions(self, &map, context.concreteType);
    }
    if not typesEqual(annotatedTy, expectedConcrete) {
        throw emitTypeMismatch(self, receiverType, TypeMismatch { expected: expectedConcrete, actual: annotatedTy });
    }
    if tm.mutable and not receiverMut {
        throw emitError(self, receiverType, ErrorKind::ImmutableBinding);
    }
    if receiverMut and not tm.mutable {
        throw emitError(self, receiverType, ErrorKind::ReceiverMutabilityMismatch);
    }

    let mut traitFn = tm.fnType;
    let mut traitRegionCount: u32 = 0;
    if let traitScope = tm.fnType.regions {
        set traitRegionCount = traitScope.entries.len;
    }
    if traitRegionCount <> modifiers.regions.len {
        throw emitError(self, methodNode, ErrorKind::RegionArgumentCount(CountMismatch {
            expected: traitRegionCount, actual: modifiers.regions.len,
        }));
    }
    if let map = try mapRegionScopes(self, tm.fnType.regions, methodScope, context.regions.len, methodNode) {
        set traitFn = substituteFnRegions(self, &map, tm.fnType, nil);
    }
    if sig.params.len <> traitFn.paramTypes.len {
        throw emitError(self, methodNode, ErrorKind::FnArgCountMismatch(CountMismatch {
            expected: traitFn.paramTypes.len, actual: sig.params.len,
        }));
    }

    let allocator = alloc::arenaAllocator(self.arena);
    let mut paramTypes: *mut [*Type] = &mut [];
    let receiverPtrType = Type::Pointer {
        class: receiverClass, target: allocType(self, annotatedTy), mutable: receiverMut,
    };
    paramTypes.append(allocType(self, receiverPtrType), allocator);
    for paramNode, i in sig.params {
        let case ast::NodeValue::FnParam(param) = paramNode.value
            else throw emitError(self, paramNode, ErrorKind::ExpectedIdentifier);
        let instanceParamTy = try resolveValueType(self, param.type);
        if not typesEqual(instanceParamTy, *traitFn.paramTypes[i]) {
            throw emitTypeMismatch(self, paramNode, TypeMismatch {
                expected: *traitFn.paramTypes[i], actual: instanceParamTy,
            });
        }
        paramTypes.append(allocType(self, instanceParamTy), allocator);
    }
    let mut returnType = Type::Void;
    if let returnNode = sig.returnType {
        set returnType = try resolveValueType(self, returnNode);
    }
    if not typesEqual(returnType, *traitFn.returnType) {
        throw emitTypeMismatch(self, methodNode, TypeMismatch {
            expected: *traitFn.returnType, actual: returnType,
        });
    }
    if sig.throwList.len <> traitFn.throwList.len {
        throw emitError(self, methodNode, ErrorKind::FnThrowCountMismatch(CountMismatch {
            expected: traitFn.throwList.len, actual: sig.throwList.len,
        }));
    }
    let mut throwList: *mut [*Type] = &mut [];
    for throwNode, i in sig.throwList {
        let throwType = try resolveValueType(self, throwNode);
        if not typesEqual(throwType, *traitFn.throwList[i]) {
            throw emitTypeMismatch(self, throwNode, TypeMismatch {
                expected: *traitFn.throwList[i], actual: throwType,
            });
        }
        throwList.append(allocType(self, throwType), allocator);
    }

    let fnType = FnType {
        regions: methodScope, paramTypes: &paramTypes[..],
        returnType: allocType(self, returnType), throwList: &throwList[..],
        isUnsafe: tm.fnType.isUnsafe,
    };
    let fnTy = Type::Fn(allocFnType(self, fnType));
    let sym = allocSymbol(self, SymbolData::Value {
        mutable: false, alignment: 0, type: fnTy, addressTaken: false,
    }, methodName, methodNode, attrMask);
    setNodeSymbol(self, methodNode, sym);
    setNodeType(self, methodNode, fnTy);
    setNodeType(self, name, fnTy);
    set self.regionScope = context.scope;
    return ResolvedInstanceMethod { method: tm, symbol: sym };
}

/// Resolve an instance declaration.
/// Validates that the trait exists, the target type exists, and all methods
/// match the trait's signatures.
unsafe fn resolveInstanceDecl(
    self: &mut Resolver,
unsafe fn resolveInstanceDecl 'arena (
    self: &mut Resolver 'arena,
    node: *ast::Node,
    traitName: *ast::Node,
    targetType: *ast::Node,
    regions: *[*ast::Node],
    methods: *[*ast::Node]
) throws (ResolveError) {
    let previous = self.regionScope;
    set self.regionScope = try bindRegions(self, node, regions);
    try resolveInstanceContents(self, node, traitName, targetType, regions, methods) catch error {
        set self.regionScope = previous;
        throw error;
    };
    set self.regionScope = previous;
}

/// Resolve an instance in its declaration region environment.
unsafe fn resolveInstanceContents 'arena (
    self: &mut Resolver 'arena,
    node: *ast::Node,
    traitName: *ast::Node,
    targetType: *ast::Node,
    regions: *[*ast::Node],
    methods: *[*ast::Node]
) throws (ResolveError) {
    let instanceScope = self.regionScope;
    // Look up the trait.
    let traitSym = try resolveNamePath(self, traitName);
    let case SymbolData::Trait(traitInfo) = traitSym.data
        else throw emitError(self, traitName, ErrorKind::Internal);


    setNodeSymbol(self, targetType, typeSym);
    // Ensure the concrete type body is resolved.
    try ensureNominalResolved(self, nominalTy, targetType);

    // Reject duplicate instance for the same (trait, type) pair.
    let concreteType = Type::Nominal(nominalTy);
    let mut concreteInfo = nominalTy;
    if regions.len > 0 {
        set concreteInfo = try applyNominalRegions(self, nominalTy, regions, targetType);
    } else {
        try requireNominalArguments(self, nominalTy, targetType);
    }
    let concreteType = Type::Nominal(concreteInfo);
    if let _ = findInstance(self, traitInfo, concreteType) {
        throw emitError(self, node, ErrorKind::DuplicateInstance);
    }

    // Build the instance entry.
    if self.instancesLen >= MAX_INSTANCES {
        throw emitError(self, node, ErrorKind::Internal);
    }
    let methodSlice = try! alloc::allocRawSlice(
        &mut self.arena, @sizeOf(*unsafe mut Symbol), @alignOf(*unsafe mut Symbol), traitInfo.methods.len as u32
        self.arena, @sizeOf(*unsafe mut Symbol), @alignOf(*unsafe mut Symbol), traitInfo.methods.len as u32
    ) as *unsafe mut [*unsafe mut Symbol];
    let mut entry = InstanceEntry {
        traitType: traitInfo,
        concreteType,
        concreteTypeName: typeSym.name,
        moduleId: self.currentMod,
        methods: methodSlice,
    };
    // Track which trait methods are covered by the instance.
    let mut covered: [bool; ast::MAX_TRAIT_METHODS] = [false; ast::MAX_TRAIT_METHODS];
    let methodContext = InstanceMethodContext {
        traitInfo, concreteType, regions, scope: instanceScope,
    };

    // Match each instance method to a trait method.
    for methodNode in methods {
        let case ast::NodeValue::MethodDecl {
            name, receiverName, receiverType, sig, body, attrs,
        } = methodNode.value else continue;

        let methodName = try nodeName(self, name);
        let attrMask = resolveAttributes(self, attrs);

        // Find the matching trait method.
        let tm = findTraitMethod(traitInfo, methodName)
            else throw emitError(self, name, ErrorKind::UnresolvedSymbol(methodName));
        let instanceUnsafe = ast::hasAttribute(attrMask, ast::Attribute::Unsafe);
        if instanceUnsafe <> tm.fnType.isUnsafe {
            throw emitError(self, methodNode, ErrorKind::TraitMethodSafetyMismatch);
        }

        // Determine receiver mutability and validate receiver type.
        // The receiver must be `*Type` or `*mut Type`.
        let case ast::NodeValue::TypeSig(typeSig) = receiverType.value
            else throw emitError(self, receiverType, ErrorKind::TraitReceiverMismatch);
        let case ast::TypeSig::Pointer {
            class: receiverClass, valueType, mutable: receiverMut,
        } = typeSig
            else throw emitError(self, receiverType, ErrorKind::TraitReceiverMismatch);
        if receiverClass <> tm.receiverClass {
            throw emitError(self, receiverType, ErrorKind::TraitReceiverMismatch);
        }

        // Validate that the receiver type annotation matches the
        // concrete type from the instance declaration.
        let annotatedTy = try infer(self, valueType);
        if not typesEqual(annotatedTy, concreteType) {
            throw emitTypeMismatch(self, receiverType, TypeMismatch {
                expected: concreteType,
                actual: annotatedTy,
            });
        }

        // Check receiver mutability matches in both directions.
        if tm.mutable and not receiverMut {
            throw emitError(self, receiverType, ErrorKind::ImmutableBinding);
        }
        if receiverMut and not tm.mutable {
            throw emitError(self, receiverType, ErrorKind::ReceiverMutabilityMismatch);
        }

        // Build the function type for the instance method.
        // The receiver becomes the first parameter.
        let receiverPtrType = Type::Pointer {
            class: receiverClass,
            target: allocType(self, concreteType),
            mutable: receiverMut,
        };

        // Validate that the instance method's signature matches the
        // trait method's signature exactly (params, return type, throws).
        if sig.params.len <> tm.fnType.paramTypes.len {
            throw emitError(self, methodNode, ErrorKind::FnArgCountMismatch(CountMismatch {
                expected: tm.fnType.paramTypes.len as u32,
                actual: sig.params.len,
            }));
        }
        for paramNode, j in sig.params {
            let case ast::NodeValue::FnParam(param) = paramNode.value
                else throw emitError(self, paramNode, ErrorKind::ExpectedIdentifier);
            let instanceParamTy = try resolveValueType(self, param.type);
            if not typesEqual(instanceParamTy, *tm.fnType.paramTypes[j]) {
                throw emitTypeMismatch(self, paramNode, TypeMismatch {
                    expected: *tm.fnType.paramTypes[j],
                    actual: instanceParamTy,
                });
            }
        }
        let mut instanceRetTy = Type::Void;
        if let retNode = sig.returnType {
            set instanceRetTy = try resolveValueType(self, retNode);
        }
        if not typesEqual(instanceRetTy, *tm.fnType.returnType) {
            throw emitTypeMismatch(self, methodNode, TypeMismatch {
                expected: *tm.fnType.returnType,
                actual: instanceRetTy,
            });
        }
        if sig.throwList.len <> tm.fnType.throwList.len {
            throw emitError(self, methodNode, ErrorKind::FnThrowCountMismatch(CountMismatch {
                expected: tm.fnType.throwList.len as u32,
                actual: sig.throwList.len,
            }));
        }
        for throwNode, j in sig.throwList {
            let instanceThrowTy = try resolveValueType(self, throwNode);
            if not typesEqual(instanceThrowTy, *tm.fnType.throwList[j]) {
                throw emitTypeMismatch(self, throwNode, TypeMismatch {
                    expected: *tm.fnType.throwList[j],
                    actual: instanceThrowTy,
                });
            }
        }

        // Build final function type: receiver plus trait's canonical types.
        let a = alloc::arenaAllocator(&mut self.arena);
        // TODO: Improve this pattern, maybe via something like `(&[]).append(..)`?
        let mut paramTypes: *mut [*Type] = &mut [];
        paramTypes.append(allocType(self, receiverPtrType), a);

        for ty in tm.fnType.paramTypes {
            paramTypes.append(ty, a);
        }
        let fnType = FnType {
            paramTypes: &paramTypes[..],
            returnType: tm.fnType.returnType,
            throwList: tm.fnType.throwList,
            isUnsafe: tm.fnType.isUnsafe,
        };

        // Create a symbol for the instance method without binding it into the
        // module scope. Instance methods are dispatched via v-table, so they
        // must not pollute the enclosing scope.
        let fnTy = Type::Fn(allocFnType(self, fnType));
        let mName = try nodeName(self, name);
        let sym = allocSymbol(self, SymbolData::Value {
            mutable: false, alignment: 0, type: fnTy, addressTaken: false,
        }, mName, methodNode, attrMask);

        setNodeSymbol(self, methodNode, sym);
        setNodeType(self, methodNode, fnTy);
        setNodeType(self, name, fnTy);

        // Store in instance entry at the matching v-table slot.
        set entry.methods[tm.index] = sym;
        set covered[tm.index] = true;
        let resolved = try resolveInstanceMethod(
            self, methodNode, &methodContext
        );
        set entry.methods[resolved.method.index] = resolved.symbol;
        set covered[resolved.method.index] = true;
    }

    // Fill inherited method slots from supertrait instances.
    for superTrait in traitInfo.supertraits {
        let superInst = findInstance(self, superTrait, concreteType)


    setNodeType(self, node, Type::Void);
}

/// Resolve instance method bodies.
unsafe fn resolveInstanceMethodBodies(self: &mut Resolver, methods: *[*ast::Node])
unsafe fn resolveInstanceMethodBodies 'arena (self: &mut Resolver 'arena, methods: *[*ast::Node])
    throws (ResolveError)
{
    for methodNode in methods {
        let case ast::NodeValue::MethodDecl {
            name, receiverName, receiverType, sig, body, ..
        } = methodNode.value else continue;
        let case ast::NodeValue::MethodDecl { .. } = methodNode.value else continue;

        // Symbol may be absent if [`resolveInstanceDecl`] reported an error
        // for this method (eg. unknown method name). Skip gracefully.
        let sym = symbolFor(self, methodNode)
            else continue;
        if symbolFor(self, methodNode) == nil {
            continue;
        }

        try resolveMethodBody(self, methodNode, receiverName, sig, body);
        try resolveMethodBody(self, methodNode);
    }
}

/// Resolve a method body shared by instance methods and standalone methods.
/// Binds the receiver and parameters, then type-checks the body.
unsafe fn resolveMethodBody(
    self: &mut Resolver,
unsafe fn resolveMethodBody 'arena (
    self: &mut Resolver 'arena,
    node: *ast::Node,
    receiverName: *ast::Node,
    sig: ast::FnSig,
    body: *ast::Node,
) throws (ResolveError) {
    let case ast::NodeValue::MethodDecl { receiverName, sig, body, .. } = node.value
        else panic "resolveMethodBody: invalid method";
    let sym = symbolFor(self, node)
        else throw emitError(self, node, ErrorKind::Internal);
    let case SymbolData::Value { type: Type::Fn(fnType), .. } = sym.data
        else panic "resolveMethodBody: expected value symbol";
    try resolveExecutableBody(self, node, fnType, receiverName, sig.params, body);
    let previous = self.regionScope;
    set self.regionScope = fnType.regions;
    try resolveExecutableBody(self, node, fnType, receiverName, sig.params, body) catch error {
        set self.regionScope = previous;
        throw error;
    };
    set self.regionScope = previous;
}

/// Resolve a standalone method declaration (signature only).
/// Validates the receiver type and registers the method in the method table.

/// Extract the type name from a resolved receiver type node.
unsafe fn receiverTypeName(
    self: &mut Resolver,
unsafe fn receiverTypeName 'arena (
    self: &mut Resolver 'arena,
    receiverType: *ast::Node,
) -> *[u8] throws (ResolveError) {
    let case ast::NodeValue::TypeSig(ast::TypeSig::Pointer { valueType, .. }) =
        receiverType.value
        else throw emitError(self, receiverType, ErrorKind::TraitReceiverMismatch);
    let case ast::NodeValue::TypeSig(ast::TypeSig::Nominal(nameNode)) = valueType.value
        else throw emitError(self, receiverType, ErrorKind::Internal);
    let mut nameNode: *ast::Node = valueType;
    match valueType.value {
        case ast::NodeValue::TypeSig(ast::TypeSig::Nominal(name)) => set nameNode = name,
        case ast::NodeValue::TypeSig(ast::TypeSig::Applied { name, .. }) => set nameNode = name,
        else => throw emitError(self, receiverType, ErrorKind::Internal),
    }
    let sym = symbolFor(self, nameNode)
        else throw emitError(self, receiverType, ErrorKind::Internal);

    return sym.name;
}

/// Resolve and register a standalone method declaration.
unsafe fn resolveMethodDecl(
    self: &mut Resolver,
unsafe fn resolveMethodDecl 'arena (
    self: &mut Resolver 'arena,
    node: *ast::Node,
) throws (ResolveError) {
    let case ast::NodeValue::MethodDecl { modifiers, .. } = node.value
        else panic "resolveMethodDecl: invalid method";
    let previous = self.regionScope;
    set self.regionScope = try bindRegions(self, node, modifiers.regions);
    try resolveMethodSignature(self, node) catch error {
        set self.regionScope = previous;
        throw error;
    };
    set self.regionScope = previous;
}

/// Resolve a standalone method signature in its region environment.
unsafe fn resolveMethodSignature 'arena (
    self: &mut Resolver 'arena,
    node: *ast::Node,
    name: *ast::Node,
    receiverName: *ast::Node,
    receiverType: *ast::Node,
    sig: ast::FnSig,
    attrs: ?ast::Attributes,
) throws (ResolveError) {
    let case ast::NodeValue::MethodDecl {
        name, modifiers, receiverType, sig, ..
    } = node.value else panic "resolveMethodSignature: invalid method";
    // Resolve the receiver type: must be `*Type` or `*mut Type` pointing to a
    // nominal type.
    let fullReceiverTy = try infer(self, receiverType);
    let case Type::Pointer {
        class: receiverClass, target: receiverTarget, mutable: receiverMut,

    try ensureNominalResolved(self, nominalTy, receiverType);

    // Get the type name from the inner type node's symbol.
    let typeName = try receiverTypeName(self, receiverType);
    let methodName = try nodeName(self, name);
    let attrMask = resolveAttributes(self, attrs);
    let attrMask = resolveAttributes(modifiers.attrs);

    // Reject duplicate method for the same (type, name).
    if let _ = findMethod(self, concreteType, methodName) {
        throw emitError(self, name, ErrorKind::DuplicateBinding(methodName));
    }

    // Resolve parameter types.
    let a = alloc::arenaAllocator(&mut self.arena);
    let a = alloc::arenaAllocator(self.arena);
    let mut paramTypes: *mut [*Type] = &mut [];

    // Receiver is the first parameter.
    let receiverPtrType = Type::Pointer {
        class: receiverClass,


    // Resolve throw list.
    let mut throwTypes: *mut [*Type] = &mut [];
    for throwNode in sig.throwList {
        let throwTy = try resolveValueType(self, throwNode);
        try validateErrorTag(self, throwNode, throwTy, &throwTypes[..]);
        throwTypes.append(allocType(self, throwTy), a);
    }

    let retTypePtr = allocType(self, returnType);
    let throwList = &throwTypes[..];

    let isUnsafe = ast::hasAttribute(attrMask, ast::Attribute::Unsafe);
    // Full function type (receiver + params) for lowering.
    let fullFnType = FnType {
        regions: self.regionScope,
        paramTypes: &paramTypes[..],
        returnType: retTypePtr,
        throwList,
        isUnsafe,
    };
    let fnTy = Type::Fn(allocFnType(self, fullFnType));

    // Function type excluding receiver, for call arg checking.
    let checkFnType = FnType {
        regions: self.regionScope,
        paramTypes: &paramTypes[1..],
        returnType: retTypePtr,
        throwList,
        isUnsafe,
    };

    };
    set self.methodsLen += 1;
}

/// Look up an instance entry by trait and concrete type.
unsafe fn findInstance(self: &Resolver, traitInfo: *unsafe TraitType, concreteType: Type) -> ?*unsafe InstanceEntry {
unsafe fn findInstance 'arena (self: &Resolver 'arena, traitInfo: *unsafe TraitType, concreteType: Type) -> ?*unsafe InstanceEntry {
    for i in 0..self.instancesLen {
        let entry: *unsafe InstanceEntry = &self.instances[i];
        if entry.traitType == traitInfo and typesEqual(entry.concreteType, concreteType) {
        if entry.traitType == traitInfo and erasedTypesEqual(entry.concreteType, concreteType) {
            return entry;
        }
    }
    return nil;
}

/// Look up a standalone method by concrete type and name.
export unsafe fn findMethod(self: &Resolver, concreteType: Type, name: *[u8]) -> ?*unsafe MethodEntry {
export unsafe fn findMethod 'arena (self: &Resolver 'arena, concreteType: Type, name: *[u8]) -> ?*unsafe MethodEntry {
    for i in 0..self.methodsLen {
        let entry: *unsafe MethodEntry = &self.methods[i];
        if typesEqual(entry.concreteType, concreteType) and entry.name == name {
        if erasedTypesEqual(entry.concreteType, concreteType) and entry.name == name {
            return entry;
        }
    }
    return nil;
}

/// Look up a standalone method entry by its symbol.
export unsafe fn findMethodBySymbol(self: &Resolver, sym: *unsafe mut Symbol) -> ?*unsafe MethodEntry {
export unsafe fn findMethodBySymbol 'arena (self: &Resolver 'arena, sym: *unsafe mut Symbol) -> ?*unsafe MethodEntry {
    for i in 0..self.methodsLen {
        let entry: *unsafe MethodEntry = &self.methods[i];
        if entry.symbol == sym {
            return entry;
        }
    }
    return nil;
}

/// Resolve union variant types after all type names are bound (Phase 2 of type resolution).
unsafe fn resolveUnionBody(self: &mut Resolver, node: *ast::Node, decl: ast::UnionDecl)
unsafe fn resolveUnionBody 'arena (self: &mut Resolver 'arena, node: *ast::Node, decl: ast::UnionDecl)
    throws (ResolveError)
{
    let previous = self.regionScope;
    set self.regionScope = try bindRegions(self, node, decl.regions);
    try resolveUnionContents(self, node, decl) catch error {
        set self.regionScope = previous;
        throw error;
    };
    set self.regionScope = previous;
}

/// Resolve union contents in the declaration's region environment.
unsafe fn resolveUnionContents 'arena (self: &mut Resolver 'arena, node: *ast::Node, decl: ast::UnionDecl)
    throws (ResolveError)
{
    // Get the type symbol that was bound to this declaration node.
    // If there's no symbol, it's because an earlier phase failed.
    let sym = symbolFor(self, node)

    // Check if already resolved, in which case there's no need to
    // do it again.
    if let case NominalType::Union(_) = *nominalTy {
        return;
    }
    let a = alloc::arenaAllocator(&mut self.arena);
    let a = alloc::arenaAllocator(self.arena);
    let mut variants: *unsafe mut [UnionVariant] = &mut [];

    // Create a temporary nominal type to replace the placeholder.This prevents infinite recursion
    // when a variant references this union type (e.g. record payloads with `*[Self]`).
    // TODO: It would be best to have a resolving state eg. `Visiting` for this situation.
    let markers = try resolveOwnershipMarkers(self, decl.derives);
    set *nominalTy = NominalType::Union(UnionType {
        variants: &[],
        layout: Layout { size: 0, alignment: 0 },
        valOffset: 0,
        isAllVoid: true,
        declaredLinear: markers.linear,
        declaredCopy: markers.copy,
    });
    set *nominalTy = NominalType::Resolving(node);

    assert decl.variants.len <= MAX_UNION_VARIANTS, "resolveUnionBody: maximum union variants exceeded";
    let mut iota: u32 = 0;
    for variantNode, i in decl.variants {
        let case ast::NodeValue::UnionDeclVariant(variantDecl) = variantNode.value

        // Resolve the variant's payload type if present.
        let mut variantType = Type::Void;
        if let typeNode = variantDecl.type {
            set variantType = try infer(self, typeNode);
            try ensureStorableType(self, typeNode, variantType);
            try ensureTypeResolved(self, variantType, typeNode);
        }
        // Process the variant's explicit discriminant value if present.
        try visitOptional(self, variantDecl.value, variantType);
        let tag = variantTag(variantDecl, &mut iota);
        // Create a symbol for this variant.

    }
    let info = computeUnionLayout(&variants[..]);

    // Update the nominal type with the resolved variants.
    set *nominalTy = NominalType::Union(UnionType {
        regions: self.regionScope,
        application: nil,
        variants: &variants[..],
        layout: info.layout,
        layout: allocLayout(self, info.layout),
        valOffset: info.valOffset,
        isAllVoid: info.isAllVoid,
        declaredLinear: markers.linear,
        declaredCopy: markers.copy,
    });
}

/// Check if a module should be analyzed based on its attributes and build configuration.
fn shouldAnalyzeModule(self: &Resolver, attrs: ?ast::Attributes) -> bool {
/// Check whether an attributed module or import is active in this build.
/// A test module is active only when its source module was registered.
unsafe fn shouldAnalyzeModule 'arena (self: &Resolver 'arena, attrs: ?ast::Attributes, name: ?*[u8]) -> bool {
    if let attributes = attrs {
        // Skip test modules unless we're building in test mode.
        if ast::attributesContains(&attributes, ast::Attribute::Test) and not self.config.buildTest {
            return false;
        if ast::attributesContains(&attributes, ast::Attribute::Test) {
            if not self.config.buildTest {
                return false;
            }
            if let moduleName = name {
                return module::findChild(self.moduleGraph, moduleName, self.currentMod) <> nil;
            }
        }
    }
    return true;
}

/// Analyze a module during the graph analysis phase.
unsafe fn resolveModGraph(self: &mut Resolver, node: *ast::Node, decl: ast::Mod)
unsafe fn resolveModGraph 'arena (self: &mut Resolver 'arena, node: *ast::Node, decl: ast::Mod)
    throws (ResolveError)
{
    if not shouldAnalyzeModule(self, decl.attrs) {
    let modName = try nodeName(self, decl.name);
    if not shouldAnalyzeModule(self, decl.attrs, modName) {
        return;
    }
    let modName = try nodeName(self, decl.name);
    let attrMask = resolveAttributes(self, decl.attrs);
    let attrMask = resolveAttributes(decl.attrs);
    try ensureDefaultAttrNotAllowed(self, node, attrMask);
    let submod = try enterSubModule(self, modName, node);

    // Bind the module symbol in the outer scope, ie. where the `mod` statement is.
    try bindModuleIdent(self, submod.entry, submod.newScope, submod.root, attrMask, submod.prevScope);


    exitModuleScope(self, submod);
}

/// Analyze a module in the declaration phase.
unsafe fn resolveModDecl(self: &mut Resolver, node: *ast::Node, decl: ast::Mod)
unsafe fn resolveModDecl 'arena (self: &mut Resolver 'arena, node: *ast::Node, decl: ast::Mod)
    throws (ResolveError)
{
    if not shouldAnalyzeModule(self, decl.attrs) {
        return;
    }
    // Find module under the current module.
    let modName = try nodeName(self, decl.name);
    if not shouldAnalyzeModule(self, decl.attrs, modName) {
        return;
    }
    let submod = try enterSubModule(self, modName, node);
    let case ast::NodeValue::Block(block) = submod.root.value
        else panic "resolveModDecl: expected block for module root";
    try resolveModuleDecls(self, &block);

    exitModuleScope(self, submod);
}

/// Analyze a `use` statement and create a symbol for the imported module.
unsafe fn resolveUse(self: &mut Resolver, node: *ast::Node, decl: ast::Use) -> Type
unsafe fn resolveUse 'arena (self: &mut Resolver 'arena, node: *ast::Node, decl: ast::Use) -> Type
    throws (ResolveError)
{
    if not shouldAnalyzeModule(self, decl.attrs, nil) {
        return Type::Void;
    }
    let resolved = try resolveModulePath(self, decl.path);
    let attrMask = resolveAttributes(self, decl.attrs);
    let attrMask = resolveAttributes(decl.attrs);

    if decl.wildcard {
        // Import all public symbols from the target module.
        for i in 0..resolved.scope.symbolsLen {
            let sym = resolved.scope.symbols[i];

    }
    return Type::Void;
}

/// Analyze a standard `if` statement.
unsafe fn resolveIf(self: &mut Resolver, node: *ast::Node, cond: ast::If) -> Type
unsafe fn resolveIf 'arena (self: &mut Resolver 'arena, node: *ast::Node, cond: ast::If) -> Type
    throws (ResolveError)
{
    try checkBoolean(self, cond.condition);
    let thenTy = try visit(self, cond.thenBranch, Type::Void);
    let elseTy = try visitOptional(self, cond.elseBranch, Type::Void);

    return setNodeType(self, node, unifyBranches(thenTy, elseTy));
}

/// Analyze a conditional expression.
unsafe fn resolveCondExpr(self: &mut Resolver, node: *ast::Node, cond: ast::CondExpr) -> Type
unsafe fn resolveCondExpr 'arena (self: &mut Resolver 'arena, node: *ast::Node, cond: ast::CondExpr, hint: Type) -> Type
    throws (ResolveError)
{
    try checkBoolean(self, cond.condition);
    let thenTy = try infer(self, cond.thenExpr);
    let elseTy = try infer(self, cond.elseExpr);
    let thenValue = try visit(self, cond.thenExpr, hint);
    let thenTy = assignableValueType(self, cond.thenExpr, thenValue);
    let elseValue = try visit(self, cond.elseExpr, hint);
    let elseTy = assignableValueType(self, cond.elseExpr, elseValue);

    // Either branch may supply the concrete type for an otherwise context-
    // dependent expression, such as an unsuffixed integer or `nil`.
    if let coercion = isAssignable(self, thenTy, elseTy, cond.elseExpr) {
        setNodeCoercion(self, cond.elseExpr, coercion);


    return setNodeType(self, node, thenTy);
}

/// Analyze a pattern match structure (used by if-let, while-let).
unsafe fn resolvePatternMatch(self: &mut Resolver, node: *ast::Node, pat: &ast::PatternMatch)
unsafe fn resolvePatternMatch 'arena (self: &mut Resolver 'arena, node: *ast::Node, pat: &ast::PatternMatch)
    throws (ResolveError)
{
    match pat.kind {
        case ast::PatternKind::Case => {
            // Analyze pattern against scrutinee type.

        try checkBoolean(self, guard);
    }
}

/// Analyze an `if let` or `if let case` pattern binding.
unsafe fn resolveIfLet(self: &mut Resolver, node: *ast::Node, cond: ast::IfLet) -> Type
unsafe fn resolveIfLet 'arena (self: &mut Resolver 'arena, node: *ast::Node, cond: ast::IfLet) -> Type
    throws (ResolveError)
{
    enterScope(self, node);
    try resolvePatternMatch(self, node, &cond.pattern);



/// Analyze a case pattern for match, if-case, let-case, or while-case.
///
/// At the top level, bare identifiers are compared against existing values.
/// Inside destructuring patterns (arrays, records), identifiers become bindings.
unsafe fn resolveCasePattern(
    self: &mut Resolver,
unsafe fn resolveCasePattern 'arena (
    self: &mut Resolver 'arena,
    pattern: *ast::Node,
    scrutineeTy: Type,
    mode: IdentMode,
    matchBy: MatchBy
) throws (ResolveError) {

                    return;
                }
                case NominalType::Record(recInfo) => {
                    match pattern.value {
                        case ast::NodeValue::Call(_), ast::NodeValue::RecordLit(_) => {
                            try bindRecordPatternFields(self, pattern, recInfo, matchBy);
                            try resolveRecordPattern(self, pattern, scrutineeTy, recInfo, matchBy);
                            return;
                        } else => {}
                    }
                } else => {}
            }

        }
    }
}

/// Analyze a traditional `while` loop.
unsafe fn resolveWhile(self: &mut Resolver, node: *ast::Node, loopNode: ast::While) -> Type
unsafe fn resolveWhile 'arena (self: &mut Resolver 'arena, node: *ast::Node, loopNode: ast::While) -> Type
    throws (ResolveError)
{
    try checkBoolean(self, loopNode.condition);
    let loopTy = try visitLoop(self, loopNode.body);
    try visitOptional(self, loopNode.elseBranch, Type::Void);

    }
    return setNodeType(self, node, Type::Void);
}

/// Analyze a `while let` loop with pattern binding.
unsafe fn resolveWhileLet(self: &mut Resolver, node: *ast::Node, loopNode: ast::WhileLet) -> Type
unsafe fn resolveWhileLet 'arena (self: &mut Resolver 'arena, node: *ast::Node, loopNode: ast::WhileLet) -> Type
    throws (ResolveError)
{
    enterScope(self, node);
    try resolvePatternMatch(self, node, &loopNode.pattern);



    return setNodeType(self, node, Type::Void);
}

/// Analyze a `for` loop, binding iteration variables.
unsafe fn resolveFor(self: &mut Resolver, node: *ast::Node, forStmt: ast::For) -> Type
unsafe fn resolveFor 'arena (self: &mut Resolver 'arena, node: *ast::Node, forStmt: ast::For) -> Type
    throws (ResolveError)
{
    let iterableTy = try infer(self, forStmt.iterable);

    // Extract binding names for the lowerer.


/// Check whether a pattern contains nested sub-patterns that further
/// refine the match beyond the outer variant (e.g. nested union variant
/// tests or literal comparisons). Used to allow the same outer variant
/// to appear in multiple match arms.
fn hasNestedRefiningPattern(self: &Resolver, pattern: *ast::Node) -> bool {
fn hasNestedRefiningPattern 'arena (self: &Resolver 'arena, pattern: *ast::Node) -> bool {
    for i in 0..patternSubCount(pattern) {
        if let sub = patternSubElement(pattern, i) {
            if isRefiningPattern(self, sub) {
                return true;
            }


/// Check whether a single pattern node is a refining pattern that tests
/// a value rather than just binding it. Union variants, literals, and
/// scope accesses are refining; identifiers, placeholders, and plain
/// record destructurings are not.
fn isRefiningPattern(self: &Resolver, pattern: *ast::Node) -> bool {
fn isRefiningPattern 'arena (self: &Resolver 'arena, pattern: *ast::Node) -> bool {
    match pattern.value {
        case ast::NodeValue::Ident(_), ast::NodeValue::Placeholder =>
            return false,
        case ast::NodeValue::RecordLit(_), ast::NodeValue::Call(_) => {
            if let keyNode = patternVariantKeyNode(pattern) {

    return true;
}

/// Analyze a match prong, checking for duplicate catch-alls. Returns the
/// unified match type.
unsafe fn resolveMatchProng(
    self: &mut Resolver,
unsafe fn resolveMatchProng 'arena (
    self: &mut Resolver 'arena,
    prongNode: *ast::Node,
    prong: ast::MatchProng,
    subjectTy: Type,
    state: &mut MatchState,
    matchType: Type,

    return try visitMatchProng(self, prongNode, prong, subjectTy, matchType, matchBy);
}

/// Analyze a `match` expression. Dispatches to specialized functions based on
/// the subject type.
unsafe fn resolveMatch(self: &mut Resolver, node: *ast::Node, sw: ast::Match) -> Type
unsafe fn resolveMatch 'arena (self: &mut Resolver 'arena, node: *ast::Node, sw: ast::Match) -> Type
    throws (ResolveError)
{
    let subjectTy = try infer(self, sw.subject);
    if isUnsafePointerType(subjectTy) {
        try requireUnsafe(self, sw.subject);

    if let case Type::Optional(inner) = subject.effectiveTy {
        try resolveMatchOptional(self, node, sw, inner, subject.by);
    } else if let case Type::Nominal(NominalType::Union(u)) = subject.effectiveTy {
        try resolveMatchUnion(self, node, sw, subject.effectiveTy, u, subject.by);
    } else {
        try resolveMatchGeneric(self, node, sw, subject.effectiveTy);
        try resolveMatchGeneric(self, node, sw, subject.effectiveTy, subject.by);
    }

    // Mark last non-guarded prong as exhaustive.
    let lastProng = sw.prongs[sw.prongs.len - 1];
    let case ast::NodeValue::MatchProng(p) = lastProng.value

    };
    return ty;
}

/// Analyze a `match` expression on an optional subject.
unsafe fn resolveMatchOptional(
    self: &mut Resolver,
unsafe fn resolveMatchOptional 'arena (
    self: &mut Resolver 'arena,
    node: *ast::Node,
    sw: ast::Match,
    innerTy: *Type,
    matchBy: MatchBy
) -> Type throws (ResolveError)

    }
    return setNodeType(self, node, matchType);
}

/// Analyze a `match` expression on a union subject.
unsafe fn resolveMatchUnion(
    self: &mut Resolver,
unsafe fn resolveMatchUnion 'arena (
    self: &mut Resolver 'arena,
    node: *ast::Node,
    sw: ast::Match,
    subjectTy: Type,
    info: UnionType,
    matchBy: MatchBy

    return setNodeType(self, node, matchType);
}

/// Analyze a `match` expression on a generic subject type. Requires exhaustiveness:
/// booleans must cover both `true` and `false`, other types require a catch-all.
unsafe fn resolveMatchGeneric(self: &mut Resolver, node: *ast::Node, sw: ast::Match, subjectTy: Type) -> Type
unsafe fn resolveMatchGeneric 'arena (self: &mut Resolver 'arena, node: *ast::Node, sw: ast::Match, subjectTy: Type, matchBy: MatchBy) -> Type
    throws (ResolveError)
{
    let prongs = sw.prongs;
    let mut state = MatchState { catchAll: false, isConst: true };
    let mut matchType = Type::Never;

    for prongNode in prongs {
        let case ast::NodeValue::MatchProng(prong) = prongNode.value
            else panic "resolveMatchGeneric: expected match prong";

        set matchType = try resolveMatchProng(
            self, prongNode, prong, subjectTy, &mut state, matchType, MatchBy::Value
            self, prongNode, prong, subjectTy, &mut state, matchType, matchBy
        );
        // Track boolean coverage. Guarded prongs don't count as covering.
        if let case ast::ProngArm::Case(patterns) = prong.arm {
            for p in patterns {
                if prong.guard == nil {


    return setNodeType(self, node, matchType);
}

/// Analyze a single `match` prong branch. Returns the unified match type.
unsafe fn visitMatchProng(
    self: &mut Resolver,
unsafe fn visitMatchProng 'arena (
    self: &mut Resolver 'arena,
    node: *ast::Node,
    prongNode: ast::MatchProng,
    subjectTy: Type,
    matchType: Type,
    matchBy: MatchBy


    return unifyBranches(matchType, prongTy);
}

/// Analyze the contents of a `match` prong while inside the prong scope.
unsafe fn resolveMatchProngBody(
    self: &mut Resolver,
unsafe fn resolveMatchProngBody 'arena (
    self: &mut Resolver 'arena,
    prong: ast::MatchProng,
    subjectTy: Type,
    matchBy: MatchBy
) -> Type throws (ResolveError) {
    match prong.arm {

    }
    return try visit(self, prong.body, Type::Void);
}

/// Ensure a scope access pattern references a compatible union variant.
unsafe fn resolveUnionScopePattern(
    self: &mut Resolver,
unsafe fn resolveUnionScopePattern 'arena (
    self: &mut Resolver 'arena,
    pattern: *ast::Node,
    access: ast::Access,
    subjectTy: Type,
    unionType: UnionType
) throws (ResolveError) {

        throw emitError(self, pattern, ErrorKind::UnionVariantPayloadMissing(variant.name));
    }
}

/// Validate and bind a union constructor call used as a `match` pattern.
unsafe fn resolveUnionCallPattern(
    self: &mut Resolver,
unsafe fn resolveUnionCallPattern 'arena (
    self: &mut Resolver 'arena,
    pattern: *ast::Node,
    call: ast::Call,
    subjectTy: Type,
    unionType: UnionType,
    matchBy: MatchBy

        throw emitError(self, pattern, ErrorKind::UnionVariantPayloadUnexpected(variant.name));
    }
}

/// Bind the payload introduced by a union constructor pattern.
unsafe fn bindUnionPatternPayload(
    self: &mut Resolver,
unsafe fn bindUnionPatternPayload 'arena (
    self: &mut Resolver 'arena,
    pattern: *ast::Node,
    call: ast::Call,
    variantName: *[u8],
    payloadTy: Type,
    matchBy: MatchBy

        throw emitError(
            self, pattern, ErrorKind::UnionVariantPayloadMissing(variantName)
        );
    }
    // All variant payloads are records.
    try ensureTypeResolved(self, payloadTy, pattern);
    let recInfo = getRecord(payloadTy)
        else panic "bindUnionPatternPayload: payload is not a record";

    try bindRecordPatternFields(self, pattern, recInfo, matchBy);
}

/// Bind a pattern variable. For ref matches, wraps the type in a pointer.
unsafe fn bindPatternVar(self: &mut Resolver, binding: *ast::Node, ty: Type, matchBy: MatchBy)
unsafe fn bindPatternVar 'arena (self: &mut Resolver 'arena, binding: *ast::Node, ty: Type, matchBy: MatchBy)
    throws (ResolveError)
{
    let mut bindTy = ty;
    match matchBy {
        case MatchBy::Value => {}

            try resolveCasePattern(self, binding, ty, IdentMode::Bind, matchBy);
        }
    }
}

/// Check a record pattern's exact nominal type before binding its fields.
unsafe fn resolveRecordPattern 'arena (
    self: &mut Resolver 'arena, pattern: *ast::Node, subjectTy: Type, body: RecordType, matchBy: MatchBy
) throws (ResolveError) {
    let mut name: ?*ast::Node = nil;
    match pattern.value {
        case ast::NodeValue::Call(call) => set name = call.callee,
        case ast::NodeValue::RecordLit(lit) => set name = lit.typeName,
        else => panic "resolveRecordPattern: expected record pattern",
    }
    if let typeName = name {
        let actual = try visit(self, typeName, subjectTy);
        let symbol = symbolFor(self, typeName) else throw emitError(self, typeName, ErrorKind::ExpectedRecord);
        let case SymbolData::Type(_) = symbol.data else throw emitError(self, typeName, ErrorKind::ExpectedRecord);
        if not typesEqual(actual, subjectTy) {
            throw emitTypeMismatch(self, typeName, TypeMismatch { expected: subjectTy, actual });
        }
    }
    setNodeType(self, pattern, subjectTy);
    try bindRecordPatternFields(self, pattern, body, matchBy);
}

/// Bind record pattern fields to variables in the current scope.
unsafe fn bindRecordPatternFields(
    self: &mut Resolver,
unsafe fn bindRecordPatternFields 'arena (
    self: &mut Resolver 'arena,
    pattern: *ast::Node,
    recInfo: RecordType,
    matchBy: MatchBy
) throws (ResolveError) {
    match pattern.value {

        else => throw emitError(self, pattern, ErrorKind::Internal)
    }
}

/// Validate and bind a record literal pattern for matching labeled union variants.
unsafe fn resolveUnionRecordPattern(
    self: &mut Resolver,
unsafe fn resolveUnionRecordPattern 'arena (
    self: &mut Resolver 'arena,
    pattern: *ast::Node,
    lit: ast::RecordLit,
    subjectTy: Type,
    unionType: UnionType,
    matchBy: MatchBy

    setVariantInfo(self, pattern, index, tag);

    if variant.valueType == Type::Void {
        throw emitError(self, pattern, ErrorKind::UnionVariantPayloadUnexpected(variant.name));
    }
    try ensureTypeResolved(self, variant.valueType, pattern);
    let recInfo = getRecord(variant.valueType)
        else panic "resolveUnionRecordPattern: payload is not a record";

    try bindRecordPatternFields(self, pattern, recInfo, matchBy);
}

/// Analyze a pattern appearing in a union case.
unsafe fn resolveUnionPattern(
    self: &mut Resolver,
unsafe fn resolveUnionPattern 'arena (
    self: &mut Resolver 'arena,
    pattern: *ast::Node,
    subjectTy: Type,
    unionType: UnionType,
    matchBy: MatchBy
) throws (ResolveError) {

    }
    return false;
}

/// Analyze a `let-else` guard.
unsafe fn resolveLetElse(self: &mut Resolver, node: *ast::Node, letElse: ast::LetElse) -> Type
unsafe fn resolveLetElse 'arena (self: &mut Resolver 'arena, node: *ast::Node, letElse: ast::LetElse) -> Type
    throws (ResolveError)
{
    let pat = letElse.pattern;
    let exprTy = try infer(self, pat.scrutinee);


    }
    return setNodeType(self, node, Type::Void);
}

/// Analyze builtin function calls like `@sizeOf(T)` and `@alignOf(T)`.
unsafe fn resolveBuiltinCall(
    self: &mut Resolver,
unsafe fn resolveBuiltinCall 'arena (
    self: &mut Resolver 'arena,
    node: *ast::Node,
    kind: ast::Builtin,
    args: *[*ast::Node]
) -> Type throws (ResolveError) {
    // Handle `@sliceOf(ptr, len)` and `@sliceOf(ptr, len, cap)`.

        negative: false,
    }));
    return setNodeType(self, node, Type::U32);
}

/// Validate call arguments against a function type: check argument count,
/// type-check each argument, and verify that throwing functions use `try`.
unsafe fn checkCallArgs(self: &mut Resolver, node: *ast::Node, call: ast::Call, info: *FnType, ctx: CallCtx)
    throws (ResolveError)
{
    if ctx == CallCtx::Normal and info.throwList.len > 0 {
        throw emitError(self, node, ErrorKind::MissingTry);
/// Allocate an initially empty argument map for a region-parameterized signature.
unsafe fn regionSubstitution 'arena (self: &mut Resolver 'arena, parameters: *RegionScope) -> RegionSubstitution {
    let count = parameters.entries.len;
    let arguments = try! alloc::allocRawSlice(
        self.arena, @sizeOf(?*unsafe types::Region), @alignOf(?*unsafe types::Region), count
    ) as *unsafe mut [?*unsafe types::Region];
    for i in 0..count {
        set arguments[i] = nil;
    }
    if call.args.len <> info.paramTypes.len as u32 {
        throw emitError(self, node, ErrorKind::FnArgCountMismatch(CountMismatch {
            expected: info.paramTypes.len as u32,
            actual: call.args.len,
        }));
    return RegionSubstitution { parameters, arguments };
}

/// Find the position of a region in a substitution's declared parameter list.
unsafe fn regionParameter(map: &RegionSubstitution, region: *unsafe types::Region) -> ?u32 {
    for parameter, i in map.parameters.entries {
        if parameter.id == region.id {
            return i;
        }
    }
    for argNode, i in call.args {
        let expectedTy = *info.paramTypes[i];
    return nil;
}

        try checkAssignable(self, argNode, expectedTy);
/// Infer one region argument from a pair of reference classes.
unsafe fn inferRegionClass 'arena (
    self: &mut Resolver 'arena, map: &RegionSubstitution,
    expected: types::PointerClass, actual: types::PointerClass, site: *ast::Node
) throws (ResolveError) {
    let case types::PointerClass::Region(parameter) = expected else return;
    let index = regionParameter(map, parameter) else return;
    let case types::PointerClass::Region(argument) = actual
        else throw emitError(self, site, ErrorKind::RegionInference(parameter.name));
    if let previous = map.arguments[index]; previous.id <> argument.id {
        throw emitError(self, site, ErrorKind::RegionInference(parameter.name));
    }
    set map.arguments[index] = argument;
}

/// Analyze a function call expression.
unsafe fn resolveCall(self: &mut Resolver, node: *ast::Node, call: ast::Call, ctx: CallCtx) -> Type
    throws (ResolveError)
/// Infer regions through matching type structure without adding lifetime subtyping.
unsafe fn inferRegionArguments 'arena (
    self: &mut Resolver 'arena, map: &RegionSubstitution, expected: Type, actual: Type, site: *ast::Node
) throws (ResolveError) {
    match expected {
        case Type::Cell { class, payload } => {
            let case Type::Cell { class: otherClass, payload: other } = actual else return;
            try inferRegionClass(self, map, class, otherClass, site);
            try inferRegionArguments(self, map, *payload, *other, site);
        }
        case Type::Session(region) => {
            let case Type::Session(other) = actual else return;
            try inferRegionClass(self, map, types::PointerClass::Region(region),
                types::PointerClass::Region(other), site);
        }
        case Type::Pointer { class, target, .. } => {
            let case Type::Pointer { class: otherClass, target: otherTarget, .. } = actual else return;
            try inferRegionClass(self, map, class, otherClass, site);
            try inferRegionArguments(self, map, *target, *otherTarget, site);
        }
        case Type::Slice { class, item, .. } => {
            let case Type::Slice { class: otherClass, item: otherItem, .. } = actual else return;
            try inferRegionClass(self, map, class, otherClass, site);
            try inferRegionArguments(self, map, *item, *otherItem, site);
        }
        case Type::TraitObject { class, .. } => {
            if let case Type::TraitObject { class: otherClass, .. } = actual {
                try inferRegionClass(self, map, class, otherClass, site);
            }
        }
        case Type::Array(array) => {
            if let case Type::Array(other) = actual {
                try inferRegionArguments(self, map, *array.item, *other.item, site);
            }
        }
        case Type::Optional(inner) => {
            if let case Type::Optional(other) = actual {
                try inferRegionArguments(self, map, *inner, *other, site);
            } else {
                try inferRegionArguments(self, map, *inner, actual, site);
            }
        }
        case Type::Fn(info) => {
            let case Type::Fn(other) = actual else return;
            if info.paramTypes.len <> other.paramTypes.len or info.throwList.len <> other.throwList.len {
                return;
            }
            for parameter, i in info.paramTypes {
                try inferRegionArguments(self, map, *parameter, *other.paramTypes[i], site);
            }
            for error, i in info.throwList {
                try inferRegionArguments(self, map, *error, *other.throwList[i], site);
            }
            try inferRegionArguments(self, map, *info.returnType, *other.returnType, site);
        }
        case Type::Nominal(info) => {
            let applied = nominalApplication(info) else return;
            let case Type::Nominal(otherInfo) = actual else return;
            let other = nominalApplication(otherInfo) else return;
            if applied.base <> other.base {
                return;
            }
            for region, i in applied.arguments {
                try inferRegionClass(self, map, types::PointerClass::Region(region),
                    types::PointerClass::Region(other.arguments[i]), site);
            }
        }
        else => {
        }
    }
}

/// Require a total substitution whose arguments satisfy each parent relation.
unsafe fn validateRegionArguments 'arena (self: &mut Resolver 'arena, map: &RegionSubstitution, site: *ast::Node)
    throws (ResolveError)
{
    for parameter, i in map.parameters.entries {
        if map.arguments[i] == nil {
            throw emitError(self, site, ErrorKind::RegionInference(parameter.name));
        }
    }
    for parameter, i in map.parameters.entries {
        let parent = parameter.parent else continue;
        let index = regionParameter(map, parent) else panic "validateRegionArguments: unknown parent";
        let parentArgument = map.arguments[index] else panic "validateRegionArguments: missing parent argument";
        let argument = map.arguments[i] else panic "validateRegionArguments: missing argument";
        if not types::regionContains(parentArgument, argument) {
            throw emitError(self, site, ErrorKind::RegionParent(parameter.name));
        }
    }
}

/// Substitute a reference's region while preserving its ownership class.
unsafe fn substituteRegionClass(map: &RegionSubstitution, class: types::PointerClass) -> types::PointerClass {
    let case types::PointerClass::Region(region) = class else return class;
    let index = regionParameter(map, region) else return class;
    let argument = map.arguments[index] else panic "substituteRegionClass: missing argument";
    return types::PointerClass::Region(argument);
}

/// Substitute free region arguments in a type without changing its runtime layout.
unsafe fn substituteRegions 'arena (self: &mut Resolver 'arena, map: &RegionSubstitution, ty: Type) -> Type {
    match ty {
        case Type::Cell { class, payload } =>
            return Type::Cell { class: substituteRegionClass(map, class), payload: allocType(self, substituteRegions(self, map, *payload)) },
        case Type::Session(region) => {
            let index = regionParameter(map, region) else return ty;
            let argument = map.arguments[index] else panic "substituteRegions: missing session region";
            return Type::Session(argument);
        }
        case Type::Pointer { class, target, mutable } => {
            let targetType = substituteRegions(self, map, *target);
            return Type::Pointer { class: substituteRegionClass(map, class), target: allocType(self, targetType), mutable };
        }
        case Type::Slice { class, item, mutable } => {
            let itemType = substituteRegions(self, map, *item);
            return Type::Slice { class: substituteRegionClass(map, class), item: allocType(self, itemType), mutable };
        }
        case Type::TraitObject { class, traitInfo, mutable } =>
            return Type::TraitObject { class: substituteRegionClass(map, class), traitInfo, mutable },
        case Type::Array(array) => {
            let itemType = substituteRegions(self, map, *array.item);
            return Type::Array(ArrayType { item: allocType(self, itemType), length: array.length });
        }
        case Type::Optional(inner) => {
            let innerType = substituteRegions(self, map, *inner);
            return Type::Optional(allocType(self, innerType));
        }
        case Type::Fn(info) => return Type::Fn(substituteFnRegions(self, map, info, info.regions)),
        case Type::Nominal(info) => {
            let applied = nominalApplication(info) else return ty;
            let arguments = regionSubstitution(self, applied.parameters);
            for region, i in applied.arguments {
                let class = substituteRegionClass(map, types::PointerClass::Region(region));
                let case types::PointerClass::Region(argument) = class else panic;
                set arguments.arguments[i] = argument;
            }
            return Type::Nominal(internNominalApplication(self, applied.base, &arguments));
        }
        else => return ty,
    }
}

/// Create a substituted signature with the specified remaining region binder.
unsafe fn substituteFnRegions 'arena (
    self: &mut Resolver 'arena, map: &RegionSubstitution, info: *FnType, regions: ?*RegionScope
) -> *FnType {
    let a = alloc::arenaAllocator(self.arena);
    let mut paramTypes: *mut [*Type] = &mut [];
    let mut throwList: *mut [*Type] = &mut [];
    for parameter in info.paramTypes {
        let ty = substituteRegions(self, map, *parameter);
        paramTypes.append(allocType(self, ty), a);
    }
    for error in info.throwList {
        let ty = substituteRegions(self, map, *error);
        throwList.append(allocType(self, ty), a);
    }
    let returnType = substituteRegions(self, map, *info.returnType);
    return allocFnType(self, FnType {
        regions,
        paramTypes: &paramTypes[..],
        returnType: allocType(self, returnType),
        throwList: &throwList[..],
        isUnsafe: info.isUnsafe,
    });
}

/// Preserve a call-scoped pointer class while inferring its region-bearing contents.
/// Named reference regions are inferred from the source storage.
unsafe fn regionInputHint 'arena (self: &mut Resolver 'arena, expected: Type) -> Type {
    if let case Type::Optional(inner) = expected {
        return regionInputHint(self, *inner);
    }
    match expected {
        case Type::Pointer { class, mutable, .. } => {
            if let case types::PointerClass::Region(_) = class {
                return Type::Unknown;
            }
            return Type::Pointer { class, target: allocType(self, Type::Unknown), mutable };
        }
        case Type::Slice { class, mutable, .. } => {
            if let case types::PointerClass::Region(_) = class {
                return Type::Unknown;
            }
            return Type::Slice { class, item: allocType(self, Type::Unknown), mutable };
        }
        else => return Type::Unknown,
    }
}

/// Infer a source function's region arguments from its call inputs.
unsafe fn instantiateCall 'arena (self: &mut Resolver 'arena, node: *ast::Node, call: ast::Call, info: *FnType) -> *FnType
    throws (ResolveError)
{
    let parameters = info.regions else return info;
    if call.args.len <> info.paramTypes.len {
        throw emitError(self, node, ErrorKind::FnArgCountMismatch(CountMismatch {
            expected: info.paramTypes.len, actual: call.args.len,
        }));
    }
    let map = regionSubstitution(self, parameters);
    for argument, i in call.args {
        let expected = *info.paramTypes[i];
        if containsRegion(expected) {
            let actual = try visit(self, argument, regionInputHint(self, expected));
            try inferRegionArguments(self, &map, expected, actual, argument);
        }
    }
    try validateRegionArguments(self, &map, node);
    return substituteFnRegions(self, &map, info, nil);
}

/// Infer a method's region arguments from its receiver and call arguments.
unsafe fn instantiateMethodCall 'arena (
    self: &mut Resolver 'arena, node: *ast::Node, call: ast::Call,
    receiver: *ast::Node, receiverType: Type, method: *unsafe MethodEntry
) -> *FnType throws (ResolveError) {
    let parameters = method.fnType.regions else return method.fnType;
    if call.args.len <> method.fnType.paramTypes.len {
        throw emitError(self, node, ErrorKind::FnArgCountMismatch(CountMismatch {
            expected: method.fnType.paramTypes.len, actual: call.args.len,
        }));
    }
    let map = regionSubstitution(self, parameters);
    try inferRegionArguments(self, &map, method.concreteType, receiverType, receiver);
    for argument, i in call.args {
        let expected = *method.fnType.paramTypes[i];
        if containsRegion(expected) {
            let actual = try visit(self, argument, regionInputHint(self, expected));
            try inferRegionArguments(self, &map, expected, actual, argument);
        }
    }
    try validateRegionArguments(self, &map, node);
    return substituteFnRegions(self, &map, method.fnType, nil);
}

/// Apply explicit current-scope regions to a function or nominal type.
unsafe fn resolveRegionApply 'arena (
    self: &mut Resolver 'arena, node: *ast::Node, value: *ast::Node, regions: *[*ast::Node]
) -> Type throws (ResolveError) {
    let ty = try infer(self, value);
    if let case Type::Nominal(base) = ty {
        let symbol = symbolFor(self, value) else throw emitError(self, node, ErrorKind::CannotInferType);
        let case SymbolData::Type(_) = symbol.data else throw emitError(self, node, ErrorKind::CannotInferType);
        let applied = try applyNominalRegions(self, base, regions, node);
        try ensureNominalResolved(self, applied, node);
        setNodeSymbol(self, node, symbol);
        return setNodeType(self, node, Type::Nominal(applied));
    }
    let case Type::Fn(info) = ty else throw emitError(self, node, ErrorKind::CannotInferType);
    let mut count: u32 = 0;
    if let scope = info.regions {
        set count = scope.entries.len;
    }
    if count <> regions.len {
        throw emitError(self, node, ErrorKind::RegionArgumentCount(CountMismatch { expected: count, actual: regions.len }));
    }
    let scope = info.regions else panic "resolveRegionApply: empty region application";
    let map = regionSubstitution(self, scope);
    for region, i in regions {
        set map.arguments[i] = try resolveRegion(self, region);
    }
    try validateRegionArguments(self, &map, node);
    let applied = substituteFnRegions(self, &map, info, nil);
    if let symbol = symbolFor(self, value) {
        setNodeSymbol(self, node, symbol);
    }
    return setNodeType(self, node, Type::Fn(applied));
}

/// Validate call arguments against a function type: check argument count,
/// type-check each argument, and verify that throwing functions use `try`.
unsafe fn checkCallArgs 'arena (self: &mut Resolver 'arena, node: *ast::Node, call: ast::Call, info: *FnType, ctx: CallCtx)
    throws (ResolveError)
{
    if ctx == CallCtx::Normal and info.throwList.len > 0 {
        throw emitError(self, node, ErrorKind::MissingTry);
    }
    if call.args.len <> info.paramTypes.len as u32 {
        throw emitError(self, node, ErrorKind::FnArgCountMismatch(CountMismatch {
            expected: info.paramTypes.len as u32,
            actual: call.args.len,
        }));
    }
    for argNode, i in call.args {
        let expectedTy = *info.paramTypes[i];

        try checkAssignable(self, argNode, expectedTy);
    }
}

/// Return whether a value can be discarded by bulk arena reclamation.
/// Pointer lifetimes are checked when their values are constructed.
unsafe fn isBulkDiscardable(ty: Type) -> bool {
    match ty {
        case Type::Void, Type::Bool, Type::U8, Type::U16, Type::U32, Type::U64,
             Type::I8, Type::I16, Type::I32, Type::I64, Type::Fn(_) => return true,
        case Type::Pointer { .. }, Type::Slice { .. }, Type::TraitObject { .. } => return true,
        case Type::Cell { .. } => return true,
        case Type::Array(array) => return isBulkDiscardable(*array.item),
        case Type::Optional(inner) => return isBulkDiscardable(*inner),
        case Type::Nominal(NominalType::Record(recordType)) => {
            if recordType.declaredLinear {
                return false;
            }
            for field in recordType.fields {
                if not isBulkDiscardable(field.fieldType) {
                    return false;
                }
            }
            return true;
        }
        case Type::Nominal(NominalType::Union(unionType)) => {
            if unionType.declaredLinear {
                return false;
            }
            for variant in unionType.variants {
                if not isBulkDiscardable(variant.valueType) {
                    return false;
                }
            }
            return true;
        }
        else => return false,
    }
}

/// Compute the end of an aligned layout within the allocator's byte-count range.
fn allocationLayoutEnd(offset: u64, layout: Layout) -> ?u64 {
    let mut aligned = offset;
    if layout.alignment > 0 {
        let mask = (layout.alignment - 1) as u64;
        set aligned = (offset + mask) & ~mask;
    }
    let end = aligned + layout.size as u64;
    if end > 4294967295 {
        return nil;
    }
    return end;
}

/// Check allocation layout arithmetic independently of the stored narrow offsets.
unsafe fn hasAllocationLayout(ty: Type) -> bool {
    let layout = getTypeLayout(ty);
    match ty {
        case Type::Cell { .. } => return true,
        case Type::Array(array) => {
            if not hasAllocationLayout(*array.item) {
                return false;
            }
            let item = getTypeLayout(*array.item);
            return item.size as u64 * array.length as u64 == layout.size as u64;
        }
        case Type::Optional(inner) => {
            if not hasAllocationLayout(*inner) {
                return false;
            }
            if isNullableType(*inner) {
                return true;
            }
            let end = allocationLayoutEnd(1, getTypeLayout(*inner)) else return false;
            let total = allocationLayoutEnd(end, Layout { size: 0, alignment: layout.alignment }) else return false;
            return total == layout.size as u64;
        }
        case Type::Nominal(NominalType::Record(recordType)) => {
            let mut offset: u64 = 0;
            for field in recordType.fields {
                if not hasAllocationLayout(field.fieldType) {
                    return false;
                }
                let fieldLayout = getTypeLayout(field.fieldType);
                let end = allocationLayoutEnd(offset, fieldLayout) else return false;
                let start = end - fieldLayout.size as u64;
                if start > 2147483647 or field.offset < 0 or start <> field.offset as u64 {
                    return false;
                }
                set offset = end;
            }
            let total = allocationLayoutEnd(offset, Layout { size: 0, alignment: layout.alignment }) else return false;
            return total == layout.size as u64;
        }
        case Type::Nominal(NominalType::Union(unionType)) => {
            let mut payloadSize: u32 = 0;
            let mut alignment: u32 = 1;
            for variant in unionType.variants {
                if not hasAllocationLayout(variant.valueType) {
                    return false;
                }
                let item = getTypeLayout(variant.valueType);
                set payloadSize = max(payloadSize, item.size);
                set alignment = max(alignment, item.alignment);
            }
            let end = allocationLayoutEnd(1, Layout { size: payloadSize, alignment }) else return false;
            let total = allocationLayoutEnd(end, Layout { size: 0, alignment }) else return false;
            return total == layout.size as u64 and end - payloadSize as u64 == unionType.valOffset as u64;
        }
        else => return true,
    }
}

/// Validate the reservation ABI used by typed session allocation.
unsafe fn sessionRuntime 'arena (
    self: &mut Resolver 'arena, node: *ast::Node, slice: bool
) -> *unsafe TraitMethod
    throws (ResolveError)
{
    let allocTrait = allocationSymbol(self, "Alloc")
        else throw emitError(self, node, ErrorKind::InvalidAllocationRuntime);
    let case SymbolData::Trait(allocInfo) = allocTrait.data
        else throw emitError(self, node, ErrorKind::InvalidAllocationRuntime);
    let name = "reserveSlice" if slice else "reserve";
    let method = findTraitMethod(allocInfo, name)
        else throw emitError(self, node, ErrorKind::InvalidAllocationRuntime);
    let error = allocationSymbol(self, "AllocError")
        else throw emitError(self, node, ErrorKind::InvalidAllocationRuntime);
    let case SymbolData::Type(errorType) = error.data
        else throw emitError(self, node, ErrorKind::InvalidAllocationRuntime);
    let count: u32 = 3 if slice else 2;
    let info = method.fnType;
    if info.regions <> nil or not info.isUnsafe or info.paramTypes.len <> count or info.throwList.len <> 1 {
        throw emitError(self, node, ErrorKind::InvalidAllocationRuntime);
    }
    if not typesEqual(*info.throwList[0], Type::Nominal(errorType)) {
        throw emitError(self, node, ErrorKind::InvalidAllocationRuntime);
    }
    for i in 0..count {
        if *info.paramTypes[i] <> Type::U32 {
            throw emitError(self, node, ErrorKind::InvalidAllocationRuntime);
        }
    }
    let expected = Type::Slice { class: types::PointerClass::Unsafe, item: allocType(self, Type::Opaque), mutable: true }
        if slice else Type::Pointer {
            class: types::PointerClass::Unsafe, target: allocType(self, Type::Opaque), mutable: true
        };
    if not typesEqual(*info.returnType, expected) {
        throw emitError(self, node, ErrorKind::InvalidAllocationRuntime);
    }
    return method;
}

/// Check initialized session allocation and retain its source region in the result.
unsafe fn resolveSessionAllocation 'arena (
    self: &mut Resolver 'arena, node: *ast::Node, call: ast::Call, access: ast::Access,
    region: *unsafe types::Region, ctx: CallCtx, hint: Type
) -> Type throws (ResolveError) {
    let name = try nodeName(self, access.child);
    let mut kind = SessionAllocationKind::New;
    if mem::eq(name, "copy") {
        set kind = SessionAllocationKind::Copy;
    }
    else if mem::eq(name, "fill") {
        set kind = SessionAllocationKind::Fill;
    }
    else if not mem::eq(name, "new") {
        throw emitError(self, access.child, ErrorKind::UnresolvedSymbol(name));
    }
    let count: u32 = 2 if kind == SessionAllocationKind::Fill else 1;
    if call.args.len <> count {
        throw emitError(self, node, ErrorKind::FnArgCountMismatch(CountMismatch { expected: count, actual: call.args.len }));
    }
    let slice = kind <> SessionAllocationKind::New;
    let mut itemHint = Type::Unknown;
    if kind == SessionAllocationKind::New {
        if let case Type::Pointer { target, .. } = hint {
            set itemHint = *target;
        }
    } else if kind == SessionAllocationKind::Fill {
        if let case Type::Slice { item, .. } = hint {
            set itemHint = *item;
        }
    } else {
        set itemHint = Type::Slice {
            class: types::PointerClass::Ref, item: allocType(self, Type::Unknown), mutable: false,
        };
    }
    let valueType = try visit(self, call.args[0], itemHint);
    let mut itemType = valueType;
    let mut parameter = valueType;
    if kind == SessionAllocationKind::Copy {
        let case Type::Slice { item, .. } = valueType
            else throw emitError(self, call.args[0], ErrorKind::ExpectedIndexable);
        set itemType = *item;
        set parameter = Type::Slice { class: types::PointerClass::Ref, item, mutable: false };
    }
    if not isTypeInferrable(itemType) or itemType == Type::Void or itemType == Type::Opaque {
        throw emitError(self, call.args[0], ErrorKind::CannotInferType);
    }
    try ensureStorableType(self, call.args[0], itemType);
    try ensureTypeResolved(self, itemType, call.args[0]);
    try validateRegionStorage(self, call.args[0], itemType, region);
    if not isBulkDiscardable(itemType) or (slice and not isCopy(itemType)) {
        throw emitError(self, call.args[0], ErrorKind::InvalidAllocationValue);
    }
    if not hasAllocationLayout(itemType) {
        throw emitError(self, call.args[0], ErrorKind::InvalidAllocationLayout);
    }
    let runtime = try sessionRuntime(self, node, slice);
    let runtimeType = runtime.fnType;
    let item = allocType(self, itemType);
    let result = Type::Slice { class: types::PointerClass::Region(region), item, mutable: true }
        if slice else Type::Pointer {
            class: types::PointerClass::Region(region), target: item, mutable: true
        };
    let a = alloc::arenaAllocator(self.arena);
    let mut parameters: *mut [*Type] = &mut [];
    parameters.append(allocType(self, parameter), a);
    if kind == SessionAllocationKind::Fill {
        parameters.append(allocType(self, Type::U32), a);
    }
    let info = allocFnType(self, FnType {
        regions: nil, paramTypes: &parameters[..], returnType: allocType(self, result),
        throwList: runtimeType.throwList, isUnsafe: false,
    });
    try checkCallArgs(self, node, call, info, ctx);
    setNodeType(self, call.callee, Type::Fn(info));
    let allocTrait = allocationSymbol(self, "Alloc") else panic;
    let case SymbolData::Trait(traitInfo) = allocTrait.data else panic;
    set self.nodeData.entries[node.id].extra = NodeExtra::SessionAllocation(SessionAllocation {
        kind, item, traitInfo, methodIndex: runtime.index,
    });
    return setNodeType(self, node, result);
}

/// Return whether a nominal declaration explicitly derives Copy.
fn nominalDeclaresCopy(node: *ast::Node) -> bool {
    let mut derives: *[*ast::Node] = &[];
    match node.value {
        case ast::NodeValue::RecordDecl(decl) => set derives = decl.derives,
        case ast::NodeValue::UnionDecl(decl) => set derives = decl.derives,
        else => return false,
    }
    for derive in derives {
        if let case ast::NodeValue::Ident(name) = derive.value {
            if mem::eq(name, "Copy") {
                return true;
            }
        }
    }
    return false;
}

/// Require a complete payload that can be copied and discarded by value.
unsafe fn validateCellPayload 'arena (self: &mut Resolver 'arena, node: *ast::Node, payload: Type) throws (ResolveError) {
    try ensureStorableType(self, node, payload);
    if let case Type::Nominal(info) = payload {
        let mut source = info;
        if let case NominalType::Application(applied) = *source {
            set source = applied.base;
        }
        if let case NominalType::Resolving(decl) = *source {
            if nominalDeclaresCopy(decl) {
                return;
            }
            throw emitError(self, node, ErrorKind::InvalidCellPayload);
        }
    }
    try ensureTypeResolved(self, payload, node);
    if not isTypeInferrable(payload) or payload == Type::Void or payload == Type::Opaque
        or not isCopy(payload) or not isBulkDiscardable(payload)
    {
        throw emitError(self, node, ErrorKind::InvalidCellPayload);
    }
    if not hasAllocationLayout(payload) {
        throw emitError(self, node, ErrorKind::InvalidAllocationLayout);
    }
}

/// Analyze a function call expression.
unsafe fn resolveCall 'arena (self: &mut Resolver 'arena, node: *ast::Node, call: ast::Call, ctx: CallCtx, hint: Type) -> Type
    throws (ResolveError)
{
    // Intercept method calls on slices before inferring the callee.
    if let case ast::NodeValue::FieldAccess(access) = call.callee.value {
        let parentTy = try infer(self, access.parent);
        if isUnsafePointerType(parentTy) {
            try requireUnsafe(self, access.parent);
        }
        let subjectTy = autoDeref(parentTy);
        if let case Type::Session(region) = subjectTy {
            return try resolveSessionAllocation(self, node, call, access, region, ctx, hint);
        }

        if let case Type::Slice { item, mutable, .. } = subjectTy {
            let methodName = try nodeName(self, access.child);
            if methodName == "append" {
                return try resolveSliceAppend(

                    self, node, access.parent, call.args, item, mutable
                );
            }
        }
    }
    let calleeTy = try infer(self, call.callee);
    let calleeTy = try visit(self, call.callee, hint);
    if let case Type::Fn(info) = calleeTy {
        try checkUnsafeCall(self, call.callee, info);
    }

    // Check if callee is a union variant and dispatch to constructor handler.
    // TODO: Move this out. We should decide on this earlier, based on the callee.
    if let calleeSym = symbolFor(self, call.callee) {
        if let case SymbolData::Variant { decl, .. } = calleeSym.data {
            // TODO: Don't pass the callee type, pass the union type by getting it from
            // the symbol.
            let declSym = symbolFor(self, decl) else panic;
            let case SymbolData::Type(ty) = declSym.data else panic;

            let case Type::Nominal(ty) = calleeTy else panic "resolveCall: invalid variant type";
            return try resolveUnionConstructorCall(self, node, call, ty);
        }
        // Check if callee is an unlabeled record type for constructor call syntax.
        if let case SymbolData::Type(ty) = calleeSym.data {
        if let case SymbolData::Type(_) = calleeSym.data {
            let case Type::Nominal(ty) = calleeTy else panic "resolveCall: invalid type callee";
            try requireNominalArguments(self, ty, call.callee);
            // Ensure the record body is resolved before checking if labeled.
            try ensureNominalResolved(self, ty, call.callee);
            if let case NominalType::Record(recInfo) = *ty {
                if not recInfo.labeled {
                    return try resolveRecordConstructorCall(self, node, call, ty);

            let methodName = try nodeName(self, access.child);
            let method = findTraitMethod(traitInfo, methodName)
                else throw emitError(self, access.child, ErrorKind::RecordFieldUnknown(methodName));

            // Reject mutable-receiver methods called on immutable trait objects.
            if method.mutable and not objMutable {
                throw emitError(self, access.parent, ErrorKind::ImmutableBinding);
            if method.mutable {
                if not objMutable or not try canMutateThrough(self, access.parent) {
                    throw emitError(self, access.parent, ErrorKind::ImmutableBinding);
                }
            }
            try checkCallArgs(self, node, call, method.fnType, ctx);
            let applied = try instantiateCall(self, node, call, method.fnType);
            try checkCallArgs(self, node, call, applied, ctx);
            setTraitMethodCall(self, node, traitInfo, method.index);

            return setNodeType(self, node, *method.fnType.returnType);
            return setNodeType(self, node, *applied.returnType);
        }

        // Check for a standalone method call on a concrete type.
        if let case Type::Nominal(_) = subjectTy {
            let methodName = try nodeName(self, access.child);

                    if not try canMutateThrough(self, access.parent) {
                        throw emitError(self, access.parent, ErrorKind::ImmutableBinding);
                    }
                }
                // Check arguments (excluding receiver).
                try checkCallArgs(self, node, call, method.fnType, ctx);
                let applied = try instantiateMethodCall(
                    self, node, call, access.parent, subjectTy, method
                );
                try checkCallArgs(self, node, call, applied, ctx);
                set self.nodeData.entries[node.id].extra = NodeExtra::MethodCall { method };

                return setNodeType(self, node, *method.fnType.returnType);
                return setNodeType(self, node, *applied.returnType);
            }
        }
    }
    let case Type::Fn(info) = calleeTy else {
        throw emitError(self, call.callee, ErrorKind::TypeMismatch(TypeMismatch {
            expected: Type::Unknown,
            actual: calleeTy,
        }));
    };
    try checkCallArgs(self, node, call, info, ctx);
    let applied = try instantiateCall(self, node, call, info);
    try checkCallArgs(self, node, call, applied, ctx);
    // Associate function type to callee.
    setNodeType(self, call.callee, calleeTy);
    setNodeType(self, call.callee, Type::Fn(applied));

    // Associate return type to call.
    return setNodeType(self, node, *info.returnType);
    return setNodeType(self, node, *applied.returnType);
}

/// Check the allocator layout and the callback ABI used by slice append.
unsafe fn isSliceAllocator(ty: Type) -> bool {
    let case Type::Nominal(NominalType::Record(rec)) = ty else return false;

        else return false;
    return class == types::PointerClass::Owned and mutable and *result == Type::Opaque;
}

/// Resolve `slice.append(val, allocator)`.
unsafe fn resolveSliceAppend(
    self: &mut Resolver,
unsafe fn resolveSliceAppend 'arena (
    self: &mut Resolver 'arena,
    node: *ast::Node,
    parent: *ast::Node,
    parentType: Type,
    args: *[*ast::Node],
    elemType: *Type,

    // Return the parent's type so the caller can rebind:
    return setNodeType(self, node, parentType);
}

/// Resolve `slice.delete(index)`.
unsafe fn resolveSliceDelete(
    self: &mut Resolver,
unsafe fn resolveSliceDelete 'arena (
    self: &mut Resolver 'arena,
    node: *ast::Node,
    parent: *ast::Node,
    args: *[*ast::Node],
    elemType: *Type,
    mutable: bool


    return setNodeType(self, node, Type::Void);
}

/// Analyze an assignment expression.
unsafe fn resolveAssign(self: &mut Resolver, node: *ast::Node, assign: ast::Assign) -> Type
unsafe fn resolveAssign 'arena (self: &mut Resolver 'arena, node: *ast::Node, assign: ast::Assign) -> Type
    throws (ResolveError)
{
    // Slice assignment: `slice[range] = value`.
    if let case ast::NodeValue::Subscript { container, index } = assign.left.value {
        if let case ast::NodeValue::Range(range) = index.value {

                    );
                }
            } else {
                try checkAssignable(self, assign.right, *item);
            }
            try validateRegionalStore(self, assign.left, assign.right, *item);
            setSliceRangeInfo(self, node, SliceRangeInfo { itemType: item, mutable: true, capacity });
            setNodeType(self, assign.left, *item);

            return setNodeType(self, node, Type::Void);
        }
    }
    let leftTy = try infer(self, assign.left);

    if let case ast::NodeValue::Deref(target) = assign.left.value {
        if let case Type::Cell { class, .. } = try infer(self, target) {
            try checkAssignable(self, assign.right, leftTy);
            if let case types::PointerClass::Region(region) = class {
                try validateRegionStorage(self, assign.right, leftTy, region);
            } else if class == types::PointerClass::Owned and containsRegion(leftTy) {
                throw emitError(self, assign.right, ErrorKind::InvalidCellPayload);
            }
            return setNodeType(self, node, leftTy);
        }
    }

    // Check if the left-hand side can be assigned to by checking if it's a mutable location.
    if not try canBorrowMutFrom(self, assign.left) {
        throw emitError(self, assign.left, ErrorKind::ImmutableBinding);
    }
    try checkAssignable(self, assign.right, leftTy);
    try validateRegionalStore(self, assign.left, assign.right, leftTy);

    return setNodeType(self, node, leftTy);
}

/// Ensure slice range bounds are valid `u32` values.
unsafe fn checkSliceRangeIndices(self: &mut Resolver, range: ast::Range) throws (ResolveError) {
unsafe fn checkSliceRangeIndices 'arena (self: &mut Resolver 'arena, range: ast::Range) throws (ResolveError) {
    if let start = range.start {
        try checkIndex(self, start);
    }
    if let end = range.end {
        try checkIndex(self, end);
    }
}

/// Emit an error when a slice range with compile-tyime values exceeds the array length.
unsafe fn validateArraySliceBounds(self: &mut Resolver, range: ast::Range, length: u32, site: *ast::Node) throws (ResolveError) {
unsafe fn validateArraySliceBounds 'arena (self: &mut Resolver 'arena, range: ast::Range, length: u32, site: *ast::Node) throws (ResolveError) {
    let mut startVal: ?u32 = nil;
    let mut endVal: ?u32 = length;

    if let startNode = range.start {
        if let val = constSliceIndex(self, startNode) {

}

/// Check that an index expression has an unsigned integer type.
/// Accepts `u8`, `u16`, `u32` and unsuffixed integer literals.
/// Smaller types are widened to `u32` via a numeric cast coercion.
unsafe fn checkIndex(self: &mut Resolver, indexNode: *ast::Node) throws (ResolveError) {
unsafe fn checkIndex 'arena (self: &mut Resolver 'arena, indexNode: *ast::Node) throws (ResolveError) {
    let indexTy = try visit(self, indexNode, Type::U32);
    if indexTy == Type::Int or indexTy == Type::U32 {
        let _ = try expectAssignable(self, Type::U32, indexTy, indexNode);
        return;
    }

        }
    }
}

/// Analyze an array or slice subscript expression.
unsafe fn resolveSubscript(self: &mut Resolver, node: *ast::Node, container: *ast::Node, indexNode: *ast::Node) -> Type
unsafe fn resolveSubscript 'arena (self: &mut Resolver 'arena, node: *ast::Node, container: *ast::Node, indexNode: *ast::Node) -> Type
    throws (ResolveError)
{
    // Range subscripts always require `&` to form a slice.
    if let case ast::NodeValue::Range(range) = indexNode.value {
        let _ = try infer(self, indexNode);

    }
    return nil;
}

/// Analyze a union constructor call with payload.
unsafe fn resolveUnionConstructorCall(self: &mut Resolver, node: *ast::Node, call: ast::Call, unionNominal: *unsafe NominalType) -> Type
unsafe fn resolveUnionConstructorCall 'arena (self: &mut Resolver 'arena, node: *ast::Node, call: ast::Call, unionNominal: *unsafe NominalType) -> Type
    throws (ResolveError)
{
    // Get the union nominal type.
    let case NominalType::Union(unionType) = *unionNominal
        else panic "resolveUnionConstructorCall: not a union type";

    setVariantInfo(self, node, index, tag);

    // Check if this variant expects a payload.
    let payloadType = variant.valueType;
    if payloadType <> Type::Void {
        try ensureTypeResolved(self, payloadType, node);
        let recInfo = getRecord(payloadType)
            else panic "resolveUnionVariantConstructor: payload is not a record";
        try checkRecordConstructorArgs(self, node, call.args, recInfo);
    } else {
        if call.args.len > 0 {

/// Analyze an unlabeled record constructor call.
///
/// Handles the syntax `R(a, b)` for unlabeled records, checking that the
/// number of arguments matches the record's field count and that each argument
/// is assignable to its corresponding field type.
unsafe fn resolveRecordConstructorCall(self: &mut Resolver, node: *ast::Node, call: ast::Call, recordType: *unsafe NominalType) -> Type
unsafe fn resolveRecordConstructorCall 'arena (self: &mut Resolver 'arena, node: *ast::Node, call: ast::Call, recordType: *unsafe NominalType) -> Type
    throws (ResolveError)
{
    let case NominalType::Record(recInfo) = *recordType
        else panic "resolveRecordConstructorCall: not a record type";


    return setNodeType(self, node, Type::Nominal(recordType));
}

/// Resolve the type name of a record literal, handling both record types and
/// union variant payloads like `Union::Variant { ... }`.
unsafe fn resolveRecordLitType(
    self: &mut Resolver, node: *ast::Node, typeIdent: *ast::Node
unsafe fn resolveRecordLitType 'arena (
    self: &mut Resolver 'arena, node: *ast::Node, typeIdent: *ast::Node, hint: Type
) -> ResolvedRecordLitType
    throws (ResolveError)
{
    if let case ast::NodeValue::RegionApply { .. } = typeIdent.value {
        let ty = try infer(self, typeIdent);
        let case Type::Nominal(info) = ty else throw emitError(self, node, ErrorKind::ExpectedRecord);
        return ResolvedRecordLitType { recordType: info, resultType: ty };
    }
    // Check if this is a scope access that might be a union variant.
    if let case ast::NodeValue::ScopeAccess(access) = typeIdent.value {
        let scope = self.scope;
        let sym = try resolveAccess(self, typeIdent, access, scope);

        // Check if resolved symbol is a union variant.
        if let case SymbolData::Variant { type, decl, ordinal, index } = sym.data {
            // Get the union type from the variant's declaration.
            let declSym = symbolFor(self, decl)
                else throw emitError(self, node, ErrorKind::Internal);
            let case SymbolData::Type(unionNominalType) = declSym.data
                else throw emitError(self, node, ErrorKind::Internal);

            // Get the variant's payload type.
            let case Type::Nominal(payloadInfo) = type
            let sourceTy = typeFor(self, typeIdent) else panic "resolveRecordLitType: missing union type";
            let case Type::Nominal(source) = sourceTy else panic "resolveRecordLitType: invalid union type";
            let unionNominalType = hintedNominal(source, hint);
            try requireNominalArguments(self, unionNominalType, typeIdent);
            try ensureNominalResolved(self, unionNominalType, typeIdent);
            let case NominalType::Union(body) = *unionNominalType else panic;
            let case Type::Nominal(payloadInfo) = body.variants[ordinal].valueType
                else throw emitError(self, node, ErrorKind::ExpectedRecord);

            // Store the variant index for the lowerer.
            setVariantInfo(self, node, ordinal, index);


        resultType: Type::Nominal(tyInfo),
    };
}

/// Analyze a record literal expression.
unsafe fn resolveRecordLit(self: &mut Resolver, node: *ast::Node, lit: ast::RecordLit, hint: Type) -> Type
unsafe fn resolveRecordLit 'arena (self: &mut Resolver 'arena, node: *ast::Node, lit: ast::RecordLit, hint: Type) -> Type
    throws (ResolveError)
{
    // If no type name, infer an anonymous tuple type.
    let typeIdent = lit.typeName else {
        return try resolveAnonRecordLit(self, node, lit, hint);
    };
    // Resolve the type name, handling both record types and union variants.
    let resolved = try resolveRecordLitType(self, node, typeIdent);
    let tyInfo = resolved.recordType;
    let resultType = resolved.resultType;
    let resolved = try resolveRecordLitType(self, node, typeIdent, hint);
    let mut tyInfo = resolved.recordType;
    let mut resultType = resolved.resultType;
    let mut target = hint;
    if let case Type::Optional(inner) = target {
        set target = *inner;
    }
    if nominalApplication(tyInfo) == nil {
        if let case Type::Nominal(info) = target {
            if let applied = nominalApplication(info); applied.base == tyInfo {
                set tyInfo = info;
                set resultType = target;
            }
        }
    }
    try requireNominalArguments(self, tyInfo, typeIdent);

    // Lazily resolve record body if not yet done.
    try ensureNominalResolved(self, tyInfo, typeIdent);
    let case NominalType::Record(recordType) = *tyInfo
        else throw emitError(self, node, ErrorKind::ExpectedRecord);

    }
    return setNodeType(self, node, resultType);
}

/// Analyze an anonymous record literal, checking fields against the hint type.
unsafe fn resolveAnonRecordLit(self: &mut Resolver, node: *ast::Node, lit: ast::RecordLit, hint: Type) -> Type
unsafe fn resolveAnonRecordLit 'arena (self: &mut Resolver 'arena, node: *ast::Node, lit: ast::RecordLit, hint: Type) -> Type
    throws (ResolveError)
{
    // Unwrap optional hint to get the inner record type.
    let mut innerHint = hint;
    if let case Type::Optional(inner) = hint {

    }
    return setNodeType(self, node, innerHint);
}

/// Analyze an array literal expression.
unsafe fn resolveArrayLit(self: &mut Resolver, node: *ast::Node, items: *[*ast::Node], hint: Type) -> Type
unsafe fn resolveArrayLit 'arena (self: &mut Resolver 'arena, node: *ast::Node, items: *[*ast::Node], hint: Type) -> Type
    throws (ResolveError)
{
    let length = items.len;
    let mut expectedTy: Type = Type::Unknown;


    let arrayTy = Type::Array(ArrayType { item: allocType(self, expectedTy), length });
    return setNodeType(self, node, arrayTy);
}

/// Analyze an array repeat literal expression.
unsafe fn resolveArrayRepeat(self: &mut Resolver, node: *ast::Node, lit: ast::ArrayRepeatLit, hint: Type) -> Type
unsafe fn resolveArrayRepeat 'arena (self: &mut Resolver 'arena, node: *ast::Node, lit: ast::ArrayRepeatLit, hint: Type) -> Type
    throws (ResolveError)
{
    let mut itemHint = hint;
    if let case Type::Array(ary) = hint {
        set itemHint = *ary.item;

    });
    return setNodeType(self, node, arrayTy);
}

/// Resolve union variant access.
unsafe fn resolveUnionVariantAccess(
    self: &mut Resolver,
unsafe fn resolveUnionVariantAccess 'arena (
    self: &mut Resolver 'arena,
    node: *ast::Node,
    access: ast::Access,
    unionType: UnionType,
    variantName: *[u8]
) -> *unsafe mut Symbol throws (ResolveError) {

    }
    throw emitError(self, access.child, ErrorKind::UnresolvedSymbol(variantName));
}

/// Analyze a scope access expression.
unsafe fn resolveScopeAccess(self: &mut Resolver, node: *ast::Node, access: ast::Access) -> Type
unsafe fn resolveScopeAccess 'arena (self: &mut Resolver 'arena, node: *ast::Node, access: ast::Access, hint: Type) -> Type
    throws (ResolveError)
{
    let scope = self.scope;
    let sym = try resolveAccess(self, node, access, scope);
    try checkStaticAccess(self, node, sym);

            setNodeSymbol(self, node, sym);
            set ty = type;
        }
        case SymbolData::Type(t) => {
            setNodeSymbol(self, node, sym);
            set ty = Type::Nominal(t);
            set ty = Type::Nominal(hintedNominal(t, hint));
        }
        case SymbolData::Variant { index, .. } => {
            let ty = typeFor(self, node)
                else throw emitError(self, node, ErrorKind::Internal);
            let case Type::Nominal(info) = ty else panic "resolveScopeAccess: invalid variant type";
            let applied = hintedNominal(info, hint);
            try requireNominalArguments(self, applied, node);
            try ensureNominalResolved(self, applied, node);
            let variantTy = Type::Nominal(applied);
            // For unions without payload, store the variant index as a constant.
            if isVoidUnion(ty) {
            if isVoidUnion(variantTy) {
                setNodeConstValue(self, node, ConstValue::Int(ConstInt {
                    magnitude: index as u64,
                    bits: 32,
                    signed: false,
                    negative: false,
                }));
            }
            return setNodeType(self, node, ty);
            return setNodeType(self, node, variantTy);
        }
        case SymbolData::Module { .. } => {
            throw emitError(self, node, ErrorKind::UnexpectedModuleName);
        }
        case SymbolData::Trait(_) => { // Trait names are not values.

    }
    return setNodeType(self, node, ty);
}

/// Analyze a field access expression.
unsafe fn resolveFieldAccess(self: &mut Resolver, node: *ast::Node, access: ast::Access) -> Type
unsafe fn resolveFieldAccess 'arena (self: &mut Resolver 'arena, node: *ast::Node, access: ast::Access) -> Type
    throws (ResolveError)
{
    let parentTy = try infer(self, access.parent);
    if isUnsafePointerType(parentTy) {
        try requireUnsafe(self, access.parent);
    }
    let subjectTy = autoDeref(parentTy);
    try ensureTypeResolved(self, subjectTy, access.parent);

    if let case Type::Slice { class, item, mutable } = subjectTy {
        let fieldNode = access.child;
        let fieldName = try nodeName(self, fieldNode);
        if mem::eq(fieldName, PTR_FIELD) {

            throw emitError(self, access.parent, ErrorKind::ExpectedRecord);
        }
    }
}

/// Check target mutability for implicit pointer access.
unsafe fn canMutateThrough(self: &mut Resolver, node: *ast::Node) -> bool
    throws (ResolveError)
{
    let ty = try infer(self, node);
/// Return whether a pointer-like value grants mutable access.
fn isMutablePointerLike(ty: Type) -> bool {
    match ty {
        case Type::Pointer { mutable, .. } => return mutable,
        case Type::Slice { mutable, .. } => return mutable,
        else => return try canBorrowMutFrom(self, node),
        case Type::TraitObject { mutable, .. } => return mutable,
        else => return false,
    }
}

/// Determine whether an expression can yield a mutable location for borrowing.
unsafe fn canBorrowMutFrom(self: &mut Resolver, node: *ast::Node) -> bool
/// Check exclusive access to an element or field of a container.
unsafe fn canAccessExclusiveProjection 'arena (self: &mut Resolver 'arena, container: *ast::Node) -> bool
    throws (ResolveError)
{
    match node.value {
        case ast::NodeValue::Ident(name) => {
            let sym = findValueSymbol(self.scope, name)
                else return false;
            let case SymbolData::Value { mutable, .. } = sym.data
                else return false;
            return mutable;
    let ty = try infer(self, container);
    if let case Type::Slice { mutable: false, .. } = autoDeref(ty) {
        return false;
    }
    match ty {
        case Type::Pointer { class, mutable, .. } => {
            if not mutable {
                return false;
            }
            if class == types::PointerClass::Unsafe {
                return true;
            }
        }
        case ast::NodeValue::FieldAccess(access) => {
        case Type::Slice { class, mutable, .. } => {
            if not mutable {
                return false;
            }
            if class == types::PointerClass::Unsafe {
                return true;
            }
        }
        else => {
        },
    }
    return try canAccessExclusiveHandle(self, container);
}

/// Check that a stored exclusive handle is not reached through shared access.
unsafe fn canAccessExclusiveHandle 'arena (self: &mut Resolver 'arena, node: *ast::Node) -> bool
    throws (ResolveError)
{
    match node.value {
        case ast::NodeValue::FieldAccess(access) =>
            return try canAccessExclusiveProjection(self, access.parent),
        case ast::NodeValue::Subscript { container, .. } =>
            return try canAccessExclusiveProjection(self, container),
        case ast::NodeValue::Deref(inner) =>
            return try canAccessExclusiveProjection(self, inner),
        case ast::NodeValue::As(expr) =>
            return try canAccessExclusiveHandle(self, expr.value),
        case ast::NodeValue::CondExpr(cond) => {
            if not try canAccessExclusiveHandle(self, cond.thenExpr) {
                return false;
            }
            return try canAccessExclusiveHandle(self, cond.elseExpr);
        }
        else => return true,
    }
}

/// Check target mutability for implicit pointer access.
unsafe fn canMutateThrough 'arena (self: &mut Resolver 'arena, node: *ast::Node) -> bool
    throws (ResolveError)
{
    let ty = try infer(self, node);
    match ty {
        case Type::Pointer { class, mutable, .. } => {
            if not mutable {
                return false;
            }
            if class == types::PointerClass::Unsafe {
                return true;
            }
            return try canAccessExclusiveHandle(self, node);
        }
        case Type::Slice { class, mutable, .. } => {
            if not mutable {
                return false;
            }
            if class == types::PointerClass::Unsafe {
                return true;
            }
            return try canAccessExclusiveHandle(self, node);
        }
        case Type::TraitObject { class, mutable, .. } => {
            if not mutable {
                return false;
            }
            if class == types::PointerClass::Unsafe {
                return true;
            }
            return try canAccessExclusiveHandle(self, node);
        }
        else => return try canBorrowMutFrom(self, node),
    }
}

/// Determine whether an expression can yield a mutable location for borrowing.
unsafe fn canBorrowMutFrom 'arena (self: &mut Resolver 'arena, node: *ast::Node) -> bool
    throws (ResolveError)
{
    match node.value {
        case ast::NodeValue::Ident(name) => {
            let sym = findValueSymbol(self.scope, name)
                else return false;
            let case SymbolData::Value { mutable, .. } = sym.data
                else return false;
            return mutable;
        }
        case ast::NodeValue::FieldAccess(access) => {
            let parentTy = try infer(self, access.parent);
            if let case Type::Slice { .. } = autoDeref(parentTy) {
                try requireUnsafe(self, node);
            }
            return try canMutateThrough(self, access.parent);

            let containerTy = try infer(self, container);
            // Subscript auto-derefs pointers, so check the actual indexed type.
            let subjectTy = autoDeref(containerTy);

            if let case Type::Slice { mutable, .. } = subjectTy {
                return mutable;
                if not mutable {
                    return false;
                }
                return try canMutateThrough(self, container);
            }
            if let case Type::Array(_) = subjectTy {
                return try canMutateThrough(self, container);
            }
            return false;

            return false;
        }
        case ast::NodeValue::Deref(inner) => {
            let innerTy = try infer(self, inner);

            if let case Type::Pointer { mutable, .. } = innerTy {
                return mutable;
            if let case Type::Pointer { .. } = innerTy {
                return try canMutateThrough(self, inner);
            }
            if let case Type::Slice { mutable, .. } = innerTy {
                return mutable;
            if let case Type::Slice { .. } = innerTy {
                return try canMutateThrough(self, inner);
            }
            // Record deref: mutability depends on the inner binding.
            if let case Type::Nominal(NominalType::Record(recInfo)) = innerTy {
                if not recInfo.labeled and recInfo.fields.len == 1 {
                    return try canBorrowMutFrom(self, inner);

            return false;
        }
    }
}

/// Restrict a pointee lifetime to the borrow of its exclusive owner.
unsafe fn constrainAddressClass(storage: types::PointerClass, owner: types::PointerClass) -> types::PointerClass {
    if owner == types::PointerClass::Owned or owner == types::PointerClass::Unsafe {
        return storage;
    }
    if owner == types::PointerClass::Ref {
        return owner;
    }
    let case types::PointerClass::Region(ownerRegion) = owner else panic;
    if let case types::PointerClass::Region(storageRegion) = storage {
        if types::regionContains(storageRegion, ownerRegion) {
            return owner;
        }
        if types::regionContains(ownerRegion, storageRegion) {
            return storage;
        }
        return types::PointerClass::Ref;
    }
    if storage == types::PointerClass::Owned {
        return owner;
    }
    return storage;
}

/// Get the usable pointee lifetime of a pointer or slice value.
unsafe fn pointerAddressClass 'arena (
    self: &Resolver 'arena, node: *ast::Node, class: types::PointerClass, mutable: bool
) -> types::PointerClass {
    if not mutable or class == types::PointerClass::Unsafe {
        return class;
    }
    return constrainAddressClass(class, exclusiveOwnerClass(self, node));
}

/// Get the lifetime of storage selected by a pointer or slice subscript.
unsafe fn indexedPointerClass 'arena (self: &Resolver 'arena, container: *ast::Node) -> ?types::PointerClass {
    let ty = typeFor(self, container) else return nil;
    if let case Type::Pointer { class, target, mutable } = ty {
        let parentClass = pointerAddressClass(self, container, class, mutable);
        if let case Type::Slice { class: sliceClass, mutable: sliceMutable, .. } = *target {
            if not sliceMutable or sliceClass == types::PointerClass::Unsafe {
                return sliceClass;
            }
            return constrainAddressClass(sliceClass, parentClass);
        }
        return parentClass;
    }
    if let case Type::Slice { class, mutable, .. } = ty {
        return pointerAddressClass(self, container, class, mutable);
    }
    return nil;
}

/// Get the borrow that controls access to a stored exclusive handle.
/// Directly owned values have no additional borrow restriction.
unsafe fn exclusiveOwnerClass 'arena (self: &Resolver 'arena, node: *ast::Node) -> types::PointerClass {
    match node.value {
        case ast::NodeValue::FieldAccess(access) => {
            if let ty = typeFor(self, access.parent) {
                match ty {
                    case Type::Pointer { class, mutable, .. } =>
                        return pointerAddressClass(self, access.parent, class, mutable),
                    case Type::Slice { class, mutable, .. } =>
                        return pointerAddressClass(self, access.parent, class, mutable),
                    else => {
                    },
                }
            }
            return exclusiveOwnerClass(self, access.parent);
        }
        case ast::NodeValue::Subscript { container, .. } => {
            if let class = indexedPointerClass(self, container) {
                return class;
            }
            return exclusiveOwnerClass(self, container);
        }
        case ast::NodeValue::Deref(target) => {
            if let ty = typeFor(self, target) {
                if let case Type::Pointer { class, mutable, .. } = ty {
                    return pointerAddressClass(self, target, class, mutable);
                }
            }
            return exclusiveOwnerClass(self, target);
        }
        case ast::NodeValue::As(expr) => return exclusiveOwnerClass(self, expr.value),
        case ast::NodeValue::CondExpr(cond) =>
            return constrainAddressClass(exclusiveOwnerClass(self, cond.thenExpr), exclusiveOwnerClass(self, cond.elseExpr)),
        else => return types::PointerClass::Owned,
    }
}

/// Return the storage class of an addressed location.
unsafe fn addressStorageClass(self: &Resolver, node: *ast::Node) -> types::PointerClass {
unsafe fn addressStorageClass 'arena (self: &Resolver 'arena, node: *ast::Node) -> types::PointerClass {
    match node.value {
        case ast::NodeValue::Ident(_), ast::NodeValue::ScopeAccess(_) => {
            if let sym = symbolFor(self, node) {
                match sym.node.value {
                    case ast::NodeValue::StaticDecl(_), ast::NodeValue::ConstDecl(_) =>

                }
            }
        }
        case ast::NodeValue::FieldAccess(access) => {
            if let ty = typeFor(self, access.parent) {
                if let case Type::Pointer { class, .. } = ty {
                    return class;
                if let case Type::Pointer { class, mutable, .. } = ty {
                    return pointerAddressClass(self, access.parent, class, mutable);
                }
            }
            return addressStorageClass(self, access.parent);
        }
        case ast::NodeValue::Subscript { container, .. } => {
            if let ty = typeFor(self, container) {
                if let case Type::Slice { class, .. } = autoDeref(ty) {
                    return class;
                }
                if let case Type::Pointer { class, .. } = ty {
                    return class;
                }
            if let class = indexedPointerClass(self, container) {
                return class;
            }
            return addressStorageClass(self, container);
        }
        case ast::NodeValue::Deref(target) => {
            if let ty = typeFor(self, target) {
                if let case Type::Pointer { class, .. } = ty {
                    return class;
                if let case Type::Pointer { class, mutable, .. } = ty {
                    return pointerAddressClass(self, target, class, mutable);
                }
            }
            return addressStorageClass(self, target);
        }
        else => {}
    }
    return types::PointerClass::Ref;
}

/// Select an address type without extending the target storage lifetime.
unsafe fn addressClass(self: &mut Resolver, target: *ast::Node, hint: Type) -> types::PointerClass
unsafe fn addressClass 'arena (self: &mut Resolver 'arena, target: *ast::Node, hint: Type) -> types::PointerClass
    throws (ResolveError)
{
    if isUnsafePointerType(hint) {
        try requireUnsafe(self, target);
        return types::PointerClass::Unsafe;
    }
    if isRefType(hint) {
        if referenceRegion(hint) <> nil {
            return addressStorageClass(self, target);
        }
        return types::PointerClass::Ref;
    }
    match target.value {
        case ast::NodeValue::ArrayLit(_), ast::NodeValue::ArrayRepeatLit(_) => {
            if isConstExpr(self, target) {

        else => {}
    }
    return addressStorageClass(self, target);
}

/// Return whether a place projects into a cell payload snapshot.
unsafe fn isCellPayloadPlace 'arena (self: &mut Resolver 'arena, node: *ast::Node) -> bool
    throws (ResolveError)
{
    match node.value {
        case ast::NodeValue::Deref(target) => {
            if let case Type::Cell { .. } = try infer(self, target) {
                return true;
            }
        }
        case ast::NodeValue::FieldAccess(access) => return try isCellPayloadPlace(self, access.parent),
        case ast::NodeValue::Subscript { container, .. } => return try isCellPayloadPlace(self, container),
        else => {}
    }
    return false;
}

/// Return whether a typed expression accesses a whole cell payload.
export unsafe fn isCellDeref 'arena (self: &Resolver 'arena, node: *ast::Node) -> bool {
    if let case ast::NodeValue::Deref(target) = node.value {
        if let ty = typeFor(self, target) {
            if let case Type::Cell { .. } = ty {
                return true;
            }
        }
    }
    return false;
}

/// Analyze an address-of expression.
unsafe fn resolveAddressOf(self: &mut Resolver, node: *ast::Node, addr: ast::AddressOf, hint: Type) -> Type
unsafe fn resolveAddressOf 'arena (self: &mut Resolver 'arena, node: *ast::Node, addr: ast::AddressOf, hint: Type) -> Type
    throws (ResolveError)
{
    if try isCellPayloadPlace(self, addr.target) {
        throw emitError(self, addr.target, ErrorKind::ImmutableBinding);
    }
    if addr.mutable {
        if not try canBorrowMutFrom(self, addr.target) {
            throw emitError(self, addr.target, ErrorKind::ImmutableBinding);
        }
    }

    };
    return setNodeType(self, node, pointerTy);
}

/// Analyze a dereference expression.
unsafe fn resolveDeref(self: &mut Resolver, node: *ast::Node, targetNode: *ast::Node, hint: Type) -> Type
unsafe fn resolveDeref 'arena (self: &mut Resolver 'arena, node: *ast::Node, targetNode: *ast::Node, hint: Type) -> Type
    throws (ResolveError)
{
    let operandTy = try visit(self, targetNode, hint);
    if let case Type::Cell { class, payload } = operandTy {
        if class == types::PointerClass::Unsafe {
            try requireUnsafe(self, targetNode);
        }
        try validateCellPayload(self, node, *payload);
        return setNodeType(self, node, *payload);
    }
    if let case Type::Pointer { class, target, .. } = operandTy {
        if class == types::PointerClass::Unsafe {
            try requireUnsafe(self, targetNode);
        }
        // Disallow dereferencing opaque pointers.

        }
    }
    return false;
}

/// Require casts into region-dependent storage to preserve its typed contents.
fn regionalCastPreservesType(source: Type, target: Type) -> bool {
    if typesEqual(source, target) {
        return true;
    }
    if let case Type::Pointer { target: sourceItem, .. } = source {
        let case Type::Pointer { target: targetItem, .. } = target else return false;
        return typesEqual(*sourceItem, *targetItem);
    }
    if let case Type::Slice { item: sourceItem, .. } = source {
        let case Type::Slice { item: targetItem, .. } = target else return false;
        return typesEqual(*sourceItem, *targetItem);
    }
    return false;
}

/// Analyze an `as` cast expression.
unsafe fn resolveAs(self: &mut Resolver, node: *ast::Node, expr: ast::As) -> Type
unsafe fn resolveAs 'arena (self: &mut Resolver 'arena, node: *ast::Node, expr: ast::As) -> Type
    throws (ResolveError)
{
    let targetTy = try infer(self, expr.type);
    let sourceTy = try visit(self, expr.value, targetTy);
    if isUnsafePointerType(sourceTy) or isUnsafePointerType(targetTy) {

    }

    assert sourceTy <> Type::Unknown;
    assert targetTy <> Type::Unknown;

    if let case Type::Cell { class, payload } = targetTy {
        if let case Type::Pointer { class: sourceClass, target, mutable: true } = sourceTy;
            sourceClass == class and class <> types::PointerClass::Unsafe and typesEqual(*target, *payload)
        {
            return setNodeType(self, node, targetTy);
        }
        if typesEqual(sourceTy, targetTy) {
            return setNodeType(self, node, targetTy);
        }
        throw emitError(self, node, ErrorKind::InvalidAsCast(InvalidAsCast { from: sourceTy, to: targetTy }));
    }
    if containsRegion(targetTy) and not regionalCastPreservesType(sourceTy, targetTy) {
        throw emitError(self, node, ErrorKind::InvalidAsCast(InvalidAsCast {
            from: sourceTy, to: targetTy,
        }));
    }
    let mut valid = isValidCast(sourceTy, targetTy);
    if let case Type::Pointer {
        class: sourceClass, target: sourceTarget, mutable: sourceMutable,
    } = sourceTy {
        if let case Type::Pointer {
            class: targetClass, target: targetTarget, mutable: targetMutable,
        } = targetTy {
            if sourceClass == types::PointerClass::Ref and
            if types::isReference(sourceClass) and
               targetClass == types::PointerClass::Unsafe and
               (not targetMutable or sourceMutable) and
               isValidCast(*sourceTarget, *targetTarget)
            {
                set valid = true;

        class: sourceClass, item: sourceItem, mutable: sourceMutable,
    } = sourceTy {
        if let case Type::Slice {
            class: targetClass, item: targetItem, mutable: targetMutable,
        } = targetTy {
            if sourceClass == types::PointerClass::Ref and
            if types::isReference(sourceClass) and
               targetClass == types::PointerClass::Unsafe and
               (not targetMutable or sourceMutable) and
               isValidCast(*sourceItem, *targetItem)
            {
                set valid = true;

        to: targetTy,
    }));
}

/// Analyze a range expression.
unsafe fn resolveRange(self: &mut Resolver, node: *ast::Node, range: ast::Range) -> Type
unsafe fn resolveRange 'arena (self: &mut Resolver 'arena, node: *ast::Node, range: ast::Range) -> Type
    throws (ResolveError)
{
    let mut start: ?*Type = nil;
    let mut end: ?*Type = nil;


}

/// Analyze a `try` expression and its handlers.
/// The `expected` type is used to determine if the value is discarded (`Void`)
/// or if the catch expression needs type checking.
unsafe fn resolveTry(self: &mut Resolver, node: *ast::Node, tryExpr: ast::Try, hint: Type) -> Type
unsafe fn resolveTry 'arena (self: &mut Resolver 'arena, node: *ast::Node, tryExpr: ast::Try, hint: Type) -> Type
    throws (ResolveError)
{
    let call = tryExpr.expr;
    let case ast::NodeValue::Call(callExpr) = call.value
        else throw emitError(self, call, ErrorKind::TryNonThrowing);
    let resultTy = try resolveCall(self, call, callExpr, CallCtx::Try);
    let resultTy = try resolveCall(self, call, callExpr, CallCtx::Try, Type::Unknown);

    // TODO: It's annoying that we need to re-fetch the function type after
    // analyzing the call.
    let calleeTy = typeFor(self, callExpr.callee)
        else return setNodeType(self, node, resultTy);

    return setNodeType(self, node, tryResultTy);
}

/// Check that a `catch` body is assignable to the expected result type, but only
/// in expression context (`hint` is neither `Unknown` nor `Void`).
unsafe fn checkCatchBody(self: &mut Resolver, body: *ast::Node, resultTy: Type, hint: Type)
unsafe fn checkCatchBody 'arena (self: &mut Resolver 'arena, body: *ast::Node, resultTy: Type, hint: Type)
    throws (ResolveError)
{
    if hint <> Type::Unknown and hint <> Type::Void {
        try checkAssignable(self, body, resultTy);
    }

/// Resolve catch clauses for a `try ... catch` expression.
///
/// For a single untyped catch (with or without binding), resolves the catch
/// body and returns the result type. Multi-error callees with inferred bindings
/// are rejected; you must use typed catches.
unsafe fn resolveTryCatches(
    self: &mut Resolver,
unsafe fn resolveTryCatches 'arena (
    self: &mut Resolver 'arena,
    node: *ast::Node,
    catches: *[*ast::Node],
    calleeInfo: *FnType,
    resultTy: Type,
    hint: Type


/// Resolve typed catch clauses (`catch e as T {..} catch e as S {..}`).
///
/// Validates that each type annotation is in the callee's throw list, that
/// there are no duplicate catch types, and that the clauses are exhaustive.
unsafe fn resolveTypedCatches(
    self: &mut Resolver,
unsafe fn resolveTypedCatches 'arena (
    self: &mut Resolver 'arena,
    node: *ast::Node,
    catches: *[*ast::Node],
    calleeInfo: *FnType,
    resultTy: Type,
    hint: Type

    }
    return catchTy if resultTy == Type::Never else resultTy;
}

/// Analyze a `throw` statement.
unsafe fn resolveThrow(self: &mut Resolver, node: *ast::Node, expr: *ast::Node) -> Type
unsafe fn resolveThrow 'arena (self: &mut Resolver 'arena, node: *ast::Node, expr: *ast::Node) -> Type
    throws (ResolveError)
{
    let fnInfo = self.currentFn
        else throw emitError(self, node, ErrorKind::ThrowRequiresThrows);
    if fnInfo.throwList.len == 0 {

    }
    throw emitError(self, expr, ErrorKind::ThrowIncompatibleError);
}

/// Analyze a `return` statement.
unsafe fn resolveReturn(self: &mut Resolver, node: *ast::Node, retVal: ?*ast::Node) -> Type
unsafe fn resolveReturn 'arena (self: &mut Resolver 'arena, node: *ast::Node, retVal: ?*ast::Node) -> Type
    throws (ResolveError)
{
    let f = self.currentFn
        else throw emitError(self, node, ErrorKind::UnexpectedReturn);
    let expected = *f.returnType;

    }
}

/// Try to constant-fold a binary operation on two resolved operands.
/// Only folds when the result type is concrete.
fn tryFoldBinOp(self: &mut Resolver, node: *ast::Node, binop: ast::BinOp, resultTy: Type) {
fn tryFoldBinOp 'arena (self: &mut Resolver 'arena, node: *ast::Node, binop: ast::BinOp, resultTy: Type) {
    let leftVal = constValueEntry(self, binop.left)
        else return;
    let rightVal = constValueEntry(self, binop.right)
        else return;


        }
    }
}

/// Analyze a binary expression.
unsafe fn resolveBinOp(self: &mut Resolver, node: *ast::Node, binop: ast::BinOp) -> Type
unsafe fn resolveBinOp 'arena (self: &mut Resolver 'arena, node: *ast::Node, binop: ast::BinOp) -> Type
    throws (ResolveError)
{
    let mut resultTy = Type::Unknown;

    match binop.op {

                // never on references.
                if let case Type::Pointer { class: leftClass, target: leftTarget, .. } = leftTy {
                    if *leftTarget == Type::Opaque {
                        throw emitError(self, node, ErrorKind::OpaquePointerArithmetic);
                    }
                    if leftClass <> types::PointerClass::Ref
                    if not types::isReference(leftClass)
                        and isNumericType(rightTy)
                    {
                        try requireUnsafe(self, node);
                        return setNodeType(self, node, leftTy);
                    }

                if let case Type::Pointer { class: rightClass, target: rightTarget, .. } = rightTy {
                    if *rightTarget == Type::Opaque {
                        throw emitError(self, node, ErrorKind::OpaquePointerArithmetic);
                    }
                    if binop.op == ast::BinaryOp::Add
                        and rightClass <> types::PointerClass::Ref
                        and not types::isReference(rightClass)
                        and isNumericType(leftTy)
                    {
                        try requireUnsafe(self, node);
                        return setNodeType(self, node, rightTy);
                    }


    return setNodeType(self, node, resultTy);
}

/// Analyze a unary expression.
unsafe fn resolveUnOp(self: &mut Resolver, node: *ast::Node, unop: ast::UnOp) -> Type
unsafe fn resolveUnOp 'arena (self: &mut Resolver 'arena, node: *ast::Node, unop: ast::UnOp) -> Type
    throws (ResolveError)
{
    let mut resultTy = Type::Unknown;

    match unop.op {

    };
    return setNodeType(self, node, resultTy);
}

/// Resolve a type signature node and set its type.
unsafe fn inferTypeSig(self: &mut Resolver, node: *ast::Node, sig: ast::TypeSig) -> Type
unsafe fn inferTypeSig 'arena (self: &mut Resolver 'arena, node: *ast::Node, sig: ast::TypeSig) -> Type
    throws (ResolveError)
{
    let resolved = try resolveTypeSig(self, node, sig);

    return setNodeType(self, node, resolved);
}

/// Convert a parsed pointer qualifier to its semantic class.
fn resolvePointerClass(class: ast::PointerClass) -> types::PointerClass {
    match class {
        case ast::PointerClass::Owned => return types::PointerClass::Owned,
        case ast::PointerClass::Ref => return types::PointerClass::Ref,
        case ast::PointerClass::Unsafe => return types::PointerClass::Unsafe,
    }
}

/// Convert a type signature node into a type value.
unsafe fn resolveTypeSig(self: &mut Resolver, node: *ast::Node, sig: ast::TypeSig) -> Type
unsafe fn resolveTypeSig 'arena (self: &mut Resolver 'arena, node: *ast::Node, sig: ast::TypeSig) -> Type
    throws (ResolveError)
{
    match sig {
        case ast::TypeSig::Cell { class, payload } => {
            let inner = try infer(self, payload);
            try validateCellPayload(self, node, inner);
            return Type::Cell { class: resolvePointerClass(class), payload: allocType(self, inner) };
        }
        case ast::TypeSig::RegionRef { region, type } => {
            let identity = try resolveRegion(self, region);
            let base = try infer(self, type);
            match base {
                case Type::Cell { payload, .. } =>
                    return Type::Cell { class: types::PointerClass::Region(identity), payload },
                case Type::Pointer { target, mutable, .. } =>
                    return Type::Pointer { class: types::PointerClass::Region(identity), target, mutable },
                case Type::Slice { item, mutable, .. } =>
                    return Type::Slice { class: types::PointerClass::Region(identity), item, mutable },
                case Type::TraitObject { traitInfo, mutable, .. } =>
                    return Type::TraitObject { class: types::PointerClass::Region(identity), traitInfo, mutable },
                else => throw emitError(self, node, ErrorKind::InvalidRefPosition),
            }
        }
        case ast::TypeSig::Applied { name, regions } => {
            if let case ast::NodeValue::Ident(spelling) = name.value;
                mem::eq(spelling, "Session") and findTypeSymbol(self.scope, spelling) == nil
            {
                if regions.len <> 1 {
                    throw emitError(self, node, ErrorKind::RegionArgumentCount(CountMismatch {
                        expected: 1, actual: regions.len,
                    }));
                }
                return Type::Session(try resolveRegion(self, regions[0]));
            }
            let base = try resolveTypeName(self, name);
            return Type::Nominal(try applyNominalRegions(self, base, regions, node));
        }
        case ast::TypeSig::Void => {
            return Type::Void;
        }
        case ast::TypeSig::Never => {
            return Type::Never;

            return Type::Array(ArrayType { item: allocType(self, item), length });
        }
        case ast::TypeSig::Slice { class, itemType, mutable } => {
            let item = try infer(self, itemType);
            return Type::Slice {
                class,
                class: resolvePointerClass(class),
                item: allocType(self, item),
                mutable,
            };
        }
        case ast::TypeSig::Pointer { class, valueType, mutable } => {
            let target = try infer(self, valueType);
            return Type::Pointer {
                class,
                class: resolvePointerClass(class),
                target: allocType(self, target),
                mutable,
            };
        }
        case ast::TypeSig::Optional { valueType } => {
            let payload = try infer(self, valueType);
            return Type::Optional(allocType(self, payload));
        }
        case ast::TypeSig::Nominal(name) => {
            let ty = try resolveTypeName(self, name);
            try requireNominalArguments(self, ty, node);
            return Type::Nominal(ty);
        }
        case ast::TypeSig::Record { fields, labeled } => {
            let mut recordType = try resolveRecordFields(self, node, fields, labeled);
            set recordType.declaredCopy = true;
            for field in recordType.fields {
                if not isCopy(field.fieldType) {
                    set recordType.declaredCopy = false;
                }
            }
            set recordType.regions = self.regionScope;
            let nominalTy = allocNominalType(self, NominalType::Record(recordType));
            if let scope = self.regionScope {
                let map = regionSubstitution(self, scope);
                for parameter, i in scope.entries {
                    set map.arguments[i] = parameter;
                }
                return Type::Nominal(internNominalApplication(self, nominalTy, &map));
            }
            return Type::Nominal(nominalTy);
        }
        case ast::TypeSig::Fn { sig: t, isUnsafe } => {
            let a = alloc::arenaAllocator(&mut self.arena);
            let a = alloc::arenaAllocator(self.arena);
            let mut paramTypes: *mut [*Type] = &mut [];
            let mut throwList: *mut [*Type] = &mut [];

            if t.params.len > MAX_FN_PARAMS {
                throw emitError(self, node, ErrorKind::FnParamOverflow(CountMismatch {

                paramTypes.append(allocType(self, paramTy), a);
            }
            for tyNode in t.throwList {
                let throwTy = try resolveValueType(self, tyNode);
                try ensureStorableType(self, tyNode, throwTy);
                try validateErrorTag(self, tyNode, throwTy, &throwList[..]);
                throwList.append(allocType(self, throwTy), a);
            }
            let mut retType = allocType(self, Type::Void);
            if let ret = t.returnType {
                let resolvedRet = try resolveValueType(self, ret);
                try ensureStorableType(self, ret, resolvedRet);
                set retType = allocType(self, resolvedRet);
            }
            let fnType = FnType {
                regions: nil,
                paramTypes: &paramTypes[..],
                returnType: retType,
                throwList: &throwList[..],
                isUnsafe,
            };

            let sym = try resolveNamePath(self, traitName);
            let case SymbolData::Trait(traitInfo) = sym.data
                else throw emitError(self, traitName, ErrorKind::Internal);
            setNodeSymbol(self, traitName, sym);

            return Type::TraitObject { class, traitInfo, mutable };
            return Type::TraitObject { class: resolvePointerClass(class), traitInfo, mutable };
        }
    }
}

/// Check if a type can be used for inferrence.

        else => return true,
    }
}

/// Analyze a standalone expression by wrapping it in a synthetic function.
export unsafe fn resolveExpr(
    self: &mut Resolver, expr: *ast::Node, arena: &mut ast::NodeArena
export unsafe fn resolveExpr 'arena (
    self: &mut Resolver 'arena, expr: *ast::Node, arena: &mut ast::NodeArena
) -> Diagnostics throws (ResolveError) {
    let a = alloc::arenaAllocator(&mut arena.arena);
    let exprStmt = ast::synthNode(arena, ast::NodeValue::ExprStmt(expr));
    let bodyStmts = ast::nodeSlice(arena, 1).append(exprStmt, a);
    let module = ast::synthFnModule(arena, ANALYZE_EXPR_FN_NAME, bodyStmts);


    return diagnostics(self);
}

/// Analyze a parsed module root, ie. a block of top-level statements.
export unsafe fn resolveModuleRoot(self: &mut Resolver, root: *ast::Node) -> Diagnostics throws (ResolveError) {
export unsafe fn resolveModuleRoot 'arena (self: &mut Resolver 'arena, root: *ast::Node) -> Diagnostics throws (ResolveError) {
    let case ast::NodeValue::Block(block) = root.value
        else panic "resolveModuleRoot: expected block for module root";

    enterScope(self, root);
    try resolveModuleDecls(self, &block) catch {

}

/// Analyze the module graph. This pass processes `mod` statements, creating symbols
/// and scopes for them, and also binds type names in each module so that cross-module
/// type references work regardless of declaration order.
unsafe fn resolveModuleGraph(self: &mut Resolver, block: &ast::Block) throws (ResolveError) {
unsafe fn resolveModuleGraph 'arena (self: &mut Resolver 'arena, block: &ast::Block) throws (ResolveError) {
    try bindTypeNames(self, block);

    for node in block.statements {
        if let case ast::NodeValue::Mod(decl) = node.value {
            try resolveModGraph(self, node, decl);

    }
}

/// Bind all type names in a module.
/// Skips declarations that have already been bound.
unsafe fn bindTypeNames(self: &mut Resolver, block: &ast::Block) throws (ResolveError) {
unsafe fn bindTypeNames 'arena (self: &mut Resolver 'arena, block: &ast::Block) throws (ResolveError) {
    for node in block.statements {
        match node.value {
            case ast::NodeValue::RecordDecl(decl) => {
                if symbolFor(self, node) == nil {
                    try bindTypeName(self, node, decl.name, decl.attrs) catch {};

        }
    }
}

/// Resolve all type bodies in a module.
unsafe fn resolveTypeBodies(self: &mut Resolver, block: &ast::Block) throws (ResolveError) {
unsafe fn resolveTypeBodies 'arena (self: &mut Resolver 'arena, block: &ast::Block) throws (ResolveError) {
    for node in block.statements {
        match node.value {
            case ast::NodeValue::RecordDecl(decl) => {
                try resolveRecordBody(self, node, decl) catch {
                    // Continue resolving other types even if one fails.

/// previous pass.
///
/// This function uses a two-phase approach:
/// Phase 1: Bind all type names to allow forward references and mutual recursion.
/// Phase 2: Resolve type bodies, ie. field types, variant types, etc.
unsafe fn resolveModuleDecls(res: &mut Resolver, block: &ast::Block) throws (ResolveError) {
unsafe fn resolveModuleDecls 'arena (res: &mut Resolver 'arena, block: &ast::Block) throws (ResolveError) {
    // Phase 1: Bind all type names as placeholders.
    try bindTypeNames(res, block);
    // Phase 2: Process imports so names available from the module graph can
    // be used in function signatures.
    for node in block.statements {

fn linearBindingAvailable(env: &LinearEnv, index: u32) -> bool {
    return (env.available & ((1 as u64) << (index as u64))) <> 0;
}

/// Add a local binding when its resolved type moves by value.
unsafe fn addLinearBinding(checker: &mut LinearChecker, env: &mut LinearEnv, node: *ast::Node)
    throws (ResolveError)
unsafe fn addLinearBinding 'arena 'checking (checker: &mut LinearChecker 'arena 'checking, env: &mut LinearEnv, node: *ast::Node)
    throws (ResolveError) where 'arena: 'checking
{
    let sym = symbolFor(checker.resolver, node) else return;
    let case SymbolData::Value { type: ty, .. } = sym.data else return;
    if not isMoveOnly(ty) {
        return;

    set env.available |= (1 as u64) << (env.len as u64);
    set env.len += 1;
}

/// Mark a tracked binding as uninitialized.
unsafe fn markLinearBindingUnavailable(self: &mut Resolver, env: &mut LinearEnv, node: *ast::Node) {
unsafe fn markLinearBindingUnavailable 'arena (self: &mut Resolver 'arena, env: &mut LinearEnv, node: *ast::Node) {
    let sym = symbolFor(self, node) else return;
    let index = findLinearBinding(env, sym) else return;
    set env.available &= ~((1 as u64) << (index as u64));
}

/// Require exact-use bindings introduced after `start` to be consumed.
unsafe fn finishLinearScope(
    checker: &mut LinearChecker,
unsafe fn finishLinearScope 'arena 'checking (
    checker: &mut LinearChecker 'arena 'checking,
    env: &mut LinearEnv,
    start: u32,
) throws (ResolveError) {
) throws (ResolveError) where 'arena: 'checking {
    if not env.terminated {
        for i in start..env.len {
            if linearBindingAvailable(env, i) {
                let sym = env.symbols[i];
                let case SymbolData::Value { type: ty, .. } = sym.data

    }
    set env.len = start;
}

/// Require a tracked identifier to remain available for any access.
unsafe fn checkLinearIdent(
    checker: &mut LinearChecker,
unsafe fn checkLinearIdent 'arena 'checking (
    checker: &mut LinearChecker 'arena 'checking,
    env: &mut LinearEnv,
    node: *ast::Node,
) throws (ResolveError) {
) throws (ResolveError) where 'arena: 'checking {
    let sym = symbolFor(checker.resolver, node) else return;
    let index = findLinearBinding(env, sym) else return;
    if not linearBindingAvailable(env, index) {
        let case SymbolData::Value { type: ty, .. } = sym.data
            else panic "consumeLinearIdent: expected value symbol";

        throw emitError(checker.resolver, node, kind);
    }
}

/// Move or consume a tracked identifier once.
unsafe fn consumeLinearIdent(
    checker: &mut LinearChecker,
unsafe fn consumeLinearIdent 'arena 'checking (
    checker: &mut LinearChecker 'arena 'checking,
    env: &mut LinearEnv,
    node: *ast::Node,
) throws (ResolveError) {
) throws (ResolveError) where 'arena: 'checking {
    try checkLinearIdent(checker, env, node);
    let sym = symbolFor(checker.resolver, node) else return;
    let index = findLinearBinding(env, sym) else return;
    set env.available &= ~((1 as u64) << (index as u64));
}

/// Merge ownership availability across two live branches.
/// Validate both inputs before writing to an output that can alias either input.
unsafe fn joinLinearBranches(
    checker: &mut LinearChecker,
unsafe fn joinLinearBranches 'arena 'checking (
    checker: &mut LinearChecker 'arena 'checking,
    env: &mut LinearEnv,
    left: &LinearEnv,
    right: &LinearEnv,
    node: *ast::Node,
) throws (ResolveError) {
) throws (ResolveError) where 'arena: 'checking {
    if left.terminated and right.terminated {
        set *env = *left;
        set env.terminated = true;
        return;
    }

                );
            }
            set available &= ~((1 as u64) << (i as u64));
        }
    }
    let regionalLoans = left.regionalLoans | right.regionalLoans;
    set *env = *left;
    set env.available = available;
    set env.regionalLoans = regionalLoans;
}

/// Require all available exact-use bindings to be consumed at a function exit.
unsafe fn finishLinearExit(
    checker: &mut LinearChecker,
unsafe fn finishLinearExit 'arena 'checking (
    checker: &mut LinearChecker 'arena 'checking,
    env: &mut LinearEnv,
) throws (ResolveError) {
) throws (ResolveError) where 'arena: 'checking {
    if env.terminated {
        return;
    }
    for i in 0..env.len {
        if linearBindingAvailable(env, i) {

    }
    set env.terminated = true;
}

/// Find the local root borrowed or consumed by an argument expression.
fn linearRootSymbol(self: &mut Resolver, node: *ast::Node) -> ?*unsafe mut Symbol {
fn linearRootSymbol 'arena (self: &mut Resolver 'arena, node: *ast::Node) -> ?*unsafe mut Symbol {
    match node.value {
        case ast::NodeValue::Ident(_), ast::NodeValue::ScopeAccess(_) =>
            return symbolFor(self, node),
        case ast::NodeValue::As(expr) => return linearRootSymbol(self, expr.value),
        case ast::NodeValue::AddressOf(addr) => return linearRootSymbol(self, addr.target),

        case ast::NodeValue::Deref(target) => return linearRootSymbol(self, target),
        else => return nil,
    }
}

/// A projection loan that remains active until its named region ends.
record RegionalLoan: Copy {
    /// Address expression that supplies access to the loan.
    source: *ast::Node,
    /// Declared lifetime of the projection.
    region: *unsafe types::Region,
    /// Storage protected by the projection.
    place: BorrowPlace,
    /// Whether accesses through other references are excluded.
    exclusive: bool,
}

/// Return whether a region identity is visible in a lexical environment.
unsafe fn regionInScope(scope: ?*RegionScope, region: *unsafe types::Region) -> bool {
    let mut cursor = scope;
    while let current = cursor {
        for entry in current.entries {
            if entry.id == region.id {
                return true;
            }
        }
        set cursor = current.parent;
    }
    return false;
}

/// Retain only loans whose regions remain active at a control-flow destination.
unsafe fn regionalLoansInScope 'arena 'checking (checker: &LinearChecker 'arena 'checking, mask: u64, scope: ?*RegionScope) -> u64 where 'arena: 'checking {
    let mut result: u64 = 0;
    for i in 0..checker.regionalLen {
        let bit = (1 as u64) << (i as u64);
        if (mask & bit) <> 0 and regionInScope(scope, checker.regional[i].region) {
            set result |= bit;
        }
    }
    return result;
}

/// Remap one loan mask after the regional loan table is compacted.
fn remapRegionalLoans(mask: u64, mapping: &[u64]) -> u64 {
    let mut result: u64 = 0;
    for replacement, i in mapping {
        if (mask & ((1 as u64) << (i as u64))) <> 0 {
            set result |= replacement;
        }
    }
    return result;
}

/// Reclaim ended-region entries and preserve loans for enclosing regions.
unsafe fn compactRegionalLoans 'arena 'checking (
    checker: &mut LinearChecker 'arena 'checking, env: &mut LinearEnv,
    scope: ?*RegionScope
) where 'arena: 'checking {
    let oldLen = checker.regionalLen;
    let mut mapping: [u64; MAX_REGIONAL_LOANS] = [0; MAX_REGIONAL_LOANS];
    let mut next: u32 = 0;
    for i in 0..oldLen {
        let loan = checker.regional[i];
        if regionInScope(scope, loan.region) {
            set checker.regional[next] = loan;
            set mapping[i] = (1 as u64) << (next as u64);
            set next += 1;
        }
    }
    set env.regionalLoans = remapRegionalLoans(env.regionalLoans, &mapping[..oldLen]);
    for i in 0..checker.loopDepth {
        set checker.loopBackLoans[i] = remapRegionalLoans(checker.loopBackLoans[i], &mapping[..oldLen]);
        set checker.loopExitLoans[i] = remapRegionalLoans(checker.loopExitLoans[i], &mapping[..oldLen]);
    }
    set checker.regionalLen = next;
}

/// Check whether an access comes from the reference created by a projection.
unsafe fn usesRegionalLoan 'arena (self: &mut Resolver 'arena, node: *ast::Node, source: *ast::Node) -> bool {
    if node.id == source.id {
        return true;
    }
    let root = linearRootSymbol(self, node) else return false;
    let origin = localReferenceSource(root) else return false;
    return usesRegionalLoan(self, origin, source);
}

/// Retain a full-region projection independently of its local binding scope.
unsafe fn addRegionalLoan 'arena 'checking (
    checker: &mut LinearChecker 'arena 'checking, env: &mut LinearEnv, node: *ast::Node, address: ast::AddressOf
) throws (ResolveError) where 'arena: 'checking {
    let ty = typeFor(checker.resolver, node) else return;
    let mut class = types::PointerClass::Ref;
    match ty {
        case Type::Cell { class: cellClass, .. } => set class = cellClass,
        case Type::Pointer { class: pointerClass, .. } => set class = pointerClass,
        case Type::Slice { class: sliceClass, .. } => set class = sliceClass,
        else => return,
    }
    let case types::PointerClass::Region(region) = class else return;
    let storage = addressStorageClass(checker.resolver, address.target);
    let case types::PointerClass::Region(parent) = storage else return;
    if parent.id <> region.id {
        return;
    }
    let place = borrowPlace(checker.resolver, address.target);
    if place.root == nil {
        return;
    }
    for loan, i in &checker.regional[..checker.regionalLen] {
        if loan.source.id == node.id {
            set env.regionalLoans |= (1 as u64) << (i as u64);
            return;
        }
    }
    if checker.regionalLen >= MAX_REGIONAL_LOANS {
        throw emitError(checker.resolver, node, ErrorKind::RegionalLoanOverflow);
    }
    let index = checker.regionalLen;
    set checker.regional[index] = RegionalLoan { source: node, region, place, exclusive: address.mutable };
    set checker.regionalLen += 1;
    set env.regionalLoans |= (1 as u64) << (index as u64);
}

/// Return whether an initializer copies a shared reference with a named region.
/// Address expressions and casts retain a loan on their source storage.
unsafe fn copiesRegionalReference(ty: Type, value: *ast::Node) -> bool {
    if referenceRegion(ty) == nil or not isCopy(ty) {
        return false;
    }
    match value.value {
        case ast::NodeValue::AddressOf(_), ast::NodeValue::As(_) => return false,
        else => return true,
    }
}

/// Return the initializer that supplies a local reference's storage.
unsafe fn localReferenceSource(sym: *unsafe mut Symbol) -> ?*ast::Node {
    let case SymbolData::Value { type: ty, .. } = sym.data else return nil;
    if let case Type::Session(_) = ty {
        if let case ast::NodeValue::RegionBinding(binding) = sym.node.value {
            return binding.value;
        }
    }
    if isRefType(ty) {
        if let case ast::NodeValue::Let(binding) = sym.node.value {
            if copiesRegionalReference(ty, binding.value) {
                return nil;
            }
            return binding.value;
        }
        if let case ast::NodeValue::RegionBinding(binding) = sym.node.value {
            return binding.value;
        }
    }
    return nil;
}

/// Resolve a place through reference locals without extending its storage lifetime.
unsafe fn borrowPlace(self: &mut Resolver, node: *ast::Node) -> BorrowPlace {
unsafe fn borrowPlace 'arena (self: &mut Resolver 'arena, node: *ast::Node) -> BorrowPlace {
    let mut place = BorrowPlace { root: nil, fields: undefined, len: 0, precise: true };
    match node.value {
        case ast::NodeValue::Ident(_), ast::NodeValue::ScopeAccess(_) => {
            let sym = symbolFor(self, node) else return place;
            if let source = localReferenceSource(sym) {
                return borrowPlace(self, source);
                let origin = borrowPlace(self, source);
                if origin.root <> nil {
                    return origin;
                }
            }
            set place.root = sym;
        }
        case ast::NodeValue::AddressOf(addr) => return borrowPlace(self, addr.target),
        case ast::NodeValue::As(expr) => return borrowPlace(self, expr.value),

            set place.precise = false;
        }
        case ast::NodeValue::Subscript { container, .. } => {
            set place = borrowPlace(self, container);
            if let ty = typeFor(self, container) {
                if let case Type::Slice { class, .. } = autoDeref(ty); class <> types::PointerClass::Ref {
                if let case Type::Slice { class, .. } = autoDeref(ty); not types::isReference(class) {
                    set place.len = 0;
                }
            }
            set place.precise = false;
        }

    }
    return true;
}

/// Check whether access uses a reference or one of its lexical reborrows.
unsafe fn usesLocalLoan(self: &mut Resolver, node: *ast::Node, binding: *unsafe mut Symbol) -> bool {
unsafe fn usesLocalLoan 'arena (self: &mut Resolver 'arena, node: *ast::Node, binding: *unsafe mut Symbol) -> bool {
    let root = linearRootSymbol(self, node) else return false;
    if root == binding {
        return true;
    }
    let source = localReferenceSource(root) else return false;
    return usesLocalLoan(self, source, binding);
}

/// Reject accesses that conflict with a reference in an active lexical scope.
unsafe fn checkLocalLoans(checker: &mut LinearChecker, node: *ast::Node, exclusive: bool)
    throws (ResolveError)
unsafe fn checkLocalLoans 'arena 'checking (checker: &mut LinearChecker 'arena 'checking, env: &LinearEnv, node: *ast::Node, exclusive: bool)
    throws (ResolveError) where 'arena: 'checking
{
    let place = borrowPlace(checker.resolver, node);
    let root = place.root else return;
    for i in 0..checker.regionalLen {
        if (env.regionalLoans & ((1 as u64) << (i as u64))) == 0 {
            continue;
        }
        let loan = checker.regional[i];
        if (exclusive or loan.exclusive) and placesOverlap(&place, &loan.place)
            and not usesRegionalLoan(checker.resolver, node, loan.source)
        {
            throw emitError(checker.resolver, node, ErrorKind::BorrowConflict(root.name));
        }
    }
    for i in 0..checker.localLen {
        let loan = checker.locals[i];
        if (exclusive or loan.exclusive) and placesOverlap(&place, &loan.place)
            and not usesLocalLoan(checker.resolver, node, loan.binding)
        {
            throw emitError(checker.resolver, node, ErrorKind::BorrowConflict(root.name));
        }
    }
}

/// Retain existing storage until its immutable reference binding leaves scope.
unsafe fn addLocalLoan(checker: &mut LinearChecker, node: *ast::Node, binding: ast::Let)
    throws (ResolveError)
/// Retain source storage for local borrows and region headers.
unsafe fn addLocalLoan 'arena 'checking (checker: &mut LinearChecker 'arena 'checking, env: &LinearEnv, node: *ast::Node, binding: ast::Let)
    throws (ResolveError) where 'arena: 'checking
{
    let ty = typeFor(checker.resolver, binding.ident) else return;
    if not isRefType(ty) {
        let case Type::Session(_) = ty else return;
        let case ast::NodeValue::RegionBinding(_) = node.value else return;
    }
    if let case ast::NodeValue::Let(_) = node.value;
        copiesRegionalReference(ty, binding.value)
    {
        return;
    }
    let place = borrowPlace(checker.resolver, binding.value);
    if place.root == nil {
        if referenceRegion(ty) <> nil {
            return;
        }
        throw emitError(checker.resolver, node, ErrorKind::RefBinding);
    }
    if checker.localLen >= MAX_LINEAR_BINDINGS {
        throw emitError(checker.resolver, node, ErrorKind::Internal);
    }
    let sym = symbolFor(checker.resolver, node) else panic "reference without binding";
    let exclusive = isExclusiveArgument(ty);
    try checkLocalLoans(checker, binding.value, exclusive);
    let mut exclusive = isExclusiveArgument(ty);
    if let case Type::Cell { .. } = ty {
        if let case ast::NodeValue::As(expr) = binding.value.value {
            if let source = typeFor(checker.resolver, expr.value) {
                if let case Type::Pointer { mutable: true, .. } = source {
                    set exclusive = true;
                }
            }
        }
    }
    try checkLocalLoans(checker, env, binding.value, exclusive);
    set checker.locals[checker.localLen] = LocalLoan { binding: sym, place, exclusive };
    set checker.localLen += 1;
}

/// Protect a pattern source until its reference bindings leave scope.
unsafe fn addPatternLoan(checker: &mut LinearChecker, subject: *ast::Node)
    throws (ResolveError)
/// Protect storage borrowed by a pointer pattern until its bindings leave scope.
unsafe fn addPatternLoan 'arena 'checking (checker: &mut LinearChecker 'arena 'checking, subject: *ast::Node)
    throws (ResolveError) where 'arena: 'checking
{
    let ty = typeFor(checker.resolver, subject) else return;
    if unwrapMatchSubject(ty).by == MatchBy::Value {
        return;
    }
    let place = borrowPlace(checker.resolver, subject);
    if place.root == nil {
        return;
    }
    if checker.loanLen >= MAX_LINEAR_BINDINGS {

    set checker.loans[checker.loanLen] = place;
    set checker.loanLen += 1;
}

/// Reject a write, mutable loan, or ownership transfer of a pattern source.
unsafe fn checkPatternLoan(checker: &mut LinearChecker, node: *ast::Node)
    throws (ResolveError)
unsafe fn checkPatternLoan 'arena 'checking (checker: &mut LinearChecker 'arena 'checking, node: *ast::Node)
    throws (ResolveError) where 'arena: 'checking
{
    let place = borrowPlace(checker.resolver, node);
    let root = place.root else return;
    for i in 0..checker.loanLen {
        if placesOverlap(&checker.loans[i], &place) {
            throw emitError(checker.resolver, node, ErrorKind::BorrowConflict(root.name));
        }
    }
}

/// Return whether a parameter borrows its argument only for the call.
unsafe fn isBorrowedReferenceParameter(ty: Type) -> bool {
    if not isRefType(ty) {
        return false;
    }
    match ty {
        case Type::Cell { class, .. } => return class == types::PointerClass::Ref,
        case Type::Pointer { class, .. } => return class == types::PointerClass::Ref,
        case Type::Slice { class, .. } => return class == types::PointerClass::Ref,
        case Type::TraitObject { class, .. } => return class == types::PointerClass::Ref,
        else => return false,
    }
}

/// Return whether a parameter can mutate or consume its argument's storage.
unsafe fn isExclusiveArgument(ty: Type) -> bool {
    match ty {
        case Type::Pointer { mutable, .. } => return mutable,
        case Type::Slice { mutable, .. } => return mutable,

    }
}

/// Add the value identifiers introduced by a pattern.
/// Return whether the pattern introduces references to its source storage.
unsafe fn addLinearPatternBindings(
    checker: &mut LinearChecker,
unsafe fn addLinearPatternBindings 'arena 'checking (
    checker: &mut LinearChecker 'arena 'checking,
    env: &mut LinearEnv,
    pattern: *ast::Node,
) -> bool throws (ResolveError) {
) -> bool throws (ResolveError) where 'arena: 'checking {
    let mut hasReferences = false;
    match pattern.value {
        case ast::NodeValue::Ident(_) => {
            try addLinearBinding(checker, env, pattern);
            if let ty = typeFor(checker.resolver, pattern) {

    }
    return hasReferences;
}

/// Check a lexical block and exact-use of locals introduced in it.
unsafe fn checkLinearBlock(
    checker: &mut LinearChecker,
unsafe fn checkLinearBlock 'arena 'checking (
    checker: &mut LinearChecker 'arena 'checking,
    env: &mut LinearEnv,
    node: *ast::Node,
) throws (ResolveError) {
) throws (ResolveError) where 'arena: 'checking {
    let start = env.len;
    let localStart = checker.localLen;
    let case ast::NodeValue::Block(block) = node.value
        else panic "checkLinearBlock: expected block";
    for stmt in block.statements {

    set checker.localLen = localStart;
}

/// Push a repeated-control-flow boundary.
/// Initialize all loop state at this depth before increasing `loopDepth`.
fn enterLinearLoop(checker: &mut LinearChecker, env: &LinearEnv) {
fn enterLinearLoop 'arena 'checking (checker: &mut LinearChecker 'arena 'checking, env: &LinearEnv) where 'arena: 'checking {
    assert checker.loopDepth < MAX_LINEAR_LOOP_DEPTH, "linear loop nesting overflow";
    let depth = checker.loopDepth;
    set checker.loopBackLoans[depth] = 0;
    set checker.loopExitLoans[depth] = 0;
    set checker.loopRegions[depth] = checker.regions;
    set checker.loopMarks[depth] = env.len;
    set checker.loopAvailable[depth] = env.available;
    set checker.loopExitAvailable[depth] = env.available;
    set checker.loopHasNaturalExit[depth] = false;
    set checker.loopBreakSeen[depth] = false;
    set checker.loopDepth += 1;
}

/// Require a repeated body's outer bindings to match its entry state.
unsafe fn checkLinearLoopBackEdge(
    checker: &mut LinearChecker,
unsafe fn checkLinearLoopBackEdge 'arena 'checking (
    checker: &mut LinearChecker 'arena 'checking,
    env: &LinearEnv,
    node: *ast::Node,
) throws (ResolveError) {
) throws (ResolveError) where 'arena: 'checking {
    if env.terminated {
        return;
    }
    assert checker.loopDepth > 0, "linear loop back edge outside loop";
    let depth = checker.loopDepth - 1;
    set checker.loopBackLoans[depth] |= regionalLoansInScope(checker, env.regionalLoans, checker.loopRegions[depth]);
    let mark = checker.loopMarks[depth];
    let entryAvailable = checker.loopAvailable[depth];
    for i in 0..mark {
        let bit = (1 as u64) << (i as u64);
        if (env.available & bit) <> (entryAvailable & bit) {

        }
    }
}

/// Record the ownership state of a loop's condition-false exit.
fn setLinearLoopNaturalExit(checker: &mut LinearChecker, env: &LinearEnv) {
unsafe fn setLinearLoopNaturalExit 'arena 'checking (checker: &mut LinearChecker 'arena 'checking, env: &LinearEnv) where 'arena: 'checking {
    assert checker.loopDepth > 0, "linear loop exit outside loop";
    let depth = checker.loopDepth - 1;
    set checker.loopExitLoans[depth] |= regionalLoansInScope(checker, env.regionalLoans, checker.loopRegions[depth]);
    set checker.loopExitAvailable[depth] = env.available;
    set checker.loopHasNaturalExit[depth] = true;
}

/// Require a break exit to agree with every other exit from this loop.
unsafe fn checkLinearLoopBreak(
    checker: &mut LinearChecker,
unsafe fn checkLinearLoopBreak 'arena 'checking (
    checker: &mut LinearChecker 'arena 'checking,
    env: &LinearEnv,
    node: *ast::Node,
) throws (ResolveError) {
) throws (ResolveError) where 'arena: 'checking {
    assert checker.loopDepth > 0, "linear loop break outside loop";
    let depth = checker.loopDepth - 1;
    set checker.loopExitLoans[depth] |= regionalLoansInScope(checker, env.regionalLoans, checker.loopRegions[depth]);
    let mark = checker.loopMarks[depth];
    if checker.loopHasNaturalExit[depth] or checker.loopBreakSeen[depth] {
        let expected = checker.loopExitAvailable[depth];
        for i in 0..mark {
            let bit = (1 as u64) << (i as u64);

    }
    set checker.loopBreakSeen[depth] = true;
}

/// Pop a repeated-control-flow boundary.
fn exitLinearLoop(checker: &mut LinearChecker) {
fn exitLinearLoop 'arena 'checking (checker: &mut LinearChecker 'arena 'checking) where 'arena: 'checking {
    assert checker.loopDepth > 0, "exitLinearLoop: not in loop";
    set checker.loopDepth -= 1;
}

/// Check a conditional and merge its ownership states.
unsafe fn checkLinearIf(
    checker: &mut LinearChecker,
unsafe fn checkLinearIf 'arena 'checking (
    checker: &mut LinearChecker 'arena 'checking,
    env: &mut LinearEnv,
    node: *ast::Node,
    conditional: ast::If,
) throws (ResolveError) {
) throws (ResolveError) where 'arena: 'checking {
    try checkLinearNode(checker, env, conditional.condition, LinearUse::Consume);
    let base = *env;
    let mut thenEnv = base;
    try checkLinearNode(checker, &mut thenEnv, conditional.thenBranch, LinearUse::Discard);
    let mut elseEnv = base;

    }
    try joinLinearBranches(checker, env, &thenEnv, &elseEnv, node);
}

/// Check an expression conditional and merge its ownership states.
unsafe fn checkLinearCondExpr(
    checker: &mut LinearChecker,
unsafe fn checkLinearCondExpr 'arena 'checking (
    checker: &mut LinearChecker 'arena 'checking,
    env: &mut LinearEnv,
    node: *ast::Node,
    conditional: ast::CondExpr,
    usage: LinearUse,
) throws (ResolveError) {
) throws (ResolveError) where 'arena: 'checking {
    try checkLinearNode(checker, env, conditional.condition, LinearUse::Consume);
    let base = *env;
    let mut thenEnv = base;
    try checkLinearNode(checker, &mut thenEnv, conditional.thenExpr, usage);
    let mut elseEnv = base;
    try checkLinearNode(checker, &mut elseEnv, conditional.elseExpr, usage);
    try joinLinearBranches(checker, env, &thenEnv, &elseEnv, node);
}

/// Pointer patterns borrow their subject; value patterns consume it.
unsafe fn patternSubjectUse(self: &Resolver, subject: *ast::Node) -> LinearUse {
unsafe fn patternSubjectUse 'arena (self: &Resolver 'arena, subject: *ast::Node) -> LinearUse {
    if let ty = typeFor(self, subject) {
        if let case Type::Pointer { .. } = ty {
            return LinearUse::Borrow;
        }
    }
    return LinearUse::Consume;
}

/// Check a match expression, including ownership transferred into patterns.
unsafe fn checkLinearMatch(
    checker: &mut LinearChecker,
unsafe fn checkLinearMatch 'arena 'checking (
    checker: &mut LinearChecker 'arena 'checking,
    env: &mut LinearEnv,
    node: *ast::Node,
    matchExpr: ast::Match,
) throws (ResolveError) {
) throws (ResolveError) where 'arena: 'checking {
    try checkLinearNode(checker, env, matchExpr.subject, patternSubjectUse(checker.resolver, matchExpr.subject));
    let base = *env;
    let mut haveResult = false;
    let mut result = base;
    for prongNode in matchExpr.prongs {

        set *env = result;
    }
}

/// Check call-scoped loans and argument ownership transfers.
unsafe fn checkLinearCall(
    checker: &mut LinearChecker,
unsafe fn checkLinearCall 'arena 'checking (
    checker: &mut LinearChecker 'arena 'checking,
    env: &mut LinearEnv,
    node: *ast::Node,
    call: ast::Call,
) throws (ResolveError) {
) throws (ResolveError) where 'arena: 'checking {
    match checker.resolver.nodeData.entries[node.id].extra {
        case NodeExtra::SliceAppend { .. }, NodeExtra::SliceDelete { .. } => {
            let case ast::NodeValue::FieldAccess(access) = call.callee.value
                else panic "slice mutation without receiver";
            try checkPatternLoan(checker, access.parent);
            try checkLocalLoans(checker, access.parent, true);
            try checkLocalLoans(checker, env, access.parent, true);
        }
        else => {}
    }
    try checkLinearNode(checker, env, call.callee, LinearUse::Observe);
    let mut fnInfo: ?*FnType = nil;

                set haveReceiver = true;
            }
            else => {}
        }
        if haveReceiver {
            try checkLocalLoans(checker, access.parent,
            try checkLocalLoans(checker, env, access.parent,
                receiverMutable or receiverClass == types::PointerClass::Owned);
            if receiverMutable or receiverClass == types::PointerClass::Owned {
                try checkPatternLoan(checker, access.parent);
            }
            if receiverClass <> types::PointerClass::Unsafe {

                    set exclusive[placesLen] =
                        receiverClass == types::PointerClass::Owned or receiverMutable;
                    set placesLen += 1;
                }
            }
            if receiverClass == types::PointerClass::Ref {
            if types::isReference(receiverClass) {
                try checkLinearNode(checker, env, access.parent, LinearUse::Borrow);
            } else if receiverClass == types::PointerClass::Owned {
                try checkLinearNode(checker, env, access.parent, LinearUse::Consume);
            }
        }

                set places[placesLen] = place;
                set exclusive[placesLen] = argExclusive;
                set placesLen += 1;
            }
        }
        try checkLocalLoans(checker, arg, argExclusive);
        if isRefType(expected) {
        try checkLocalLoans(checker, env, arg, argExclusive);
        if isBorrowedReferenceParameter(expected) {
            try checkLinearNode(checker, env, arg, LinearUse::Borrow);
        } else {
            try checkLinearNode(checker, env, arg, LinearUse::Consume);
        }
    }

        set env.terminated = true;
    }
}

/// Check a pattern conditional. Linear scrutinees require an exhaustive match.
unsafe fn checkLinearIfLet(
    checker: &mut LinearChecker,
unsafe fn checkLinearIfLet 'arena 'checking (
    checker: &mut LinearChecker 'arena 'checking,
    env: &mut LinearEnv,
    node: *ast::Node,
    conditional: ast::IfLet,
) throws (ResolveError) {
) throws (ResolveError) where 'arena: 'checking {
    if let subjectTy = typeFor(checker.resolver, conditional.pattern.scrutinee);
        isLinear(subjectTy)
    {
        throw emitError(
            checker.resolver,

        try checkLinearNode(checker, &mut elseEnv, branch, LinearUse::Discard);
    }
    try joinLinearBranches(checker, env, &thenEnv, &elseEnv, node);
}

/// Check one expression or statement under an ownership-use context.
unsafe fn checkLinearNode(
    checker: &mut LinearChecker,
    env: &mut LinearEnv,
/// Check a repeated region-loan flow until its loop-entry mask is stable.
/// Each additional pass must add a bit from the bounded regional loan table.
unsafe fn checkLinearLoop 'arena 'checking (checker: &mut LinearChecker 'arena 'checking, env: &mut LinearEnv, node: *ast::Node)
    throws (ResolveError) where 'arena: 'checking
{
    if let case ast::NodeValue::For(forStmt) = node.value {
        try checkLinearNode(checker, env, forStmt.iterable, LinearUse::Consume);
    }
    let base = *env;
    let depth = checker.loopDepth;
    let mut entryLoans = base.regionalLoans;
    loop {
        let mut pass = base;
        set pass.regionalLoans = entryLoans;
        try checkLinearLoopPass(checker, &mut pass, node);
        let next = entryLoans | checker.loopBackLoans[depth];
        if next == entryLoans {
            set *env = pass;
            return;
        }
        set entryLoans = next;
    }
}

/// Check one pass through a loop with the current loop-entry loan state.
unsafe fn checkLinearLoopPass 'arena 'checking (checker: &mut LinearChecker 'arena 'checking, env: &mut LinearEnv, node: *ast::Node)
    throws (ResolveError) where 'arena: 'checking
{
    match node.value {
        case ast::NodeValue::While(whileStmt) => {
            enterLinearLoop(checker, env);
            try checkLinearNode(checker, env, whileStmt.condition, LinearUse::Consume);
            let conditionExit = *env;
            setLinearLoopNaturalExit(checker, &conditionExit);
            let mut bodyEnv = conditionExit;
            try checkLinearNode(checker, &mut bodyEnv, whileStmt.body, LinearUse::Discard);
            try checkLinearLoopBackEdge(checker, &bodyEnv, whileStmt.body);
            exitLinearLoop(checker);
            set *env = conditionExit;
            set env.regionalLoans = checker.loopExitLoans[checker.loopDepth];
            if let elseBranch = whileStmt.elseBranch {
                let mut elseEnv = conditionExit;
                try checkLinearNode(
                    checker,
                    &mut elseEnv,
                    elseBranch,
                    LinearUse::Discard,
                );
                let exits = *env;
                try joinLinearBranches(checker, env, &exits, &elseEnv, node);
            }
        }
        case ast::NodeValue::WhileLet(whileStmt) => {
            if let subjectTy = typeFor(checker.resolver, whileStmt.pattern.scrutinee);
                isLinear(subjectTy)
            {
                throw emitError(
                    checker.resolver,
                    whileStmt.pattern.scrutinee,
                    ErrorKind::LinearPartialMove,
                );
            }
            let base = *env;
            enterLinearLoop(checker, env);
            let mut bodyEnv = base;
            try checkLinearNode(
                checker,
                &mut bodyEnv,
                whileStmt.pattern.scrutinee,
                patternSubjectUse(checker.resolver, whileStmt.pattern.scrutinee),
            );
            let mut conditionExit = bodyEnv;
            let start = bodyEnv.len;
            let loanStart = checker.loanLen;
            if try addLinearPatternBindings(checker, &mut bodyEnv, whileStmt.pattern.pattern) {
                try addPatternLoan(checker, whileStmt.pattern.scrutinee);
            }
            if let guard = whileStmt.pattern.guard {
                try checkLinearNode(checker, &mut bodyEnv, guard, LinearUse::Consume);
                let mut guardExit = bodyEnv;
                try finishLinearScope(checker, &mut guardExit, start);
                let previous = conditionExit;
                try joinLinearBranches(
                    checker,
                    &mut conditionExit,
                    &previous,
                    &guardExit,
                    guard,
                );
            }
            setLinearLoopNaturalExit(checker, &conditionExit);
            try checkLinearNode(checker, &mut bodyEnv, whileStmt.body, LinearUse::Discard);
            try finishLinearScope(checker, &mut bodyEnv, start);
            set checker.loanLen = loanStart;
            try checkLinearLoopBackEdge(checker, &bodyEnv, whileStmt.body);
            exitLinearLoop(checker);
            set *env = conditionExit;
            set env.regionalLoans = checker.loopExitLoans[checker.loopDepth];
            if let elseBranch = whileStmt.elseBranch {
                let mut elseEnv = conditionExit;
                try checkLinearNode(
                    checker,
                    &mut elseEnv,
                    elseBranch,
                    LinearUse::Discard,
                );
                let exits = *env;
                try joinLinearBranches(checker, env, &exits, &elseEnv, node);
            }
        }
        case ast::NodeValue::For(forStmt) => {
            if let iterableTy = typeFor(checker.resolver, forStmt.iterable) {
                if isLinear(iterableTy) {
                    throw emitError(
                        checker.resolver,
                        forStmt.iterable,
                        ErrorKind::LinearPartialMove,
                    );
                }
            }
            let base = *env;
            enterLinearLoop(checker, env);
            setLinearLoopNaturalExit(checker, &base);
            let mut bodyEnv = base;
            let start = bodyEnv.len;
            try addLinearBinding(checker, &mut bodyEnv, forStmt.binding);
            if let index = forStmt.index {
                try addLinearBinding(checker, &mut bodyEnv, index);
            }
            try checkLinearNode(checker, &mut bodyEnv, forStmt.body, LinearUse::Discard);
            try finishLinearScope(checker, &mut bodyEnv, start);
            try checkLinearLoopBackEdge(checker, &bodyEnv, forStmt.body);
            exitLinearLoop(checker);
            set *env = base;
            set env.regionalLoans = checker.loopExitLoans[checker.loopDepth];
            if let elseBranch = forStmt.elseBranch {
                let mut elseEnv = base;
                try checkLinearNode(
                    checker,
                    &mut elseEnv,
                    elseBranch,
                    LinearUse::Discard,
                );
                let exits = *env;
                try joinLinearBranches(checker, env, &exits, &elseEnv, node);
            }
        }
        case ast::NodeValue::Loop { body } => {
            let base = *env;
            enterLinearLoop(checker, env);
            let mut bodyEnv = base;
            try checkLinearNode(checker, &mut bodyEnv, body, LinearUse::Discard);
            try checkLinearLoopBackEdge(checker, &bodyEnv, body);
            let depth = checker.loopDepth - 1;
            let breakSeen = checker.loopBreakSeen[depth];
            let exitAvailable = checker.loopExitAvailable[depth];
            exitLinearLoop(checker);
            set *env = base;
            set env.regionalLoans = checker.loopExitLoans[checker.loopDepth];
            if breakSeen {
                set env.available = exitAvailable;
            } else {
                set env.terminated = true;
            }
        }
        else => panic "checkLinearLoopPass: expected loop",
    }
}

/// Check one expression or statement under an ownership-use context.
unsafe fn checkLinearNode 'arena 'checking (
    checker: &mut LinearChecker 'arena 'checking,
    env: &mut LinearEnv,
    node: *ast::Node,
    usage: LinearUse,
) throws (ResolveError) {
) throws (ResolveError) where 'arena: 'checking {
    if env.terminated {
        return;
    }
    if usage <> LinearUse::Locate {
        match node.value {
            case ast::NodeValue::Ident(_), ast::NodeValue::ScopeAccess(_),
                 ast::NodeValue::FieldAccess(_), ast::NodeValue::Subscript { .. },
                 ast::NodeValue::Deref(_) => {
                let mut exclusive = usage == LinearUse::Place;
                let mut exclusive = usage == LinearUse::Place and not isCellDeref(checker.resolver, node);
                if usage == LinearUse::Consume {
                    if let ty = typeFor(checker.resolver, node) {
                        set exclusive = isExclusiveArgument(ty);
                    }
                }
                try checkLocalLoans(checker, node, exclusive);
                try checkLocalLoans(checker, env, node, exclusive);
            }
            else => {}
        }
    }
    match node.value {

                    throw emitError(checker.resolver, expr, ErrorKind::LinearDiscard);
                }
            }
            try checkLinearNode(checker, env, expr, LinearUse::Consume);
        }
        case ast::NodeValue::RegionBlock { bindings, body, .. } => {
            let previousRegions = checker.regions;
            let case NodeExtra::Regions(scope) = checker.resolver.nodeData.entries[node.id].extra else {
                if checker.resolver.errors.len > 0 {
                    return;
                }
                panic "checkLinearNode: missing region scope";
            };
            set checker.regions = scope;
            let start = env.len;
            let localStart = checker.localLen;
            for bindingNode in bindings {
                let case ast::NodeValue::RegionBinding(binding) = bindingNode.value
                    else panic "checkLinearNode: invalid borrow binding";
                try checkLinearNode(checker, env, binding.value, LinearUse::Consume);
                if env.terminated {
                    break;
                }
                try addLinearBinding(checker, env, bindingNode);
                try addLocalLoan(checker, env, bindingNode, ast::borrowBinding(binding));
            }
            try checkLinearBlock(checker, env, body);
            try finishLinearScope(checker, env, start);
            set checker.localLen = localStart;
            set checker.regions = previousRegions;
            compactRegionalLoans(checker, env, previousRegions);
        }
        case ast::NodeValue::Block(_) => try checkLinearBlock(checker, env, node),
        case ast::NodeValue::Let(binding) => {
            let mut isUndefined = false;
            if let case ast::NodeValue::Undef = binding.value.value {
                set isUndefined = true;

            try checkLinearNode(checker, env, binding.value, LinearUse::Consume);
            if env.terminated {
                return;
            }
            try addLinearBinding(checker, env, node);
            try addLocalLoan(checker, node, binding);
            try addLocalLoan(checker, env, node, binding);
            if isUndefined {
                markLinearBindingUnavailable(checker.resolver, env, node);
            }
        }
        case ast::NodeValue::Assign(assign) => {
            try checkPatternLoan(checker, assign.left);
            if not isCellDeref(checker.resolver, assign.left) {
                try checkPatternLoan(checker, assign.left);
            }
            let mut target: ?u32 = nil;
            let mut targetLinear = false;
            if let leftTy = typeFor(checker.resolver, assign.left) {
                if isMoveOnly(leftTy) {
                    set targetLinear = isLinear(leftTy);

                    );
                }
                set env.available |= (1 as u64) << (index as u64);
            }
        }
        case ast::NodeValue::RegionApply { value, .. } =>
            try checkLinearNode(checker, env, value, usage),
        case ast::NodeValue::Call(call) => try checkLinearCall(checker, env, node, call),
        case ast::NodeValue::AddressOf(addr) => {
            try checkLocalLoans(checker, addr.target, addr.mutable);
            try checkLocalLoans(checker, env, addr.target, addr.mutable);
            if addr.mutable {
                try checkPatternLoan(checker, addr.target);
            }
            try checkLinearNode(checker, env, addr.target, LinearUse::Locate);
            try addRegionalLoan(checker, env, node, addr);
        }
        case ast::NodeValue::Deref(target) => {
            if let resultTy = typeFor(checker.resolver, node) {
                if isMoveOnly(resultTy) and usage == LinearUse::Consume {
                    throw emitError(checker.resolver, node, ErrorKind::LinearPartialMove);

        case ast::NodeValue::UnOp(op) => {
            try checkLinearNode(checker, env, op.value, LinearUse::Consume);
        }
        case ast::NodeValue::As(expr) => {
            let mut castUse = usage;
            if let targetTy = typeFor(checker.resolver, node) {
                if let case Type::Cell { .. } = targetTy {
                    set castUse = LinearUse::Consume;
                }
            }
            if let targetTy = typeFor(checker.resolver, node); isNumericType(targetTy) {
                set castUse = LinearUse::Observe;
            }
            try checkLinearNode(checker, env, expr.value, castUse);
        }

                try finishLinearScope(checker, &mut branch, start);
                let previous = *env;
                try joinLinearBranches(checker, env, &previous, &branch, node);
            }
        }
        case ast::NodeValue::While(whileStmt) => {
            enterLinearLoop(checker, env);
            try checkLinearNode(checker, env, whileStmt.condition, LinearUse::Consume);
            let conditionExit = *env;
            setLinearLoopNaturalExit(checker, &conditionExit);
            let mut bodyEnv = conditionExit;
            try checkLinearNode(checker, &mut bodyEnv, whileStmt.body, LinearUse::Discard);
            try checkLinearLoopBackEdge(checker, &bodyEnv, whileStmt.body);
            exitLinearLoop(checker);
            set *env = conditionExit;
            if let elseBranch = whileStmt.elseBranch {
                let mut elseEnv = conditionExit;
                try checkLinearNode(
                    checker,
                    &mut elseEnv,
                    elseBranch,
                    LinearUse::Discard,
                );
                try joinLinearBranches(checker, env, &conditionExit, &elseEnv, node);
            }
        }
        case ast::NodeValue::WhileLet(whileStmt) => {
            if let subjectTy = typeFor(checker.resolver, whileStmt.pattern.scrutinee);
                isLinear(subjectTy)
            {
                throw emitError(
                    checker.resolver,
                    whileStmt.pattern.scrutinee,
                    ErrorKind::LinearPartialMove,
                );
            }
            let base = *env;
            enterLinearLoop(checker, env);
            let mut bodyEnv = base;
            try checkLinearNode(
                checker,
                &mut bodyEnv,
                whileStmt.pattern.scrutinee,
                patternSubjectUse(checker.resolver, whileStmt.pattern.scrutinee),
            );
            let mut conditionExit = bodyEnv;
            let start = bodyEnv.len;
            let loanStart = checker.loanLen;
            if try addLinearPatternBindings(checker, &mut bodyEnv, whileStmt.pattern.pattern) {
                try addPatternLoan(checker, whileStmt.pattern.scrutinee);
            }
            if let guard = whileStmt.pattern.guard {
                try checkLinearNode(checker, &mut bodyEnv, guard, LinearUse::Consume);
                let mut guardExit = bodyEnv;
                try finishLinearScope(checker, &mut guardExit, start);
                let previous = conditionExit;
                try joinLinearBranches(
                    checker,
                    &mut conditionExit,
                    &previous,
                    &guardExit,
                    guard,
                );
            }
            setLinearLoopNaturalExit(checker, &conditionExit);
            try checkLinearNode(checker, &mut bodyEnv, whileStmt.body, LinearUse::Discard);
            try finishLinearScope(checker, &mut bodyEnv, start);
            set checker.loanLen = loanStart;
            try checkLinearLoopBackEdge(checker, &bodyEnv, whileStmt.body);
            exitLinearLoop(checker);
            set *env = conditionExit;
            if let elseBranch = whileStmt.elseBranch {
                let mut elseEnv = conditionExit;
                try checkLinearNode(
                    checker,
                    &mut elseEnv,
                    elseBranch,
                    LinearUse::Discard,
                );
                try joinLinearBranches(checker, env, &conditionExit, &elseEnv, node);
            }
        }
        case ast::NodeValue::For(forStmt) => {
            if let iterableTy = typeFor(checker.resolver, forStmt.iterable) {
                if isLinear(iterableTy) {
                    throw emitError(
                        checker.resolver,
                        forStmt.iterable,
                        ErrorKind::LinearPartialMove,
                    );
                }
            }
            try checkLinearNode(checker, env, forStmt.iterable, LinearUse::Consume);
            let base = *env;
            enterLinearLoop(checker, env);
            setLinearLoopNaturalExit(checker, &base);
            let mut bodyEnv = base;
            let start = bodyEnv.len;
            try addLinearBinding(checker, &mut bodyEnv, forStmt.binding);
            if let index = forStmt.index {
                try addLinearBinding(checker, &mut bodyEnv, index);
            }
            try checkLinearNode(checker, &mut bodyEnv, forStmt.body, LinearUse::Discard);
            try finishLinearScope(checker, &mut bodyEnv, start);
            try checkLinearLoopBackEdge(checker, &bodyEnv, forStmt.body);
            exitLinearLoop(checker);
            set *env = base;
            if let elseBranch = forStmt.elseBranch {
                let mut elseEnv = base;
                try checkLinearNode(
                    checker,
                    &mut elseEnv,
                    elseBranch,
                    LinearUse::Discard,
                );
                try joinLinearBranches(checker, env, &base, &elseEnv, node);
            }
        }
        case ast::NodeValue::Loop { body } => {
            let base = *env;
            enterLinearLoop(checker, env);
            let mut bodyEnv = base;
            try checkLinearNode(checker, &mut bodyEnv, body, LinearUse::Discard);
            try checkLinearLoopBackEdge(checker, &bodyEnv, body);
            let depth = checker.loopDepth - 1;
            let breakSeen = checker.loopBreakSeen[depth];
            let exitAvailable = checker.loopExitAvailable[depth];
            exitLinearLoop(checker);
            set *env = base;
            if breakSeen {
                set env.available = exitAvailable;
            } else {
                set env.terminated = true;
            }
        }
        case ast::NodeValue::While(_), ast::NodeValue::WhileLet(_),
             ast::NodeValue::For(_), ast::NodeValue::Loop { .. } =>
            try checkLinearLoop(checker, env, node),
        case ast::NodeValue::Break => {
            assert checker.loopDepth > 0, "linear loop control outside loop";
            let start = checker.loopMarks[checker.loopDepth - 1];
            try finishLinearScope(checker, env, start);
            try checkLinearLoopBreak(checker, env, node);

        else => {}
    }
}

/// Check exact-use ownership for one resolved function.
unsafe fn checkLinearFn(
    self: &mut Resolver,
unsafe fn checkLinearFn 'arena (
    self: &mut Resolver 'arena,
    receiver: ?*ast::Node,
    params: *[*ast::Node],
    body: *ast::Node,
) throws (ResolveError) {
    let mut checker = LinearChecker {
        resolver: self as *unsafe mut Resolver,
        loans: undefined,
        loanLen: 0,
        locals: undefined,
        localLen: 0,
        loopMarks: undefined,
        loopAvailable: undefined,
        loopExitAvailable: undefined,
        loopHasNaturalExit: undefined,
        loopBreakSeen: undefined,
        loopDepth: 0,
    };
    let mut env = LinearEnv {
        symbols: undefined,
        available: 0,
        len: 0,
        terminated: false,
    };
    if let receiverNode = receiver {
        try addLinearBinding(&mut checker, &mut env, receiverNode);
    }
    for paramNode in params {
        let case ast::NodeValue::FnParam(_) = paramNode.value
            else panic "checkLinearFn: expected parameter";
        try addLinearBinding(&mut checker, &mut env, paramNode);
    try resolveNominalApplications(self, body);
    let regions = self.regionScope;
    let resolved: 'checking = &mut *self where 'arena: 'checking in {
        let mut checker = LinearChecker 'arena 'checking {
            resolver: resolved,
            regional: undefined,
            regionalLen: 0,
            regions,
            loopBackLoans: undefined,
            loopExitLoans: undefined,
            loopRegions: undefined,
            loans: undefined,
            loanLen: 0,
            locals: undefined,
            localLen: 0,
            loopMarks: undefined,
            loopAvailable: undefined,
            loopExitAvailable: undefined,
            loopHasNaturalExit: undefined,
            loopBreakSeen: undefined,
            loopDepth: 0,
        };
        let mut env = LinearEnv {
            regionalLoans: 0,
            symbols: undefined,
            available: 0,
            len: 0,
            terminated: false,
        };
        if let receiverNode = receiver {
            try addLinearBinding(&mut checker, &mut env, receiverNode);
        }
        for paramNode in params {
            let case ast::NodeValue::FnParam(_) = paramNode.value
                else panic "checkLinearFn: expected parameter";
            try addLinearBinding(&mut checker, &mut env, paramNode);
        }
        try checkLinearNode(&mut checker, &mut env, body, LinearUse::Discard);
        try finishLinearScope(&mut checker, &mut env, 0);
    }
    try checkLinearNode(&mut checker, &mut env, body, LinearUse::Discard);
    try finishLinearScope(&mut checker, &mut env, 0);
}

/// Analyze module definitions. This pass analyzes function bodies, recursing into sub-modules.
unsafe fn resolveModuleDefs(self: &mut Resolver, block: &ast::Block) throws (ResolveError) {
unsafe fn resolveModuleDefs 'arena (self: &mut Resolver 'arena, block: &ast::Block) throws (ResolveError) {
    for stmt in block.statements {
        try resolveNominalApplications(self, stmt);
        try visitDef(self, stmt);
        try resolveNominalApplications(self, stmt);
    }
}

/// Resolve all packages.
/// The graph must outlive later uses of the resolver.
export unsafe fn resolve(self: &mut Resolver, graph: &module::ModuleGraph, packages: &[Pkg]) -> Diagnostics throws (ResolveError) {
export unsafe fn resolve 'arena (self: &mut Resolver 'arena, graph: &module::ModuleGraph, packages: &[Pkg]) -> Diagnostics throws (ResolveError) {
    set self.moduleGraph = graph as *unsafe module::ModuleGraph;

    // 1. Bind all package roots to enable cross-package references.
    for i in 0..packages.len {
        let pkg = packages[i];

    }
    return diagnostics(self);
}

/// Resolve a package.
unsafe fn resolvePackage(self: &mut Resolver, rootEntry: *module::ModuleEntry, node: *ast::Node) -> Diagnostics throws (ResolveError) {
unsafe fn resolvePackage 'arena (self: &mut Resolver 'arena, rootEntry: *module::ModuleEntry, node: *ast::Node) -> Diagnostics throws (ResolveError) {
    let rootId = rootEntry.id;
    let scope = self.moduleScopes[rootId as u32]
        else panic "resolvePackage: module scope not found";

    // Set up the module scope for this package.

lib/std/lang/resolver/printer.rad +91 -6

    io::print(name);
    io::print("'");
}

/// Print a pointer-like type prefix.
fn printPtrPrefix(class: types::PointerClass, mutable: bool) {
unsafe fn printPtrPrefix(class: types::PointerClass, mutable: bool) {
    match class {
        case types::PointerClass::Owned => io::print("*"),
        case types::PointerClass::Ref => io::print("&"),
        case types::PointerClass::Region(region) => {
            io::print("&");
            io::print(region.name);
            io::print(" ");
        }
        case types::PointerClass::Unsafe => io::print("*unsafe "),
    }
    if mutable {
        io::print("mut ");
    }

            io::print("i32");
        }
        case super::Type::I64 => {
            io::print("i64");
        }
        case super::Type::Cell { class, payload } => {
            printPtrPrefix(class, false);
            io::print("cell ");
            printTypeBody(*payload, brief);
        }
        case super::Type::Session(region) => {
            io::print("Session ");
            io::print(region.name);
        }
        case super::Type::Pointer { class, target, mutable } => {
            printPtrPrefix(class, mutable);
            printTypeBody(*target, brief);
        }
        case super::Type::Slice { class, item, mutable } => {

}

/// Print detailed information about a nominal type (record or union).
unsafe fn printNominalType(info: *unsafe super::NominalType) {
    match *info {
        case super::NominalType::Placeholder(_) => {
        case super::NominalType::Placeholder(_), super::NominalType::Resolving(_) => {
            io::print("<placeholder>");
        }
        case super::NominalType::Application(applied) => {
            printNominalTypeName(applied.base);
            printNominalArguments(applied);
        }
        case super::NominalType::Record(recordType) => {
            io::print("record {");
            if recordType.fields.len > 0 {
                io::print(" ");
                for i in 0..recordType.fields.len {

                io::print(" ");
            }
            io::print("}");
        }
    }
    if let applied = super::nominalApplication(info) {
        if let case super::NominalType::Application(_) = *info {
            return;
        }
        printNominalArguments(applied);
    }
}

/// Print just the type kind for a nominal type, without detailed info.
unsafe fn printNominalTypeName(info: *unsafe super::NominalType) {
    match *info {
        case super::NominalType::Placeholder(_) => {
        case super::NominalType::Placeholder(_), super::NominalType::Resolving(_) => {
            io::print("<placeholder>");
        }
        case super::NominalType::Application(applied) => {
            printNominalTypeName(applied.base);
            printNominalArguments(applied);
        }
        case super::NominalType::Record(_) => {
            io::print("<record>");
        }
        case super::NominalType::Union(_) => {
            io::print("<union>");
        }
    }
    if let applied = super::nominalApplication(info) {
        if let case super::NominalType::Application(_) = *info {
            return;
        }
        printNominalArguments(applied);
    }
}

/// Print a single diagnostic entry.
unsafe fn printError(err: &super::Error, res: &super::Resolver) {
unsafe fn printError 'arena (err: &super::Error, res: &super::Resolver 'arena) {
    if let node = err.node {
        // Find the module containing this error.
        if let moduleEntry = module::get(res.moduleGraph, err.moduleId) {
            // Get the source text if available.
            if let source = moduleEntry.source {
            if let source = module::sourceFor(moduleEntry) {
                // Convert offset to location.
                if let loc = scanner::getLocation(scanner::SourceLoc::File(moduleEntry.filePath), source, node.span.offset) {
                    // Print: filename:line:col: error: message
                    if let case scanner::SourceLoc::File(path) = loc.source {
                        io::print(path);

            io::print("catch with inferred binding requires single error type; use typed catches for multiple error types");
        }
        case super::ErrorKind::TryCatchDuplicateType => {
            io::print("duplicate error type in catch clauses");
        }
        case super::ErrorKind::AmbiguousRegionalError => {
            io::print("error types must remain distinct after region erasure");
        }
        case super::ErrorKind::TryCatchNonExhaustive => {
            io::print("catch clauses do not cover all error types");
        }
        case super::ErrorKind::MissingTry => {
            io::print("called fallible function without using try");

            io::print("`Copy` composite contains a non-copy value");
        }
        case super::ErrorKind::ConflictingOwnershipMarkers => {
            io::print("a composite cannot be both `Copy` and `Once`");
        }
        case super::ErrorKind::UnknownRegion(name) => {
            io::print("unknown region ");
            io::print(name);
        }
        case super::ErrorKind::RegionArgumentCount(count) => {
            printMismatch("region argument count", "expected", count);
        }
        case super::ErrorKind::RegionInference(name) => {
            io::print("cannot infer a consistent argument for region ");
            io::print(name);
        }
        case super::ErrorKind::RegionParent(name) => {
            io::print("region argument does not satisfy the parent relation for ");
            io::print(name);
        }
        case super::ErrorKind::RecursiveType => io::print("recursive value type has no finite layout"),
        case super::ErrorKind::RegionCycle(name) => {
            io::print("cyclic region parent relation for ");
            io::print(name);
        }
        case super::ErrorKind::InvalidRefPosition => {
            io::print("reference type is only allowed as a parameter or local binding");
        }
        case super::ErrorKind::RefBinding => {
            io::print("reference local requires an immutable binding to existing storage");

            io::print("unsafe operation requires an unsafe function or block");
        }
        case super::ErrorKind::UnsafeCall => {
            io::print("calling an unsafe function requires an unsafe function or block");
        }
        case super::ErrorKind::InvalidAllocationValue => {
            io::print("session allocation requires a value safe for bulk reclamation and plain Copy elements for slices");
        }
        case super::ErrorKind::InvalidAllocationLayout => {
            io::print("invalid or overflowing allocation layout");
        }
        case super::ErrorKind::InvalidAllocationRuntime => {
            io::print("invalid standard allocation trait signature");
        }
        case super::ErrorKind::InvalidCellPayload => {
            io::print("cell payload must be a storable plain Copy value");
        }
        case super::ErrorKind::InvalidSessionSource => {
            io::print("session requires one exclusive borrow of an std::lang::alloc::Alloc implementer");
        }
        case super::ErrorKind::RegionalLoanOverflow => io::print("too many simultaneous regional projections"),
        case super::ErrorKind::RegionEscape(name) => {
            io::print("value outlives region ");
            io::print(name);
        }
        case super::ErrorKind::Internal => {
            io::print("internal compiler error");
        }
        case super::ErrorKind::RecordFieldOutOfOrder { .. } => {
            io::print("record field out of order");

    }
    io::print("\n");
}

/// Entry point for printing resolver diagnostics in vim quickfix format.
export unsafe fn printDiagnostics(diag: &super::Diagnostics, res: &super::Resolver) {
export unsafe fn printDiagnostics 'arena (diag: &super::Diagnostics, res: &super::Resolver 'arena) {
    for i in 0..diag.errors.len {
        printError(&diag.errors[i], res);
    }
}

/// Print an applied nominal type's explicit region arguments.
unsafe fn printNominalArguments(applied: *unsafe super::NominalApplication) {
    for region in applied.arguments {
        io::print(" ");
        io::print(region.name);
    }
}

lib/std/lang/resolver/tests.rad +4954 -3120

//! Resolver tests.

/// Region identity, borrowing, and nominal application tests.
@test mod regions;

use std::mem;
use std::testing;
use std::lang::alloc;
use std::lang::ast;
use std::lang::types;


/// Package scope used by resolver tests.
unsafe static PKG_SCOPE: super::Scope = undefined;

/// Module entries used by resolver tests.
unsafe static MODULE_ENTRIES: [module::ModuleEntry; 8] = undefined;
unsafe static MODULE_ENTRIES: [?*module::ModuleEntry; 8] = [nil; 8];

/// Module graph used by resolver tests.
unsafe static MODULE_GRAPH: module::ModuleGraph = undefined;

/// Module AST arena storage used by resolver tests.
static MODULE_ARENA_STORAGE: [u8; 4096] = [0; 4096];
static MODULE_ARENA_STORAGE: [u8; 16384] = [0; 16384];

/// Module AST arena used by resolver tests.
unsafe static MODULE_ARENA: ast::NodeArena = undefined;

/// Interned string pool used by resolver tests.

    "Second", "Opt", "x",
    "value", "idx"
];

/// Resolver result with AST, used by test helpers.
record TestResult: Copy {
export record TestResult: Copy {
    /// Diagnostics from semantic analysis.
    diagnostics: super::Diagnostics,
    /// Root of the parsed test program.
    root: *ast::Node,
}

/// Create isolated storage for tests to avoid conflicts with global resolver storage.
unsafe fn testStorage() -> super::ResolverStorage {
    return super::ResolverStorage {
        arena: alloc::new(&mut ARENA_STORAGE[..]),
        nodeData: &mut NODE_DATA_STORAGE[..],
        pkgScope: &mut PKG_SCOPE,
        errors: &mut ERROR_STORAGE[..],
    };
}

/// Create an arena owner for one resolver test scope.
export unsafe fn testArena() -> alloc::Arena {
    return alloc::new(&mut ARENA_STORAGE[..]);
}

/// Construct a resolver backed by test storage and a synthetic module graph.
unsafe fn testResolver() -> super::Resolver {
export unsafe fn testResolver 'arena (arena: &'arena mut alloc::Arena) -> super::Resolver 'arena {
    // TODO: This should be initialized only once.
    for i in 0..LITERALS.len {
        strings::intern(&mut STRING_POOL, LITERALS[i]);
    }
    // TODO: Use local static for this.
    // Reset the module graph for each test.
    set MODULE_ARENA = ast::nodeArena(&mut MODULE_ARENA_STORAGE[..]);
    set MODULE_GRAPH = module::moduleGraph(&mut MODULE_ENTRIES[..], &mut MODULE_ARENA);
    let config = super::Config { buildTest: true };
    let res = super::resolver(testStorage(), config);
    let res = super::resolver(arena, testStorage(), config);

    return res;
}

/// Resolve a block of statements by wrapping them in a synthetic function.
unsafe fn resolveStatements(
    self: &mut super::Resolver, block: ast::Block, arena: &mut ast::NodeArena
unsafe fn resolveStatements 'arena (
    self: &mut super::Resolver 'arena, block: ast::Block, arena: &mut ast::NodeArena
) -> TestResult throws (super::ResolveError) {
    let module = ast::synthFnModule(arena, super::ANALYZE_BLOCK_FN_NAME, block.statements);
    let diagnostics = try super::resolveModuleRoot(self, module.modBody) catch {
        return TestResult { diagnostics: super::diagnostics(self), root: module.modBody };
    };
    return TestResult { diagnostics, root: module.fnBody };
}

/// Parse and analyze an expression string for testing.
unsafe fn resolveExprStr(self: &mut super::Resolver, stmt: *[u8]) -> TestResult throws (testing::TestError) {
unsafe fn resolveExprStr 'arena (self: &mut super::Resolver 'arena, stmt: *[u8]) -> TestResult throws (testing::TestError) {
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut p = parser::mkParser(scanner::SourceLoc::String, stmt, &mut arena, &mut STRING_POOL);
    parser::advance(&mut p);

    let expr = try parser::parseExpr(&mut p) catch {

    return TestResult { diagnostics, root: expr };
}

/// Parse and analyze a module string for testing.
/// Use this for code with `fn`, `record`, `union`, etc. at the top level.
unsafe fn resolveProgramStr(self: &mut super::Resolver, stmt: *[u8]) -> TestResult throws (testing::TestError) {
export unsafe fn resolveProgramStr 'arena (self: &mut super::Resolver 'arena, stmt: *[u8]) -> TestResult throws (testing::TestError) {
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let stmt: *ast::Node = try parser::parse(scanner::SourceLoc::String, stmt, &mut arena, &mut STRING_POOL) catch {
        panic "resolveProgramStr: parsing failed";
    };
    let diagnostics = try super::resolveModuleRoot(self, stmt) catch {
        throw testing::TestError::Failed;
    };
    return TestResult { diagnostics, root: stmt };
}

/// Resolve session diagnostics against the standard allocator declaration contract.
export unsafe fn resolveSessionProgramStr 'arena (self: &mut super::Resolver 'arena, program: *[u8]) -> TestResult
    throws (testing::TestError)
{
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let root = try registerModule(&mut MODULE_GRAPH, nil, "std", "export mod lang; mod app;", &mut arena);
    let lang = try registerModule(&mut MODULE_GRAPH, root, "lang", "export mod alloc;", &mut arena);
    let allocator = try registerModule(&mut MODULE_GRAPH, lang, "alloc",
        "export record Arena { data: *mut [u8], offset: u32 } export fn reset(arena: &mut Arena) { set arena.offset = 0; } export union AllocError: Copy { OutOfMemory } export trait Alloc { unsafe fn (&mut Alloc) reserve(size: u32, alignment: u32) -> *unsafe mut opaque throws (AllocError); unsafe fn (&mut Alloc) reserveSlice(itemSize: u32, itemAlignment: u32, count: u32) -> *unsafe mut [opaque] throws (AllocError); } instance Alloc for Arena { unsafe fn (arena: &mut Arena) reserve(size: u32, alignment: u32) -> *unsafe mut opaque throws (AllocError) { panic; } unsafe fn (arena: &mut Arena) reserveSlice(size: u32, alignment: u32, count: u32) -> *unsafe mut [opaque] throws (AllocError) { panic; } }",
        &mut arena);
    let app = try registerModule(&mut MODULE_GRAPH, root, "app", program, &mut arena);
    return try resolveModuleTree(self, root);
}

/// Parse and analyze a block of statements (eg. inside a function body) for testing.
/// Use this for code with `let` bindings and expressions, not module-level declarations.
unsafe fn resolveBlockStr(self: &mut super::Resolver, stmt: *[u8]) -> TestResult throws (testing::TestError) {
unsafe fn resolveBlockStr 'arena (self: &mut super::Resolver 'arena, stmt: *[u8]) -> TestResult throws (testing::TestError) {
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let parsed = try parser::parse(scanner::SourceLoc::String, stmt, &mut arena, &mut STRING_POOL) catch {
        panic "resolveBlockStr: parsing failed";
    };
    let case ast::NodeValue::Block(block) = parsed.value

        root: analysis.root,
    };
}

/// Resolve a module with the full resolution process.
unsafe fn resolveModuleTree(
    res: &mut super::Resolver,
unsafe fn resolveModuleTree 'arena (
    res: &mut super::Resolver 'arena,
    rootId: u16
) -> TestResult throws (testing::TestError) {
    let root = module::get(&MODULE_GRAPH, rootId)
        else throw testing::TestError::Failed;
    let rootAst = root.ast
    let rootAst = module::astFor(root)
        else throw testing::TestError::Failed;
    let packages = [super::Pkg {
        rootEntry: root,
        rootAst,
    }];

    };
    return modId;
}

/// Ensure an expression statement produces the expected type and return the expression node.
fn expectExprStmtType(self: &super::Resolver, node: *ast::Node, expected: super::Type) -> *ast::Node
fn expectExprStmtType 'arena (self: &super::Resolver 'arena, node: *ast::Node, expected: super::Type) -> *ast::Node
    throws (testing::TestError)
{
    let case ast::NodeValue::ExprStmt(expr) = node.value
        else throw testing::TestError::Failed;
    try expectType(self, expr, expected);

    return expr;
}

/// Assert that the test result contains no diagnostic errors.
fn expectNoErrors(r: &TestResult) throws (testing::TestError) {
export fn expectNoErrors(r: &TestResult) throws (testing::TestError) {
    try testing::expect(super::success(&r.diagnostics));
}

/// Extract the first error from a test result, failing if none exists.
fn expectError(result: &TestResult) -> super::Error throws (testing::TestError) {
export fn expectError(result: &TestResult) -> super::Error throws (testing::TestError) {
    let err = super::errorAt(&result.diagnostics.errors[..], 0)
        else throw testing::TestError::Failed;
    return err;
}


    }
    return *actual == expected;
}

/// Extract the first error and ensure it has the expected kind.
fn expectErrorKind(result: &TestResult, kind: super::ErrorKind) -> super::Error
export fn expectErrorKind(result: &TestResult, kind: super::ErrorKind) -> super::Error
    throws (testing::TestError)
{
    let err = try expectError(result);
    try testing::expect(errorKindMatches(&err.kind, kind));
    return err;
}

/// Ensure an expression resolves to the expected type annotation.
fn expectType(self: &super::Resolver, expr: *ast::Node, expected: super::Type)
fn expectType 'arena (self: &super::Resolver 'arena, expr: *ast::Node, expected: super::Type)
    throws (testing::TestError)
{
    let actual = super::typeFor(self, expr)
        else throw testing::TestError::Failed;


    try testing::expect(mismatch.actual == actual);
}

/// Resolve a program and require successful analysis.
unsafe fn expectAnalyzeOk(program: *[u8]) throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena1 = testArena();
    let testStorage1: 'test1 = &mut testArena1 in {
        let mut a = testResolver(testStorage1);
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Require an inferred integer type mismatch.
unsafe fn expectIntMismatch(program: *[u8], expected: super::Type)
    throws (testing::TestError)
{
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, expected, super::Type::Int);
    let mut testArena2 = testArena();
    let testStorage2: 'test2 = &mut testArena2 in {
        let mut a = testResolver(testStorage2);
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        try expectTypeMismatch(err, expected, super::Type::Int);
    }
}

/// Retrieve the nth statement from a block node.
fn getBlockStmt(block: *ast::Node, index: u32) -> *ast::Node
export fn getBlockStmt(block: *ast::Node, index: u32) -> *ast::Node
    throws (testing::TestError)
{
    let case ast::NodeValue::Block(body) = block.value
        else throw testing::TestError::Failed;


    }
    return body.statements[index];
}

/// Retrieve a function body block by function name from the program scope.
unsafe fn getFnBody(a: &super::Resolver, root: *ast::Node, name: *[u8]) -> ast::Block
unsafe fn getFnBody 'arena (a: &super::Resolver 'arena, root: *ast::Node, name: *[u8]) -> ast::Block
    throws (testing::TestError)
{
    let scope = super::scopeFor(a, root)
        else throw testing::TestError::Failed;
    let sym = super::findSymbolInScope(scope, name)

    }
    panic "getUnionVariantPayload: variant not found";
}

/// Get a nominal type by name, in the scope of the given block node.
unsafe fn getTypeInScopeOf(a: &super::Resolver, blk: *ast::Node, name: *[u8]) -> *unsafe super::NominalType
unsafe fn getTypeInScopeOf 'arena (a: &super::Resolver 'arena, blk: *ast::Node, name: *[u8]) -> *unsafe super::NominalType
    throws (testing::TestError)
{
    let scope = super::scopeFor(a, blk)
        else throw testing::TestError::Failed;
    let sym = super::findSymbolInScope(scope, name)

        else throw testing::TestError::Failed;
    return ty;
}

/// Return the resolved type of a syntax node.
fn typeOf(a: &super::Resolver, node: *ast::Node) -> super::Type
fn typeOf 'arena (a: &super::Resolver 'arena, node: *ast::Node) -> super::Type
    throws (testing::TestError)
{
    let ty = super::typeFor(a, node)
        else throw testing::TestError::Failed;
    return ty;


    return *target;
}

/// Verify that a node has a constant integer value with the expected magnitude.
fn expectConstInt(a: &super::Resolver, node: *ast::Node, expected: u32)
fn expectConstInt 'arena (a: &super::Resolver 'arena, node: *ast::Node, expected: u32)
    throws (testing::TestError)
{
    let constVal = super::constValueEntry(a, node)
        else throw testing::TestError::Failed;



/// Resolve an expression that should evaluate to a constant, and verify it equals the expected value.
unsafe fn resolveAndExpectConstExpr(expr: *[u8], expected: u32)
    throws (testing::TestError)
{
    let mut a = testResolver();
    let result = try resolveExprStr(&mut a, expr);
    try expectNoErrors(&result);
    try expectType(&a, result.root, super::Type::U32);
    try expectConstInt(&a, result.root, expected);
    let mut testArena3 = testArena();
    let testStorage3: 'test3 = &mut testArena3 in {
        let mut a = testResolver(testStorage3);
        let result = try resolveExprStr(&mut a, expr);
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::U32);
        try expectConstInt(&a, result.root, expected);
    }
}

/// Resolve a statement that should evaluate to a constant, and verify it equals the expected value.
unsafe fn resolveAndExpectConstStmt(expr: *[u8], expected: u32)
    throws (testing::TestError)
{
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, expr);
    try expectNoErrors(&result);
    let stmt = try getBlockStmt(result.root, 1);
    let expr = try expectExprStmtType(&a, stmt, super::Type::U32);
    try expectConstInt(&a, expr, expected);
    let mut testArena4 = testArena();
    let testStorage4: 'test4 = &mut testArena4 in {
        let mut a = testResolver(testStorage4);
        let result = try resolveProgramStr(&mut a, expr);
        try expectNoErrors(&result);
        let stmt = try getBlockStmt(result.root, 1);
        let expr = try expectExprStmtType(&a, stmt, super::Type::U32);
        try expectConstInt(&a, expr, expected);
    }
}

// Tests ///////////////////////////////////////////////////////////////////////

@test unsafe fn testResolveLit() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveExprStr(&mut a, "true");
    let mut testArena5 = testArena();
    let testStorage5: 'test5 = &mut testArena5 in {
        let mut a = testResolver(testStorage5);
        let result = try resolveExprStr(&mut a, "true");

    try expectNoErrors(&result);
    try expectType(&a, result.root, super::Type::Bool);
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
    }
}

@test unsafe fn testResolveStringLiteralType() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveExprStr(&mut a, "\"hello\"");
    let mut testArena6 = testArena();
    let testStorage6: 'test6 = &mut testArena6 in {
        let mut a = testResolver(testStorage6);
        let result = try resolveExprStr(&mut a, "\"hello\"");

    try expectNoErrors(&result);
    let ty = try typeOf(&a, result.root);
    let elemTy = try expectSliceType(ty, false);
    try testing::expect(elemTy == super::Type::U8);
        try expectNoErrors(&result);
        let ty = try typeOf(&a, result.root);
        let elemTy = try expectSliceType(ty, false);
        try testing::expect(elemTy == super::Type::U8);
    }
}

@test unsafe fn testResolveAsNumeric() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "1 as u32");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::U32);
        let mut testArena7 = testArena();
        let testStorage7: 'test7 = &mut testArena7 in {
            let mut a = testResolver(testStorage7);
            let result = try resolveExprStr(&mut a, "1 as u32");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::U32);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u32 = 913; x as u8;");
        try expectNoErrors(&result);
        let mut testArena8 = testArena();
        let testStorage8: 'test8 = &mut testArena8 in {
            let mut a = testResolver(testStorage8);
            let result = try resolveBlockStr(&mut a, "let x: u32 = 913; x as u8;");
            try expectNoErrors(&result);

        let x = try getBlockStmt(result.root, 1);
        try expectExprStmtType(&a, x, super::Type::U8);
            let x = try getBlockStmt(result.root, 1);
            try expectExprStmtType(&a, x, super::Type::U8);
        }
    }
}

@test unsafe fn testResolveAsInvalid() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "true as u32");

    try expectErrorKind(
        &result,
        super::ErrorKind::InvalidAsCast(super::InvalidAsCast {
            from: super::Type::Bool,
            to: super::Type::U32,
    let mut testArena9 = testArena();
    let testStorage9: 'test9 = &mut testArena9 in {
        let mut a = testResolver(testStorage9);
        let result = try resolveProgramStr(&mut a, "true as u32");

        try expectErrorKind(
            &result,
            super::ErrorKind::InvalidAsCast(super::InvalidAsCast {
                from: super::Type::Bool,
                to: super::Type::U32,
        })
    );
        );
    }
}

@test unsafe fn testResolveAsUnionToInt() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Color { Red } Color::Red as u32;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena10 = testArena();
    let testStorage10: 'test10 = &mut testArena10 in {
        let mut a = testResolver(testStorage10);
        let program = "union Color { Red } Color::Red as u32;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let red = try getBlockStmt(result.root, 1);
    try expectExprStmtType(&a, red, super::Type::U32);
        let red = try getBlockStmt(result.root, 1);
        try expectExprStmtType(&a, red, super::Type::U32);
    }
}

@test unsafe fn testResolveBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveBlockStr(&mut a, "let x: bool = true; x;");
    let stmt = try parser::tests::getBlockLastStmt(result.root);
    let mut testArena11 = testArena();
    let testStorage11: 'test11 = &mut testArena11 in {
        let mut a = testResolver(testStorage11);
        let result = try resolveBlockStr(&mut a, "let x: bool = true; x;");
        let stmt = try parser::tests::getBlockLastStmt(result.root);

    try expectNoErrors(&result);
    try expectType(&a, stmt, super::Type::Void);
    try expectExprStmtType(&a, stmt, super::Type::Bool);
        try expectNoErrors(&result);
        try expectType(&a, stmt, super::Type::Void);
        try expectExprStmtType(&a, stmt, super::Type::Bool);

    let case ast::NodeValue::ExprStmt(x) = stmt.value
        else throw testing::TestError::Failed;
        let case ast::NodeValue::ExprStmt(x) = stmt.value
            else throw testing::TestError::Failed;

    let sym = super::symbolFor(&a, x)
        else throw testing::TestError::Failed;
    let case super::SymbolData::Value { type: valType, .. } = sym.data
        else throw testing::TestError::Failed;
    try testing::expect(valType == super::Type::Bool);
        let sym = super::symbolFor(&a, x)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: valType, .. } = sym.data
            else throw testing::TestError::Failed;
        try testing::expect(valType == super::Type::Bool);
    }
}

@test unsafe fn testResolveBindingInvalid() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveBlockStr(&mut a, "let x: i32 = true;");
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::I32, super::Type::Bool);
    let mut testArena12 = testArena();
    let testStorage12: 'test12 = &mut testArena12 in {
        let mut a = testResolver(testStorage12);
        let result = try resolveBlockStr(&mut a, "let x: i32 = true;");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::I32, super::Type::Bool);
    }
}

@test unsafe fn testResolveDuplicateBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveBlockStr(&mut a, "let x: bool = true; let x: u8 = 1;");
    let stmt = try parser::tests::getBlockLastStmt(result.root);
    try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("x"));
    let mut testArena13 = testArena();
    let testStorage13: 'test13 = &mut testArena13 in {
        let mut a = testResolver(testStorage13);
        let result = try resolveBlockStr(&mut a, "let x: bool = true; let x: u8 = 1;");
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("x"));
    }
}

@test unsafe fn testResolveConstLiteralValue() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "constant ANSWER: i32 = 42;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena14 = testArena();
    let testStorage14: 'test14 = &mut testArena14 in {
        let mut a = testResolver(testStorage14);
        let program = "constant ANSWER: i32 = 42;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let constNode = try getBlockStmt(result.root, 0);
    let sym = super::symbolFor(&a, constNode)
        else throw testing::TestError::Failed;
    let case super::SymbolData::Constant { type: constType, .. } = sym.data
        else throw testing::TestError::Failed;
    try testing::expect(constType == super::Type::I32);
        let constNode = try getBlockStmt(result.root, 0);
        let sym = super::symbolFor(&a, constNode)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Constant { type: constType, .. } = sym.data
            else throw testing::TestError::Failed;
        try testing::expect(constType == super::Type::I32);
    }
}

@test unsafe fn testResolveConstRequiresConstantExpr() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn value() -> i32 { return 1 } fn main() { constant ANSWER: i32 = value(); }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectErrorKind(&result, super::ErrorKind::ConstExprRequired);
    let mut testArena15 = testArena();
    let testStorage15: 'test15 = &mut testArena15 in {
        let mut a = testResolver(testStorage15);
        let program = "fn value() -> i32 { return 1 } fn main() { constant ANSWER: i32 = value(); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectErrorKind(&result, super::ErrorKind::ConstExprRequired);

    let errNode = err.node
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Call(_) = errNode.value
        else throw testing::TestError::Failed;
        let errNode = err.node
            else throw testing::TestError::Failed;
        let case ast::NodeValue::Call(_) = errNode.value
            else throw testing::TestError::Failed;
    }
}

@test unsafe fn testResolveStaticLiteralValue() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "static COUNTER: i32 = 0;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena16 = testArena();
    let testStorage16: 'test16 = &mut testArena16 in {
        let mut a = testResolver(testStorage16);
        let program = "static COUNTER: i32 = 0;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let staticNode = try getBlockStmt(result.root, 0);
    let sym = super::symbolFor(&a, staticNode)
        else throw testing::TestError::Failed;
    let case super::SymbolData::Value { type: valType, .. } = sym.data
        else throw testing::TestError::Failed;
    try testing::expect(valType == super::Type::I32);
        let staticNode = try getBlockStmt(result.root, 0);
        let sym = super::symbolFor(&a, staticNode)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: valType, .. } = sym.data
            else throw testing::TestError::Failed;
        try testing::expect(valType == super::Type::I32);
    }
}

@test unsafe fn testResolveStaticRequiresConstantExpr() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn seed() -> i32 { return 1; } static COUNTER: i32 = seed();";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectErrorKind(&result, super::ErrorKind::ConstExprRequired);
    let mut testArena17 = testArena();
    let testStorage17: 'test17 = &mut testArena17 in {
        let mut a = testResolver(testStorage17);
        let program = "fn seed() -> i32 { return 1; } static COUNTER: i32 = seed();";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectErrorKind(&result, super::ErrorKind::ConstExprRequired);

    let errNode = err.node
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Call(_) = errNode.value
        else throw testing::TestError::Failed;
        let errNode = err.node
            else throw testing::TestError::Failed;
        let case ast::NodeValue::Call(_) = errNode.value
            else throw testing::TestError::Failed;
    }
}

@test unsafe fn testSymbolStoresFnAttributes() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "@default export fn f() { return; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena18 = testArena();
    let testStorage18: 'test18 = &mut testArena18 in {
        let mut a = testResolver(testStorage18);
        let program = "@default export fn f() { return; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let scope = super::scopeFor(&a, result.root)
        else throw testing::TestError::Failed;
    let sym = super::findSymbolInScope(scope, "f")
        else throw testing::TestError::Failed;
        let scope = super::scopeFor(&a, result.root)
            else throw testing::TestError::Failed;
        let sym = super::findSymbolInScope(scope, "f")
            else throw testing::TestError::Failed;

    try testing::expect(ast::hasAttribute(sym.attrs, ast::Attribute::Export));
    try testing::expect(ast::hasAttribute(sym.attrs, ast::Attribute::Default));
    try testing::expectNot(ast::hasAttribute(sym.attrs, ast::Attribute::Extern));
        try testing::expect(ast::hasAttribute(sym.attrs, ast::Attribute::Export));
        try testing::expect(ast::hasAttribute(sym.attrs, ast::Attribute::Default));
        try testing::expectNot(ast::hasAttribute(sym.attrs, ast::Attribute::Extern));
    }
}

@test unsafe fn testSymbolStoresRecordAttributes() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "export record S { value: i32 }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena19 = testArena();
    let testStorage19: 'test19 = &mut testArena19 in {
        let mut a = testResolver(testStorage19);
        let program = "export record S { value: i32 }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let scope = super::scopeFor(&a, result.root)
        else throw testing::TestError::Failed;
    let sym = super::findSymbolInScope(scope, "S")
        else throw testing::TestError::Failed;
        let scope = super::scopeFor(&a, result.root)
            else throw testing::TestError::Failed;
        let sym = super::findSymbolInScope(scope, "S")
            else throw testing::TestError::Failed;

    try testing::expect(ast::hasAttribute(sym.attrs, ast::Attribute::Export));
    try testing::expectNot(ast::hasAttribute(sym.attrs, ast::Attribute::Default));
        try testing::expect(ast::hasAttribute(sym.attrs, ast::Attribute::Export));
        try testing::expectNot(ast::hasAttribute(sym.attrs, ast::Attribute::Default));
    }
}

@test unsafe fn testDefaultAttributeRejectedOnRecord() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "@default record T { value: i32 }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::DefaultAttrOnlyOnFn);
    let mut testArena20 = testArena();
    let testStorage20: 'test20 = &mut testArena20 in {
        let mut a = testResolver(testStorage20);
        let program = "@default record T { value: i32 }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::DefaultAttrOnlyOnFn);
    }
}

@test unsafe fn testDefaultAttributeRejectedOnUnion() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "@default union Result { Ok, Err }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::DefaultAttrOnlyOnFn);
    let mut testArena21 = testArena();
    let testStorage21: 'test21 = &mut testArena21 in {
        let mut a = testResolver(testStorage21);
        let program = "@default union Result { Ok, Err }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::DefaultAttrOnlyOnFn);
    }
}

@test unsafe fn testResolveArrayLiteralTyped() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 2] = [1, 2];");
    try expectNoErrors(&result);
    let mut testArena22 = testArena();
    let testStorage22: 'test22 = &mut testArena22 in {
        let mut a = testResolver(testStorage22);
        let result = try resolveProgramStr(&mut a, "let xs: [i32; 2] = [1, 2];");
        try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 0);
    let case ast::NodeValue::Let(decl) = stmt.value
        else throw testing::TestError::Failed;
    let arrayTy = try typeOf(&a, decl.value);
    let elemTy = try expectArrayType(arrayTy, 2);
    try testing::expect(elemTy == super::Type::I32);
        let stmt = try getBlockStmt(result.root, 0);
        let case ast::NodeValue::Let(decl) = stmt.value
            else throw testing::TestError::Failed;
        let arrayTy = try typeOf(&a, decl.value);
        let elemTy = try expectArrayType(arrayTy, 2);
        try testing::expect(elemTy == super::Type::I32);
    }
}

@test unsafe fn testResolveArrayLiteralElementMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [bool; 2] = [true, 1];");
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
    let mut testArena23 = testArena();
    let testStorage23: 'test23 = &mut testArena23 in {
        let mut a = testResolver(testStorage23);
        let result = try resolveProgramStr(&mut a, "let xs: [bool; 2] = [true, 1];");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
    }
}

@test unsafe fn testResolveArrayLiteralCannotInfer() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs = [1, 2];");
    try expectErrorKind(&result, super::ErrorKind::CannotInferType);
    let mut testArena24 = testArena();
    let testStorage24: 'test24 = &mut testArena24 in {
        let mut a = testResolver(testStorage24);
        let result = try resolveProgramStr(&mut a, "let xs = [1, 2];");
        try expectErrorKind(&result, super::ErrorKind::CannotInferType);
    }
}

@test unsafe fn testResolveArrayLiteralOverflow() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [u8; 2] = [1, 256];");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena25 = testArena();
    let testStorage25: 'test25 = &mut testArena25 in {
        let mut a = testResolver(testStorage25);
        let result = try resolveProgramStr(&mut a, "let xs: [u8; 2] = [1, 256];");
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

@test unsafe fn testResolveArrayLiteralTooFewElements() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 2] = [1];");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena26 = testArena();
    let testStorage26: 'test26 = &mut testArena26 in {
        let mut a = testResolver(testStorage26);
        let result = try resolveProgramStr(&mut a, "let xs: [i32; 2] = [1];");
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

@test unsafe fn testResolveArrayLiteralTooManyElements() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 2] = [1, 2, 3];");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena27 = testArena();
    let testStorage27: 'test27 = &mut testArena27 in {
        let mut a = testResolver(testStorage27);
        let result = try resolveProgramStr(&mut a, "let xs: [i32; 2] = [1, 2, 3];");
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

@test unsafe fn testResolveArrayLiteralEmptyWithAnnotation() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 0] = [];");
    try expectNoErrors(&result);
    let mut testArena28 = testArena();
    let testStorage28: 'test28 = &mut testArena28 in {
        let mut a = testResolver(testStorage28);
        let result = try resolveProgramStr(&mut a, "let xs: [i32; 0] = [];");
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveNestedArrayLiteralTyped() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let grid: [[i32; 2]; 2] = [[1, 2], [3, 4]];");
    try expectNoErrors(&result);
    let mut testArena29 = testArena();
    let testStorage29: 'test29 = &mut testArena29 in {
        let mut a = testResolver(testStorage29);
        let result = try resolveProgramStr(&mut a, "let grid: [[i32; 2]; 2] = [[1, 2], [3, 4]];");
        try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 0);
    let case ast::NodeValue::Let(decl) = stmt.value
        else throw testing::TestError::Failed;
    let gridTy = try typeOf(&a, decl.value);
    let rowTy = try expectArrayType(gridTy, 2);
    let elemTy = try expectArrayType(rowTy, 2);
    try testing::expect(elemTy == super::Type::I32);
        let stmt = try getBlockStmt(result.root, 0);
        let case ast::NodeValue::Let(decl) = stmt.value
            else throw testing::TestError::Failed;
        let gridTy = try typeOf(&a, decl.value);
        let rowTy = try expectArrayType(gridTy, 2);
        let elemTy = try expectArrayType(rowTy, 2);
        try testing::expect(elemTy == super::Type::I32);
    }
}

@test unsafe fn testResolveArrayLiteralWithOptionalElems() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [?i32; 2] = [1, 2];");
    try expectNoErrors(&result);
    let mut testArena30 = testArena();
    let testStorage30: 'test30 = &mut testArena30 in {
        let mut a = testResolver(testStorage30);
        let result = try resolveProgramStr(&mut a, "let xs: [?i32; 2] = [1, 2];");
        try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 0);
    let case ast::NodeValue::Let(decl) = stmt.value
        else throw testing::TestError::Failed;
    let arrayTy = try typeOf(&a, decl.value);
    let elemTy = try expectArrayType(arrayTy, 2);
    let case super::Type::Optional(inner) = elemTy
        else throw testing::TestError::Failed;
    try testing::expect(*inner == super::Type::I32);
        let stmt = try getBlockStmt(result.root, 0);
        let case ast::NodeValue::Let(decl) = stmt.value
            else throw testing::TestError::Failed;
        let arrayTy = try typeOf(&a, decl.value);
        let elemTy = try expectArrayType(arrayTy, 2);
        let case super::Type::Optional(inner) = elemTy
            else throw testing::TestError::Failed;
        try testing::expect(*inner == super::Type::I32);
    }
}

@test unsafe fn testResolveArrayLiteralOptionalMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [?bool; 2] = [1, 2];");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena31 = testArena();
    let testStorage31: 'test31 = &mut testArena31 in {
        let mut a = testResolver(testStorage31);
        let result = try resolveProgramStr(&mut a, "let xs: [?bool; 2] = [1, 2];");
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

@test unsafe fn testResolveArrayRepeatBasic() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 3] = [42; 3];");
    try expectNoErrors(&result);
    let mut testArena32 = testArena();
    let testStorage32: 'test32 = &mut testArena32 in {
        let mut a = testResolver(testStorage32);
        let result = try resolveProgramStr(&mut a, "let xs: [i32; 3] = [42; 3];");
        try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 0);
    let case ast::NodeValue::Let(decl) = stmt.value
        else throw testing::TestError::Failed;
    let arrayTy = try typeOf(&a, decl.value);
    let elemTy = try expectArrayType(arrayTy, 3);
    try testing::expect(elemTy == super::Type::I32);
        let stmt = try getBlockStmt(result.root, 0);
        let case ast::NodeValue::Let(decl) = stmt.value
            else throw testing::TestError::Failed;
        let arrayTy = try typeOf(&a, decl.value);
        let elemTy = try expectArrayType(arrayTy, 3);
        try testing::expect(elemTy == super::Type::I32);
    }
}

@test unsafe fn testResolveArrayRepeatWithExpression() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 5] = [3 + 2; 5];");
    try expectNoErrors(&result);
    let mut testArena33 = testArena();
    let testStorage33: 'test33 = &mut testArena33 in {
        let mut a = testResolver(testStorage33);
        let result = try resolveProgramStr(&mut a, "let xs: [i32; 5] = [3 + 2; 5];");
        try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 0);
    let case ast::NodeValue::Let(decl) = stmt.value
        else throw testing::TestError::Failed;
    let arrayTy = try typeOf(&a, decl.value);
    let elemTy = try expectArrayType(arrayTy, 5);
    try testing::expect(elemTy == super::Type::I32);
        let stmt = try getBlockStmt(result.root, 0);
        let case ast::NodeValue::Let(decl) = stmt.value
            else throw testing::TestError::Failed;
        let arrayTy = try typeOf(&a, decl.value);
        let elemTy = try expectArrayType(arrayTy, 5);
        try testing::expect(elemTy == super::Type::I32);
    }
}

@test unsafe fn testResolveArrayRepeatLiteralArithmetic() throws (testing::TestError) {
    let mut a = testResolver();
    // `3 * 1` folds to a compile-time constant, so the repeat count is valid.
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 3] = [42; 3 * 1];");
    try expectNoErrors(&result);
    let mut testArena34 = testArena();
    let testStorage34: 'test34 = &mut testArena34 in {
        let mut a = testResolver(testStorage34);
        // `3 * 1` folds to a compile-time constant, so the repeat count is valid.
        let result = try resolveProgramStr(&mut a, "let xs: [i32; 3] = [42; 3 * 1];");
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveArrayRepeatNonConstCount() throws (testing::TestError) {
    let mut a = testResolver();
    // A function call is not a constant expression.
    let result = try resolveProgramStr(&mut a, "fn f() -> u32 { return 3; } let xs: [i32; 3] = [42; f()];");
    try expectErrorKind(&result, super::ErrorKind::ConstExprRequired);
    let mut testArena35 = testArena();
    let testStorage35: 'test35 = &mut testArena35 in {
        let mut a = testResolver(testStorage35);
        // A function call is not a constant expression.
        let result = try resolveProgramStr(&mut a, "fn f() -> u32 { return 3; } let xs: [i32; 3] = [42; f()];");
        try expectErrorKind(&result, super::ErrorKind::ConstExprRequired);
    }
}

@test unsafe fn testResolveArrayRepeatCountMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 4] = [1; 3];");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena36 = testArena();
    let testStorage36: 'test36 = &mut testArena36 in {
        let mut a = testResolver(testStorage36);
        let result = try resolveProgramStr(&mut a, "let xs: [i32; 4] = [1; 3];");
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

@test unsafe fn testResolveArrayIndex() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [i32; 3] = [1, 2, 3]; xs[1];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena37 = testArena();
    let testStorage37: 'test37 = &mut testArena37 in {
        let mut a = testResolver(testStorage37);
        let program = "let xs: [i32; 3] = [1, 2, 3]; xs[1];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 1);
    try expectExprStmtType(&a, stmt, super::Type::I32);
        let stmt = try getBlockStmt(result.root, 1);
        try expectExprStmtType(&a, stmt, super::Type::I32);
    }
}

@test unsafe fn testResolveSliceIndex() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "static xs: [i32; 4] = [1, 2, 3, 4]; let slice = &xs[1..]; slice[1];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena38 = testArena();
    let testStorage38: 'test38 = &mut testArena38 in {
        let mut a = testResolver(testStorage38);
        let program = "static xs: [i32; 4] = [1, 2, 3, 4]; let slice = &xs[1..]; slice[1];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let sliceStmt = try getBlockStmt(result.root, 1);
    let case ast::NodeValue::Let(sliceDecl) = sliceStmt.value
        else throw testing::TestError::Failed;
    let sliceTy = try typeOf(&a, sliceDecl.value);
    let elemTy = try expectSliceType(sliceTy, false);
    try testing::expect(elemTy == super::Type::I32);
        let sliceStmt = try getBlockStmt(result.root, 1);
        let case ast::NodeValue::Let(sliceDecl) = sliceStmt.value
            else throw testing::TestError::Failed;
        let sliceTy = try typeOf(&a, sliceDecl.value);
        let elemTy = try expectSliceType(sliceTy, false);
        try testing::expect(elemTy == super::Type::I32);

    let indexStmt = try getBlockStmt(result.root, 2);
    try expectExprStmtType(&a, indexStmt, super::Type::I32);
        let indexStmt = try getBlockStmt(result.root, 2);
        try expectExprStmtType(&a, indexStmt, super::Type::I32);
    }
}

@test unsafe fn testResolveSliceFields() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "static xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[1..]; slice.len; unsafe { slice.ptr; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena39 = testArena();
    let testStorage39: 'test39 = &mut testArena39 in {
        let mut a = testResolver(testStorage39);
        let program = "static xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[1..]; slice.len; unsafe { slice.ptr; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let lenStmt = try getBlockStmt(result.root, 2);
    let case ast::NodeValue::ExprStmt(lenExpr) = lenStmt.value
        else throw testing::TestError::Failed;
    let lenTy = try typeOf(&a, lenExpr);
    try testing::expect(lenTy == super::Type::U32);
        let lenStmt = try getBlockStmt(result.root, 2);
        let case ast::NodeValue::ExprStmt(lenExpr) = lenStmt.value
            else throw testing::TestError::Failed;
        let lenTy = try typeOf(&a, lenExpr);
        try testing::expect(lenTy == super::Type::U32);

    let ptrStmt = try getBlockStmt(result.root, 3);
    let case ast::NodeValue::Block(ptrBlock) = ptrStmt.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::ExprStmt(ptrExpr) = ptrBlock.statements[0].value
        else throw testing::TestError::Failed;
    let ptrTy = try typeOf(&a, ptrExpr);
    let targetTy = try expectPointerType(ptrTy, false);
    try testing::expect(targetTy == super::Type::I32);
        let ptrStmt = try getBlockStmt(result.root, 3);
        let case ast::NodeValue::Block(ptrBlock) = ptrStmt.value
            else throw testing::TestError::Failed;
        let case ast::NodeValue::ExprStmt(ptrExpr) = ptrBlock.statements[0].value
            else throw testing::TestError::Failed;
        let ptrTy = try typeOf(&a, ptrExpr);
        let targetTy = try expectPointerType(ptrTy, false);
        try testing::expect(targetTy == super::Type::I32);
    }
}

@test unsafe fn testResolveSliceLiteralImmutable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let slice: *[i32] = &[1, 2, 3];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena40 = testArena();
    let testStorage40: 'test40 = &mut testArena40 in {
        let mut a = testResolver(testStorage40);
        let program = "let slice: *[i32] = &[1, 2, 3];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Empty array literal infers element type from slice annotation.
@test unsafe fn testResolveSliceLiteralEmpty() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let slice: *[i32] = &[];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena41 = testArena();
    let testStorage41: 'test41 = &mut testArena41 in {
        let mut a = testResolver(testStorage41);
        let program = "let slice: *[i32] = &[];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Nested array literal should infer inner element type from slice annotation.
@test unsafe fn testResolveSliceLiteralNestedArray() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let slice: *[[i32; 2]] = &[[1, 2], [3, 4]];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena42 = testArena();
    let testStorage42: 'test42 = &mut testArena42 in {
        let mut a = testResolver(testStorage42);
        let program = "let slice: *[[i32; 2]] = &[[1, 2], [3, 4]];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveSliceFromArray() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "static xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[..];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena43 = testArena();
        let testStorage43: 'test43 = &mut testArena43 in {
            let mut a = testResolver(testStorage43);
            let program = "static xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[..];";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let program = "static xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[0..3];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena44 = testArena();
        let testStorage44: 'test44 = &mut testArena44 in {
            let mut a = testResolver(testStorage44);
            let program = "static xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[0..3];";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let program = "static xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[..3];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena45 = testArena();
        let testStorage45: 'test45 = &mut testArena45 in {
            let mut a = testResolver(testStorage45);
            let program = "static xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[..3];";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let program = "static xs: [u8; 2] = [1, 2]; let slice = &xs[1..1];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena46 = testArena();
        let testStorage46: 'test46 = &mut testArena46 in {
            let mut a = testResolver(testStorage46);
            let program = "static xs: [u8; 2] = [1, 2]; let slice = &xs[1..1];";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

@test unsafe fn testResolveSliceLiteralMutableRequiresMut() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let slice: *mut [i32] = &[1, 2, 3];";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena47 = testArena();
    let testStorage47: 'test47 = &mut testArena47 in {
        let mut a = testResolver(testStorage47);
        let program = "let slice: *mut [i32] = &[1, 2, 3];";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

@test unsafe fn testResolveSliceLiteralMutable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let slice: *mut [i32] = &mut [1, 2, 3];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena48 = testArena();
    let testStorage48: 'test48 = &mut testArena48 in {
        let mut a = testResolver(testStorage48);
        let program = "let slice: *mut [i32] = &mut [1, 2, 3];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolvePointerMutableAssignmentRequiresMut() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let x: i32 = 0; let ptr: *mut i32 = &x;";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena49 = testArena();
    let testStorage49: 'test49 = &mut testArena49 in {
        let mut a = testResolver(testStorage49);
        let program = "let x: i32 = 0; let ptr: *mut i32 = &x;";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

@test unsafe fn testResolvePointerMutableToImmutableAssignment() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "static x: i32 = 0; let mptr: *mut i32 = &mut x; let ptr: *i32 = mptr;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena50 = testArena();
    let testStorage50: 'test50 = &mut testArena50 in {
        let mut a = testResolver(testStorage50);
        let program = "static x: i32 = 0; let mptr: *mut i32 = &mut x; let ptr: *i32 = mptr;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveAddressOfRequiresMutableBinding() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let x: i32 = 0; let ptr = &mut x;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        let mut testArena51 = testArena();
        let testStorage51: 'test51 = &mut testArena51 in {
            let mut a = testResolver(testStorage51);
            let program = "let x: i32 = 0; let ptr = &mut x;";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        }
    } {
        let mut a = testResolver();
        let program = "let mut x: i32 = 0; &mut x;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena52 = testArena();
        let testStorage52: 'test52 = &mut testArena52 in {
            let mut a = testResolver(testStorage52);
            let program = "let mut x: i32 = 0; &mut x;";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

@test unsafe fn testResolveAddressOfSliceRequiresMutableBinding() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let xs: [i32; 3] = [1, 2, 3]; let slice = &mut xs[..];";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        let mut testArena53 = testArena();
        let testStorage53: 'test53 = &mut testArena53 in {
            let mut a = testResolver(testStorage53);
            let program = "let xs: [i32; 3] = [1, 2, 3]; let slice = &mut xs[..];";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        }
    } {
        let mut a = testResolver();
        let program = "let mut xs: [i32; 3] = [1, 2, 3]; &mut xs[..];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena54 = testArena();
        let testStorage54: 'test54 = &mut testArena54 in {
            let mut a = testResolver(testStorage54);
            let program = "let mut xs: [i32; 3] = [1, 2, 3]; &mut xs[..];";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

@test unsafe fn testResolveSliceCannotAssignToArray() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: *[u8] = &[1, 2]; let ys: [u8; 2] = xs;";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena55 = testArena();
    let testStorage55: 'test55 = &mut testArena55 in {
        let mut a = testResolver(testStorage55);
        let program = "let xs: *[u8] = &[1, 2]; let ys: [u8; 2] = xs;";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

@test unsafe fn testResolveSliceSyntaxRequiresAddressOf() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [u8; 2] = [1, 2]; xs[..];";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::SliceRequiresAddress);
    let mut testArena56 = testArena();
    let testStorage56: 'test56 = &mut testArena56 in {
        let mut a = testResolver(testStorage56);
        let program = "let xs: [u8; 2] = [1, 2]; xs[..];";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::SliceRequiresAddress);
    }
}

@test unsafe fn testResolveSliceResliceRequiresAddressOf() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(s: *[u8]) -> *[u8] { return s[..]; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::SliceRequiresAddress);
    let mut testArena57 = testArena();
    let testStorage57: 'test57 = &mut testArena57 in {
        let mut a = testResolver(testStorage57);
        let program = "fn f(s: *[u8]) -> *[u8] { return s[..]; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::SliceRequiresAddress);
    }
}

@test unsafe fn testResolveSliceRangeOutOfBounds() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let xs: [u8; 2] = [1, 2]; let slice = &xs[..3];";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::SliceRangeOutOfBounds);
        let mut testArena58 = testArena();
        let testStorage58: 'test58 = &mut testArena58 in {
            let mut a = testResolver(testStorage58);
            let program = "let xs: [u8; 2] = [1, 2]; let slice = &xs[..3];";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::SliceRangeOutOfBounds);
        }
    } {
        let mut a = testResolver();
        let program = "let xs: [u8; 2] = [1, 2]; let slice = &xs[3..];";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::SliceRangeOutOfBounds);
        let mut testArena59 = testArena();
        let testStorage59: 'test59 = &mut testArena59 in {
            let mut a = testResolver(testStorage59);
            let program = "let xs: [u8; 2] = [1, 2]; let slice = &xs[3..];";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::SliceRangeOutOfBounds);
        }
    } {
        let mut a = testResolver();
        let program = "let xs: [u8; 4] = [1, 2, 3, 4]; let slice = &xs[3..2];";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::SliceRangeOutOfBounds);
        let mut testArena60 = testArena();
        let testStorage60: 'test60 = &mut testArena60 in {
            let mut a = testResolver(testStorage60);
            let program = "let xs: [u8; 4] = [1, 2, 3, 4]; let slice = &xs[3..2];";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::SliceRangeOutOfBounds);
        }
    }
}

@test unsafe fn testResolveArrayLenConstValue() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [i32; 3] = [1, 2, 3]; constant LEN: u32 = xs.len;";
    let result = try resolveBlockStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena61 = testArena();
    let testStorage61: 'test61 = &mut testArena61 in {
        let mut a = testResolver(testStorage61);
        let program = "let xs: [i32; 3] = [1, 2, 3]; constant LEN: u32 = xs.len;";
        let result = try resolveBlockStr(&mut a, program);
        try expectNoErrors(&result);

    let constStmt = try getBlockStmt(result.root, 1);
    let case ast::NodeValue::ConstDecl(decl) = constStmt.value
        else throw testing::TestError::Failed;
    let valueConst = super::constValueEntry(&a, decl.value)
        else throw testing::TestError::Failed;
    let case super::ConstValue::Int(lenVal) = valueConst
        else throw testing::TestError::Failed;
    try testing::expect(lenVal.magnitude == 3);
    try testing::expect(not lenVal.negative);
        let constStmt = try getBlockStmt(result.root, 1);
        let case ast::NodeValue::ConstDecl(decl) = constStmt.value
            else throw testing::TestError::Failed;
        let valueConst = super::constValueEntry(&a, decl.value)
            else throw testing::TestError::Failed;
        let case super::ConstValue::Int(lenVal) = valueConst
            else throw testing::TestError::Failed;
        try testing::expect(lenVal.magnitude == 3);
        try testing::expect(not lenVal.negative);
    }
}

@test unsafe fn testResolveIndexNonIndexable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let flag: bool = true; flag[0];";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ExpectedIndexable);
    let mut testArena62 = testArena();
    let testStorage62: 'test62 = &mut testArena62 in {
        let mut a = testResolver(testStorage62);
        let program = "let flag: bool = true; flag[0];";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ExpectedIndexable);
    }
}

@test unsafe fn testResolveSliceFieldUnknown() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [i32; 2] = [1, 2]; (&xs[0..]).unknown;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::SliceFieldUnknown("unknown"));
    let mut testArena63 = testArena();
    let testStorage63: 'test63 = &mut testArena63 in {
        let mut a = testResolver(testStorage63);
        let program = "let xs: [i32; 2] = [1, 2]; (&xs[0..]).unknown;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::SliceFieldUnknown("unknown"));
    }
}

@test unsafe fn testResolveArrayFieldUnknown() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [i32; 2] = [1, 2]; xs.field;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ArrayFieldUnknown("field"));
    let mut testArena64 = testArena();
    let testStorage64: 'test64 = &mut testArena64 in {
        let mut a = testResolver(testStorage64);
        let program = "let xs: [i32; 2] = [1, 2]; xs.field;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ArrayFieldUnknown("field"));
    }
}

@test unsafe fn testResolveIfConditionRequiresBool() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "if 42 {}");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
        let mut testArena65 = testArena();
        let testStorage65: 'test65 = &mut testArena65 in {
            let mut a = testResolver(testStorage65);
            let result = try resolveProgramStr(&mut a, "if 42 {}");
            let err = try expectError(&result);
            try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "if true {}");
        try expectNoErrors(&result);
        let mut testArena66 = testArena();
        let testStorage66: 'test66 = &mut testArena66 in {
            let mut a = testResolver(testStorage66);
            let result = try resolveProgramStr(&mut a, "if true {}");
            try expectNoErrors(&result);
        }
    }
}

@test unsafe fn testResolveIfLetScopeBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let opt: ?i32 = 42; if let x = opt { x }");
    try expectNoErrors(&result);
    let mut testArena67 = testArena();
    let testStorage67: 'test67 = &mut testArena67 in {
        let mut a = testResolver(testStorage67);
        let result = try resolveProgramStr(&mut a, "let opt: ?i32 = 42; if let x = opt { x }");
        try expectNoErrors(&result);

    // Get the if-let statement and verify `x` has type `i32`.
    let ifLetStmt = try parser::tests::getBlockLastStmt(result.root);
    let case ast::NodeValue::IfLet(ifLet) = ifLetStmt.value
        else throw testing::TestError::Failed;
        // Get the if-let statement and verify `x` has type `i32`.
        let ifLetStmt = try parser::tests::getBlockLastStmt(result.root);
        let case ast::NodeValue::IfLet(ifLet) = ifLetStmt.value
            else throw testing::TestError::Failed;

    let thenStmt = try parser::tests::getBlockLastStmt(ifLet.thenBranch);
    let case ast::NodeValue::ExprStmt(xExpr) = thenStmt.value
        else throw testing::TestError::Failed;
        let thenStmt = try parser::tests::getBlockLastStmt(ifLet.thenBranch);
        let case ast::NodeValue::ExprStmt(xExpr) = thenStmt.value
            else throw testing::TestError::Failed;

    try expectType(&a, xExpr, super::Type::I32);
        try expectType(&a, xExpr, super::Type::I32);

    let scope = super::scopeFor(&a, ifLetStmt)
        else throw testing::TestError::Failed;
    let xSym = super::findSymbolInScope(scope, "x")
        else throw testing::TestError::Failed;
    let case super::SymbolData::Value { type: valType, .. } = xSym.data
        else throw testing::TestError::Failed;
        let scope = super::scopeFor(&a, ifLetStmt)
            else throw testing::TestError::Failed;
        let xSym = super::findSymbolInScope(scope, "x")
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: valType, .. } = xSym.data
            else throw testing::TestError::Failed;

    try testing::expect(valType == super::Type::I32);
        try testing::expect(valType == super::Type::I32);
    }
}

@test unsafe fn testResolveIfLetScopeBindingError() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let opt: ?i32 = 42; if let x = opt { x } else { x }");
    let err = try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("x"));

    // Verify the error comes from the else branch (offset 48).
    let errNode = err.node
        else throw testing::TestError::Failed;
    try testing::expect(errNode.span.offset == 48);
    let mut testArena68 = testArena();
    let testStorage68: 'test68 = &mut testArena68 in {
        let mut a = testResolver(testStorage68);
        let result = try resolveProgramStr(&mut a, "let opt: ?i32 = 42; if let x = opt { x } else { x }");
        let err = try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("x"));

        // Verify the error comes from the else branch (offset 48).
        let errNode = err.node
            else throw testing::TestError::Failed;
        try testing::expect(errNode.span.offset == 48);
    }
}

/// Tests that `if let` with a condition expression binds the variable in scope.
@test unsafe fn testResolveIfLetConditionBindsVariable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; if let x = opt; x == 1 { x }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena69 = testArena();
    let testStorage69: 'test69 = &mut testArena69 in {
        let mut a = testResolver(testStorage69);
        let program = "let opt: ?i32 = 42; if let x = opt; x == 1 { x }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveWhileConditionRequiresBool() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "while 1 {}");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
        let mut testArena70 = testArena();
        let testStorage70: 'test70 = &mut testArena70 in {
            let mut a = testResolver(testStorage70);
            let result = try resolveProgramStr(&mut a, "while 1 {}");
            let err = try expectError(&result);
            try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "while true {}");
        try expectNoErrors(&result);
        let mut testArena71 = testArena();
        let testStorage71: 'test71 = &mut testArena71 in {
            let mut a = testResolver(testStorage71);
            let result = try resolveProgramStr(&mut a, "while true {}");
            try expectNoErrors(&result);
        }
    }
}

@test unsafe fn testResolveWhileLetBindingScope() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let mut opt: ?i32 = 42; while let x = opt; x > 0 { x; opt; }";
        let mut testArena72 = testArena();
        let testStorage72: 'test72 = &mut testArena72 in {
            let mut a = testResolver(testStorage72);
            let program = "let mut opt: ?i32 = 42; while let x = opt; x > 0 { x; opt; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);

            let whileStmt = try parser::tests::getBlockLastStmt(result.root);
            let case ast::NodeValue::WhileLet(loopNode) = whileStmt.value
                else throw testing::TestError::Failed;

            let bodyStmt = try parser::tests::getBlockFirstStmt(loopNode.body);
            try expectExprStmtType(&a, bodyStmt, super::Type::I32);

            let scope = super::scopeFor(&a, whileStmt)
                else throw testing::TestError::Failed;
            let xSym = super::findSymbolInScope(scope, "x")
                else throw testing::TestError::Failed;
            let case super::SymbolData::Value { type: valType, .. } = xSym.data
                else throw testing::TestError::Failed;
            try testing::expect(valType == super::Type::I32);
        }
    } {
        let mut testArena73 = testArena();
        let testStorage73: 'test73 = &mut testArena73 in {
            let mut a = testResolver(testStorage73);
            let program = "let opt: ?i32 = nil; while let x = opt; true { break } else { x }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("x"));
        }
    }
}

@test unsafe fn testResolveForArrayBindsElementType() throws (testing::TestError) {
    let mut testArena74 = testArena();
    let testStorage74: 'test74 = &mut testArena74 in {
        let mut a = testResolver(testStorage74);
        let program = "let xs: [i32; 2] = [1, 2]; for x in xs { x; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

        let whileStmt = try parser::tests::getBlockLastStmt(result.root);
        let case ast::NodeValue::WhileLet(loopNode) = whileStmt.value
        let forStmt = try parser::tests::getBlockLastStmt(result.root);
        let case ast::NodeValue::For(loopNode) = forStmt.value
            else throw testing::TestError::Failed;

        let bodyStmt = try parser::tests::getBlockFirstStmt(loopNode.body);
        try expectExprStmtType(&a, bodyStmt, super::Type::I32);

        let scope = super::scopeFor(&a, whileStmt)
        let scope = super::scopeFor(&a, forStmt)
            else throw testing::TestError::Failed;
        let xSym = super::findSymbolInScope(scope, "x")
        let sym = super::findSymbolInScope(scope, "x")
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: valType, .. } = xSym.data
        let case super::SymbolData::Value { type: valType, .. } = sym.data
            else throw testing::TestError::Failed;
        try testing::expect(valType == super::Type::I32);
    } {
        let mut a = testResolver();
        let program = "let opt: ?i32 = nil; while let x = opt; true { break } else { x }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("x"));
    }
}

@test unsafe fn testResolveForArrayBindsElementType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [i32; 2] = [1, 2]; for x in xs { x; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let forStmt = try parser::tests::getBlockLastStmt(result.root);
    let case ast::NodeValue::For(loopNode) = forStmt.value
        else throw testing::TestError::Failed;

    let scope = super::scopeFor(&a, forStmt)
        else throw testing::TestError::Failed;
    let sym = super::findSymbolInScope(scope, "x")
        else throw testing::TestError::Failed;
    let case super::SymbolData::Value { type: valType, .. } = sym.data
        else throw testing::TestError::Failed;
    try testing::expect(valType == super::Type::I32);

    let bindingTy = super::typeFor(&a, loopNode.binding)
        else throw testing::TestError::Failed;
    try testing::expect(bindingTy == super::Type::I32);
        let bindingTy = super::typeFor(&a, loopNode.binding)
            else throw testing::TestError::Failed;
        try testing::expect(bindingTy == super::Type::I32);
    }
}

@test unsafe fn testResolveForIndexedLoopBindsIndex() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [bool; 3] = [true; 3]; for value, idx in xs { value; idx; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena75 = testArena();
    let testStorage75: 'test75 = &mut testArena75 in {
        let mut a = testResolver(testStorage75);
        let program = "let xs: [bool; 3] = [true; 3]; for value, idx in xs { value; idx; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let forStmt = try parser::tests::getBlockLastStmt(result.root);
    let case ast::NodeValue::For(loopNode) = forStmt.value
        else throw testing::TestError::Failed;
        let forStmt = try parser::tests::getBlockLastStmt(result.root);
        let case ast::NodeValue::For(loopNode) = forStmt.value
            else throw testing::TestError::Failed;

    let scope = super::scopeFor(&a, forStmt)
        else throw testing::TestError::Failed;
    let valueSym = super::findSymbolInScope(scope, "value")
        else throw testing::TestError::Failed;
    let case super::SymbolData::Value { type: valueValType, .. } = valueSym.data
        else throw testing::TestError::Failed;
    try testing::expect(valueValType == super::Type::Bool);
    let indexSym = super::findSymbolInScope(scope, "idx")
        else throw testing::TestError::Failed;
    let case super::SymbolData::Value { type: indexValType, .. } = indexSym.data
        else throw testing::TestError::Failed;
    try testing::expect(indexValType == super::Type::U32);
        let scope = super::scopeFor(&a, forStmt)
            else throw testing::TestError::Failed;
        let valueSym = super::findSymbolInScope(scope, "value")
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: valueValType, .. } = valueSym.data
            else throw testing::TestError::Failed;
        try testing::expect(valueValType == super::Type::Bool);
        let indexSym = super::findSymbolInScope(scope, "idx")
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: indexValType, .. } = indexSym.data
            else throw testing::TestError::Failed;
        try testing::expect(indexValType == super::Type::U32);

    let indexNode = loopNode.index
        else throw testing::TestError::Failed;
    let indexTy = super::typeFor(&a, indexNode)
        else throw testing::TestError::Failed;
    try testing::expect(indexTy == super::Type::U32);
        let indexNode = loopNode.index
            else throw testing::TestError::Failed;
        let indexTy = super::typeFor(&a, indexNode)
            else throw testing::TestError::Failed;
        try testing::expect(indexTy == super::Type::U32);
    }
}

@test unsafe fn testResolveForSliceIterable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [i32; 3] = [1, 2, 3]; for x in &xs[..] { x; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena76 = testArena();
    let testStorage76: 'test76 = &mut testArena76 in {
        let mut a = testResolver(testStorage76);
        let program = "let xs: [i32; 3] = [1, 2, 3]; for x in &xs[..] { x; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let forStmt = try parser::tests::getBlockLastStmt(result.root);
    let case ast::NodeValue::For(loopNode) = forStmt.value
        else throw testing::TestError::Failed;
        let forStmt = try parser::tests::getBlockLastStmt(result.root);
        let case ast::NodeValue::For(loopNode) = forStmt.value
            else throw testing::TestError::Failed;

    let bindingTy = super::typeFor(&a, loopNode.binding)
        else throw testing::TestError::Failed;
    try testing::expect(bindingTy == super::Type::I32);
        let bindingTy = super::typeFor(&a, loopNode.binding)
            else throw testing::TestError::Failed;
        try testing::expect(bindingTy == super::Type::I32);
    }
}

@test unsafe fn testResolveForRequiresIterable() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "for x in true { x; }");
    try expectErrorKind(&result, super::ErrorKind::ExpectedIterable);
    let mut testArena77 = testArena();
    let testStorage77: 'test77 = &mut testArena77 in {
        let mut a = testResolver(testStorage77);
        let result = try resolveProgramStr(&mut a, "for x in true { x; }");
        try expectErrorKind(&result, super::ErrorKind::ExpectedIterable);
    }
}

@test unsafe fn testResolveForRangeBoundsMustNumeric() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveBlockStr(&mut a, "for i in 0..true { i; }");
    try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
    let mut testArena78 = testArena();
    let testStorage78: 'test78 = &mut testArena78 in {
        let mut a = testResolver(testStorage78);
        let result = try resolveBlockStr(&mut a, "for i in 0..true { i; }");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
    }
}

@test unsafe fn testResolveMatchPatternTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let val: i32 = 0; match val { case true => {} }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::I32, super::Type::Bool);
    let mut testArena79 = testArena();
    let testStorage79: 'test79 = &mut testArena79 in {
        let mut a = testResolver(testStorage79);
        let program = "let val: i32 = 0; match val { case true => {} }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::I32, super::Type::Bool);
    }
}

@test unsafe fn testResolveMatchUnionVariantTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union First { A }  union Second { B } fn run(val: First) { match val { case Second::B => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let mut testArena80 = testArena();
    let testStorage80: 'test80 = &mut testArena80 in {
        let mut a = testResolver(testStorage80);
        let program = "union First { A }  union Second { B } fn run(val: First) { match val { case Second::B => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);

    let firstTy = try getTypeInScopeOf(&a, result.root, "First");
    let secondTy = try getTypeInScopeOf(&a, result.root, "Second");
    try expectTypeMismatch(err, super::Type::Nominal(firstTy), super::Type::Nominal(secondTy));
        let firstTy = try getTypeInScopeOf(&a, result.root, "First");
        let secondTy = try getTypeInScopeOf(&a, result.root, "Second");
        try expectTypeMismatch(err, super::Type::Nominal(firstTy), super::Type::Nominal(secondTy));
    }
}

@test unsafe fn testResolveMatchUnionPayloadMissing() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some(i32) } fn run(val: Opt) { match val { case Opt::Some => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnionVariantPayloadMissing("Some"));
    let mut testArena81 = testArena();
    let testStorage81: 'test81 = &mut testArena81 in {
        let mut a = testResolver(testStorage81);
        let program = "union Opt { Some(i32) } fn run(val: Opt) { match val { case Opt::Some => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnionVariantPayloadMissing("Some"));
    }
}

@test unsafe fn testResolveMatchUnionVoidVariantExplicitDiscriminant() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some = 5 } fn run(val: Opt) { match val { case Opt::Some => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena82 = testArena();
    let testStorage82: 'test82 = &mut testArena82 in {
        let mut a = testResolver(testStorage82);
        let program = "union Opt { Some = 5 } fn run(val: Opt) { match val { case Opt::Some => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveMatchUnionPayloadUnexpected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { None } fn run(val: Opt) { match val { case Opt::None(x) => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnionVariantPayloadUnexpected("None"));
    let mut testArena83 = testArena();
    let testStorage83: 'test83 = &mut testArena83 in {
        let mut a = testResolver(testStorage83);
        let program = "union Opt { None } fn run(val: Opt) { match val { case Opt::None(x) => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnionVariantPayloadUnexpected("None"));
    }
}

@test unsafe fn testResolveMatchUnionUnknownVariant() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some, None } fn run(value: Opt) { match value { case Opt::Unknown => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("Unknown"));
    let mut testArena84 = testArena();
    let testStorage84: 'test84 = &mut testArena84 in {
        let mut a = testResolver(testStorage84);
        let program = "union Opt { Some, None } fn run(value: Opt) { match value { case Opt::Unknown => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("Unknown"));
    }
}

@test unsafe fn testResolveMatchUnionNonExhaustive() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "union Opt { Some, None } fn run(value: Opt) { match value { case Opt::Some => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnionMatchNonExhaustive("None"));
        let mut testArena85 = testArena();
        let testStorage85: 'test85 = &mut testArena85 in {
            let mut a = testResolver(testStorage85);
            let program = "union Opt { Some, None } fn run(value: Opt) { match value { case Opt::Some => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnionMatchNonExhaustive("None"));
        }
    } {
        let mut a = testResolver();
        let program = "union Opt { Some, None } fn run(value: Opt) { match value { else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena86 = testArena();
        let testStorage86: 'test86 = &mut testArena86 in {
            let mut a = testResolver(testStorage86);
            let program = "union Opt { Some, None } fn run(value: Opt) { match value { else => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

@test unsafe fn testResolveMatchUnionNonExhaustiveExplicitDiscriminants() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union U { A = 3, B = 9 } fn run(value: U) { match value { case U::A => {}, case U::B => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena87 = testArena();
    let testStorage87: 'test87 = &mut testArena87 in {
        let mut a = testResolver(testStorage87);
        let program = "union U { A = 3, B = 9 } fn run(value: U) { match value { case U::A => {}, case U::B => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveMatchUnionBindingScope() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some(i32), None } fn f(value: Opt) { match value { case Opt::Some(x) if x > 0 => { x; } else => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena88 = testArena();
    let testStorage88: 'test88 = &mut testArena88 in {
        let mut a = testResolver(testStorage88);
        let program = "union Opt { Some(i32), None } fn f(value: Opt) { match value { case Opt::Some(x) if x > 0 => { x; } else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let fnBlock = try getFnBody(&a, result.root, "f");
    try testing::expect(fnBlock.statements.len > 0);
        let fnBlock = try getFnBody(&a, result.root, "f");
        try testing::expect(fnBlock.statements.len > 0);

    let matchNode = fnBlock.statements[0];
    let case ast::NodeValue::Match(sw) = matchNode.value
        else throw testing::TestError::Failed;
    let caseNode = sw.prongs[0];
        let matchNode = fnBlock.statements[0];
        let case ast::NodeValue::Match(sw) = matchNode.value
            else throw testing::TestError::Failed;
        let caseNode = sw.prongs[0];

    let scope = super::scopeFor(&a, caseNode)
        else throw testing::TestError::Failed;
    let payloadSym = super::findSymbolInScope(scope, "x")
        else throw testing::TestError::Failed;
    let case super::SymbolData::Value { type: payloadValType, .. } = payloadSym.data
        else throw testing::TestError::Failed;
    try testing::expect(payloadValType == super::Type::I32);
        let scope = super::scopeFor(&a, caseNode)
            else throw testing::TestError::Failed;
        let payloadSym = super::findSymbolInScope(scope, "x")
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: payloadValType, .. } = payloadSym.data
            else throw testing::TestError::Failed;
        try testing::expect(payloadValType == super::Type::I32);
    }
}

@test unsafe fn testResolveMatchUnionPatternNonUnionType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some, None } fn f(value: Opt) { match value { case true => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let optionTy = try getTypeInScopeOf(&a, result.root, "Opt");
    try expectTypeMismatch(err, super::Type::Nominal(optionTy), super::Type::Bool);
    let mut testArena89 = testArena();
    let testStorage89: 'test89 = &mut testArena89 in {
        let mut a = testResolver(testStorage89);
        let program = "union Opt { Some, None } fn f(value: Opt) { match value { case true => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let optionTy = try getTypeInScopeOf(&a, result.root, "Opt");
        try expectTypeMismatch(err, super::Type::Nominal(optionTy), super::Type::Bool);
    }
}

@test unsafe fn testResolveMatchGuardForms() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn first(value: i32) { match value { case _ if true => {}, else => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena90 = testArena();
    let testStorage90: 'test90 = &mut testArena90 in {
        let mut a = testResolver(testStorage90);
        let program = "fn first(value: i32) { match value { case _ if true => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that a binding prong binds the subject to the identifier.
@test unsafe fn testResolveMatchBindingProng() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(value: i32) -> i32 { match value { x => return x } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena91 = testArena();
    let testStorage91: 'test91 = &mut testArena91 in {
        let mut a = testResolver(testStorage91);
        let program = "fn f(value: i32) -> i32 { match value { x => return x } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that a binding prong with guard can use the bound variable.
@test unsafe fn testResolveMatchBindingProngGuard() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(value: i32) -> i32 { match value { x if x > 0 => return x, _ => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena92 = testArena();
    let testStorage92: 'test92 = &mut testArena92 in {
        let mut a = testResolver(testStorage92);
        let program = "fn f(value: i32) -> i32 { match value { x if x > 0 => return x, _ => return 0 } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that a binding prong covers all union variants for exhaustiveness.
@test unsafe fn testResolveMatchBindingProngExhaustive() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union U { A, B, C } fn f(u: U) -> i32 { match u { x => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena93 = testArena();
    let testStorage93: 'test93 = &mut testArena93 in {
        let mut a = testResolver(testStorage93);
        let program = "union U { A, B, C } fn f(u: U) -> i32 { match u { x => return 0 } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that `case x =>` fails if `x` is not in scope, since bare identifiers
/// in case patterns are values to compare against, not bindings.
@test unsafe fn testResolveMatchCaseUndefinedIdent() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(n: i32) -> i32 { match n { case x => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("x"));
    let mut testArena94 = testArena();
    let testStorage94: 'test94 = &mut testArena94 in {
        let mut a = testResolver(testStorage94);
        let program = "fn f(n: i32) -> i32 { match n { case x => return 0 } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("x"));
    }
}

/// Test matching on optionals: exhaustiveness and type unwrapping.
@test unsafe fn testResolveMatchOptional() throws (testing::TestError) {
    {
        // Exhaustive: binding + nil case.
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) { match opt { v => {}, case nil => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena95 = testArena();
        let testStorage95: 'test95 = &mut testArena95 in {
            let mut a = testResolver(testStorage95);
            let program = "fn f(opt: ?i32) { match opt { v => {}, case nil => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        // Missing nil case.
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) { match opt { v => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::OptionalMatchMissingNil);
        let mut testArena96 = testArena();
        let testStorage96: 'test96 = &mut testArena96 in {
            let mut a = testResolver(testStorage96);
            let program = "fn f(opt: ?i32) { match opt { v => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::OptionalMatchMissingNil);
        }
    } {
        // Missing value case.
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) { match opt { case nil => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::OptionalMatchMissingValue);
        let mut testArena97 = testArena();
        let testStorage97: 'test97 = &mut testArena97 in {
            let mut a = testResolver(testStorage97);
            let program = "fn f(opt: ?i32) { match opt { case nil => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::OptionalMatchMissingValue);
        }
    } {
        // Else covers both cases.
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) { match opt { else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena98 = testArena();
        let testStorage98: 'test98 = &mut testArena98 in {
            let mut a = testResolver(testStorage98);
            let program = "fn f(opt: ?i32) { match opt { else => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        // Binding unwraps the inner type.
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) -> i32 { match opt { v => return v + 1, case nil => return 0 } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena99 = testArena();
        let testStorage99: 'test99 = &mut testArena99 in {
            let mut a = testResolver(testStorage99);
            let program = "fn f(opt: ?i32) -> i32 { match opt { v => return v + 1, case nil => return 0 } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

/// Test that match on non-union types requires exhaustiveness.
@test unsafe fn testResolveMatchGenericExhaustive() throws (testing::TestError) {
    {
        // Match on i32 without catch-all should error.
        let mut a = testResolver();
        let program = "fn f(x: i32) { match x { case 1 => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::MatchNonExhaustive);
        let mut testArena100 = testArena();
        let testStorage100: 'test100 = &mut testArena100 in {
            let mut a = testResolver(testStorage100);
            let program = "fn f(x: i32) { match x { case 1 => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::MatchNonExhaustive);
        }
    } {
        // Match on i32 with else is fine.
        let mut a = testResolver();
        let program = "fn f(x: i32) { match x { case 1 => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena101 = testArena();
        let testStorage101: 'test101 = &mut testArena101 in {
            let mut a = testResolver(testStorage101);
            let program = "fn f(x: i32) { match x { case 1 => {}, else => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        // Match on i32 with binding catch-all is fine.
        let mut a = testResolver();
        let program = "fn f(x: i32) { match x { y => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena102 = testArena();
        let testStorage102: 'test102 = &mut testArena102 in {
            let mut a = testResolver(testStorage102);
            let program = "fn f(x: i32) { match x { y => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        // Match on i32 with wildcard catch-all is fine.
        let mut a = testResolver();
        let program = "fn f(x: i32) { match x { case _ => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena103 = testArena();
        let testStorage103: 'test103 = &mut testArena103 in {
            let mut a = testResolver(testStorage103);
            let program = "fn f(x: i32) { match x { case _ => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

/// Test that match on bool requires both true and false cases.
@test unsafe fn testResolveMatchBoolExhaustive() throws (testing::TestError) {
    {
        // Match on bool with both cases is fine.
        let mut a = testResolver();
        let program = "fn f(x: bool) { match x { case true => {}, case false => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena104 = testArena();
        let testStorage104: 'test104 = &mut testArena104 in {
            let mut a = testResolver(testStorage104);
            let program = "fn f(x: bool) { match x { case true => {}, case false => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        // Match on bool missing true should error.
        let mut a = testResolver();
        let program = "fn f(x: bool) { match x { case false => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BoolMatchMissing(true));
        let mut testArena105 = testArena();
        let testStorage105: 'test105 = &mut testArena105 in {
            let mut a = testResolver(testStorage105);
            let program = "fn f(x: bool) { match x { case false => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::BoolMatchMissing(true));
        }
    } {
        // Match on bool missing false should error.
        let mut a = testResolver();
        let program = "fn f(x: bool) { match x { case true => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BoolMatchMissing(false));
        let mut testArena106 = testArena();
        let testStorage106: 'test106 = &mut testArena106 in {
            let mut a = testResolver(testStorage106);
            let program = "fn f(x: bool) { match x { case true => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::BoolMatchMissing(false));
        }
    } {
        // Match on bool with else is fine.
        let mut a = testResolver();
        let program = "fn f(x: bool) { match x { else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena107 = testArena();
        let testStorage107: 'test107 = &mut testArena107 in {
            let mut a = testResolver(testStorage107);
            let program = "fn f(x: bool) { match x { else => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        // Match on bool with binding catch-all is fine.
        let mut a = testResolver();
        let program = "fn f(x: bool) { match x { b => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena108 = testArena();
        let testStorage108: 'test108 = &mut testArena108 in {
            let mut a = testResolver(testStorage108);
            let program = "fn f(x: bool) { match x { b => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

@test unsafe fn testResolveBreakRequiresLoop() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "break;");
        try expectErrorKind(&result, super::ErrorKind::InvalidLoopControl);
        let mut testArena109 = testArena();
        let testStorage109: 'test109 = &mut testArena109 in {
            let mut a = testResolver(testStorage109);
            let result = try resolveProgramStr(&mut a, "break;");
            try expectErrorKind(&result, super::ErrorKind::InvalidLoopControl);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "loop { break }");
        try expectNoErrors(&result);
        let mut testArena110 = testArena();
        let testStorage110: 'test110 = &mut testArena110 in {
            let mut a = testResolver(testStorage110);
            let result = try resolveProgramStr(&mut a, "loop { break }");
            try expectNoErrors(&result);
        }
    }
}

@test unsafe fn testResolveContinueRequiresLoop() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "continue;");
        try expectErrorKind(&result, super::ErrorKind::InvalidLoopControl);
        let mut testArena111 = testArena();
        let testStorage111: 'test111 = &mut testArena111 in {
            let mut a = testResolver(testStorage111);
            let result = try resolveProgramStr(&mut a, "continue;");
            try expectErrorKind(&result, super::ErrorKind::InvalidLoopControl);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "while true { continue }");
        try expectNoErrors(&result);
        let mut testArena112 = testArena();
        let testStorage112: 'test112 = &mut testArena112 in {
            let mut a = testResolver(testStorage112);
            let result = try resolveProgramStr(&mut a, "while true { continue }");
            try expectNoErrors(&result);
        }
    }
}

@test unsafe fn testResolveFnTypeVoidNoParams() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn f() {} f();");
    try expectNoErrors(&result);

    let blockNode = result.root;
    let case ast::NodeValue::Block(block) = blockNode.value
        else throw testing::TestError::Failed;
    let fnNode = try getBlockStmt(blockNode, 0);
    let callStmt = try getBlockStmt(blockNode, 1);

    { // Verify the function symbol captures an empty parameter list and void return.
        let sym = super::symbolFor(&a, fnNode)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = sym.data
            else throw testing::TestError::Failed;
        try testing::expect(fnTy.paramTypes.len == 0);
        try testing::expect(*fnTy.returnType == super::Type::Void);
    }
    { // Checking that the type of the call matches the function return type.
        let callExpr = try expectExprStmtType(&a, callStmt, super::Type::Void);
    let mut testArena113 = testArena();
    let testStorage113: 'test113 = &mut testArena113 in {
        let mut a = testResolver(testStorage113);
        let result = try resolveProgramStr(&mut a, "fn f() {} f();");
        try expectNoErrors(&result);

        let fnSym = super::symbolFor(&a, fnNode)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = fnSym.data
        let blockNode = result.root;
        let case ast::NodeValue::Block(block) = blockNode.value
            else throw testing::TestError::Failed;
        try expectType(&a, callExpr, *fnTy.returnType);
        let fnNode = try getBlockStmt(blockNode, 0);
        let callStmt = try getBlockStmt(blockNode, 1);

        { // Verify the function symbol captures an empty parameter list and void return.
            let sym = super::symbolFor(&a, fnNode)
                else throw testing::TestError::Failed;
            let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = sym.data
                else throw testing::TestError::Failed;
            try testing::expect(fnTy.paramTypes.len == 0);
            try testing::expect(*fnTy.returnType == super::Type::Void);
        }
        { // Checking that the type of the call matches the function return type.
            let callExpr = try expectExprStmtType(&a, callStmt, super::Type::Void);

            let fnSym = super::symbolFor(&a, fnNode)
                else throw testing::TestError::Failed;
            let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = fnSym.data
                else throw testing::TestError::Failed;
            try expectType(&a, callExpr, *fnTy.returnType);
        }
    }
}

@test unsafe fn testResolveFnTypeReturnsValue() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f() -> i32 { return 1; } f();";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let blockNode = result.root;
    let case ast::NodeValue::Block(block) = blockNode.value
        else throw testing::TestError::Failed;
    let fnNode = try getBlockStmt(blockNode, 0);
    let callStmt = try getBlockStmt(blockNode, 1);

    { // Function returns i32 with no parameters.
        let sym = super::symbolFor(&a, fnNode)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = sym.data
            else throw testing::TestError::Failed;
        try testing::expect(fnTy.paramTypes.len == 0);
        try testing::expect(*fnTy.returnType == super::Type::I32);
    }
    { // Call expression should inherit the function's return type.
        let callExpr = try expectExprStmtType(&a, callStmt, super::Type::I32);
    let mut testArena114 = testArena();
    let testStorage114: 'test114 = &mut testArena114 in {
        let mut a = testResolver(testStorage114);
        let program = "fn f() -> i32 { return 1; } f();";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

        let fnSym = super::symbolFor(&a, fnNode)
        let blockNode = result.root;
        let case ast::NodeValue::Block(block) = blockNode.value
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = fnSym.data
            else throw testing::TestError::Failed;
        try expectType(&a, callExpr, *fnTy.returnType);
        let fnNode = try getBlockStmt(blockNode, 0);
        let callStmt = try getBlockStmt(blockNode, 1);

        { // Function returns i32 with no parameters.
            let sym = super::symbolFor(&a, fnNode)
                else throw testing::TestError::Failed;
            let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = sym.data
                else throw testing::TestError::Failed;
            try testing::expect(fnTy.paramTypes.len == 0);
            try testing::expect(*fnTy.returnType == super::Type::I32);
        }
        { // Call expression should inherit the function's return type.
            let callExpr = try expectExprStmtType(&a, callStmt, super::Type::I32);

            let fnSym = super::symbolFor(&a, fnNode)
                else throw testing::TestError::Failed;
            let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = fnSym.data
                else throw testing::TestError::Failed;
            try expectType(&a, callExpr, *fnTy.returnType);
        }
    }
}

@test unsafe fn testResolveFnTypeSingleParam() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(x: i8) {} let x: i8 = 1; f(x);";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let blockNode = result.root;
    let case ast::NodeValue::Block(block) = blockNode.value
        else throw testing::TestError::Failed;
    let fnNode = try getBlockStmt(blockNode, 0);
    let callStmt = try getBlockStmt(blockNode, 2);

    { // Single parameter propagates nominal type onto the symbol and parameter node.
        let sym = super::symbolFor(&a, fnNode)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = sym.data
            else throw testing::TestError::Failed;
        try testing::expect(fnTy.paramTypes.len == 1);
        try testing::expect(*fnTy.paramTypes[0] == super::Type::I8);
        try testing::expect(*fnTy.returnType == super::Type::Void);
    let mut testArena115 = testArena();
    let testStorage115: 'test115 = &mut testArena115 in {
        let mut a = testResolver(testStorage115);
        let program = "fn f(x: i8) {} let x: i8 = 1; f(x);";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

        let case ast::NodeValue::FnDecl(fnDecl) = fnNode.value
        let blockNode = result.root;
        let case ast::NodeValue::Block(block) = blockNode.value
            else throw testing::TestError::Failed;
        try testing::expect(fnDecl.sig.params.len == 1);

        let paramNode = fnDecl.sig.params[0];
        try expectType(&a, paramNode, super::Type::I8);
    }
    { // Call should resolve to void, matching the function's return type.
        let callExpr = try expectExprStmtType(&a, callStmt, super::Type::Void);
        let fnSym = super::symbolFor(&a, fnNode)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = fnSym.data
            else throw testing::TestError::Failed;
        try expectType(&a, callExpr, *fnTy.returnType);
        let fnNode = try getBlockStmt(blockNode, 0);
        let callStmt = try getBlockStmt(blockNode, 2);

        { // Single parameter propagates nominal type onto the symbol and parameter node.
            let sym = super::symbolFor(&a, fnNode)
                else throw testing::TestError::Failed;
            let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = sym.data
                else throw testing::TestError::Failed;
            try testing::expect(fnTy.paramTypes.len == 1);
            try testing::expect(*fnTy.paramTypes[0] == super::Type::I8);
            try testing::expect(*fnTy.returnType == super::Type::Void);

            let case ast::NodeValue::FnDecl(fnDecl) = fnNode.value
                else throw testing::TestError::Failed;
            try testing::expect(fnDecl.sig.params.len == 1);

            let paramNode = fnDecl.sig.params[0];
            try expectType(&a, paramNode, super::Type::I8);
        }
        { // Call should resolve to void, matching the function's return type.
            let callExpr = try expectExprStmtType(&a, callStmt, super::Type::Void);
            let fnSym = super::symbolFor(&a, fnNode)
                else throw testing::TestError::Failed;
            let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = fnSym.data
                else throw testing::TestError::Failed;
            try expectType(&a, callExpr, *fnTy.returnType);
        }
    }
}

@test unsafe fn testResolveFnTypeMultipleParams() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(x: i8, y: i32) {} let x: i8 = 1; let y: i32 = 2; f(x, y);";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let blockNode = result.root;
    let case ast::NodeValue::Block(block) = blockNode.value
        else throw testing::TestError::Failed;
    let fnNode = try getBlockStmt(blockNode, 0);
    let callStmt = try getBlockStmt(blockNode, 3);

    { // Ensure multi-parameter signatures record both argument types.
        let sym = super::symbolFor(&a, fnNode)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = sym.data
            else throw testing::TestError::Failed;
        try testing::expect(fnTy.paramTypes.len == 2);
        try testing::expect(*fnTy.paramTypes[0] == super::Type::I8);
        try testing::expect(*fnTy.paramTypes[1] == super::Type::I32);
        try testing::expect(*fnTy.returnType == super::Type::Void);

        let case ast::NodeValue::FnDecl(fnDecl) = fnNode.value
            else throw testing::TestError::Failed;
        try testing::expect(fnDecl.sig.params.len == 2);
    let mut testArena116 = testArena();
    let testStorage116: 'test116 = &mut testArena116 in {
        let mut a = testResolver(testStorage116);
        let program = "fn f(x: i8, y: i32) {} let x: i8 = 1; let y: i32 = 2; f(x, y);";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

        let firstParam = fnDecl.sig.params[0];
        let secondParam = fnDecl.sig.params[1];
        try expectType(&a, firstParam, super::Type::I8);
        try expectType(&a, secondParam, super::Type::I32);
    }
    { // Call expression should again mirror the function return type.
        let callExpr = try expectExprStmtType(&a, callStmt, super::Type::Void);
        let fnSym = super::symbolFor(&a, fnNode)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = fnSym.data
        let blockNode = result.root;
        let case ast::NodeValue::Block(block) = blockNode.value
            else throw testing::TestError::Failed;
        try expectType(&a, callExpr, *fnTy.returnType);
        let fnNode = try getBlockStmt(blockNode, 0);
        let callStmt = try getBlockStmt(blockNode, 3);

        { // Ensure multi-parameter signatures record both argument types.
            let sym = super::symbolFor(&a, fnNode)
                else throw testing::TestError::Failed;
            let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = sym.data
                else throw testing::TestError::Failed;
            try testing::expect(fnTy.paramTypes.len == 2);
            try testing::expect(*fnTy.paramTypes[0] == super::Type::I8);
            try testing::expect(*fnTy.paramTypes[1] == super::Type::I32);
            try testing::expect(*fnTy.returnType == super::Type::Void);

            let case ast::NodeValue::FnDecl(fnDecl) = fnNode.value
                else throw testing::TestError::Failed;
            try testing::expect(fnDecl.sig.params.len == 2);

            let firstParam = fnDecl.sig.params[0];
            let secondParam = fnDecl.sig.params[1];
            try expectType(&a, firstParam, super::Type::I8);
            try expectType(&a, secondParam, super::Type::I32);
        }
        { // Call expression should again mirror the function return type.
            let callExpr = try expectExprStmtType(&a, callStmt, super::Type::Void);
            let fnSym = super::symbolFor(&a, fnNode)
                else throw testing::TestError::Failed;
            let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = fnSym.data
                else throw testing::TestError::Failed;
            try expectType(&a, callExpr, *fnTy.returnType);
        }
    }
}

@test unsafe fn testResolveFnRecursiveCall() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn flip(b: bool) -> bool { if b { return false; } return flip(false); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let blockNode = result.root;
    let case ast::NodeValue::Block(block) = blockNode.value
        else throw testing::TestError::Failed;
    let fnNode = try getBlockStmt(blockNode, 0);
    let mut testArena117 = testArena();
    let testStorage117: 'test117 = &mut testArena117 in {
        let mut a = testResolver(testStorage117);
        let program = "fn flip(b: bool) -> bool { if b { return false; } return flip(false); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    { // Function symbol should be visible for recursive calls within its own body.
        let sym = super::symbolFor(&a, fnNode)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = sym.data
        let blockNode = result.root;
        let case ast::NodeValue::Block(block) = blockNode.value
            else throw testing::TestError::Failed;
        try testing::expect(fnTy.paramTypes.len == 1);
        try testing::expect(*fnTy.paramTypes[0] == super::Type::Bool);
        try testing::expect(*fnTy.returnType == super::Type::Bool);
        let fnNode = try getBlockStmt(blockNode, 0);

        { // Function symbol should be visible for recursive calls within its own body.
            let sym = super::symbolFor(&a, fnNode)
                else throw testing::TestError::Failed;
            let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = sym.data
                else throw testing::TestError::Failed;
            try testing::expect(fnTy.paramTypes.len == 1);
            try testing::expect(*fnTy.paramTypes[0] == super::Type::Bool);
            try testing::expect(*fnTy.returnType == super::Type::Bool);
        }
    }
}

@test unsafe fn testResolveFnCallMissingArgument() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(x: i8) {} f();";
    let result = try resolveProgramStr(&mut a, program);
    // Expect an error when a required parameter is omitted.
    try expectErrorKind(&result, super::ErrorKind::FnArgCountMismatch(super::CountMismatch {
        expected: 1,
        actual: 0,
    }));
    let mut testArena118 = testArena();
    let testStorage118: 'test118 = &mut testArena118 in {
        let mut a = testResolver(testStorage118);
        let program = "fn f(x: i8) {} f();";
        let result = try resolveProgramStr(&mut a, program);
        // Expect an error when a required parameter is omitted.
        try expectErrorKind(&result, super::ErrorKind::FnArgCountMismatch(super::CountMismatch {
            expected: 1,
            actual: 0,
        }));
    }
}

@test unsafe fn testResolveFnCallExtraArgument() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f() {} f(1);";
    let result = try resolveProgramStr(&mut a, program);
    // Passing more arguments than declared should fail.
    try expectErrorKind(&result, super::ErrorKind::FnArgCountMismatch(super::CountMismatch {
        expected: 0,
        actual: 1,
    }));
    let mut testArena119 = testArena();
    let testStorage119: 'test119 = &mut testArena119 in {
        let mut a = testResolver(testStorage119);
        let program = "fn f() {} f(1);";
        let result = try resolveProgramStr(&mut a, program);
        // Passing more arguments than declared should fail.
        try expectErrorKind(&result, super::ErrorKind::FnArgCountMismatch(super::CountMismatch {
            expected: 0,
            actual: 1,
        }));
    }
}

@test unsafe fn testResolveFnCallArgumentTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(x: i8) {} f(true);";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    // The argument type (bool) should not match the parameter type (i8).
    try expectTypeMismatch(err, super::Type::I8, super::Type::Bool);
    let mut testArena120 = testArena();
    let testStorage120: 'test120 = &mut testArena120 in {
        let mut a = testResolver(testStorage120);
        let program = "fn f(x: i8) {} f(true);";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        // The argument type (bool) should not match the parameter type (i8).
        try expectTypeMismatch(err, super::Type::I8, super::Type::Bool);
    }
}

@test unsafe fn testResolveFnReturnTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f() -> i32 { return true; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::I32, super::Type::Bool);
    let mut testArena121 = testArena();
    let testStorage121: 'test121 = &mut testArena121 in {
        let mut a = testResolver(testStorage121);
        let program = "fn f() -> i32 { return true; }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::I32, super::Type::Bool);
    }
}

@test unsafe fn testResolveFnReturnVoid() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f() { return; }");
        try expectNoErrors(&result);
        let mut testArena122 = testArena();
        let testStorage122: 'test122 = &mut testArena122 in {
            let mut a = testResolver(testStorage122);
            let result = try resolveProgramStr(&mut a, "fn f() { return; }");
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn g() -> i32 { return; }");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::I32, super::Type::Void);
        let mut testArena123 = testArena();
        let testStorage123: 'test123 = &mut testArena123 in {
            let mut a = testResolver(testStorage123);
            let result = try resolveProgramStr(&mut a, "fn g() -> i32 { return; }");
            let err = try expectError(&result);
            try expectTypeMismatch(err, super::Type::I32, super::Type::Void);
        }
    }
}

@test unsafe fn testResolveFnMissingReturn() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f() -> i32 {}");
        try expectErrorKind(&result, super::ErrorKind::FnMissingReturn);
        let mut testArena124 = testArena();
        let testStorage124: 'test124 = &mut testArena124 in {
            let mut a = testResolver(testStorage124);
            let result = try resolveProgramStr(&mut a, "fn f() -> i32 {}");
            try expectErrorKind(&result, super::ErrorKind::FnMissingReturn);
        }
    } {
        let mut a = testResolver();
        let program = "fn g(flag: bool) -> i32 { if flag { return 1; } 2; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::FnMissingReturn);
        let mut testArena125 = testArena();
        let testStorage125: 'test125 = &mut testArena125 in {
            let mut a = testResolver(testStorage125);
            let program = "fn g(flag: bool) -> i32 { if flag { return 1; } 2; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::FnMissingReturn);
        }
    }
}

/// Never-returning functions require divergence on every path.
@test unsafe fn testResolveNeverReturn() throws (testing::TestError) {

        "fn f() -> ! { while true {} }",
        "fn f(flag: bool) -> ! { if flag { panic; } else { while true {} } }",
        "fn f() -> ! throws (i32) { throw 1; } fn g() -> ! throws (i32) { try f(); }",
        "fn f() -> ! throws (i32) { throw 1; } fn g() -> i32 { try f() catch { return 2; }; }",
    ] {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena126 = testArena();
        let testStorage126: 'test126 = &mut testArena126 in {
            let mut a = testResolver(testStorage126);
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

/// A never-returning signature rejects any normal completion path.
@test unsafe fn testResolveNeverFallthrough() throws (testing::TestError) {

        "fn f(flag: bool) -> ! { if flag { panic; } }",
        "fn f() -> ! { while true { break; } }",
        "fn f() -> ! throws (i32) { throw 1; } fn g() -> ! { try f() catch {}; }",
        "fn f() -> ! throws (i32) { throw 1; } fn g() -> ! { try f() catch e as i32 {}; }",
    ] {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::FnMissingReturn);
        let mut testArena127 = testArena();
        let testStorage127: 'test127 = &mut testArena127 in {
            let mut a = testResolver(testStorage127);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::FnMissingReturn);
        }
    }
}

/// No value, including undefined, can construct a never return value.
@test unsafe fn testResolveNeverValue() throws (testing::TestError) {

        "fn f() -> ! { return; }",
        "fn f() -> ! { return 1; }",
        "unsafe fn f() -> ! { return undefined; }",
        "fn ordinary() {} fn f() { let callback: fn() -> ! = ordinary; }",
    ] {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        let error = try expectError(&result);
        let mut testArena128 = testArena();
        let testStorage128: 'test128 = &mut testArena128 in {
            let mut a = testResolver(testStorage128);
            let result = try resolveProgramStr(&mut a, program);
            let error = try expectError(&result);
        }
    }
}

/// Caught errors preserve the caller's exact-use ownership obligations.
@test unsafe fn testResolveNeverCaughtOwnership() throws (testing::TestError) {
    for program in &[
        "union Token: Once { Held(u32) } fn fail() -> ! throws (i32) { throw 1; } fn f(token: Token) { try fail() catch {}; }",
        "union Token: Once { Held(u32) } fn fail() -> ! throws (i32) { throw 1; } fn f(token: Token) { let absent = try? fail(); }",
    ] {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        let error = try expectError(&result);
        let case super::ErrorKind::LinearNotConsumed(_) = error.kind
            else throw testing::TestError::Failed;
        let mut testArena129 = testArena();
        let testStorage129: 'test129 = &mut testArena129 in {
            let mut a = testResolver(testStorage129);
            let result = try resolveProgramStr(&mut a, program);
            let error = try expectError(&result);
            let case super::ErrorKind::LinearNotConsumed(_) = error.kind
                else throw testing::TestError::Failed;
        }
    }
}

@test unsafe fn testResolveFnAllPathsReturn() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn h(flag: bool) -> i32 { if flag { return 1; } else { return 2; } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena130 = testArena();
    let testStorage130: 'test130 = &mut testArena130 in {
        let mut a = testResolver(testStorage130);
        let program = "fn h(flag: bool) -> i32 { if flag { return 1; } else { return 2; } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that match statements with returns in all branches don't require a
/// return at the end of the function.
@test unsafe fn testResolveFnMatchAllPathsReturn() throws (testing::TestError) {
    {
        // Union match with all variants returning.
        let mut a = testResolver();
        let program = "union E { A, B } fn f(e: E) -> i32 { match e { case E::A => return 1, case E::B => return 2 } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena131 = testArena();
        let testStorage131: 'test131 = &mut testArena131 in {
            let mut a = testResolver(testStorage131);
            let program = "union E { A, B } fn f(e: E) -> i32 { match e { case E::A => return 1, case E::B => return 2 } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        // Match with default case where all branches return.
        let mut a = testResolver();
        let program = "fn f(x: i32) -> i32 { match x { case 1 => return 1, else => return 0, } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena132 = testArena();
        let testStorage132: 'test132 = &mut testArena132 in {
            let mut a = testResolver(testStorage132);
            let program = "fn f(x: i32) -> i32 { match x { case 1 => return 1, else => return 0, } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        // Match where not all branches return should error.
        let mut a = testResolver();
        let program = "union E { A, B } fn f(e: E) -> i32 { match e { case E::A => return 1, case E::B => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::FnMissingReturn);
        let mut testArena133 = testArena();
        let testStorage133: 'test133 = &mut testArena133 in {
            let mut a = testResolver(testStorage133);
            let program = "union E { A, B } fn f(e: E) -> i32 { match e { case E::A => return 1, case E::B => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::FnMissingReturn);
        }
    }
}

@test unsafe fn testResolveAssign() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let mut x: i32 = 0; set x = 1;");
        try expectNoErrors(&result);
        let mut testArena134 = testArena();
        let testStorage134: 'test134 = &mut testArena134 in {
            let mut a = testResolver(testStorage134);
            let result = try resolveProgramStr(&mut a, "let mut x: i32 = 0; set x = 1;");
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let x: i32 = 0; set x = 1;");
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        let mut testArena135 = testArena();
        let testStorage135: 'test135 = &mut testArena135 in {
            let mut a = testResolver(testStorage135);
            let result = try resolveProgramStr(&mut a, "let x: i32 = 0; set x = 1;");
            try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let mut x: bool = false; set x = 1;");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
        let mut testArena136 = testArena();
        let testStorage136: 'test136 = &mut testArena136 in {
            let mut a = testResolver(testStorage136);
            let result = try resolveProgramStr(&mut a, "let mut x: bool = false; set x = 1;");
            let err = try expectError(&result);
            try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "set x = 1;");
        try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("x"));
        let mut testArena137 = testArena();
        let testStorage137: 'test137 = &mut testArena137 in {
            let mut a = testResolver(testStorage137);
            let result = try resolveProgramStr(&mut a, "set x = 1;");
            try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("x"));
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let mut x: ?i32 = 0; set x = 1;");
        try expectNoErrors(&result);
        let mut testArena138 = testArena();
        let testStorage138: 'test138 = &mut testArena138 in {
            let mut a = testResolver(testStorage138);
            let result = try resolveProgramStr(&mut a, "let mut x: ?i32 = 0; set x = 1;");
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let mut x: ?i32 = 0; set x = nil;");
        try expectNoErrors(&result);
        let mut testArena139 = testArena();
        let testStorage139: 'test139 = &mut testArena139 in {
            let mut a = testResolver(testStorage139);
            let result = try resolveProgramStr(&mut a, "let mut x: ?i32 = 0; set x = nil;");
            try expectNoErrors(&result);
        }
    }
}

@test unsafe fn testResolveAssignSubscript() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let mut xs: [u8; 2] = [0, 1]; set xs[0] = 9;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena140 = testArena();
        let testStorage140: 'test140 = &mut testArena140 in {
            let mut a = testResolver(testStorage140);
            let program = "let mut xs: [u8; 2] = [0, 1]; set xs[0] = 9;";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
    {
        let mut a = testResolver();
        let program = "static xs: [u8; 2] = [0, 1]; let slice: *mut [u8] = &mut xs[..]; set slice[0] = 1;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena141 = testArena();
        let testStorage141: 'test141 = &mut testArena141 in {
            let mut a = testResolver(testStorage141);
            let program = "static xs: [u8; 2] = [0, 1]; let slice: *mut [u8] = &mut xs[..]; set slice[0] = 1;";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
    {
        let mut a = testResolver();
        let program = "static xs: [u8; 2] = [0, 1]; let mut slice: *[u8] = &xs[..]; set slice[0] = 1;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        let mut testArena142 = testArena();
        let testStorage142: 'test142 = &mut testArena142 in {
            let mut a = testResolver(testStorage142);
            let program = "static xs: [u8; 2] = [0, 1]; let mut slice: *[u8] = &xs[..]; set slice[0] = 1;";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        }
    }
    {
        let mut a = testResolver();
        let program = "let xs: [u8; 2] = [0, 1]; set xs[0] = 9;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        let mut testArena143 = testArena();
        let testStorage143: 'test143 = &mut testArena143 in {
            let mut a = testResolver(testStorage143);
            let program = "let xs: [u8; 2] = [0, 1]; set xs[0] = 9;";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        }
    }
    {
        let mut a = testResolver();
        let program = "static xs: [u8; 2] = [0, 1]; let slice: *[u8] = &xs[..]; set slice[0] = 1;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        let mut testArena144 = testArena();
        let testStorage144: 'test144 = &mut testArena144 in {
            let mut a = testResolver(testStorage144);
            let program = "static xs: [u8; 2] = [0, 1]; let slice: *[u8] = &xs[..]; set slice[0] = 1;";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        }
    }
}

@test unsafe fn testResolveAssignIntegerLits() throws (testing::TestError) {
    try expectAnalyzeOk("let x: i8 = 127;");

    try expectIntMismatch("constant LIMIT: u8 = -5;", super::Type::U8);
}

@test unsafe fn testNilCoercions() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let opt: ?i32 = nil;");
        try expectNoErrors(&result);
        let mut testArena145 = testArena();
        let testStorage145: 'test145 = &mut testArena145 in {
            let mut a = testResolver(testStorage145);
            let result = try resolveBlockStr(&mut a, "let opt: ?i32 = nil;");
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let program = "fn g(opt: ?i32) {} fn f() { g(nil); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena146 = testArena();
        let testStorage146: 'test146 = &mut testArena146 in {
            let mut a = testResolver(testStorage146);
            let program = "fn g(opt: ?i32) {} fn f() { g(nil); }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let program = "fn make(flag: bool) -> ?i32 { if flag { return 1; } return nil; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena147 = testArena();
        let testStorage147: 'test147 = &mut testArena147 in {
            let mut a = testResolver(testStorage147);
            let program = "fn make(flag: bool) -> ?i32 { if flag { return 1; } return nil; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

@test unsafe fn testOptionalComparedWithNil() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = nil; opt == nil; nil == opt; opt == 1; 1 == opt; opt == opt; nil == nil;";
    let result = try resolveBlockStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena148 = testArena();
    let testStorage148: 'test148 = &mut testArena148 in {
        let mut a = testResolver(testStorage148);
        let program = "let opt: ?i32 = nil; opt == nil; nil == opt; opt == 1; 1 == opt; opt == opt; nil == nil;";
        let result = try resolveBlockStr(&mut a, program);
        try expectNoErrors(&result);

    for i in 1..7 {
        let stmt = try getBlockStmt(result.root, i);
        try expectExprStmtType(&a, stmt, super::Type::Bool);
        for i in 1..7 {
            let stmt = try getBlockStmt(result.root, i);
            try expectExprStmtType(&a, stmt, super::Type::Bool);
        }
    }
}

@test unsafe fn testResolveRecordLiteralAllFieldsSet() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } let p = Pt { x: 1, y: 2 };";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena149 = testArena();
    let testStorage149: 'test149 = &mut testArena149 in {
        let mut a = testResolver(testStorage149);
        let program = "record Pt { x: i32, y: i32 } let p = Pt { x: 1, y: 2 };";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveRecordLiteralMissingField() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } let p = Pt { x: 1 };";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::RecordFieldMissing("y"));
    let mut testArena150 = testArena();
    let testStorage150: 'test150 = &mut testArena150 in {
        let mut a = testResolver(testStorage150);
        let program = "record Pt { x: i32, y: i32 } let p = Pt { x: 1 };";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::RecordFieldMissing("y"));
    }
}

@test unsafe fn testResolveRecordLiteralFieldTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } let p = Pt { x: true, y: 2 };";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::I32, super::Type::Bool);
    let mut testArena151 = testArena();
    let testStorage151: 'test151 = &mut testArena151 in {
        let mut a = testResolver(testStorage151);
        let program = "record Pt { x: i32, y: i32 } let p = Pt { x: true, y: 2 };";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::I32, super::Type::Bool);

    let errNode = err.node
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Bool(_) = errNode.value
        else throw testing::TestError::Failed;
        let errNode = err.node
            else throw testing::TestError::Failed;
        let case ast::NodeValue::Bool(_) = errNode.value
            else throw testing::TestError::Failed;
    }
}

@test unsafe fn testResolveRecordLiteralExtraField() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } let p = Pt { x: 1, z: 3, y: 2 };";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::RecordFieldCountMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena152 = testArena();
    let testStorage152: 'test152 = &mut testArena152 in {
        let mut a = testResolver(testStorage152);
        let program = "record Pt { x: i32, y: i32 } let p = Pt { x: 1, z: 3, y: 2 };";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::RecordFieldCountMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Test that anonymous record literals with labels can be passed to functions expecting named records.
@test unsafe fn testResolveAnonRecordLabeledToNamedRecord() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) -> i32 { return p.x; } foo({ x: 1, y: 2 });";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena153 = testArena();
    let testStorage153: 'test153 = &mut testArena153 in {
        let mut a = testResolver(testStorage153);
        let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) -> i32 { return p.x; } foo({ x: 1, y: 2 });";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that anonymous record with wrong field name causes out of order error.
@test unsafe fn testResolveAnonRecordWrongFieldName() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) {} foo({ x: 1, z: 2 });";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::RecordFieldOutOfOrder { field: _, prev: _ } = err.kind
        else throw testing::TestError::Failed;
    let mut testArena154 = testArena();
    let testStorage154: 'test154 = &mut testArena154 in {
        let mut a = testResolver(testStorage154);
        let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) {} foo({ x: 1, z: 2 });";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::RecordFieldOutOfOrder { field: _, prev: _ } = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Test that anonymous record with wrong field type causes type mismatch.
@test unsafe fn testResolveAnonRecordWrongFieldType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) {} foo({ x: true, y: 2 });";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena155 = testArena();
    let testStorage155: 'test155 = &mut testArena155 in {
        let mut a = testResolver(testStorage155);
        let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) {} foo({ x: true, y: 2 });";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Test that anonymous record with missing field causes a missing field error.
@test unsafe fn testResolveAnonRecordMissingField() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) {} foo({ x: 1 });";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::RecordFieldMissing("y"));
    let mut testArena156 = testArena();
    let testStorage156: 'test156 = &mut testArena156 in {
        let mut a = testResolver(testStorage156);
        let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) {} foo({ x: 1 });";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::RecordFieldMissing("y"));
    }
}

/// Test that anonymous record with extra field causes a count mismatch error.
@test unsafe fn testResolveAnonRecordExtraField() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) {} foo({ x: 1, y: 2, z: 3 });";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::RecordFieldCountMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena157 = testArena();
    let testStorage157: 'test157 = &mut testArena157 in {
        let mut a = testResolver(testStorage157);
        let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) {} foo({ x: 1, y: 2, z: 3 });";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::RecordFieldCountMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Test that anonymous record fields can be coerced (e.g., i32 to optional).
@test unsafe fn testResolveAnonRecordFieldCoercion() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Opt { x: ?i32 } fn foo(p: Opt) {} foo({ x: 42 });";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena158 = testArena();
    let testStorage158: 'test158 = &mut testArena158 in {
        let mut a = testResolver(testStorage158);
        let program = "record Opt { x: ?i32 } fn foo(p: Opt) {} foo({ x: 42 });";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that arrays of anonymous records with labeled fields are allowed.
@test unsafe fn testResolveAnonRecordArray() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } constant ARR: [Pt; 2] = [{ x: 1, y: 2 }, { x: 3, y: 4 }];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena159 = testArena();
    let testStorage159: 'test159 = &mut testArena159 in {
        let mut a = testResolver(testStorage159);
        let program = "record Pt { x: i32, y: i32 } constant ARR: [Pt; 2] = [{ x: 1, y: 2 }, { x: 3, y: 4 }];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that arrays of anonymous records with extra fields cause count mismatch.
@test unsafe fn testResolveAnonRecordArrayMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } constant ARR: [Pt; 2] = [{ x: 1, y: 2 }, { x: 3, y: 4, z: 5 }];";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::RecordFieldCountMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena160 = testArena();
    let testStorage160: 'test160 = &mut testArena160 in {
        let mut a = testResolver(testStorage160);
        let program = "record Pt { x: i32, y: i32 } constant ARR: [Pt; 2] = [{ x: 1, y: 2 }, { x: 3, y: 4, z: 5 }];";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::RecordFieldCountMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Test that unlabeled record declarations are analyzed correctly.
@test unsafe fn testResolveUnlabeledRecordDecl() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record R(i32, bool);";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    // Verify the type symbol was created with labeled=false.
    let nominalTy = try getTypeInScopeOf(&a, result.root, "R");
    let case super::NominalType::Record(recordType) = *nominalTy
        else throw testing::TestError::Failed;
    try testing::expect(not recordType.labeled);
    try testing::expect(recordType.fields.len == 2);
    try testing::expect(recordType.fields[0].name == nil);
    try testing::expect(recordType.fields[1].name == nil);
    let mut testArena161 = testArena();
    let testStorage161: 'test161 = &mut testArena161 in {
        let mut a = testResolver(testStorage161);
        let program = "record R(i32, bool);";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

        // Verify the type symbol was created with labeled=false.
        let nominalTy = try getTypeInScopeOf(&a, result.root, "R");
        let case super::NominalType::Record(recordType) = *nominalTy
            else throw testing::TestError::Failed;
        try testing::expect(not recordType.labeled);
        try testing::expect(recordType.fields.len == 2);
        try testing::expect(recordType.fields[0].name == nil);
        try testing::expect(recordType.fields[1].name == nil);
    }
}

@test unsafe fn testResolveLabeledRecordDecl() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record R { x: i32, y: i32 }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena162 = testArena();
    let testStorage162: 'test162 = &mut testArena162 in {
        let mut a = testResolver(testStorage162);
        let program = "record R { x: i32, y: i32 }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let nominalTy = try getTypeInScopeOf(&a, result.root, "R");
    let case super::NominalType::Record(recordType) = *nominalTy
        else throw testing::TestError::Failed;
    try testing::expect(recordType.labeled);
    try testing::expect(recordType.fields.len == 2);
    try testing::expect(recordType.fields[0].name <> nil);
    try testing::expect(recordType.fields[1].name <> nil);
        let nominalTy = try getTypeInScopeOf(&a, result.root, "R");
        let case super::NominalType::Record(recordType) = *nominalTy
            else throw testing::TestError::Failed;
        try testing::expect(recordType.labeled);
        try testing::expect(recordType.fields.len == 2);
        try testing::expect(recordType.fields[0].name <> nil);
        try testing::expect(recordType.fields[1].name <> nil);
    }
}

@test unsafe fn testResolveRecordFieldAccessValid() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: u8 } let p = Pt { x: 1, y: 2 }; p.y;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena163 = testArena();
    let testStorage163: 'test163 = &mut testArena163 in {
        let mut a = testResolver(testStorage163);
        let program = "record Pt { x: i32, y: u8 } let p = Pt { x: 1, y: 2 }; p.y;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let fieldStmt = try getBlockStmt(result.root, 2);
    try expectExprStmtType(&a, fieldStmt, super::Type::U8);
        let fieldStmt = try getBlockStmt(result.root, 2);
        try expectExprStmtType(&a, fieldStmt, super::Type::U8);
    }
}

@test unsafe fn testResolveRecordFieldAccessUnknownField() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32 } let p = Pt { x: 1 }; p.y;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::RecordFieldUnknown("y"));
    let mut testArena164 = testArena();
    let testStorage164: 'test164 = &mut testArena164 in {
        let mut a = testResolver(testStorage164);
        let program = "record Pt { x: i32 } let p = Pt { x: 1 }; p.y;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::RecordFieldUnknown("y"));
    }
}

@test unsafe fn testResolveRecordFieldAccessOnFunctionReturn() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } fn make() -> Pt { return Pt { x: 5, y: 10 }; } make().x;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena165 = testArena();
    let testStorage165: 'test165 = &mut testArena165 in {
        let mut a = testResolver(testStorage165);
        let program = "record Pt { x: i32, y: i32 } fn make() -> Pt { return Pt { x: 5, y: 10 }; } make().x;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 2);
    try expectExprStmtType(&a, stmt, super::Type::I32);
        let stmt = try getBlockStmt(result.root, 2);
        try expectExprStmtType(&a, stmt, super::Type::I32);
    }
}

@test unsafe fn testResolveRecordFieldAccessChained() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record C { value: i32 } record B { c: C } record A { b: B } let a = A { b: B { c: C { value: 100 } } }; a.b.c.value;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena166 = testArena();
    let testStorage166: 'test166 = &mut testArena166 in {
        let mut a = testResolver(testStorage166);
        let program = "record C { value: i32 } record B { c: C } record A { b: B } let a = A { b: B { c: C { value: 100 } } }; a.b.c.value;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 4);
    try expectExprStmtType(&a, stmt, super::Type::I32);
        let stmt = try getBlockStmt(result.root, 4);
        try expectExprStmtType(&a, stmt, super::Type::I32);
    }
}

@test unsafe fn testResolveRecordFieldAccessOnInteger() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let x: i32 = 42; x.field;";
    let result = try resolveBlockStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ExpectedRecord);
    let mut testArena167 = testArena();
    let testStorage167: 'test167 = &mut testArena167 in {
        let mut a = testResolver(testStorage167);
        let program = "let x: i32 = 42; x.field;";
        let result = try resolveBlockStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ExpectedRecord);
    }
}

@test unsafe fn testResolveRecordFieldAccessOnArray() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let arr: [i32; 3] = [1, 2, 3]; arr.field;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ArrayFieldUnknown("field"));
    let mut testArena168 = testArena();
    let testStorage168: 'test168 = &mut testArena168 in {
        let mut a = testResolver(testStorage168);
        let program = "let arr: [i32; 3] = [1, 2, 3]; arr.field;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ArrayFieldUnknown("field"));
    }
}

@test unsafe fn testResolveRecordFieldAccessOnBool() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let b: bool = true; b.field;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ExpectedRecord);
    let mut testArena169 = testArena();
    let testStorage169: 'test169 = &mut testArena169 in {
        let mut a = testResolver(testStorage169);
        let program = "let b: bool = true; b.field;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ExpectedRecord);
    }
}

@test unsafe fn testResolveRecordFieldAccessOnOptional() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32 } let opt: ?Pt = Pt { x: 5 }; opt.x;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ExpectedRecord);
    let mut testArena170 = testArena();
    let testStorage170: 'test170 = &mut testArena170 in {
        let mut a = testResolver(testStorage170);
        let program = "record Pt { x: i32 } let opt: ?Pt = Pt { x: 5 }; opt.x;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ExpectedRecord);
    }
}

/// Records may reference themselves through pointers without causing resolution errors.
@test unsafe fn testResolveRecordSelfReferentialPointer() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record A { next: *A }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena171 = testArena();
    let testStorage171: 'test171 = &mut testArena171 in {
        let mut a = testResolver(testStorage171);
        let program = "record A { next: *A }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Mutually recursive records should resolve without infinite loops.
@test unsafe fn testResolveRecordMutuallyRecursive() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record A { b: *B } record B { a: *A }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena172 = testArena();
    let testStorage172: 'test172 = &mut testArena172 in {
        let mut a = testResolver(testStorage172);
        let program = "record A { b: *B } record B { a: *A }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Unions may reference themselves through pointers without causing resolution errors.
@test unsafe fn testResolveUnionSelfReferentialPointerAllowed() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union List { Cons(*List), Nil }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena173 = testArena();
    let testStorage173: 'test173 = &mut testArena173 in {
        let mut a = testResolver(testStorage173);
        let program = "union List { Cons(*List), Nil }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Mutually recursive unions should resolve without infinite loops.
@test unsafe fn testResolveUnionMutuallyRecursive() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union A { HasB(*B), None } union B { HasA(*A), None }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena174 = testArena();
    let testStorage174: 'test174 = &mut testArena174 in {
        let mut a = testResolver(testStorage174);
        let program = "union A { HasB(*B), None } union B { HasA(*A), None }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Unions with record payloads containing slice references to self should resolve.
/// This matches the pattern in sexpr.rad: `List { tail: *[Expr] }`.
@test unsafe fn testResolveUnionRecordPayloadWithSliceSelfRef() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Expr { Null, List { head: *[u8], tail: *[Expr] } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena175 = testArena();
    let testStorage175: 'test175 = &mut testArena175 in {
        let mut a = testResolver(testStorage175);
        let program = "union Expr { Null, List { head: *[u8], tail: *[Expr] } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testUndefinedCoercions() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "unsafe { let count: i32 = undefined; }");
        try expectNoErrors(&result);
        let mut testArena176 = testArena();
        let testStorage176: 'test176 = &mut testArena176 in {
            let mut a = testResolver(testStorage176);
            let result = try resolveBlockStr(&mut a, "unsafe { let count: i32 = undefined; }");
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let program = "unsafe { let mut value: i32 = 0; set value = undefined; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena177 = testArena();
        let testStorage177: 'test177 = &mut testArena177 in {
            let mut a = testResolver(testStorage177);
            let program = "unsafe { let mut value: i32 = 0; set value = undefined; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let program = "fn f(x: i32) {} unsafe fn g() { f(undefined); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena178 = testArena();
        let testStorage178: 'test178 = &mut testArena178 in {
            let mut a = testResolver(testStorage178);
            let program = "fn f(x: i32) {} unsafe fn g() { f(undefined); }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let program = "unsafe fn fetch() -> i32 { return undefined; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena179 = testArena();
        let testStorage179: 'test179 = &mut testArena179 in {
            let mut a = testResolver(testStorage179);
            let program = "unsafe fn fetch() -> i32 { return undefined; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

@test unsafe fn testResolveBlockVoid() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "{ 42; }");
    try expectNoErrors(&result);
    let mut testArena180 = testArena();
    let testStorage180: 'test180 = &mut testArena180 in {
        let mut a = testResolver(testStorage180);
        let result = try resolveProgramStr(&mut a, "{ 42; }");
        try expectNoErrors(&result);

    let block = try getBlockStmt(result.root, 0);
    try expectType(&a, block, super::Type::Void);
        let block = try getBlockStmt(result.root, 0);
        try expectType(&a, block, super::Type::Void);
    }
}

@test unsafe fn testResolveBlockNever() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "{ panic; }");
    try expectNoErrors(&result);
    let mut testArena181 = testArena();
    let testStorage181: 'test181 = &mut testArena181 in {
        let mut a = testResolver(testStorage181);
        let result = try resolveProgramStr(&mut a, "{ panic; }");
        try expectNoErrors(&result);

    let block = try getBlockStmt(result.root, 0);
    try expectType(&a, block, super::Type::Never);
        let block = try getBlockStmt(result.root, 0);
        try expectType(&a, block, super::Type::Never);
    }
}

@test unsafe fn testResolveIfAllBranchesNever() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "if true { panic; } else { panic; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena182 = testArena();
    let testStorage182: 'test182 = &mut testArena182 in {
        let mut a = testResolver(testStorage182);
        let program = "if true { panic; } else { panic; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 0);
    try expectType(&a, stmt, super::Type::Never);
        let stmt = try getBlockStmt(result.root, 0);
        try expectType(&a, stmt, super::Type::Never);
    }
}

@test unsafe fn testResolveIfMixedBranchesNotNever() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "if true { panic; } else {}";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena183 = testArena();
    let testStorage183: 'test183 = &mut testArena183 in {
        let mut a = testResolver(testStorage183);
        let program = "if true { panic; } else {}";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 0);
    try expectType(&a, stmt, super::Type::Void);
        let stmt = try getBlockStmt(result.root, 0);
        try expectType(&a, stmt, super::Type::Void);
    }
}

@test unsafe fn testResolveLetElse() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; let value = opt else panic; value;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena184 = testArena();
    let testStorage184: 'test184 = &mut testArena184 in {
        let mut a = testResolver(testStorage184);
        let program = "let opt: ?i32 = 42; let value = opt else panic; value;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let blockNode = result.root;
    let case ast::NodeValue::Block(block) = blockNode.value
        else throw testing::TestError::Failed;
    let letElseNode = try getBlockStmt(blockNode, 1);
    let valueStmt = try getBlockStmt(blockNode, 2);
        let blockNode = result.root;
        let case ast::NodeValue::Block(block) = blockNode.value
            else throw testing::TestError::Failed;
        let letElseNode = try getBlockStmt(blockNode, 1);
        let valueStmt = try getBlockStmt(blockNode, 2);

    { // Ensure the bound identifier receives the inner optional type.
        let valueExpr = try expectExprStmtType(&a, valueStmt, super::Type::I32);
        { // Ensure the bound identifier receives the inner optional type.
            let valueExpr = try expectExprStmtType(&a, valueStmt, super::Type::I32);

        let sym = super::symbolFor(&a, valueExpr)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: valType, .. } = sym.data
            else throw testing::TestError::Failed;
        try testing::expect(valType == super::Type::I32);
            let sym = super::symbolFor(&a, valueExpr)
                else throw testing::TestError::Failed;
            let case super::SymbolData::Value { type: valType, .. } = sym.data
                else throw testing::TestError::Failed;
            try testing::expect(valType == super::Type::I32);
        }
        // The let-else statement itself should be typed as void.
        try expectType(&a, letElseNode, super::Type::Void);
    }
    // The let-else statement itself should be typed as void.
    try expectType(&a, letElseNode, super::Type::Void);
}

@test unsafe fn testResolveLetElseDefaultValue() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = nil; let value = opt else 42; value;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena185 = testArena();
    let testStorage185: 'test185 = &mut testArena185 in {
        let mut a = testResolver(testStorage185);
        let program = "let opt: ?i32 = nil; let value = opt else 42; value;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveLetElseRequiresDivergentElse() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = nil; let value = opt else {}; value;";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::I32, super::Type::Void);
    let mut testArena186 = testArena();
    let testStorage186: 'test186 = &mut testArena186 in {
        let mut a = testResolver(testStorage186);
        let program = "let opt: ?i32 = nil; let value = opt else {}; value;";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::I32, super::Type::Void);
    }
}

@test unsafe fn testResolveLetElseRequiresOptional() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let x: i32 = 42; let value = x else panic;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ExpectedOptional);
    let mut testArena187 = testArena();
    let testStorage187: 'test187 = &mut testArena187 in {
        let mut a = testResolver(testStorage187);
        let program = "let x: i32 = 42; let value = x else panic;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ExpectedOptional);
    }
}

/// Test that `if let mut` produces a mutable binding.
@test unsafe fn testResolveIfLetMut() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; if let mut v = opt { set v = v + 1; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena188 = testArena();
    let testStorage188: 'test188 = &mut testArena188 in {
        let mut a = testResolver(testStorage188);
        let program = "let opt: ?i32 = 42; if let mut v = opt { set v = v + 1; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that `if let` (without mut) rejects assignment.
@test unsafe fn testResolveIfLetImmutable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; if let v = opt { set v = 1; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    let mut testArena189 = testArena();
    let testStorage189: 'test189 = &mut testArena189 in {
        let mut a = testResolver(testStorage189);
        let program = "let opt: ?i32 = 42; if let v = opt { set v = 1; }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
}

/// Test that `let mut ... else` produces a mutable binding.
@test unsafe fn testResolveLetMutElse() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; let mut v = opt else panic; set v = v + 1;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena190 = testArena();
    let testStorage190: 'test190 = &mut testArena190 in {
        let mut a = testResolver(testStorage190);
        let program = "let opt: ?i32 = 42; let mut v = opt else panic; set v = v + 1;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that `let ... else` (without mut) rejects assignment.
@test unsafe fn testResolveLetElseImmutable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; let v = opt else panic; set v = 1;";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    let mut testArena191 = testArena();
    let testStorage191: 'test191 = &mut testArena191 in {
        let mut a = testResolver(testStorage191);
        let program = "let opt: ?i32 = 42; let v = opt else panic; set v = 1;";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
}

@test unsafe fn testResolveLetCaseElse() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let case _ = 1 else panic;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena192 = testArena();
        let testStorage192: 'test192 = &mut testArena192 in {
            let mut a = testResolver(testStorage192);
            let program = "let case _ = 1 else panic;";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let program = "let case _ = true else false;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena193 = testArena();
        let testStorage193: 'test193 = &mut testArena193 in {
            let mut a = testResolver(testStorage193);
            let program = "let case _ = true else false;";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

@test unsafe fn testResolveLetCaseElseRequiresDivergentElse() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let case _ = 1 else {};";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::Int, super::Type::Void);
    let mut testArena194 = testArena();
    let testStorage194: 'test194 = &mut testArena194 in {
        let mut a = testResolver(testStorage194);
        let program = "let case _ = 1 else {};";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Int, super::Type::Void);
    }
}

@test unsafe fn testResolveTryValidPropagation() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn fallible() throws (i32) {} fn caller() throws (i32) { try fallible() }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena195 = testArena();
    let testStorage195: 'test195 = &mut testArena195 in {
        let mut a = testResolver(testStorage195);
        let program = "fn fallible() throws (i32) {} fn caller() throws (i32) { try fallible() }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveTryRequiresThrowsClause() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn fallible() throws (i32) {} fn caller() { try fallible() }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TryRequiresThrows);
    let mut testArena196 = testArena();
    let testStorage196: 'test196 = &mut testArena196 in {
        let mut a = testResolver(testStorage196);
        let program = "fn fallible() throws (i32) {} fn caller() { try fallible() }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::TryRequiresThrows);
    }
}

@test unsafe fn testResolveTryIncompatibleError() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn fallible() throws (i32) {} fn caller() throws (i8) { try fallible() }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TryIncompatibleError);
    let mut testArena197 = testArena();
    let testStorage197: 'test197 = &mut testArena197 in {
        let mut a = testResolver(testStorage197);
        let program = "fn fallible() throws (i32) {} fn caller() throws (i8) { try fallible() }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::TryIncompatibleError);
    }
}

@test unsafe fn testResolveTryNonThrowing() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn safe() {} fn caller() throws (i32) { try safe() }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TryNonThrowing);
    let mut testArena198 = testArena();
    let testStorage198: 'test198 = &mut testArena198 in {
        let mut a = testResolver(testStorage198);
        let program = "fn safe() {} fn caller() throws (i32) { try safe() }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::TryNonThrowing);
    }
}

@test unsafe fn testResolveTryCatchBlockMatchesResult() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Error { Fail } fn fallible() -> u32 throws (Error) { throw Error::Fail; return 0; } fn caller() -> u32 { return try fallible() catch { return 42; }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena199 = testArena();
    let testStorage199: 'test199 = &mut testArena199 in {
        let mut a = testResolver(testStorage199);
        let program = "union Error { Fail } fn fallible() -> u32 throws (Error) { throw Error::Fail; return 0; } fn caller() -> u32 { return try fallible() catch { return 42; }; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveTryCatchBlockDiverges() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Error { Fail } fn fallible() -> u32 throws (Error) { throw Error::Fail; return 0; } fn caller() -> u32 { return try fallible() catch { return 7; }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena200 = testArena();
    let testStorage200: 'test200 = &mut testArena200 in {
        let mut a = testResolver(testStorage200);
        let program = "union Error { Fail } fn fallible() -> u32 throws (Error) { throw Error::Fail; return 0; } fn caller() -> u32 { return try fallible() catch { return 7; }; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveTryCatchBlockMustDiverge() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Error { Fail } fn fallible() -> u32 throws (Error) { throw Error::Fail; return 0; } fn caller() -> u32 { return try fallible() catch { 7; }; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::U32, super::Type::Void);
    let mut testArena201 = testArena();
    let testStorage201: 'test201 = &mut testArena201 in {
        let mut a = testResolver(testStorage201);
        let program = "union Error { Fail } fn fallible() -> u32 throws (Error) { throw Error::Fail; return 0; } fn caller() -> u32 { return try fallible() catch { 7; }; }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::U32, super::Type::Void);
    }
}

@test unsafe fn testResolveCallMissingTry() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn fallible() throws (i32) {} fn caller() { fallible() }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::MissingTry);
    let mut testArena202 = testArena();
    let testStorage202: 'test202 = &mut testArena202 in {
        let mut a = testResolver(testStorage202);
        let program = "fn fallible() throws (i32) {} fn caller() { fallible() }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::MissingTry);
    }
}

/// Test that `try?` converts errors to optionals without requiring caller to throw.
@test unsafe fn testResolveTryOptionalConvertsToOptional() throws (testing::TestError) {
    // `try?` should wrap the return type in optional and not require caller to throw.
    {
        let mut a = testResolver();
        let program = "record S {} fn fallible() -> *S throws (i32) { panic; } fn caller() -> ?*S { return try? fallible(); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena203 = testArena();
        let testStorage203: 'test203 = &mut testArena203 in {
            let mut a = testResolver(testStorage203);
            let program = "record S {} fn fallible() -> *S throws (i32) { panic; } fn caller() -> ?*S { return try? fallible(); }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
    // `try?` works in non-throwing function.
    {
        let mut a = testResolver();
        let program = "fn fallible() -> i32 throws (i32) { panic; } fn caller() -> ?i32 { return try? fallible(); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena204 = testArena();
        let testStorage204: 'test204 = &mut testArena204 in {
            let mut a = testResolver(testStorage204);
            let program = "fn fallible() -> i32 throws (i32) { panic; } fn caller() -> ?i32 { return try? fallible(); }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
    // `try?` can be used in if-let patterns.
    {
        let mut a = testResolver();
        let program = "fn fallible() -> i32 throws (i32) { panic; } fn caller() -> i32 { if let x = try? fallible() { return x; } return 0; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena205 = testArena();
        let testStorage205: 'test205 = &mut testArena205 in {
            let mut a = testResolver(testStorage205);
            let program = "fn fallible() -> i32 throws (i32) { panic; } fn caller() -> i32 { if let x = try? fallible() { return x; } return 0; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

@test unsafe fn testResolveThrowValid() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn fail() throws (i32) { throw 1; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena206 = testArena();
    let testStorage206: 'test206 = &mut testArena206 in {
        let mut a = testResolver(testStorage206);
        let program = "fn fail() throws (i32) { throw 1; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveThrowRequiresThrowsClause() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn fail() { throw 1; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ThrowRequiresThrows);
    let mut testArena207 = testArena();
    let testStorage207: 'test207 = &mut testArena207 in {
        let mut a = testResolver(testStorage207);
        let program = "fn fail() { throw 1; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ThrowRequiresThrows);
    }
}

@test unsafe fn testResolveThrowIncompatibleError() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn fail() throws (i32) { throw true; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ThrowIncompatibleError);
    let mut testArena208 = testArena();
    let testStorage208: 'test208 = &mut testArena208 in {
        let mut a = testResolver(testStorage208);
        let program = "fn fail() throws (i32) { throw true; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ThrowIncompatibleError);
    }
}

// Binary operation tests //////////////////////////////////////////////////////

@test unsafe fn testResolveBinaryOpArithmetic() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "4 + 4");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
        let mut testArena209 = testArena();
        let testStorage209: 'test209 = &mut testArena209 in {
            let mut a = testResolver(testStorage209);
            let result = try resolveExprStr(&mut a, "4 + 4");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "10 - 3");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
        let mut testArena210 = testArena();
        let testStorage210: 'test210 = &mut testArena210 in {
            let mut a = testResolver(testStorage210);
            let result = try resolveExprStr(&mut a, "10 - 3");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "5 * 6");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
        let mut testArena211 = testArena();
        let testStorage211: 'test211 = &mut testArena211 in {
            let mut a = testResolver(testStorage211);
            let result = try resolveExprStr(&mut a, "5 * 6");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "20 / 4");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
        let mut testArena212 = testArena();
        let testStorage212: 'test212 = &mut testArena212 in {
            let mut a = testResolver(testStorage212);
            let result = try resolveExprStr(&mut a, "20 / 4");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "17 % 5");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
        let mut testArena213 = testArena();
        let testStorage213: 'test213 = &mut testArena213 in {
            let mut a = testResolver(testStorage213);
            let result = try resolveExprStr(&mut a, "17 % 5");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: i32 = 4; let y: i32 = 5; x + y;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::I32);
        let mut testArena214 = testArena();
        let testStorage214: 'test214 = &mut testArena214 in {
            let mut a = testResolver(testStorage214);
            let result = try resolveBlockStr(&mut a, "let x: i32 = 4; let y: i32 = 5; x + y;");
            try expectNoErrors(&result);
            let stmt = try parser::tests::getBlockLastStmt(result.root);
            try expectExprStmtType(&a, stmt, super::Type::I32);
        }
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "1 + (2 * 3) - 4");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
        let mut testArena215 = testArena();
        let testStorage215: 'test215 = &mut testArena215 in {
            let mut a = testResolver(testStorage215);
            let result = try resolveExprStr(&mut a, "1 + (2 * 3) - 4");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let n: i32 = 5; n * 2;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::I32);
        let mut testArena216 = testArena();
        let testStorage216: 'test216 = &mut testArena216 in {
            let mut a = testResolver(testStorage216);
            let result = try resolveBlockStr(&mut a, "let n: i32 = 5; n * 2;");
            try expectNoErrors(&result);
            let stmt = try parser::tests::getBlockLastStmt(result.root);
            try expectExprStmtType(&a, stmt, super::Type::I32);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let n: i32 = 5; 2 * n;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::I32);
        let mut testArena217 = testArena();
        let testStorage217: 'test217 = &mut testArena217 in {
            let mut a = testResolver(testStorage217);
            let result = try resolveBlockStr(&mut a, "let n: i32 = 5; 2 * n;");
            try expectNoErrors(&result);
            let stmt = try parser::tests::getBlockLastStmt(result.root);
            try expectExprStmtType(&a, stmt, super::Type::I32);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let n: i32 = 5; n - 1;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::I32);
        let mut testArena218 = testArena();
        let testStorage218: 'test218 = &mut testArena218 in {
            let mut a = testResolver(testStorage218);
            let result = try resolveBlockStr(&mut a, "let n: i32 = 5; n - 1;");
            try expectNoErrors(&result);
            let stmt = try parser::tests::getBlockLastStmt(result.root);
            try expectExprStmtType(&a, stmt, super::Type::I32);
        }
    }
}

@test unsafe fn testResolveBinaryOpComparison() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "5 == 5");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
        let mut testArena219 = testArena();
        let testStorage219: 'test219 = &mut testArena219 in {
            let mut a = testResolver(testStorage219);
            let result = try resolveExprStr(&mut a, "5 == 5");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Bool);
        }
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "5 <> 10");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
        let mut testArena220 = testArena();
        let testStorage220: 'test220 = &mut testArena220 in {
            let mut a = testResolver(testStorage220);
            let result = try resolveExprStr(&mut a, "5 <> 10");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Bool);
        }
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "5 < 10");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
        let mut testArena221 = testArena();
        let testStorage221: 'test221 = &mut testArena221 in {
            let mut a = testResolver(testStorage221);
            let result = try resolveExprStr(&mut a, "5 < 10");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Bool);
        }
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "10 > 5");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
        let mut testArena222 = testArena();
        let testStorage222: 'test222 = &mut testArena222 in {
            let mut a = testResolver(testStorage222);
            let result = try resolveExprStr(&mut a, "10 > 5");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Bool);
        }
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "5 <= 5");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
        let mut testArena223 = testArena();
        let testStorage223: 'test223 = &mut testArena223 in {
            let mut a = testResolver(testStorage223);
            let result = try resolveExprStr(&mut a, "5 <= 5");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Bool);
        }
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "10 >= 5");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
        let mut testArena224 = testArena();
        let testStorage224: 'test224 = &mut testArena224 in {
            let mut a = testResolver(testStorage224);
            let result = try resolveExprStr(&mut a, "10 >= 5");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Bool);
        }
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "true == false");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
        let mut testArena225 = testArena();
        let testStorage225: 'test225 = &mut testArena225 in {
            let mut a = testResolver(testStorage225);
            let result = try resolveExprStr(&mut a, "true == false");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Bool);
        }
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "5 + 3 > 10 - 4");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
        let mut testArena226 = testArena();
        let testStorage226: 'test226 = &mut testArena226 in {
            let mut a = testResolver(testStorage226);
            let result = try resolveExprStr(&mut a, "5 + 3 > 10 - 4");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Bool);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let n: i32 = 5; n == 1;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::Bool);
        let mut testArena227 = testArena();
        let testStorage227: 'test227 = &mut testArena227 in {
            let mut a = testResolver(testStorage227);
            let result = try resolveBlockStr(&mut a, "let n: i32 = 5; n == 1;");
            try expectNoErrors(&result);
            let stmt = try parser::tests::getBlockLastStmt(result.root);
            try expectExprStmtType(&a, stmt, super::Type::Bool);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let n: i32 = 5; 1 == n;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::Bool);
        let mut testArena228 = testArena();
        let testStorage228: 'test228 = &mut testArena228 in {
            let mut a = testResolver(testStorage228);
            let result = try resolveBlockStr(&mut a, "let n: i32 = 5; 1 == n;");
            try expectNoErrors(&result);
            let stmt = try parser::tests::getBlockLastStmt(result.root);
            try expectExprStmtType(&a, stmt, super::Type::Bool);
        }
    }
}

@test unsafe fn testResolveBinaryOpLogical() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: bool = true; let y: bool = false; x and y;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::Bool);
        let mut testArena229 = testArena();
        let testStorage229: 'test229 = &mut testArena229 in {
            let mut a = testResolver(testStorage229);
            let result = try resolveBlockStr(&mut a, "let x: bool = true; let y: bool = false; x and y;");
            try expectNoErrors(&result);
            let stmt = try parser::tests::getBlockLastStmt(result.root);
            try expectExprStmtType(&a, stmt, super::Type::Bool);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: bool = true; let y: bool = false; x or y;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::Bool);
        let mut testArena230 = testArena();
        let testStorage230: 'test230 = &mut testArena230 in {
            let mut a = testResolver(testStorage230);
            let result = try resolveBlockStr(&mut a, "let x: bool = true; let y: bool = false; x or y;");
            try expectNoErrors(&result);
            let stmt = try parser::tests::getBlockLastStmt(result.root);
            try expectExprStmtType(&a, stmt, super::Type::Bool);
        }
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "true and false");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
        let mut testArena231 = testArena();
        let testStorage231: 'test231 = &mut testArena231 in {
            let mut a = testResolver(testStorage231);
            let result = try resolveExprStr(&mut a, "true and false");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Bool);
        }
    }
}

@test unsafe fn testResolveBinaryOpArithmeticTypeMismatch() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "4 + true");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        let mut testArena232 = testArena();
        let testStorage232: 'test232 = &mut testArena232 in {
            let mut a = testResolver(testStorage232);
            let result = try resolveProgramStr(&mut a, "4 + true");
            try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: i32 = 4; let y: bool = false; x + y;");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        let mut testArena233 = testArena();
        let testStorage233: 'test233 = &mut testArena233 in {
            let mut a = testResolver(testStorage233);
            let result = try resolveBlockStr(&mut a, "let x: i32 = 4; let y: bool = false; x + y;");
            try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "10 - false");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        let mut testArena234 = testArena();
        let testStorage234: 'test234 = &mut testArena234 in {
            let mut a = testResolver(testStorage234);
            let result = try resolveProgramStr(&mut a, "10 - false");
            try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "5 * true");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        let mut testArena235 = testArena();
        let testStorage235: 'test235 = &mut testArena235 in {
            let mut a = testResolver(testStorage235);
            let result = try resolveProgramStr(&mut a, "5 * true");
            try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "20 / false");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        let mut testArena236 = testArena();
        let testStorage236: 'test236 = &mut testArena236 in {
            let mut a = testResolver(testStorage236);
            let result = try resolveProgramStr(&mut a, "20 / false");
            try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "17 % true");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        let mut testArena237 = testArena();
        let testStorage237: 'test237 = &mut testArena237 in {
            let mut a = testResolver(testStorage237);
            let result = try resolveProgramStr(&mut a, "17 % true");
            try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "1 + (true * 3)");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        let mut testArena238 = testArena();
        let testStorage238: 'test238 = &mut testArena238 in {
            let mut a = testResolver(testStorage238);
            let result = try resolveProgramStr(&mut a, "1 + (true * 3)");
            try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        }
    }
}

@test unsafe fn testResolveBinaryOpLogicalTypeMismatch() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "42 and true");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
        let mut testArena239 = testArena();
        let testStorage239: 'test239 = &mut testArena239 in {
            let mut a = testResolver(testStorage239);
            let result = try resolveProgramStr(&mut a, "42 and true");
            let err = try expectError(&result);
            try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "true or 5");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
        let mut testArena240 = testArena();
        let testStorage240: 'test240 = &mut testArena240 in {
            let mut a = testResolver(testStorage240);
            let result = try resolveProgramStr(&mut a, "true or 5");
            let err = try expectError(&result);
            try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "1 and 2");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
        let mut testArena241 = testArena();
        let testStorage241: 'test241 = &mut testArena241 in {
            let mut a = testResolver(testStorage241);
            let result = try resolveProgramStr(&mut a, "1 and 2");
            let err = try expectError(&result);
            try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
        }
    }
}

@test unsafe fn testResolveBinaryOpComparisonTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "true < false");
    try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
    let mut testArena242 = testArena();
    let testStorage242: 'test242 = &mut testArena242 in {
        let mut a = testResolver(testStorage242);
        let result = try resolveProgramStr(&mut a, "true < false");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
    }
}

// Unary operation tests ///////////////////////////////////////////////////////

@test unsafe fn testResolveUnaryOpNot() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "not true");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
        let mut testArena243 = testArena();
        let testStorage243: 'test243 = &mut testArena243 in {
            let mut a = testResolver(testStorage243);
            let result = try resolveExprStr(&mut a, "not true");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Bool);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: bool = true; not x;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::Bool);
        let mut testArena244 = testArena();
        let testStorage244: 'test244 = &mut testArena244 in {
            let mut a = testResolver(testStorage244);
            let result = try resolveBlockStr(&mut a, "let x: bool = true; not x;");
            try expectNoErrors(&result);
            let stmt = try parser::tests::getBlockLastStmt(result.root);
            try expectExprStmtType(&a, stmt, super::Type::Bool);
        }
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "not (true and false)");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
        let mut testArena245 = testArena();
        let testStorage245: 'test245 = &mut testArena245 in {
            let mut a = testResolver(testStorage245);
            let result = try resolveExprStr(&mut a, "not (true and false)");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Bool);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "not 42");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
        let mut testArena246 = testArena();
        let testStorage246: 'test246 = &mut testArena246 in {
            let mut a = testResolver(testStorage246);
            let result = try resolveProgramStr(&mut a, "not 42");
            let err = try expectError(&result);
            try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: i32 = 5; not x;");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Bool, super::Type::I32);
        let mut testArena247 = testArena();
        let testStorage247: 'test247 = &mut testArena247 in {
            let mut a = testResolver(testStorage247);
            let result = try resolveBlockStr(&mut a, "let x: i32 = 5; not x;");
            let err = try expectError(&result);
            try expectTypeMismatch(err, super::Type::Bool, super::Type::I32);
        }
    }
}

@test unsafe fn testResolveUnaryOpNeg() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "-42");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
        let mut testArena248 = testArena();
        let testStorage248: 'test248 = &mut testArena248 in {
            let mut a = testResolver(testStorage248);
            let result = try resolveExprStr(&mut a, "-42");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: i32 = 10; -x;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::I32);
        let mut testArena249 = testArena();
        let testStorage249: 'test249 = &mut testArena249 in {
            let mut a = testResolver(testStorage249);
            let result = try resolveBlockStr(&mut a, "let x: i32 = 10; -x;");
            try expectNoErrors(&result);
            let stmt = try parser::tests::getBlockLastStmt(result.root);
            try expectExprStmtType(&a, stmt, super::Type::I32);
        }
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "-(5 + 3)");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
        let mut testArena250 = testArena();
        let testStorage250: 'test250 = &mut testArena250 in {
            let mut a = testResolver(testStorage250);
            let result = try resolveExprStr(&mut a, "-(5 + 3)");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: i8 = 5; -x;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::I8);
        let mut testArena251 = testArena();
        let testStorage251: 'test251 = &mut testArena251 in {
            let mut a = testResolver(testStorage251);
            let result = try resolveBlockStr(&mut a, "let x: i8 = 5; -x;");
            try expectNoErrors(&result);
            let stmt = try parser::tests::getBlockLastStmt(result.root);
            try expectExprStmtType(&a, stmt, super::Type::I8);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "-true");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        let mut testArena252 = testArena();
        let testStorage252: 'test252 = &mut testArena252 in {
            let mut a = testResolver(testStorage252);
            let result = try resolveProgramStr(&mut a, "-true");
            try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: bool = false; -x;");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        let mut testArena253 = testArena();
        let testStorage253: 'test253 = &mut testArena253 in {
            let mut a = testResolver(testStorage253);
            let result = try resolveBlockStr(&mut a, "let x: bool = false; -x;");
            try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        }
    }
}

@test unsafe fn testResolveUnaryOpBitNot() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "~42");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
        let mut testArena254 = testArena();
        let testStorage254: 'test254 = &mut testArena254 in {
            let mut a = testResolver(testStorage254);
            let result = try resolveExprStr(&mut a, "~42");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u32 = 255; ~x;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::U32);
        let mut testArena255 = testArena();
        let testStorage255: 'test255 = &mut testArena255 in {
            let mut a = testResolver(testStorage255);
            let result = try resolveBlockStr(&mut a, "let x: u32 = 255; ~x;");
            try expectNoErrors(&result);
            let stmt = try parser::tests::getBlockLastStmt(result.root);
            try expectExprStmtType(&a, stmt, super::Type::U32);
        }
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "~(0xFF)");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
        let mut testArena256 = testArena();
        let testStorage256: 'test256 = &mut testArena256 in {
            let mut a = testResolver(testStorage256);
            let result = try resolveExprStr(&mut a, "~(0xFF)");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: i8 = 5; ~x;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::I8);
        let mut testArena257 = testArena();
        let testStorage257: 'test257 = &mut testArena257 in {
            let mut a = testResolver(testStorage257);
            let result = try resolveBlockStr(&mut a, "let x: i8 = 5; ~x;");
            try expectNoErrors(&result);
            let stmt = try parser::tests::getBlockLastStmt(result.root);
            try expectExprStmtType(&a, stmt, super::Type::I8);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "~true");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        let mut testArena258 = testArena();
        let testStorage258: 'test258 = &mut testArena258 in {
            let mut a = testResolver(testStorage258);
            let result = try resolveProgramStr(&mut a, "~true");
            try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: bool = false; ~x;");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        let mut testArena259 = testArena();
        let testStorage259: 'test259 = &mut testArena259 in {
            let mut a = testResolver(testStorage259);
            let result = try resolveBlockStr(&mut a, "let x: bool = false; ~x;");
            try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        }
    }
}

@test unsafe fn testResolveUnaryOpNested() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "not not true");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
        let mut testArena260 = testArena();
        let testStorage260: 'test260 = &mut testArena260 in {
            let mut a = testResolver(testStorage260);
            let result = try resolveExprStr(&mut a, "not not true");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Bool);
        }
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "--42");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
        let mut testArena261 = testArena();
        let testStorage261: 'test261 = &mut testArena261 in {
            let mut a = testResolver(testStorage261);
            let result = try resolveExprStr(&mut a, "--42");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "~~0xFF");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
        let mut testArena262 = testArena();
        let testStorage262: 'test262 = &mut testArena262 in {
            let mut a = testResolver(testStorage262);
            let result = try resolveExprStr(&mut a, "~~0xFF");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "-(~42)");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
        let mut testArena263 = testArena();
        let testStorage263: 'test263 = &mut testArena263 in {
            let mut a = testResolver(testStorage263);
            let result = try resolveExprStr(&mut a, "-(~42)");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    }
}

// test fn testNormalPointerArithmetic() throws (testing::TestError) {
//     mut a = testResolver();


// Dereference tests //////////////////////////////////////////////////////////

@test unsafe fn testResolveDeref() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "static x: i32 = 42; let ptr: *i32 = &x; *ptr;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::I32);
        let mut testArena264 = testArena();
        let testStorage264: 'test264 = &mut testArena264 in {
            let mut a = testResolver(testStorage264);
            let result = try resolveBlockStr(&mut a, "static x: i32 = 42; let ptr: *i32 = &x; *ptr;");
            try expectNoErrors(&result);
            let stmt = try parser::tests::getBlockLastStmt(result.root);
            try expectExprStmtType(&a, stmt, super::Type::I32);
        }
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "*42");
        try expectErrorKind(&result, super::ErrorKind::ExpectedPointer);
        let mut testArena265 = testArena();
        let testStorage265: 'test265 = &mut testArena265 in {
            let mut a = testResolver(testStorage265);
            let result = try resolveExprStr(&mut a, "*42");
            try expectErrorKind(&result, super::ErrorKind::ExpectedPointer);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: i32 = 5; *x;");
        try expectErrorKind(&result, super::ErrorKind::ExpectedPointer);
        let mut testArena266 = testArena();
        let testStorage266: 'test266 = &mut testArena266 in {
            let mut a = testResolver(testStorage266);
            let result = try resolveBlockStr(&mut a, "let x: i32 = 5; *x;");
            try expectErrorKind(&result, super::ErrorKind::ExpectedPointer);
        }
    }
}

@test unsafe fn testResolveAssignDeref() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "static x: i32 = 0; let ptr: *mut i32 = &mut x; set *ptr = 42;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena267 = testArena();
        let testStorage267: 'test267 = &mut testArena267 in {
            let mut a = testResolver(testStorage267);
            let program = "static x: i32 = 0; let ptr: *mut i32 = &mut x; set *ptr = 42;";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let program = "static x: i32 = 0; let ptr: *i32 = &x; set *ptr = 42;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        let mut testArena268 = testArena();
        let testStorage268: 'test268 = &mut testArena268 in {
            let mut a = testResolver(testStorage268);
            let program = "static x: i32 = 0; let ptr: *i32 = &x; set *ptr = 42;";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        }
    } {
        let mut a = testResolver();
        let program = "static x: i32 = 0; let mut ptr: *i32 = &x; set *ptr = 42;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        let mut testArena269 = testArena();
        let testStorage269: 'test269 = &mut testArena269 in {
            let mut a = testResolver(testStorage269);
            let program = "static x: i32 = 0; let mut ptr: *i32 = &x; set *ptr = 42;";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        }
    } {
        let mut a = testResolver();
        let program = "static x: u8 = 0; let mut ptr: *mut u8 = &mut x; set *ptr = 255;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena270 = testArena();
        let testStorage270: 'test270 = &mut testArena270 in {
            let mut a = testResolver(testStorage270);
            let program = "static x: u8 = 0; let mut ptr: *mut u8 = &mut x; set *ptr = 255;";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

// Type inference tests ///////////////////////////////////////////////////////

@test unsafe fn testResolveBasicTypeInference() throws (testing::TestError) {
    {
        // Boolean literals are unambiguous.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let x = true; x;");
        try expectNoErrors(&result);

        let xStmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, xStmt, super::Type::Bool);
        let mut testArena271 = testArena();
        let testStorage271: 'test271 = &mut testArena271 in {
            let mut a = testResolver(testStorage271);
            let result = try resolveProgramStr(&mut a, "let x = true; x;");
            try expectNoErrors(&result);

            let xStmt = try parser::tests::getBlockLastStmt(result.root);
            try expectExprStmtType(&a, xStmt, super::Type::Bool);
        }
    } {
        // Integer literals are ambiguous.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let x = 34;");
        try expectErrorKind(&result, super::ErrorKind::CannotInferType);
        let mut testArena272 = testArena();
        let testStorage272: 'test272 = &mut testArena272 in {
            let mut a = testResolver(testStorage272);
            let result = try resolveProgramStr(&mut a, "let x = 34;");
            try expectErrorKind(&result, super::ErrorKind::CannotInferType);
        }
    }
}

// Union tests /////////////////////////////////////////////////////////////////

@test unsafe fn testResolveUnionVariantWithoutPayload() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Status { Ok, Error } Status::Ok;";
    let result = try resolveProgramStr(&mut a, program);
    let mut testArena273 = testArena();
    let testStorage273: 'test273 = &mut testArena273 in {
        let mut a = testResolver(testStorage273);
        let program = "union Status { Ok, Error } Status::Ok;";
        let result = try resolveProgramStr(&mut a, program);

    let ty = try getTypeInScopeOf(&a, result.root, "Status");
    let case super::NominalType::Union(unionType) = *ty
        else throw testing::TestError::Failed;
    try testing::expect(unionType.variants.len == 2);
    try testing::expect(mem::eq(unionType.variants[0].name, "Ok"));
    try testing::expect(mem::eq(unionType.variants[1].name, "Error"));
    if getUnionVariantPayload(ty, "Ok") <> super::Type::Void {
        throw testing::TestError::Failed;
        let ty = try getTypeInScopeOf(&a, result.root, "Status");
        let case super::NominalType::Union(unionType) = *ty
            else throw testing::TestError::Failed;
        try testing::expect(unionType.variants.len == 2);
        try testing::expect(mem::eq(unionType.variants[0].name, "Ok"));
        try testing::expect(mem::eq(unionType.variants[1].name, "Error"));
        if getUnionVariantPayload(ty, "Ok") <> super::Type::Void {
            throw testing::TestError::Failed;
        }
        let stmt = try getBlockStmt(result.root, 1);
        try expectExprStmtType(&a, stmt, super::Type::Nominal(ty));
        try expectNoErrors(&result);
    }
    let stmt = try getBlockStmt(result.root, 1);
    try expectExprStmtType(&a, stmt, super::Type::Nominal(ty));
    try expectNoErrors(&result);
}

@test unsafe fn testResolveUnionVariantWithPayload() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union R { Ok(i32), Err(bool) } R::Ok(42);";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena274 = testArena();
    let testStorage274: 'test274 = &mut testArena274 in {
        let mut a = testResolver(testStorage274);
        let program = "union R { Ok(i32), Err(bool) } R::Ok(42);";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let ty = try getTypeInScopeOf(&a, result.root, "R");
        let ty = try getTypeInScopeOf(&a, result.root, "R");

    let okPayload = getUnionVariantPayload(ty, "Ok");
    try testing::expect(okPayload == super::Type::I32);
        let okPayload = getUnionVariantPayload(ty, "Ok");
        try testing::expect(okPayload == super::Type::I32);

    let errPayload = getUnionVariantPayload(ty, "Err");
    try testing::expect(errPayload == super::Type::Bool);
        let errPayload = getUnionVariantPayload(ty, "Err");
        try testing::expect(errPayload == super::Type::Bool);

    let stmt = try getBlockStmt(result.root, 1);
    try expectExprStmtType(&a, stmt, super::Type::Nominal(ty));
        let stmt = try getBlockStmt(result.root, 1);
        try expectExprStmtType(&a, stmt, super::Type::Nominal(ty));

    // TODO: Test payload type.
        // TODO: Test payload type.
    }
}

@test unsafe fn testResolveUnionVariantWithoutPayloadExplicitDiscriminant() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union R { Ok = 7, Err = 11 } R::Ok;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena275 = testArena();
    let testStorage275: 'test275 = &mut testArena275 in {
        let mut a = testResolver(testStorage275);
        let program = "union R { Ok = 7, Err = 11 } R::Ok;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let ty = try getTypeInScopeOf(&a, result.root, "R");
    let stmt = try getBlockStmt(result.root, 1);
    try expectExprStmtType(&a, stmt, super::Type::Nominal(ty));
        let ty = try getTypeInScopeOf(&a, result.root, "R");
        let stmt = try getBlockStmt(result.root, 1);
        try expectExprStmtType(&a, stmt, super::Type::Nominal(ty));
    }
}

@test unsafe fn testResolveUnionVariantPayloadTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union R { Ok(i32), Error(bool) } R::Ok(true);";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::I32, super::Type::Bool);
    let mut testArena276 = testArena();
    let testStorage276: 'test276 = &mut testArena276 in {
        let mut a = testResolver(testStorage276);
        let program = "union R { Ok(i32), Error(bool) } R::Ok(true);";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::I32, super::Type::Bool);

    let ty = try getTypeInScopeOf(&a, result.root, "R");
    let payload = getUnionVariantPayload(ty, "Ok");
    try testing::expect(payload == super::Type::I32);
        let ty = try getTypeInScopeOf(&a, result.root, "R");
        let payload = getUnionVariantPayload(ty, "Ok");
        try testing::expect(payload == super::Type::I32);

    let errNode = err.node
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Bool(_) = errNode.value
        else throw testing::TestError::Failed;
        let errNode = err.node
            else throw testing::TestError::Failed;
        let case ast::NodeValue::Bool(_) = errNode.value
            else throw testing::TestError::Failed;
    }
}

@test unsafe fn testResolveUnionVariantUnexpectedPayload() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Status { Ok, Error } Status::Ok(42);";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let mut testArena277 = testArena();
    let testStorage277: 'test277 = &mut testArena277 in {
        let mut a = testResolver(testStorage277);
        let program = "union Status { Ok, Error } Status::Ok(42);";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);

    let case super::ErrorKind::UnionVariantPayloadUnexpected(_) = err.kind
        else throw testing::TestError::Failed;
    let node = err.node
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Call(_) = node.value
        else throw testing::TestError::Failed;
        let case super::ErrorKind::UnionVariantPayloadUnexpected(_) = err.kind
            else throw testing::TestError::Failed;
        let node = err.node
            else throw testing::TestError::Failed;
        let case ast::NodeValue::Call(_) = node.value
            else throw testing::TestError::Failed;
    }
}

@test unsafe fn testResolveUnionVariantUnknown() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Status { Ok, Error } Status::Unknown;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("Unknown"));
    let mut testArena278 = testArena();
    let testStorage278: 'test278 = &mut testArena278 in {
        let mut a = testResolver(testStorage278);
        let program = "union Status { Ok, Error } Status::Unknown;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("Unknown"));
    }
}

@test unsafe fn testResolveScopeAccessUndefinedType() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "Unknown::X;");
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("Unknown"));
    let mut testArena279 = testArena();
    let testStorage279: 'test279 = &mut testArena279 in {
        let mut a = testResolver(testStorage279);
        let result = try resolveProgramStr(&mut a, "Unknown::X;");
        try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("Unknown"));
    }
}

@test unsafe fn testResolveUnionVariantVoidPayload() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union R { Success(i32), Pending } R::Pending;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena280 = testArena();
    let testStorage280: 'test280 = &mut testArena280 in {
        let mut a = testResolver(testStorage280);
        let program = "union R { Success(i32), Pending } R::Pending;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let ty = try getTypeInScopeOf(&a, result.root, "R");
    let payload = getUnionVariantPayload(ty, "Pending");
    try testing::expect(payload == super::Type::Void);
        let ty = try getTypeInScopeOf(&a, result.root, "R");
        let payload = getUnionVariantPayload(ty, "Pending");
        try testing::expect(payload == super::Type::Void);

    let stmt = try getBlockStmt(result.root, 1);
    try expectExprStmtType(&a, stmt, super::Type::Nominal(ty));
        let stmt = try getBlockStmt(result.root, 1);
        try expectExprStmtType(&a, stmt, super::Type::Nominal(ty));
    }
}

@test unsafe fn testResolveUnionVariantRecordPayload() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record P { x: i32, y: i32 } union S { Point(P), Num(u32) } S::Point(P { x: 10, y: 20 });";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena281 = testArena();
    let testStorage281: 'test281 = &mut testArena281 in {
        let mut a = testResolver(testStorage281);
        let program = "record P { x: i32, y: i32 } union S { Point(P), Num(u32) } S::Point(P { x: 10, y: 20 });";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let ty = try getTypeInScopeOf(&a, result.root, "S");
    let stmt = try getBlockStmt(result.root, 2);
    try expectExprStmtType(&a, stmt, super::Type::Nominal(ty));
        let ty = try getTypeInScopeOf(&a, result.root, "S");
        let stmt = try getBlockStmt(result.root, 2);
        try expectExprStmtType(&a, stmt, super::Type::Nominal(ty));
    }
}

@test unsafe fn testResolveBuiltinSizeOf() throws (testing::TestError) {
    try resolveAndExpectConstExpr("@sizeOf(u8)", 1);
    try resolveAndExpectConstExpr("@sizeOf(u16)", 2);

    try resolveAndExpectConstStmt("union T { A, B, C }; @alignOf(T);", 1);
    try resolveAndExpectConstStmt("union T { A, B(u32), C }; @alignOf(T);", 4);
}

@test unsafe fn testResolveBuiltinSizeOfRecord() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record T { x: u8, y: u32 } @sizeOf(T);";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena282 = testArena();
    let testStorage282: 'test282 = &mut testArena282 in {
        let mut a = testResolver(testStorage282);
        let program = "record T { x: u8, y: u32 } @sizeOf(T);";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 1);
    let expr = try expectExprStmtType(&a, stmt, super::Type::U32);
    try expectConstInt(&a, expr, 8);
        let stmt = try getBlockStmt(result.root, 1);
        let expr = try expectExprStmtType(&a, stmt, super::Type::U32);
        try expectConstInt(&a, expr, 8);
    }
}

@test unsafe fn testResolveBuiltinSizeOfUnion() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Result { Ok(u32), Err(u8) } @sizeOf(Result);";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena283 = testArena();
    let testStorage283: 'test283 = &mut testArena283 in {
        let mut a = testResolver(testStorage283);
        let program = "union Result { Ok(u32), Err(u8) } @sizeOf(Result);";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 1);
    let expr = try expectExprStmtType(&a, stmt, super::Type::U32);
    try expectConstInt(&a, expr, 8);
        let stmt = try getBlockStmt(result.root, 1);
        let expr = try expectExprStmtType(&a, stmt, super::Type::U32);
        try expectConstInt(&a, expr, 8);
    }
}

@test unsafe fn testResolveAlignAnnotation() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u8 align(8) = 0;");
        try expectNoErrors(&result);

        let stmt = try getBlockStmt(result.root, 0);
        let sym = super::symbolFor(&a, stmt)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: valType, .. } = sym.data
            else throw testing::TestError::Failed;
        let layout = super::getLayout(&a, sym.node, valType);
        try testing::expect(layout.alignment == 8);
        let mut testArena284 = testArena();
        let testStorage284: 'test284 = &mut testArena284 in {
            let mut a = testResolver(testStorage284);
            let result = try resolveBlockStr(&mut a, "let x: u8 align(8) = 0;");
            try expectNoErrors(&result);

            let stmt = try getBlockStmt(result.root, 0);
            let sym = super::symbolFor(&a, stmt)
                else throw testing::TestError::Failed;
            let case super::SymbolData::Value { type: valType, .. } = sym.data
                else throw testing::TestError::Failed;
            let layout = super::getLayout(&a, sym.node, valType);
            try testing::expect(layout.alignment == 8);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let x: u32 align(3) = 0;");
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAlignmentValue(val) = err.kind
            else throw testing::TestError::Failed;
        try testing::expect(val == 3);
        let mut testArena285 = testArena();
        let testStorage285: 'test285 = &mut testArena285 in {
            let mut a = testResolver(testStorage285);
            let result = try resolveProgramStr(&mut a, "let x: u32 align(3) = 0;");
            let err = try expectError(&result);
            let case super::ErrorKind::InvalidAlignmentValue(val) = err.kind
                else throw testing::TestError::Failed;
            try testing::expect(val == 3);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let x: u32 align(7) = 0;");
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAlignmentValue(val) = err.kind
            else throw testing::TestError::Failed;
        try testing::expect(val == 7);
        let mut testArena286 = testArena();
        let testStorage286: 'test286 = &mut testArena286 in {
            let mut a = testResolver(testStorage286);
            let result = try resolveProgramStr(&mut a, "let x: u32 align(7) = 0;");
            let err = try expectError(&result);
            let case super::ErrorKind::InvalidAlignmentValue(val) = err.kind
                else throw testing::TestError::Failed;
            try testing::expect(val == 7);
        }
    }
}

@test unsafe fn testResolveVoidAssignmentError() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn voidFn() {} let _ = voidFn();";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::CannotAssignVoid);
        let mut testArena287 = testArena();
        let testStorage287: 'test287 = &mut testArena287 in {
            let mut a = testResolver(testStorage287);
            let program = "fn voidFn() {} let _ = voidFn();";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::CannotAssignVoid);
        }
    } {
        let mut a = testResolver();
        let program = "fn voidFn() {} let x = voidFn();";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::CannotAssignVoid);
        let mut testArena288 = testArena();
        let testStorage288: 'test288 = &mut testArena288 in {
            let mut a = testResolver(testStorage288);
            let program = "fn voidFn() {} let x = voidFn();";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::CannotAssignVoid);
        }
    }
}

//
// Module Declaration Tests
//

@test unsafe fn testResolveEmptyMod() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut graph = &mut MODULE_GRAPH;
    let mut testArena289 = testArena();
    let testStorage289: 'test289 = &mut testArena289 in {
        let mut a = testResolver(testStorage289);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
        let mut graph = &mut MODULE_GRAPH;

    let rootId = try registerModule(graph, nil, "root", "mod child;", &mut arena);
    let childId = try registerModule(graph, rootId, "child", "{}", &mut arena);
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
        let rootId = try registerModule(graph, nil, "root", "mod child;", &mut arena);
        let childId = try registerModule(graph, rootId, "child", "{}", &mut arena);
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveModuleCannotAccessParentScope() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena290 = testArena();
    let testStorage290: 'test290 = &mut testArena290 in {
        let mut a = testResolver(testStorage290);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root and util modules.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod util; export fn helper() {}", &mut arena);
    let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "util", "fn main() { helper(); }", &mut arena);
        // Register root and util modules.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod util; export fn helper() {}", &mut arena);
        let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "util", "fn main() { helper(); }", &mut arena);

    // Resolve should fail: the parent module is not in scope.
    let result = try resolveModuleTree(&mut a, rootId);
    let err = try expectError(&result);
    let case super::ErrorKind::UnresolvedSymbol(name) = err.kind
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(name, "helper"));
        // Resolve should fail: the parent module is not in scope.
        let result = try resolveModuleTree(&mut a, rootId);
        let err = try expectError(&result);
        let case super::ErrorKind::UnresolvedSymbol(name) = err.kind
            else throw testing::TestError::Failed;
        try testing::expect(mem::eq(name, "helper"));
    }
}

@test unsafe fn testResolveModuleAccessPrivateSubModule() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena291 = testArena();
    let testStorage291: 'test291 = &mut testArena291 in {
        let mut a = testResolver(testStorage291);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root and util modules.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod util; fn main() { util::helper(); }", &mut arena);
    let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "util", "export fn helper() {}", &mut arena);
        // Register root and util modules.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod util; fn main() { util::helper(); }", &mut arena);
        let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "util", "export fn helper() {}", &mut arena);

    // Resolve should succeed: parent can access child.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
        // Resolve should succeed: parent can access child.
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveSiblingModulesCannotAccessDirectly() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena292 = testArena();
    let testStorage292: 'test292 = &mut testArena292 in {
        let mut a = testResolver(testStorage292);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with two sibling modules.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod paul; export mod patrick;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "paul", "fn main() { patrick::helper(); }", &mut arena);
    let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "patrick", "export fn helper() -> i32 { return 42; }", &mut arena);
        // Register root with two sibling modules.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod paul; export mod patrick;", &mut arena);
        let appId = try registerModule(&mut MODULE_GRAPH, rootId, "paul", "fn main() { patrick::helper(); }", &mut arena);
        let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "patrick", "export fn helper() -> i32 { return 42; }", &mut arena);

    // Resolve should fail: siblings can't access each other directly.
    let result = try resolveModuleTree(&mut a, rootId);
    let err = try expectError(&result);
    let case super::ErrorKind::UnresolvedSymbol(name) = err.kind
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(name, "patrick"));
        // Resolve should fail: siblings can't access each other directly.
        let result = try resolveModuleTree(&mut a, rootId);
        let err = try expectError(&result);
        let case super::ErrorKind::UnresolvedSymbol(name) = err.kind
            else throw testing::TestError::Failed;
        try testing::expect(mem::eq(name, "patrick"));
    }
}

@test unsafe fn testResolveSiblingModulesViaRoot() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena293 = testArena();
    let testStorage293: 'test293 = &mut testArena293 in {
        let mut a = testResolver(testStorage293);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with two sibling modules.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod paul; export mod patrick;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "paul", "use root::patrick; fn main() -> i32 { return patrick::helper(); }", &mut arena);
    let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "patrick", "export fn helper() -> i32 { return 42; }", &mut arena);
        // Register root with two sibling modules.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod paul; export mod patrick;", &mut arena);
        let appId = try registerModule(&mut MODULE_GRAPH, rootId, "paul", "use root::patrick; fn main() -> i32 { return patrick::helper(); }", &mut arena);
        let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "patrick", "export fn helper() -> i32 { return 42; }", &mut arena);

    // Resolve should succeed: siblings can access each other via root.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
        // Resolve should succeed: siblings can access each other via root.
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveModuleMutualRecursion() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena294 = testArena();
    let testStorage294: 'test294 = &mut testArena294 in {
        let mut a = testResolver(testStorage294);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with two sibling modules that call each other.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod left; export mod right;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "left", "use root::right; export fn leftHelper() -> i32 { return right::rightHelper(); }", &mut arena);
    let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "right", "use root::left; export fn rightHelper() -> i32 { return left::leftHelper(); }", &mut arena);
        // Register root with two sibling modules that call each other.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod left; export mod right;", &mut arena);
        let appId = try registerModule(&mut MODULE_GRAPH, rootId, "left", "use root::right; export fn leftHelper() -> i32 { return right::rightHelper(); }", &mut arena);
        let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "right", "use root::left; export fn rightHelper() -> i32 { return left::leftHelper(); }", &mut arena);

    // Resolve should succeed: cyclic use is allowed.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
        // Resolve should succeed: cyclic use is allowed.
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveAccessModuleType() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena295 = testArena();
    let testStorage295: 'test295 = &mut testArena295 in {
        let mut a = testResolver(testStorage295);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with types module containing a record.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod types; mod app;", &mut arena);
    let typesId = try registerModule(&mut MODULE_GRAPH, rootId, "types", "export record Point { x: i32, y: i32 }", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::types; fn main() -> i32 { let p = types::Point { x: 1, y: 2 }; return p.x; }", &mut arena);
        // Register root with types module containing a record.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod types; mod app;", &mut arena);
        let typesId = try registerModule(&mut MODULE_GRAPH, rootId, "types", "export record Point { x: i32, y: i32 }", &mut arena);
        let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::types; fn main() -> i32 { let p = types::Point { x: 1, y: 2 }; return p.x; }", &mut arena);

    // Resolve should succeed: types can be accessed.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
        // Resolve should succeed: types can be accessed.
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveAccessModuleConstant() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena296 = testArena();
    let testStorage296: 'test296 = &mut testArena296 in {
        let mut a = testResolver(testStorage296);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with constants module.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
    let constantsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export constant MAX_SIZE: i32 = 100;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; fn main() -> i32 { return consts::MAX_SIZE; }", &mut arena);
        // Register root with constants module.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
        let constantsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export constant MAX_SIZE: i32 = 100;", &mut arena);
        let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; fn main() -> i32 { return consts::MAX_SIZE; }", &mut arena);

    // Resolve should succeed: constants can be accessed.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
        // Resolve should succeed: constants can be accessed.
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveRootSymbolMustBeImported() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena297 = testArena();
    let testStorage297: 'test297 = &mut testArena297 in {
        let mut a = testResolver(testStorage297);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register deeply nested modules: `root::app::services::auth`.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod main; export fn helper() -> i32 { return 42; }", &mut arena);
    let mainId = try registerModule(&mut MODULE_GRAPH, rootId, "main", "fn run() -> i32 { return root::helper(); }", &mut arena);
        // Register deeply nested modules: `root::app::services::auth`.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod main; export fn helper() -> i32 { return 42; }", &mut arena);
        let mainId = try registerModule(&mut MODULE_GRAPH, rootId, "main", "fn run() -> i32 { return root::helper(); }", &mut arena);

    // Resolve should fail: the `root` module must be imported.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("root"));
        // Resolve should fail: the `root` module must be imported.
        let result = try resolveModuleTree(&mut a, rootId);
        try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("root"));
    }
}

@test unsafe fn testResolveUseImportsNestedSymbol() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena298 = testArena();
    let testStorage298: 'test298 = &mut testArena298 in {
        let mut a = testResolver(testStorage298);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register deeply nested modules: `root::app::services::auth`.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod app; mod main;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "export mod services;", &mut arena);
    let servicesId = try registerModule(&mut MODULE_GRAPH, appId, "services", "export mod auth;", &mut arena);
    let authId = try registerModule(&mut MODULE_GRAPH, servicesId, "auth", "export fn login() -> i32 { return 1; }", &mut arena);
    let mainId = try registerModule(&mut MODULE_GRAPH, rootId, "main", "use root::app::services::auth; fn run() -> i32 { return auth::login(); }", &mut arena);
    let otherId = try registerModule(&mut MODULE_GRAPH, rootId, "other", "use root; fn run() -> i32 { return root::app::services::auth::login(); }", &mut arena);
        // Register deeply nested modules: `root::app::services::auth`.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod app; mod main;", &mut arena);
        let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "export mod services;", &mut arena);
        let servicesId = try registerModule(&mut MODULE_GRAPH, appId, "services", "export mod auth;", &mut arena);
        let authId = try registerModule(&mut MODULE_GRAPH, servicesId, "auth", "export fn login() -> i32 { return 1; }", &mut arena);
        let mainId = try registerModule(&mut MODULE_GRAPH, rootId, "main", "use root::app::services::auth; fn run() -> i32 { return auth::login(); }", &mut arena);
        let otherId = try registerModule(&mut MODULE_GRAPH, rootId, "other", "use root; fn run() -> i32 { return root::app::services::auth::login(); }", &mut arena);

    // Resolve should succeed: use imports the module symbol.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
        // Resolve should succeed: use imports the module symbol.
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveUseNonExistentModule() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena299 = testArena();
    let testStorage299: 'test299 = &mut testArena299 in {
        let mut a = testResolver(testStorage299);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with app trying to use a non-existent module.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod app;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::unknown;", &mut arena);
        // Register root with app trying to use a non-existent module.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod app;", &mut arena);
        let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::unknown;", &mut arena);

    // Resolve should fail: module doesn't exist.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("unknown"));
        // Resolve should fail: module doesn't exist.
        let result = try resolveModuleTree(&mut a, rootId);
        try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("unknown"));
    }
}

@test unsafe fn testResolveUsePrivateFn() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena300 = testArena();
    let testStorage300: 'test300 = &mut testArena300 in {
        let mut a = testResolver(testStorage300);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with util module containing a private function.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod util; mod app;", &mut arena);
    let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "util", "fn private() -> i32 { return 42; }", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::util; fn main() -> i32 { return util::private(); }", &mut arena);
        // Register root with util module containing a private function.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod util; mod app;", &mut arena);
        let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "util", "fn private() -> i32 { return 42; }", &mut arena);
        let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::util; fn main() -> i32 { return util::private(); }", &mut arena);

    // Resolve should fail: function is not public.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("private"));
        // Resolve should fail: function is not public.
        let result = try resolveModuleTree(&mut a, rootId);
        try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("private"));
    }
}

@test unsafe fn testResolveUsePrivateMod() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena301 = testArena();
    let testStorage301: 'test301 = &mut testArena301 in {
        let mut a = testResolver(testStorage301);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with public and private child modules.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod main; mod private;", &mut arena);
    let privateId = try registerModule(&mut MODULE_GRAPH, rootId, "private", "{}", &mut arena);
    let publicId = try registerModule(&mut MODULE_GRAPH, rootId, "main", "use root::private;", &mut arena);
        // Register root with public and private child modules.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod main; mod private;", &mut arena);
        let privateId = try registerModule(&mut MODULE_GRAPH, rootId, "private", "{}", &mut arena);
        let publicId = try registerModule(&mut MODULE_GRAPH, rootId, "main", "use root::private;", &mut arena);

    // Resolve should fail: module is not public.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("private"));
        // Resolve should fail: module is not public.
        let result = try resolveModuleTree(&mut a, rootId);
        try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("private"));
    }
}

@test unsafe fn testResolveUsePublicMod() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena302 = testArena();
    let testStorage302: 'test302 = &mut testArena302 in {
        let mut a = testResolver(testStorage302);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with public and private child modules.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod main; export mod public;", &mut arena);
    let privateId = try registerModule(&mut MODULE_GRAPH, rootId, "public", "{}", &mut arena);
    let publicId = try registerModule(&mut MODULE_GRAPH, rootId, "main", "use root::public;", &mut arena);
        // Register root with public and private child modules.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod main; export mod public;", &mut arena);
        let privateId = try registerModule(&mut MODULE_GRAPH, rootId, "public", "{}", &mut arena);
        let publicId = try registerModule(&mut MODULE_GRAPH, rootId, "main", "use root::public;", &mut arena);

    // Resolve should succeed: module is public.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
        // Resolve should succeed: module is public.
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveUseNonPublicType() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena303 = testArena();
    let testStorage303: 'test303 = &mut testArena303 in {
        let mut a = testResolver(testStorage303);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with types module containing a private record.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod types; mod app;", &mut arena);
    let typesId = try registerModule(&mut MODULE_GRAPH, rootId, "types", "record Priv { x: i32 }", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::types; fn main() -> types::Priv { return types::Priv { x: 1 }; }", &mut arena);
        // Register root with types module containing a private record.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod types; mod app;", &mut arena);
        let typesId = try registerModule(&mut MODULE_GRAPH, rootId, "types", "record Priv { x: i32 }", &mut arena);
        let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::types; fn main() -> types::Priv { return types::Priv { x: 1 }; }", &mut arena);

    // Resolve should fail: record is not public.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("Priv"));
        // Resolve should fail: record is not public.
        let result = try resolveModuleTree(&mut a, rootId);
        try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("Priv"));
    }
}

@test unsafe fn testResolveImportPublicType() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena304 = testArena();
    let testStorage304: 'test304 = &mut testArena304 in {
        let mut a = testResolver(testStorage304);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with types module containing a public record.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod types; mod app;", &mut arena);
    let typesId = try registerModule(&mut MODULE_GRAPH, rootId, "types", "export record Pub { x: i32 }", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::types; fn main() -> types::Pub { return types::Pub { x: 1 }; }", &mut arena);
        // Register root with types module containing a public record.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod types; mod app;", &mut arena);
        let typesId = try registerModule(&mut MODULE_GRAPH, rootId, "types", "export record Pub { x: i32 }", &mut arena);
        let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::types; fn main() -> types::Pub { return types::Pub { x: 1 }; }", &mut arena);

    // Resolve should succeed: record is public.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
        // Resolve should succeed: record is public.
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveUseNonPublicStatic() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena305 = testArena();
    let testStorage305: 'test305 = &mut testArena305 in {
        let mut a = testResolver(testStorage305);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with statics module containing a private static.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod statics; mod app;", &mut arena);
    let staticsId = try registerModule(&mut MODULE_GRAPH, rootId, "statics", "static PRIVATE: i32 = 42;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::statics; fn main() -> i32 { return statics::PRIVATE; }", &mut arena);
        // Register root with statics module containing a private static.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod statics; mod app;", &mut arena);
        let staticsId = try registerModule(&mut MODULE_GRAPH, rootId, "statics", "static PRIVATE: i32 = 42;", &mut arena);
        let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::statics; fn main() -> i32 { return statics::PRIVATE; }", &mut arena);

    // Resolve should fail: static is not public.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("PRIVATE"));
        // Resolve should fail: static is not public.
        let result = try resolveModuleTree(&mut a, rootId);
        try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("PRIVATE"));
    }
}

@test unsafe fn testResolveImportPublicStatic() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena306 = testArena();
    let testStorage306: 'test306 = &mut testArena306 in {
        let mut a = testResolver(testStorage306);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with statics module containing a public static.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod statics; mod app;", &mut arena);
    let staticsId = try registerModule(&mut MODULE_GRAPH, rootId, "statics", "export static PUBLIC: i32 = 42;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::statics; fn main() -> i32 { return statics::PUBLIC; }", &mut arena);
        // Register root with statics module containing a public static.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod statics; mod app;", &mut arena);
        let staticsId = try registerModule(&mut MODULE_GRAPH, rootId, "statics", "export static PUBLIC: i32 = 42;", &mut arena);
        let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::statics; fn main() -> i32 { return statics::PUBLIC; }", &mut arena);

    // Resolve should succeed: static is public.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
        // Resolve should succeed: static is public.
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveAccessSuper() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

        // Test function access.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod child; export fn parentFn() -> i32 { return 42; }", &mut arena);
        let childId = try registerModule(&mut MODULE_GRAPH, rootId, "child", "fn main() -> i32 { return super::parentFn(); }", &mut arena);
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
        let mut testArena307 = testArena();
        let testStorage307: 'test307 = &mut testArena307 in {
            let mut a = testResolver(testStorage307);
            let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

            // Test function access.
            let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod child; export fn parentFn() -> i32 { return 42; }", &mut arena);
            let childId = try registerModule(&mut MODULE_GRAPH, rootId, "child", "fn main() -> i32 { return super::parentFn(); }", &mut arena);
            let result = try resolveModuleTree(&mut a, rootId);
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
        let mut testArena308 = testArena();
        let testStorage308: 'test308 = &mut testArena308 in {
            let mut a = testResolver(testStorage308);
            let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

        // Test type access.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod child; export record Point { x: i32, y: i32 }", &mut arena);
        let childId = try registerModule(&mut MODULE_GRAPH, rootId, "child", "fn make() -> super::Point { return super::Point { x: 1, y: 2 }; }", &mut arena);
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
            // Test type access.
            let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod child; export record Point { x: i32, y: i32 }", &mut arena);
            let childId = try registerModule(&mut MODULE_GRAPH, rootId, "child", "fn make() -> super::Point { return super::Point { x: 1, y: 2 }; }", &mut arena);
            let result = try resolveModuleTree(&mut a, rootId);
            try expectNoErrors(&result);
        }
    }
}

/// Test nested super access to union variants (e.g. `super::E::A`).
@test unsafe fn testResolveSuperUnionVariant() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena309 = testArena();
    let testStorage309: 'test309 = &mut testArena309 in {
        let mut a = testResolver(testStorage309);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod c; export union E { A, B }", &mut arena);
    let childId = try registerModule(&mut MODULE_GRAPH, rootId, "c",
        "fn f(x: super::E) { match x { case super::E::A => {}, case super::E::B => {} } }",
        &mut arena);
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod c; export union E { A, B }", &mut arena);
        let childId = try registerModule(&mut MODULE_GRAPH, rootId, "c",
            "fn f(x: super::E) { match x { case super::E::A => {}, case super::E::B => {} } }",
            &mut arena);
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveUseSuper() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena310 = testArena();
    let testStorage310: 'test310 = &mut testArena310 in {
        let mut a = testResolver(testStorage310);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with a function, and a child module that uses super to access it.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod joe; export mod kate;", &mut arena);
    let kateId = try registerModule(&mut MODULE_GRAPH, rootId, "kate", "export fn run() {}", &mut arena);
    let joeId = try registerModule(&mut MODULE_GRAPH, rootId, "joe", "use super::kate; fn main() { kate::run(); }", &mut arena);
        // Register root with a function, and a child module that uses super to access it.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod joe; export mod kate;", &mut arena);
        let kateId = try registerModule(&mut MODULE_GRAPH, rootId, "kate", "export fn run() {}", &mut arena);
        let joeId = try registerModule(&mut MODULE_GRAPH, rootId, "joe", "use super::kate; fn main() { kate::run(); }", &mut arena);

    // Resolve should succeed - super allows accessing parent module.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
        // Resolve should succeed - super allows accessing parent module.
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveModNotFound() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena311 = testArena();
    let testStorage311: 'test311 = &mut testArena311 in {
        let mut a = testResolver(testStorage311);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root that declares a module that doesn't exist.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod unknown;", &mut arena);
        // Register root that declares a module that doesn't exist.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod unknown;", &mut arena);

    // Resolve should fail: module doesn't exist.
    let result = try resolveModuleTree(&mut a, rootId);
    let err = try expectError(&result);
    let case super::ErrorKind::UnresolvedSymbol(name) = err.kind
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(name, "unknown"));
        // Resolve should fail: module doesn't exist.
        let result = try resolveModuleTree(&mut a, rootId);
        let err = try expectError(&result);
        let case super::ErrorKind::UnresolvedSymbol(name) = err.kind
            else throw testing::TestError::Failed;
        try testing::expect(mem::eq(name, "unknown"));
    }
}

@test unsafe fn testResolveDuplicateSubModule() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena312 = testArena();
    let testStorage312: 'test312 = &mut testArena312 in {
        let mut a = testResolver(testStorage312);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root that declares a module twice.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod child; mod child;", &mut arena);
    let childId = try registerModule(&mut MODULE_GRAPH, rootId, "child", "{}", &mut arena);
        // Register root that declares a module twice.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod child; mod child;", &mut arena);
        let childId = try registerModule(&mut MODULE_GRAPH, rootId, "child", "{}", &mut arena);

    // Resolve should fail: can't declare the same module twice.
    let result = try resolveModuleTree(&mut a, rootId);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("child"));
        // Resolve should fail: can't declare the same module twice.
        let result = try resolveModuleTree(&mut a, rootId);
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("child"));
    }
}

@test unsafe fn testResolveUseSubModule() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena313 = testArena();
    let testStorage313: 'test313 = &mut testArena313 in {
        let mut a = testResolver(testStorage313);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root that declares and imports the same module.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod child; use child;", &mut arena);
    let childId = try registerModule(&mut MODULE_GRAPH, rootId, "child", "{}", &mut arena);
        // Register root that declares and imports the same module.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod child; use child;", &mut arena);
        let childId = try registerModule(&mut MODULE_GRAPH, rootId, "child", "{}", &mut arena);

    // Resolve should fail: Both `mod` and `use` are trying to create the same binding.
    let result = try resolveModuleTree(&mut a, rootId);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("child"));
        // Resolve should fail: Both `mod` and `use` are trying to create the same binding.
        let result = try resolveModuleTree(&mut a, rootId);
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("child"));
    }
}

@test unsafe fn testResolveDuplicateUse() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena314 = testArena();
    let testStorage314: 'test314 = &mut testArena314 in {
        let mut a = testResolver(testStorage314);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register a module that imports the same module twice.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod child", &mut arena);
    let childId = try registerModule(&mut MODULE_GRAPH, rootId, "child", "use root; use root;", &mut arena);
        // Register a module that imports the same module twice.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod child", &mut arena);
        let childId = try registerModule(&mut MODULE_GRAPH, rootId, "child", "use root; use root;", &mut arena);

    // Resolve should fail.
    let result = try resolveModuleTree(&mut a, rootId);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("root"));
        // Resolve should fail.
        let result = try resolveModuleTree(&mut a, rootId);
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("root"));
    }
}

/// Test that opaque pointers are allowed in record fields.
@test unsafe fn testOpaquePointerInRecordField() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "record T { x: *opaque }");
    try expectNoErrors(&result);
    let mut testArena315 = testArena();
    let testStorage315: 'test315 = &mut testArena315 in {
        let mut a = testResolver(testStorage315);
        let result = try resolveProgramStr(&mut a, "record T { x: *opaque }");
        try expectNoErrors(&result);
    }
}

/// You cannot use `@sizeOf` or `@alignOf` on opaque type.
@test unsafe fn testOpaqueTypeNoSizeOfAlignOf() throws (testing::TestError) {
    let mut a = testResolver();
    let mut testArena316 = testArena();
    let testStorage316: 'test316 = &mut testArena316 in {
        let mut a = testResolver(testStorage316);

    let result1 = try resolveExprStr(&mut a, "@sizeOf(opaque)");
    let err1 = try expectError(&result1);
    try expectErrorKind(&result1, super::ErrorKind::OpaqueTypeNotAllowed);
        let result1 = try resolveExprStr(&mut a, "@sizeOf(opaque)");
        let err1 = try expectError(&result1);
        try expectErrorKind(&result1, super::ErrorKind::OpaqueTypeNotAllowed);

    let result2 = try resolveExprStr(&mut a, "@alignOf(opaque)");
    let err2 = try expectError(&result2);
    try expectErrorKind(&result2, super::ErrorKind::OpaqueTypeNotAllowed);
        let result2 = try resolveExprStr(&mut a, "@alignOf(opaque)");
        let err2 = try expectError(&result2);
        try expectErrorKind(&result2, super::ErrorKind::OpaqueTypeNotAllowed);
    }
}

/// Test that immutable slice/pointer parameters cannot be borrowed mutably.
@test unsafe fn testMutableBorrowFromImmutablePointer() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(p: *i32) { let x = &mut *p; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    let mut testArena317 = testArena();
    let testStorage317: 'test317 = &mut testArena317 in {
        let mut a = testResolver(testStorage317);
        let program = "fn f(p: *i32) { let x = &mut *p; }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
}

/// Test that immutable slice parameters cannot be borrowed mutably.
@test unsafe fn testMutableBorrowFromImmutableSlice() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(s: *[i32]) { let x: *mut i32 = &mut s[0]; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    let mut testArena318 = testArena();
    let testStorage318: 'test318 = &mut testArena318 in {
        let mut a = testResolver(testStorage318);
        let program = "fn f(s: *[i32]) { let x: *mut i32 = &mut s[0]; }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
}

/// Test that mutable pointer parameters can be borrowed mutably.
@test unsafe fn testMutableBorrowFromMutablePointer() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(p: *mut i32) { let x: *mut i32 = &mut *p; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena319 = testArena();
    let testStorage319: 'test319 = &mut testArena319 in {
        let mut a = testResolver(testStorage319);
        let program = "fn f(p: *mut i32) { let x: *mut i32 = &mut *p; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that mutable slice parameters can be borrowed mutably.
@test unsafe fn testMutableBorrowFromMutableSlice() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(s: *mut [i32]) { let x: *mut i32 = &mut s[0]; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena320 = testArena();
    let testStorage320: 'test320 = &mut testArena320 in {
        let mut a = testResolver(testStorage320);
        let program = "fn f(s: *mut [i32]) { let x: *mut i32 = &mut s[0]; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test borrowing mutably from a field access on a call returning `*mut`.
@test unsafe fn testMutableBorrowFromCallReturningMutablePointer() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Box { x: i32 } fn idBox(b: *mut Box) -> *mut Box { return b; } fn f() { static b: Box = Box { x: 1 }; let px: *mut i32 = &mut idBox(&mut b).x; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena321 = testArena();
    let testStorage321: 'test321 = &mut testArena321 in {
        let mut a = testResolver(testStorage321);
        let program = "record Box { x: i32 } fn idBox(b: *mut Box) -> *mut Box { return b; } fn f() { static b: Box = Box { x: 1 }; let px: *mut i32 = &mut idBox(&mut b).x; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that calls returning immutable pointers cannot be mutably borrowed.
@test unsafe fn testMutableBorrowFromCallReturningImmutablePointer() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Box { x: i32 } fn idBox(b: *Box) -> *Box { return b; } fn f() { constant b: Box = Box { x: 1 }; let px: *mut i32 = &mut idBox(&b).x; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    let mut testArena322 = testArena();
    let testStorage322: 'test322 = &mut testArena322 in {
        let mut a = testResolver(testStorage322);
        let program = "record Box { x: i32 } fn idBox(b: *Box) -> *Box { return b; } fn f() { constant b: Box = Box { x: 1 }; let px: *mut i32 = &mut idBox(&b).x; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
}

/// Test borrowing mutably from a public static through scope access.
@test unsafe fn testMutableBorrowFromScopeAccessStatic() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena323 = testArena();
    let testStorage323: 'test323 = &mut testArena323 in {
        let mut a = testResolver(testStorage323);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod statics; mod app;", &mut arena);
    let staticsId = try registerModule(&mut MODULE_GRAPH, rootId, "statics", "export static COUNTER: i32 = 0;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::statics; fn main() { let p: *mut i32 = &mut statics::COUNTER; set *p = 7; }", &mut arena);
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod statics; mod app;", &mut arena);
        let staticsId = try registerModule(&mut MODULE_GRAPH, rootId, "statics", "export static COUNTER: i32 = 0;", &mut arena);
        let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::statics; fn main() { let p: *mut i32 = &mut statics::COUNTER; set *p = 7; }", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    }
}

/// Test that constants through scope access cannot be mutably borrowed.
@test unsafe fn testMutableBorrowFromScopeAccessConstant() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena324 = testArena();
    let testStorage324: 'test324 = &mut testArena324 in {
        let mut a = testResolver(testStorage324);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export constant LIMIT: i32 = 7;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; fn main() { let p: *mut i32 = &mut consts::LIMIT; set *p = 9; }", &mut arena);
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
        let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export constant LIMIT: i32 = 7;", &mut arena);
        let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; fn main() { let p: *mut i32 = &mut consts::LIMIT; set *p = 9; }", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        let result = try resolveModuleTree(&mut a, rootId);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
}

/// Test that mutable bindings of immutable pointers cannot borrow mutably through the pointer.
@test unsafe fn testMutableBorrowFromMutableBindingOfPointer() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f() { static x: i32 = 1; let p: *i32 = &x; let y = &mut *p; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    let mut testArena325 = testArena();
    let testStorage325: 'test325 = &mut testArena325 in {
        let mut a = testResolver(testStorage325);
        let program = "fn f() { static x: i32 = 1; let p: *i32 = &x; let y = &mut *p; }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
}

/// Test that mutable pointer to immutable slice cannot be assigned through index.
/// This tests the case where we have `*mut *[T]`; the outer pointer is mutable but
/// the inner slice is immutable, so we shouldn't be able to mutate the elements.
@test unsafe fn testAssignThroughMutablePointerToImmutableSlice() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(slice: *[i32]) { let p: *mut *[i32] = &mut slice; set p[0] = 1; }";
    let result = try resolveProgramStr(&mut a, program);
    let mut testArena326 = testArena();
    let testStorage326: 'test326 = &mut testArena326 in {
        let mut a = testResolver(testStorage326);
        let program = "fn f(slice: *[i32]) { let p: *mut *[i32] = &mut slice; set p[0] = 1; }";
        let result = try resolveProgramStr(&mut a, program);

    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
}

/// Test that mutable slice parameters can be assigned through index.
@test unsafe fn testAssignThroughMutableSliceParam() throws (testing::TestError) {
    {
        // Mutable slice param: direct assignment should work
        let mut a = testResolver();
        let program = "fn f(slice: *mut [i32]) { set slice[0] = 1; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena327 = testArena();
        let testStorage327: 'test327 = &mut testArena327 in {
            let mut a = testResolver(testStorage327);
            let program = "fn f(slice: *mut [i32]) { set slice[0] = 1; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        // Immutable slice param: direct assignment should fail
        let mut a = testResolver();
        let program = "fn f(slice: *[i32]) { set slice[0] = 1; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        let mut testArena328 = testArena();
        let testStorage328: 'test328 = &mut testArena328 in {
            let mut a = testResolver(testStorage328);
            let program = "fn f(slice: *[i32]) { set slice[0] = 1; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        }
    }
}

/// Test range end type coercion with assignable types.
@test unsafe fn testRangeEndTypeCoercion() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn f(end: u32) { for i in 0..end {} }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena329 = testArena();
        let testStorage329: 'test329 = &mut testArena329 in {
            let mut a = testResolver(testStorage329);
            let program = "fn f(end: u32) { for i in 0..end {} }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let program = "fn f(start: u32) { for i in start..9 {} }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena330 = testArena();
        let testStorage330: 'test330 = &mut testArena330 in {
            let mut a = testResolver(testStorage330);
            let program = "fn f(start: u32) { for i in start..9 {} }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

/// Mixed-width range bounds require an explicit cast.
@test unsafe fn testRangeEndTypeSubType() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn f(start: i8, end: u32) { for i in start..end {} }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::I8, super::Type::U32);
        let mut testArena331 = testArena();
        let testStorage331: 'test331 = &mut testArena331 in {
            let mut a = testResolver(testStorage331);
            let program = "fn f(start: i8, end: u32) { for i in start..end {} }";
            let result = try resolveProgramStr(&mut a, program);
            let err = try expectError(&result);
            try expectTypeMismatch(err, super::Type::I8, super::Type::U32);
        }
    } {
        let mut a = testResolver();
        let program = "fn f(start: i8, end: u32) { for i in (start as u32)..end {} }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena332 = testArena();
        let testStorage332: 'test332 = &mut testArena332 in {
            let mut a = testResolver(testStorage332);
            let program = "fn f(start: i8, end: u32) { for i in (start as u32)..end {} }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

/// Test that try-catch expressions in statement context accept mismatched types.
@test unsafe fn testTryCatchInStatementContextTypeMismatchOk() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f() { try g() catch {}; } fn g() -> bool throws (i32) { panic; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena333 = testArena();
    let testStorage333: 'test333 = &mut testArena333 in {
        let mut a = testResolver(testStorage333);
        let program = "fn f() { try g() catch {}; } fn g() -> bool throws (i32) { panic; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that try-catch blocks in value context require divergence or void.
@test unsafe fn testTryCatchInValueContextTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f() -> bool { return try g() catch {}; } fn g() -> bool throws (i32) { panic; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::Bool, super::Type::Void);
    let mut testArena334 = testArena();
    let testStorage334: 'test334 = &mut testArena334 in {
        let mut a = testResolver(testStorage334);
        let program = "fn f() -> bool { return try g() catch {}; } fn g() -> bool throws (i32) { panic; }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Bool, super::Type::Void);
    }
}

/// Test that try-catch blocks in value context work when they diverge.
@test unsafe fn testTryCatchInValueContextDiverges() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f() -> bool { return try g() catch { return false; }; } fn g() -> bool throws (i32) { panic; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena335 = testArena();
    let testStorage335: 'test335 = &mut testArena335 in {
        let mut a = testResolver(testStorage335);
        let program = "fn f() -> bool { return try g() catch { return false; }; } fn g() -> bool throws (i32) { panic; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that `try?` lifts result type to optional.
@test unsafe fn testTryOptionalLiftsToOptional() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S {} fn f() -> ?*S { return try? g(); } fn g() -> *S throws (i32) { panic; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena336 = testArena();
    let testStorage336: 'test336 = &mut testArena336 in {
        let mut a = testResolver(testStorage336);
        let program = "record S {} fn f() -> ?*S { return try? g(); } fn g() -> *S throws (i32) { panic; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that record fields can be assigned if the record binding is mutable.
@test unsafe fn testMutableAssignToMutableRecordBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S { x: i32 } fn f() { let mut s = S { x: 1 }; set s.x = 2; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena337 = testArena();
    let testStorage337: 'test337 = &mut testArena337 in {
        let mut a = testResolver(testStorage337);
        let program = "record S { x: i32 } fn f() { let mut s = S { x: 1 }; set s.x = 2; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that record fields cannot be assigned if the record binding is immutable.
@test unsafe fn testMutableAssignToImmutableRecordBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S { x: i32 } fn f() { let s = S { x: 1 }; set s.x = 2; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    let mut testArena338 = testArena();
    let testStorage338: 'test338 = &mut testArena338 in {
        let mut a = testResolver(testStorage338);
        let program = "record S { x: i32 } fn f() { let s = S { x: 1 }; set s.x = 2; }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
}

/// Test that record fields can be assigned through a mutable pointer.
@test unsafe fn testMutableAssignToMutablePointerToRecord() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S { x: i32 } fn f(p: *mut S) { set p.x = 2; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena339 = testArena();
    let testStorage339: 'test339 = &mut testArena339 in {
        let mut a = testResolver(testStorage339);
        let program = "record S { x: i32 } fn f(p: *mut S) { set p.x = 2; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that record fields cannot be assigned through an immutable pointer.
@test unsafe fn testMutableAssignToImmutablePointerToRecord() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S { x: i32 } fn f(p: *S) { set p.x = 2; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    let mut testArena340 = testArena();
    let testStorage340: 'test340 = &mut testArena340 in {
        let mut a = testResolver(testStorage340);
        let program = "record S { x: i32 } fn f(p: *S) { set p.x = 2; }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
}

// Opaque pointer tests.

/// You can assign any pointer (*T) to an opaque pointer (*opaque) without a cast.
@test unsafe fn testOpaquePointerAutoCoercion() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "unsafe fn f(x: *i32) { let mut ptr: *i32 = x; let o: *opaque = ptr; set ptr = o as *i32; }");
    try expectNoErrors(&result);
    let mut testArena341 = testArena();
    let testStorage341: 'test341 = &mut testArena341 in {
        let mut a = testResolver(testStorage341);
        let result = try resolveProgramStr(&mut a, "unsafe fn f(x: *i32) { let mut ptr: *i32 = x; let o: *opaque = ptr; set ptr = o as *i32; }");
        try expectNoErrors(&result);
    }
}

/// You cannot assign an opaque pointer to a non-opaque pointer without a cast.
@test unsafe fn testOpaquePointerNoReverseCoercion() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let ptr: *i32 = o; }");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(mismatch) = err.kind
        else throw testing::TestError::Failed;
    let case super::Type::Pointer { target: expectedTarget, .. } = mismatch.expected
        else throw testing::TestError::Failed;
    let case super::Type::Pointer { target: actualTarget, .. } = mismatch.actual
        else throw testing::TestError::Failed;
    let mut testArena342 = testArena();
    let testStorage342: 'test342 = &mut testArena342 in {
        let mut a = testResolver(testStorage342);
        let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let ptr: *i32 = o; }");
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(mismatch) = err.kind
            else throw testing::TestError::Failed;
        let case super::Type::Pointer { target: expectedTarget, .. } = mismatch.expected
            else throw testing::TestError::Failed;
        let case super::Type::Pointer { target: actualTarget, .. } = mismatch.actual
            else throw testing::TestError::Failed;

    try testing::expect(*expectedTarget == super::Type::I32);
    try testing::expect(*actualTarget == super::Type::Opaque);
        try testing::expect(*expectedTarget == super::Type::I32);
        try testing::expect(*actualTarget == super::Type::Opaque);
    }
}

/// You cannot have a value of type `opaque` (function parameter).
@test unsafe fn testOpaqueValue() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(x: opaque) {}");
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::OpaqueTypeNotAllowed);
        let mut testArena343 = testArena();
        let testStorage343: 'test343 = &mut testArena343 in {
            let mut a = testResolver(testStorage343);
            let result = try resolveProgramStr(&mut a, "fn f(x: opaque) {}");
            let err = try expectError(&result);
            try expectErrorKind(&result, super::ErrorKind::OpaqueTypeNotAllowed);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "unsafe fn f() { let x: opaque = undefined; }");
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::OpaqueTypeNotAllowed);
        let mut testArena344 = testArena();
        let testStorage344: 'test344 = &mut testArena344 in {
            let mut a = testResolver(testStorage344);
            let result = try resolveProgramStr(&mut a, "unsafe fn f() { let x: opaque = undefined; }");
            let err = try expectError(&result);
            try expectErrorKind(&result, super::ErrorKind::OpaqueTypeNotAllowed);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "record R { x: opaque }");
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::OpaqueTypeNotAllowed);
        let mut testArena345 = testArena();
        let testStorage345: 'test345 = &mut testArena345 in {
            let mut a = testResolver(testStorage345);
            let result = try resolveProgramStr(&mut a, "record R { x: opaque }");
            let err = try expectError(&result);
            try expectErrorKind(&result, super::ErrorKind::OpaqueTypeNotAllowed);
        }
    }
}

/// You cannot dereference an opaque pointer, you have to cast it first.
@test unsafe fn testOpaquePointerNoDereference() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let x = *o; }");
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::OpaqueTypeDeref);
    let mut testArena346 = testArena();
    let testStorage346: 'test346 = &mut testArena346 in {
        let mut a = testResolver(testStorage346);
        let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let x = *o; }");
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::OpaqueTypeDeref);
    }
}

/// Test that you can dereference after casting.
@test unsafe fn testOpaquePointerDereferenceAfterCast() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "unsafe fn f() { let o: *opaque = undefined; let x = *(o as *i32); }");
    try expectNoErrors(&result);
    let mut testArena347 = testArena();
    let testStorage347: 'test347 = &mut testArena347 in {
        let mut a = testResolver(testStorage347);
        let result = try resolveProgramStr(&mut a, "unsafe fn f() { let o: *opaque = undefined; let x = *(o as *i32); }");
        try expectNoErrors(&result);
    }
}

/// You cannot do pointer arithmetic with an opaque pointer.
@test unsafe fn testOpaquePointerNoArithmetic() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let x = o + 1; }");
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::OpaquePointerArithmetic);
        let mut testArena348 = testArena();
        let testStorage348: 'test348 = &mut testArena348 in {
            let mut a = testResolver(testStorage348);
            let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let x = o + 1; }");
            let err = try expectError(&result);
            try expectErrorKind(&result, super::ErrorKind::OpaquePointerArithmetic);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let x = 1 + o; }");
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::OpaquePointerArithmetic);
        let mut testArena349 = testArena();
        let testStorage349: 'test349 = &mut testArena349 in {
            let mut a = testResolver(testStorage349);
            let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let x = 1 + o; }");
            let err = try expectError(&result);
            try expectErrorKind(&result, super::ErrorKind::OpaquePointerArithmetic);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let x = o - 1; }");
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::OpaquePointerArithmetic);
        let mut testArena350 = testArena();
        let testStorage350: 'test350 = &mut testArena350 in {
            let mut a = testResolver(testStorage350);
            let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let x = o - 1; }");
            let err = try expectError(&result);
            try expectErrorKind(&result, super::ErrorKind::OpaquePointerArithmetic);
        }
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let x = 1 - o; }");
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::OpaquePointerArithmetic);
        let mut testArena351 = testArena();
        let testStorage351: 'test351 = &mut testArena351 in {
            let mut a = testResolver(testStorage351);
            let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let x = 1 - o; }");
            let err = try expectError(&result);
            try expectErrorKind(&result, super::ErrorKind::OpaquePointerArithmetic);
        }
    }
}

// Wildcard import/reexport tests.

/// Test transitive re-export.
@test unsafe fn testWildcardReexportTransitive() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena352 = testArena();
    let testStorage352: 'test352 = &mut testArena352 in {
        let mut a = testResolver(testStorage352);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod a; export mod b;", &mut arena);
    let aId = try registerModule(&mut MODULE_GRAPH, rootId, "a", "use root::b; fn main() -> i32 { return b::helper() + b::MAX; }", &mut arena);
    let bId = try registerModule(&mut MODULE_GRAPH, rootId, "b", "mod c; export use c::*;", &mut arena);
    let cId = try registerModule(&mut MODULE_GRAPH, bId, "c", "mod d; export use d::*; export fn helper() -> i32 { return 42; }", &mut arena);
    let dId = try registerModule(&mut MODULE_GRAPH, cId, "d", "export constant MAX: i32 = 100;", &mut arena);
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod a; export mod b;", &mut arena);
        let aId = try registerModule(&mut MODULE_GRAPH, rootId, "a", "use root::b; fn main() -> i32 { return b::helper() + b::MAX; }", &mut arena);
        let bId = try registerModule(&mut MODULE_GRAPH, rootId, "b", "mod c; export use c::*;", &mut arena);
        let cId = try registerModule(&mut MODULE_GRAPH, bId, "c", "mod d; export use d::*; export fn helper() -> i32 { return 42; }", &mut arena);
        let dId = try registerModule(&mut MODULE_GRAPH, cId, "d", "export constant MAX: i32 = 100;", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    }
}

/// Test that wildcard import can access public symbols.
@test unsafe fn testWildcardImportPublicOnly() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena353 = testArena();
    let testStorage353: 'test353 = &mut testArena353 in {
        let mut a = testResolver(testStorage353);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod b; mod a;", &mut arena);
    let bId = try registerModule(&mut MODULE_GRAPH, rootId, "b", "export record Value { number: i32 } export fn public() -> i32 { return 1; } fn private() -> i32 { return 2; }", &mut arena);
    let aId = try registerModule(&mut MODULE_GRAPH, rootId, "a", "use root::b::*; fn id(value: Value) -> Value { return value; } fn main() -> i32 { return public() + id(Value { number: 2 }).number; }", &mut arena);
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod b; mod a;", &mut arena);
        let bId = try registerModule(&mut MODULE_GRAPH, rootId, "b", "export record Value { number: i32 } export fn public() -> i32 { return 1; } fn private() -> i32 { return 2; }", &mut arena);
        let aId = try registerModule(&mut MODULE_GRAPH, rootId, "a", "use root::b::*; fn id(value: Value) -> Value { return value; } fn main() -> i32 { return public() + id(Value { number: 2 }).number; }", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    }
}

/// Test that wildcard import cannot access private symbols.
@test unsafe fn testWildcardImportSkipsPrivate() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena354 = testArena();
    let testStorage354: 'test354 = &mut testArena354 in {
        let mut a = testResolver(testStorage354);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod b; mod a;", &mut arena);
    let bId = try registerModule(&mut MODULE_GRAPH, rootId, "b", "export fn public() -> i32 { return 1; } fn private() -> i32 { return 2; }", &mut arena);
    let aId = try registerModule(&mut MODULE_GRAPH, rootId, "a", "use root::b::*; fn main() -> i32 { return private(); }", &mut arena);
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod b; mod a;", &mut arena);
        let bId = try registerModule(&mut MODULE_GRAPH, rootId, "b", "export fn public() -> i32 { return 1; } fn private() -> i32 { return 2; }", &mut arena);
        let aId = try registerModule(&mut MODULE_GRAPH, rootId, "a", "use root::b::*; fn main() -> i32 { return private(); }", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("private"));
        let result = try resolveModuleTree(&mut a, rootId);
        try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("private"));
    }
}

/// Test that a constant array can use another constant as its length.
@test unsafe fn testConstArrayWithConstLength() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "constant LEN: u32 = 3; constant ARR: [i32; LEN] = [1, 2, 3];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    // Verify the array constant has the correct type with length 3.
    let arrStmt = try getBlockStmt(result.root, 1);
    let sym = super::symbolFor(&a, arrStmt)
        else throw testing::TestError::Failed;
    let case super::SymbolData::Constant { type: super::Type::Array(arrType), .. } = sym.data
        else throw testing::TestError::Failed;
    try testing::expect(arrType.length == 3);
    let mut testArena355 = testArena();
    let testStorage355: 'test355 = &mut testArena355 in {
        let mut a = testResolver(testStorage355);
        let program = "constant LEN: u32 = 3; constant ARR: [i32; LEN] = [1, 2, 3];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

        // Verify the array constant has the correct type with length 3.
        let arrStmt = try getBlockStmt(result.root, 1);
        let sym = super::symbolFor(&a, arrStmt)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Constant { type: super::Type::Array(arrType), .. } = sym.data
            else throw testing::TestError::Failed;
        try testing::expect(arrType.length == 3);
    }
}

/// Test that a record field can use a constant as its array length.
@test unsafe fn testRecordFieldWithConstArrayLength() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "constant SIZE: u32 = 4; record Buffer { data: [i32; SIZE], }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena356 = testArena();
    let testStorage356: 'test356 = &mut testArena356 in {
        let mut a = testResolver(testStorage356);
        let program = "constant SIZE: u32 = 4; record Buffer { data: [i32; SIZE], }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that a constant can have a record literal value (lazy record body resolution).
@test unsafe fn testConstWithRecordLiteral() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Point { x: i32, y: i32 } constant ORIGIN: Point = Point { x: 0, y: 0 };";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena357 = testArena();
    let testStorage357: 'test357 = &mut testArena357 in {
        let mut a = testResolver(testStorage357);
        let program = "record Point { x: i32, y: i32 } constant ORIGIN: Point = Point { x: 0, y: 0 };";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that a constant can have a union variant value (lazy union body resolution).
@test unsafe fn testConstWithUnionVariant() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Color { Red, Green, Blue } constant DEFAULT: Color = Color::Red;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena358 = testArena();
    let testStorage358: 'test358 = &mut testArena358 in {
        let mut a = testResolver(testStorage358);
        let program = "union Color { Red, Green, Blue } constant DEFAULT: Color = Color::Red;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that record field types can reference imported types.
///
/// This tests that `use` statements are processed before record body resolution,
/// allowing record fields to use types from imported modules.
@test unsafe fn testRecordFieldUsesImportedType() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena359 = testArena();
    let testStorage359: 'test359 = &mut testArena359 in {
        let mut a = testResolver(testStorage359);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod types; mod scanner;", &mut arena);
    let typesId = try registerModule(&mut MODULE_GRAPH, rootId, "types", "export record Pool { count: u32 }", &mut arena);
    let scannerId = try registerModule(&mut MODULE_GRAPH, rootId, "scanner", "use root::types; record Scanner { pool: *types::Pool }", &mut arena);
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod types; mod scanner;", &mut arena);
        let typesId = try registerModule(&mut MODULE_GRAPH, rootId, "types", "export record Pool { count: u32 }", &mut arena);
        let scannerId = try registerModule(&mut MODULE_GRAPH, rootId, "scanner", "use root::types; record Scanner { pool: *types::Pool }", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    }
}

/// Test that imported constants can be used in array size expressions.
///
/// This tests that constant values are propagated through scope access expressions,
/// enabling compile-time evaluation of array sizes using imported constants.
@test unsafe fn testImportedConstantInArraySize() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena360 = testArena();
    let testStorage360: 'test360 = &mut testArena360 in {
        let mut a = testResolver(testStorage360);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export constant SIZE: u32 = 8;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; static BUFFER: [u8; consts::SIZE] = [0; consts::SIZE];", &mut arena);
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
        let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export constant SIZE: u32 = 8;", &mut arena);
        let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; static BUFFER: [u8; consts::SIZE] = [0; consts::SIZE];", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    }
}

/// Test that `if let case` binds payload variables in the then branch.
///
/// When using `if let case Union::Variant(x) = expr { ... }`, the variable `x` should
/// be bound to the payload value within the then branch scope.
@test unsafe fn testResolveIfCaseBindsPayload() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some(i32), None } fn f(value: Opt) -> i32 { if let case Opt::Some(x) = value { return x; } return 0; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena361 = testArena();
    let testStorage361: 'test361 = &mut testArena361 in {
        let mut a = testResolver(testStorage361);
        let program = "union Opt { Some(i32), None } fn f(value: Opt) -> i32 { if let case Opt::Some(x) = value { return x; } return 0; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that `if let case` payload binding is scoped to the then branch.
///
/// The payload variable should not be accessible outside the then branch.
@test unsafe fn testResolveIfCasePayloadScopeError() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some(i32), None } fn f(value: Opt) -> i32 { if let case Opt::Some(x) = value {} return x; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::UnresolvedSymbol(name) = err.kind
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(name, "x"));
    let mut testArena362 = testArena();
    let testStorage362: 'test362 = &mut testArena362 in {
        let mut a = testResolver(testStorage362);
        let program = "union Opt { Some(i32), None } fn f(value: Opt) -> i32 { if let case Opt::Some(x) = value {} return x; }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::UnresolvedSymbol(name) = err.kind
            else throw testing::TestError::Failed;
        try testing::expect(mem::eq(name, "x"));
    }
}

/// Test that `let case` binds payload variables in the current scope.
///
/// When using `let case Union::Variant(x) = expr else { ... }`, the variable `x`
/// should be bound in the scope after the statement.
@test unsafe fn testResolveLetCaseElseBindsPayload() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some(i32), None } fn f(value: Opt) -> i32 { let case Opt::Some(x) = value else panic; return x; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena363 = testArena();
    let testStorage363: 'test363 = &mut testArena363 in {
        let mut a = testResolver(testStorage363);
        let program = "union Opt { Some(i32), None } fn f(value: Opt) -> i32 { let case Opt::Some(x) = value else panic; return x; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that function pointers with identical signatures are assignable.
///
/// Two function types with the same parameters, return type, and throw list
/// should be considered structurally equal, even if they are separate allocations.
@test unsafe fn testFnPointerAssignability() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn apply(f: fn(i32) -> i32, x: i32) -> i32 { return f(x); } fn double(n: i32) -> i32 { return n * 2; } apply(double, 5);";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena364 = testArena();
    let testStorage364: 'test364 = &mut testArena364 in {
        let mut a = testResolver(testStorage364);
        let program = "fn apply(f: fn(i32) -> i32, x: i32) -> i32 { return f(x); } fn double(n: i32) -> i32 { return n * 2; } apply(double, 5);";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that function pointers with different parameter types are not assignable.
@test unsafe fn testFnPointerParamMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn apply(f: fn(i32) -> i32, x: i32) -> i32 { return f(x); } fn other(n: i8) -> i32 { return n as i32; } apply(other, 5);";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena365 = testArena();
    let testStorage365: 'test365 = &mut testArena365 in {
        let mut a = testResolver(testStorage365);
        let program = "fn apply(f: fn(i32) -> i32, x: i32) -> i32 { return f(x); } fn other(n: i8) -> i32 { return n as i32; } apply(other, 5);";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Test that function pointers with different return types are not assignable.
@test unsafe fn testFnPointerReturnMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn apply(f: fn(i32) -> i32, x: i32) -> i32 { return f(x); } fn other(n: i32) -> i8 { return n as i8; } apply(other, 5);";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena366 = testArena();
    let testStorage366: 'test366 = &mut testArena366 in {
        let mut a = testResolver(testStorage366);
        let program = "fn apply(f: fn(i32) -> i32, x: i32) -> i32 { return f(x); } fn other(n: i32) -> i8 { return n as i8; } apply(other, 5);";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Test that named records use nominal typing, not structural.
///
/// Two different named record types with identical fields should NOT be
/// assignable to each other, because they are distinct nominal types.
@test unsafe fn testNamedRecordNominalTyping() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Point { x: i32, y: i32 } record Vec2 { x: i32, y: i32 } fn take(p: Point) -> i32 { return p.x; } let v = Vec2 { x: 1, y: 2 }; take(v);";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena367 = testArena();
    let testStorage367: 'test367 = &mut testArena367 in {
        let mut a = testResolver(testStorage367);
        let program = "record Point { x: i32, y: i32 } record Vec2 { x: i32, y: i32 } fn take(p: Point) -> i32 { return p.x; } let v = Vec2 { x: 1, y: 2 }; take(v);";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Test that union variants with labeled record payloads can be constructed.
@test unsafe fn testUnionVariantAnonRecordPayload() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Event { Click { x: i32, y: i32 }, Key { code: u32 } } let e = Event::Click { x: 10, y: 20 };";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena368 = testArena();
    let testStorage368: 'test368 = &mut testArena368 in {
        let mut a = testResolver(testStorage368);
        let program = "union Event { Click { x: i32, y: i32 }, Key { code: u32 } } let e = Event::Click { x: 10, y: 20 };";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that unlabeled record literals with positional fields work correctly.
///
/// When a record is declared with positional fields (e.g., `record R(i32, bool)`),
/// the literal must use constructor call syntax with positional arguments.
@test unsafe fn testResolveUnlabeledRecordLitValid() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record R(i32, bool); let r: R = R(1, true);";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena369 = testArena();
    let testStorage369: 'test369 = &mut testArena369 in {
        let mut a = testResolver(testStorage369);
        let program = "record R(i32, bool); let r: R = R(1, true);";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that using brace syntax for an unlabeled record causes an error.
@test unsafe fn testResolveUnlabeledRecordLitStyleMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record R(i32); let r = R { x: 1 };";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::RecordFieldStyleMismatch);
    let mut testArena370 = testArena();
    let testStorage370: 'test370 = &mut testArena370 in {
        let mut a = testResolver(testStorage370);
        let program = "record R(i32); let r = R { x: 1 };";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::RecordFieldStyleMismatch);
    }
}

/// Test that providing too many fields for an unlabeled record causes count mismatch.
@test unsafe fn testResolveUnlabeledRecordLitTooManyFields() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record R(i32, bool); let r = R(1, true, 3);";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::RecordFieldCountMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena371 = testArena();
    let testStorage371: 'test371 = &mut testArena371 in {
        let mut a = testResolver(testStorage371);
        let program = "record R(i32, bool); let r = R(1, true, 3);";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::RecordFieldCountMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Test that match pattern with wrong number of bindings causes count mismatch.
@test unsafe fn testResolveMatchPatternWrongBindingCount() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Event { Click { x: i32, y: i32 } } fn f(e: Event) { match e { case Event::Click(a) => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::RecordFieldCountMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena372 = testArena();
    let testStorage372: 'test372 = &mut testArena372 in {
        let mut a = testResolver(testStorage372);
        let program = "union Event { Click { x: i32, y: i32 } } fn f(e: Event) { match e { case Event::Click(a) => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::RecordFieldCountMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Test that shorthand field syntax works in record literals.
/// `Point { x, y }` should be equivalent to `Point { x: x, y: y }`.
@test unsafe fn testResolveRecordLiteralShorthand() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Point { x: i32, y: i32 } fn f() { let x: i32 = 1; let y: i32 = 2; let p = Point { x, y }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena373 = testArena();
    let testStorage373: 'test373 = &mut testArena373 in {
        let mut a = testResolver(testStorage373);
        let program = "record Point { x: i32, y: i32 } fn f() { let x: i32 = 1; let y: i32 = 2; let p = Point { x, y }; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test shorthand field syntax with mixed explicit and shorthand fields.
@test unsafe fn testResolveRecordLiteralMixedShorthand() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Point { x: i32, y: i32 } fn f() { let x: i32 = 5; let p = Point { x, y: 10 }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena374 = testArena();
    let testStorage374: 'test374 = &mut testArena374 in {
        let mut a = testResolver(testStorage374);
        let program = "record Point { x: i32, y: i32 } fn f() { let x: i32 = 5; let p = Point { x, y: 10 }; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test record-style union variant patterns with shorthand syntax.
@test unsafe fn testResolveMatchRecordPatternShorthand() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Shape { Rect { width: i32, height: i32 } } fn f(s: Shape) -> i32 { match s { case Shape::Rect { width, height } => return width + height } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena375 = testArena();
    let testStorage375: 'test375 = &mut testArena375 in {
        let mut a = testResolver(testStorage375);
        let program = "union Shape { Rect { width: i32, height: i32 } } fn f(s: Shape) -> i32 { match s { case Shape::Rect { width, height } => return width + height } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test record pattern with mixed shorthand and explicit labels.
@test unsafe fn testResolveMatchRecordPatternMixed() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Shape { Rect { width: i32, height: i32 } } fn f(s: Shape) -> i32 { match s { case Shape::Rect { width, height: h } => return width + h } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena376 = testArena();
    let testStorage376: 'test376 = &mut testArena376 in {
        let mut a = testResolver(testStorage376);
        let program = "union Shape { Rect { width: i32, height: i32 } } fn f(s: Shape) -> i32 { match s { case Shape::Rect { width, height: h } => return width + h } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test record pattern with fields in reverse order.
@test unsafe fn testResolveMatchRecordPatternReversed() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Shape { Rect { width: i32, height: i32 } } fn f(s: Shape) -> i32 { match s { case Shape::Rect { height: h, width: w } => return w + h } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena377 = testArena();
    let testStorage377: 'test377 = &mut testArena377 in {
        let mut a = testResolver(testStorage377);
        let program = "union Shape { Rect { width: i32, height: i32 } } fn f(s: Shape) -> i32 { match s { case Shape::Rect { height: h, width: w } => return w + h } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test record pattern with shorthand syntax in reverse order.
/// Pattern `{ height, width }` binds all fields using shorthand, but not in definition order.
@test unsafe fn testResolveMatchRecordPatternShorthandReversed() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Shape { Rect { width: i32, height: i32 } } fn f(s: Shape) -> i32 { match s { case Shape::Rect { height, width } => return width + height } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena378 = testArena();
    let testStorage378: 'test378 = &mut testArena378 in {
        let mut a = testResolver(testStorage378);
        let program = "union Shape { Rect { width: i32, height: i32 } } fn f(s: Shape) -> i32 { match s { case Shape::Rect { height, width } => return width + height } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test record pattern with `..` ignoring fields.
@test unsafe fn testResolveMatchRecordPatternIgnoreRest() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "union G { Point { x: i32, y: i32, z: i32 } } fn f(g: G) -> i32 { match g { case G::Point { x, .. } => return x } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena379 = testArena();
        let testStorage379: 'test379 = &mut testArena379 in {
            let mut a = testResolver(testStorage379);
            let program = "union G { Point { x: i32, y: i32, z: i32 } } fn f(g: G) -> i32 { match g { case G::Point { x, .. } => return x } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let program = "union G { Point { x: i32, y: i32, z: i32 } } fn f(g: G) -> i32 { match g { case G::Point { x: val, .. } => return val } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena380 = testArena();
        let testStorage380: 'test380 = &mut testArena380 in {
            let mut a = testResolver(testStorage380);
            let program = "union G { Point { x: i32, y: i32, z: i32 } } fn f(g: G) -> i32 { match g { case G::Point { x: val, .. } => return val } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let program = "union G { Point { x: i32, y: i32, z: i32 } } fn f(g: G) -> i32 { match g { case G::Point { z, .. } => return z } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena381 = testArena();
        let testStorage381: 'test381 = &mut testArena381 in {
            let mut a = testResolver(testStorage381);
            let program = "union G { Point { x: i32, y: i32, z: i32 } } fn f(g: G) -> i32 { match g { case G::Point { z, .. } => return z } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let program = "union G { Point { x: i32, y: i32, z: i32 } } fn f(g: G) -> i32 { match g { case G::Point { z, x, .. } => return x + z } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena382 = testArena();
        let testStorage382: 'test382 = &mut testArena382 in {
            let mut a = testResolver(testStorage382);
            let program = "union G { Point { x: i32, y: i32, z: i32 } } fn f(g: G) -> i32 { match g { case G::Point { z, x, .. } => return x + z } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let program = "union G { Point { x: i32, y: i32, z: i32 } } fn f(g: G) -> bool { match g { case G::Point { .. } => return true } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena383 = testArena();
        let testStorage383: 'test383 = &mut testArena383 in {
            let mut a = testResolver(testStorage383);
            let program = "union G { Point { x: i32, y: i32, z: i32 } } fn f(g: G) -> bool { match g { case G::Point { .. } => return true } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

/// Test standalone record pattern matching with unlabeled patterns.
@test unsafe fn testResolveMatchStandaloneRecordUnlabeledPattern() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S(i32); fn f(s: S) -> i32 { match s { case S(x) => return x, else => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena384 = testArena();
    let testStorage384: 'test384 = &mut testArena384 in {
        let mut a = testResolver(testStorage384);
        let program = "record S(i32); fn f(s: S) -> i32 { match s { case S(x) => return x, else => return 0 } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test standalone record pattern matching with labeled patterns.
/// Pattern syntax: `T { x }` matches a named record and binds x to the field.
@test unsafe fn testResolveMatchStandaloneRecordLabeledPattern() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record T { x: i32 } fn f(t: T) -> i32 { match t { case T { x } => return x, else => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena385 = testArena();
    let testStorage385: 'test385 = &mut testArena385 in {
        let mut a = testResolver(testStorage385);
        let program = "record T { x: i32 } fn f(t: T) -> i32 { match t { case T { x } => return x, else => return 0 } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test standalone record pattern with multiple fields.
/// Pattern syntax: `R(a, b)` matches an unlabeled record with multiple fields.
@test unsafe fn testResolveMatchStandaloneRecordMultipleFields() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record R(bool, u8); fn f(r: R) -> u8 { match r { case R(_, x) => return x, else => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena386 = testArena();
    let testStorage386: 'test386 = &mut testArena386 in {
        let mut a = testResolver(testStorage386);
        let program = "record R(bool, u8); fn f(r: R) -> u8 { match r { case R(_, x) => return x, else => return 0 } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test standalone record pattern with wrong field count.
/// Pattern `S(x, y)` should fail for a single-field record.
@test unsafe fn testResolveMatchStandaloneRecordWrongFieldCount() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S(i32); fn f(s: S) -> i32 { match s { case S(x, y) => return x + y, else => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::RecordFieldCountMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena387 = testArena();
    let testStorage387: 'test387 = &mut testArena387 in {
        let mut a = testResolver(testStorage387);
        let program = "record S(i32); fn f(s: S) -> i32 { match s { case S(x, y) => return x + y, else => return 0 } }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::RecordFieldCountMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Test array pattern matching with element bindings.
/// Pattern syntax: `[x, y]` matches an array and binds elements.
@test unsafe fn testResolveMatchArrayPattern() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(arr: [i32; 2]) -> i32 { match arr { case [x, y] => return x + y } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena388 = testArena();
    let testStorage388: 'test388 = &mut testArena388 in {
        let mut a = testResolver(testStorage388);
        let program = "fn f(arr: [i32; 2]) -> i32 { match arr { case [x, y] => return x + y } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test array pattern with placeholder elements.
/// Pattern syntax: `[_, y]` ignores first element.
@test unsafe fn testResolveMatchArrayPatternPlaceholder() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(arr: [i32; 2]) -> i32 { match arr { case [_, y] => return y } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena389 = testArena();
    let testStorage389: 'test389 = &mut testArena389 in {
        let mut a = testResolver(testStorage389);
        let program = "fn f(arr: [i32; 2]) -> i32 { match arr { case [_, y] => return y } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test identifier pattern that binds the whole value.
/// Pattern syntax: `x` matches any value and binds it.
@test unsafe fn testResolveMatchIdentPattern() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(val: i32) -> i32 { match val { x => return x } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena390 = testArena();
    let testStorage390: 'test390 = &mut testArena390 in {
        let mut a = testResolver(testStorage390);
        let program = "fn f(val: i32) -> i32 { match val { x => return x } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test numeric literal pattern matching.
@test unsafe fn testResolveMatchNumericLiteralPattern() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(val: i32) -> i32 { match val { case 42 => return 1, else => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena391 = testArena();
    let testStorage391: 'test391 = &mut testArena391 in {
        let mut a = testResolver(testStorage391);
        let program = "fn f(val: i32) -> i32 { match val { case 42 => return 1, else => return 0 } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test string literal pattern matching.
@test unsafe fn testResolveMatchStringLiteralPattern() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(val: *[u8]) -> i32 { match val { case \"hello\" => return 1, else => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena392 = testArena();
    let testStorage392: 'test392 = &mut testArena392 in {
        let mut a = testResolver(testStorage392);
        let program = "fn f(val: *[u8]) -> i32 { match val { case \"hello\" => return 1, else => return 0 } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test boolean literal pattern matching.
@test unsafe fn testResolveMatchBoolLiteralPattern() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(val: bool) -> i32 { match val { case true => return 1, case false => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena393 = testArena();
    let testStorage393: 'test393 = &mut testArena393 in {
        let mut a = testResolver(testStorage393);
        let program = "fn f(val: bool) -> i32 { match val { case true => return 1, case false => return 0 } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test @sliceOf with correct arguments succeeds.
@test unsafe fn testResolveSliceOfCorrect() throws (testing::TestError) {
    // Immutable pointer.
    {
        let mut a = testResolver();
        let program = "unsafe fn f(ptr: *u8, len: u32) -> *[u8] { return @sliceOf(ptr, len); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena394 = testArena();
        let testStorage394: 'test394 = &mut testArena394 in {
            let mut a = testResolver(testStorage394);
            let program = "unsafe fn f(ptr: *u8, len: u32) -> *[u8] { return @sliceOf(ptr, len); }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
    // Mutable pointer produces mutable slice.
    {
        let mut a = testResolver();
        let program = "unsafe fn f(ptr: *mut u8, len: u32) -> *mut [u8] { return @sliceOf(ptr, len); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena395 = testArena();
        let testStorage395: 'test395 = &mut testArena395 in {
            let mut a = testResolver(testStorage395);
            let program = "unsafe fn f(ptr: *mut u8, len: u32) -> *mut [u8] { return @sliceOf(ptr, len); }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

/// Test @sliceOf with wrong argument count produces an error.
@test unsafe fn testResolveSliceOfWrongArgCount() throws (testing::TestError) {
    // No arguments.
    {
        let mut a = testResolver();
        let program = "fn f() -> *[u8] { return @sliceOf(); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::BuiltinArgCountMismatch(mismatch) = err.kind
            else throw testing::TestError::Failed;
        try testing::expect(mismatch.expected == 2);
        try testing::expect(mismatch.actual == 0);
        let mut testArena396 = testArena();
        let testStorage396: 'test396 = &mut testArena396 in {
            let mut a = testResolver(testStorage396);
            let program = "fn f() -> *[u8] { return @sliceOf(); }";
            let result = try resolveProgramStr(&mut a, program);
            let err = try expectError(&result);
            let case super::ErrorKind::BuiltinArgCountMismatch(mismatch) = err.kind
                else throw testing::TestError::Failed;
            try testing::expect(mismatch.expected == 2);
            try testing::expect(mismatch.actual == 0);
        }
    }
    // Too few arguments.
    {
        let mut a = testResolver();
        let program = "fn f(ptr: *u8) -> *[u8] { return @sliceOf(ptr); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::BuiltinArgCountMismatch(mismatch) = err.kind
            else throw testing::TestError::Failed;
        try testing::expect(mismatch.expected == 2);
        try testing::expect(mismatch.actual == 1);
        let mut testArena397 = testArena();
        let testStorage397: 'test397 = &mut testArena397 in {
            let mut a = testResolver(testStorage397);
            let program = "fn f(ptr: *u8) -> *[u8] { return @sliceOf(ptr); }";
            let result = try resolveProgramStr(&mut a, program);
            let err = try expectError(&result);
            let case super::ErrorKind::BuiltinArgCountMismatch(mismatch) = err.kind
                else throw testing::TestError::Failed;
            try testing::expect(mismatch.expected == 2);
            try testing::expect(mismatch.actual == 1);
        }
    }
    // Too many arguments.
    {
        let mut a = testResolver();
        let program = "fn f(ptr: *u8, len: u32, cap: u32, extra: u32) -> *[u8] { return @sliceOf(ptr, len, cap, extra); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::BuiltinArgCountMismatch(mismatch) = err.kind
            else throw testing::TestError::Failed;
        try testing::expect(mismatch.expected == 2);
        try testing::expect(mismatch.actual == 4);
        let mut testArena398 = testArena();
        let testStorage398: 'test398 = &mut testArena398 in {
            let mut a = testResolver(testStorage398);
            let program = "fn f(ptr: *u8, len: u32, cap: u32, extra: u32) -> *[u8] { return @sliceOf(ptr, len, cap, extra); }";
            let result = try resolveProgramStr(&mut a, program);
            let err = try expectError(&result);
            let case super::ErrorKind::BuiltinArgCountMismatch(mismatch) = err.kind
                else throw testing::TestError::Failed;
            try testing::expect(mismatch.expected == 2);
            try testing::expect(mismatch.actual == 4);
        }
    }
}

/// Test @sliceOf with wrong argument types produces errors.
@test unsafe fn testResolveSliceOfWrongArgTypes() throws (testing::TestError) {
    // Non-pointer first argument.
    {
        let mut a = testResolver();
        let program = "fn f(val: u32, len: u32) -> *[u8] { return @sliceOf(val, len); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::ExpectedPointer = err.kind
            else throw testing::TestError::Failed;
        let mut testArena399 = testArena();
        let testStorage399: 'test399 = &mut testArena399 in {
            let mut a = testResolver(testStorage399);
            let program = "fn f(val: u32, len: u32) -> *[u8] { return @sliceOf(val, len); }";
            let result = try resolveProgramStr(&mut a, program);
            let err = try expectError(&result);
            let case super::ErrorKind::ExpectedPointer = err.kind
                else throw testing::TestError::Failed;
        }
    }
    // Array instead of pointer.
    {
        let mut a = testResolver();
        let program = "fn f(arr: [u8; 4], len: u32) -> *[u8] { return @sliceOf(arr, len); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::ExpectedPointer = err.kind
            else throw testing::TestError::Failed;
        let mut testArena400 = testArena();
        let testStorage400: 'test400 = &mut testArena400 in {
            let mut a = testResolver(testStorage400);
            let program = "fn f(arr: [u8; 4], len: u32) -> *[u8] { return @sliceOf(arr, len); }";
            let result = try resolveProgramStr(&mut a, program);
            let err = try expectError(&result);
            let case super::ErrorKind::ExpectedPointer = err.kind
                else throw testing::TestError::Failed;
        }
    }
    // Non-numeric second argument.
    {
        let mut a = testResolver();
        let program = "fn f(ptr: *u8, len: bool) -> *[u8] { return @sliceOf(ptr, len); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
        let mut testArena401 = testArena();
        let testStorage401: 'test401 = &mut testArena401 in {
            let mut a = testResolver(testStorage401);
            let program = "fn f(ptr: *u8, len: bool) -> *[u8] { return @sliceOf(ptr, len); }";
            let result = try resolveProgramStr(&mut a, program);
            let err = try expectError(&result);
            let case super::ErrorKind::TypeMismatch(_) = err.kind
                else throw testing::TestError::Failed;
        }
    }
    // Pointer second argument.
    {
        let mut a = testResolver();
        let program = "fn f(ptr: *u8, len: *u32) -> *[u8] { return @sliceOf(ptr, len); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
        let mut testArena402 = testArena();
        let testStorage402: 'test402 = &mut testArena402 in {
            let mut a = testResolver(testStorage402);
            let program = "fn f(ptr: *u8, len: *u32) -> *[u8] { return @sliceOf(ptr, len); }";
            let result = try resolveProgramStr(&mut a, program);
            let err = try expectError(&result);
            let case super::ErrorKind::TypeMismatch(_) = err.kind
                else throw testing::TestError::Failed;
        }
    }
}

/// Test @sliceOf with 3 arguments (ptr, len, cap) succeeds.
@test unsafe fn testResolveSliceOfWithCap() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "unsafe fn f(ptr: *u8, len: u32, cap: u32) -> *[u8] { return @sliceOf(ptr, len, cap); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena403 = testArena();
        let testStorage403: 'test403 = &mut testArena403 in {
            let mut a = testResolver(testStorage403);
            let program = "unsafe fn f(ptr: *u8, len: u32, cap: u32) -> *[u8] { return @sliceOf(ptr, len, cap); }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
    // Mutable pointer produces mutable slice.
    {
        let mut a = testResolver();
        let program = "unsafe fn f(ptr: *mut u8, len: u32, cap: u32) -> *mut [u8] { return @sliceOf(ptr, len, cap); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena404 = testArena();
        let testStorage404: 'test404 = &mut testArena404 in {
            let mut a = testResolver(testStorage404);
            let program = "unsafe fn f(ptr: *mut u8, len: u32, cap: u32) -> *mut [u8] { return @sliceOf(ptr, len, cap); }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

/// Test @sliceOf with 3 arguments but wrong cap type.
@test unsafe fn testResolveSliceOfCapWrongType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(ptr: *u8, len: u32, cap: bool) -> *[u8] { return @sliceOf(ptr, len, cap); }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena405 = testArena();
    let testStorage405: 'test405 = &mut testArena405 in {
        let mut a = testResolver(testStorage405);
        let program = "fn f(ptr: *u8, len: u32, cap: bool) -> *[u8] { return @sliceOf(ptr, len, cap); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Test .cap field access on slices resolves to u32.
@test unsafe fn testResolveSliceCapField() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(s: *[u8]) -> u32 { return s.cap; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena406 = testArena();
    let testStorage406: 'test406 = &mut testArena406 in {
        let mut a = testResolver(testStorage406);
        let program = "fn f(s: *[u8]) -> u32 { return s.cap; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test `.append()` on immutable slice produces an error.
@test unsafe fn testResolveSliceAppendImmutable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn f(s: *[i32], a: A) { s.append(1, a); }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::ImmutableBinding = err.kind
        else throw testing::TestError::Failed;
    let mut testArena407 = testArena();
    let testStorage407: 'test407 = &mut testArena407 in {
        let mut a = testResolver(testStorage407);
        let program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn f(s: *[i32], a: A) { s.append(1, a); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::ImmutableBinding = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Test `.append()` with wrong argument count produces an error.
@test unsafe fn testResolveSliceAppendWrongArgCount() throws (testing::TestError) {
    // Too few arguments.
    {
        let mut a = testResolver();
        let program = "fn f(s: *mut [i32]) { s.append(1); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::FnArgCountMismatch(m) = err.kind
            else throw testing::TestError::Failed;
        try testing::expect(m.expected == 2);
        try testing::expect(m.actual == 1);
        let mut testArena408 = testArena();
        let testStorage408: 'test408 = &mut testArena408 in {
            let mut a = testResolver(testStorage408);
            let program = "fn f(s: *mut [i32]) { s.append(1); }";
            let result = try resolveProgramStr(&mut a, program);
            let err = try expectError(&result);
            let case super::ErrorKind::FnArgCountMismatch(m) = err.kind
                else throw testing::TestError::Failed;
            try testing::expect(m.expected == 2);
            try testing::expect(m.actual == 1);
        }
    }
    // Too many arguments.
    {
        let mut a = testResolver();
        let program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn f(s: *mut [i32], a: A) { s.append(1, a, 0); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::FnArgCountMismatch(m) = err.kind
            else throw testing::TestError::Failed;
        try testing::expect(m.expected == 2);
        try testing::expect(m.actual == 3);
        let mut testArena409 = testArena();
        let testStorage409: 'test409 = &mut testArena409 in {
            let mut a = testResolver(testStorage409);
            let program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn f(s: *mut [i32], a: A) { s.append(1, a, 0); }";
            let result = try resolveProgramStr(&mut a, program);
            let err = try expectError(&result);
            let case super::ErrorKind::FnArgCountMismatch(m) = err.kind
                else throw testing::TestError::Failed;
            try testing::expect(m.expected == 2);
            try testing::expect(m.actual == 3);
        }
    }
}

/// Test `.append()` with correct arguments succeeds.
@test unsafe fn testResolveSliceAppendCorrect() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn f(s: *mut [i32], a: A) { s.append(1, a); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena410 = testArena();
    let testStorage410: 'test410 = &mut testArena410 in {
        let mut a = testResolver(testStorage410);
        let program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn f(s: *mut [i32], a: A) { s.append(1, a); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test `.append()` with wrong element type produces an error.
@test unsafe fn testResolveSliceAppendWrongElemType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn f(s: *mut [i32], a: A) { s.append(true, a); }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena411 = testArena();
    let testStorage411: 'test411 = &mut testArena411 in {
        let mut a = testResolver(testStorage411);
        let program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn f(s: *mut [i32], a: A) { s.append(true, a); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Test `.delete()` on immutable slice produces an error.
@test unsafe fn testResolveSliceDeleteImmutable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(s: *[i32]) { s.delete(0); }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::ImmutableBinding = err.kind
        else throw testing::TestError::Failed;
    let mut testArena412 = testArena();
    let testStorage412: 'test412 = &mut testArena412 in {
        let mut a = testResolver(testStorage412);
        let program = "fn f(s: *[i32]) { s.delete(0); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::ImmutableBinding = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Test `.delete()` with wrong argument count produces an error.
@test unsafe fn testResolveSliceDeleteWrongArgCount() throws (testing::TestError) {
    // No arguments.
    {
        let mut a = testResolver();
        let program = "fn f(s: *mut [i32]) { s.delete(); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::FnArgCountMismatch(m) = err.kind
            else throw testing::TestError::Failed;
        try testing::expect(m.expected == 1);
        try testing::expect(m.actual == 0);
        let mut testArena413 = testArena();
        let testStorage413: 'test413 = &mut testArena413 in {
            let mut a = testResolver(testStorage413);
            let program = "fn f(s: *mut [i32]) { s.delete(); }";
            let result = try resolveProgramStr(&mut a, program);
            let err = try expectError(&result);
            let case super::ErrorKind::FnArgCountMismatch(m) = err.kind
                else throw testing::TestError::Failed;
            try testing::expect(m.expected == 1);
            try testing::expect(m.actual == 0);
        }
    }
    // Too many arguments.
    {
        let mut a = testResolver();
        let program = "fn f(s: *mut [i32]) { s.delete(0, 1); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::FnArgCountMismatch(m) = err.kind
            else throw testing::TestError::Failed;
        try testing::expect(m.expected == 1);
        try testing::expect(m.actual == 2);
        let mut testArena414 = testArena();
        let testStorage414: 'test414 = &mut testArena414 in {
            let mut a = testResolver(testStorage414);
            let program = "fn f(s: *mut [i32]) { s.delete(0, 1); }";
            let result = try resolveProgramStr(&mut a, program);
            let err = try expectError(&result);
            let case super::ErrorKind::FnArgCountMismatch(m) = err.kind
                else throw testing::TestError::Failed;
            try testing::expect(m.expected == 1);
            try testing::expect(m.actual == 2);
        }
    }
}

/// Test `.delete()` with correct arguments succeeds.
@test unsafe fn testResolveSliceDeleteCorrect() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(s: *mut [i32]) { s.delete(0); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena415 = testArena();
    let testStorage415: 'test415 = &mut testArena415 in {
        let mut a = testResolver(testStorage415);
        let program = "fn f(s: *mut [i32]) { s.delete(0); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test `.delete()` with wrong argument type produces an error.
@test unsafe fn testResolveSliceDeleteWrongArgType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(s: *mut [i32]) { s.delete(true); }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena416 = testArena();
    let testStorage416: 'test416 = &mut testArena416 in {
        let mut a = testResolver(testStorage416);
        let program = "fn f(s: *mut [i32]) { s.delete(true); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Test `match &opt` produces immutable pointer bindings.
@test unsafe fn testResolveMatchRefUnionBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some(i32), None } fn f() { let opt = Opt::Some(42); match &opt { case Opt::Some(x) => { *x; } else => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let fnBlock = try getFnBody(&a, result.root, "f");
    let matchNode = fnBlock.statements[1];
    let case ast::NodeValue::Match(sw) = matchNode.value
        else throw testing::TestError::Failed;
    let caseNode = sw.prongs[0];
    let mut testArena417 = testArena();
    let testStorage417: 'test417 = &mut testArena417 in {
        let mut a = testResolver(testStorage417);
        let program = "union Opt { Some(i32), None } fn f() { let opt = Opt::Some(42); match &opt { case Opt::Some(x) => { *x; } else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let scope = super::scopeFor(&a, caseNode)
        else throw testing::TestError::Failed;
    let payloadSym = super::findSymbolInScope(scope, "x")
        else throw testing::TestError::Failed;
    let case super::SymbolData::Value { type: payloadValType, .. } = payloadSym.data
        else throw testing::TestError::Failed;
    let case super::Type::Pointer { class: types::PointerClass::Ref, target, mutable } = payloadValType
        else throw testing::TestError::Failed;
    try testing::expect(not mutable);
    try testing::expect(*target == super::Type::I32);
        let fnBlock = try getFnBody(&a, result.root, "f");
        let matchNode = fnBlock.statements[1];
        let case ast::NodeValue::Match(sw) = matchNode.value
            else throw testing::TestError::Failed;
        let caseNode = sw.prongs[0];

        let scope = super::scopeFor(&a, caseNode)
            else throw testing::TestError::Failed;
        let payloadSym = super::findSymbolInScope(scope, "x")
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: payloadValType, .. } = payloadSym.data
            else throw testing::TestError::Failed;
        let case super::Type::Pointer { class: types::PointerClass::Ref, target, mutable } = payloadValType
            else throw testing::TestError::Failed;
        try testing::expect(not mutable);
        try testing::expect(*target == super::Type::I32);
    }
}

/// Test `match &mut opt` produces mutable pointer bindings.
@test unsafe fn testResolveMatchMutRefUnionBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some(i32), None } fn f() { let mut opt = Opt::Some(42); match &mut opt { case Opt::Some(x) => { *x; } else => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let fnBlock = try getFnBody(&a, result.root, "f");
    let matchNode = fnBlock.statements[1];
    let case ast::NodeValue::Match(sw) = matchNode.value
        else throw testing::TestError::Failed;
    let caseNode = sw.prongs[0];
    let mut testArena418 = testArena();
    let testStorage418: 'test418 = &mut testArena418 in {
        let mut a = testResolver(testStorage418);
        let program = "union Opt { Some(i32), None } fn f() { let mut opt = Opt::Some(42); match &mut opt { case Opt::Some(x) => { *x; } else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let scope = super::scopeFor(&a, caseNode)
        else throw testing::TestError::Failed;
    let payloadSym = super::findSymbolInScope(scope, "x")
        else throw testing::TestError::Failed;
    let case super::SymbolData::Value { type: payloadValType, .. } = payloadSym.data
        else throw testing::TestError::Failed;
    let case super::Type::Pointer { class: types::PointerClass::Ref, target, mutable } = payloadValType
        else throw testing::TestError::Failed;
    try testing::expect(mutable);
    try testing::expect(*target == super::Type::I32);
        let fnBlock = try getFnBody(&a, result.root, "f");
        let matchNode = fnBlock.statements[1];
        let case ast::NodeValue::Match(sw) = matchNode.value
            else throw testing::TestError::Failed;
        let caseNode = sw.prongs[0];

        let scope = super::scopeFor(&a, caseNode)
            else throw testing::TestError::Failed;
        let payloadSym = super::findSymbolInScope(scope, "x")
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: payloadValType, .. } = payloadSym.data
            else throw testing::TestError::Failed;
        let case super::Type::Pointer { class: types::PointerClass::Ref, target, mutable } = payloadValType
            else throw testing::TestError::Failed;
        try testing::expect(mutable);
        try testing::expect(*target == super::Type::I32);
    }
}

/// Non-constant integer widening must use an explicit cast.
@test unsafe fn testResolveIntegerWideningRequiresCast() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = x;");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::U32, super::Type::U8);
        let mut testArena419 = testArena();
        let testStorage419: 'test419 = &mut testArena419 in {
            let mut a = testResolver(testStorage419);
            let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = x;");
            let err = try expectError(&result);
            try expectTypeMismatch(err, super::Type::U32, super::Type::U8);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u16 = x;");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::U16, super::Type::U8);
        let mut testArena420 = testArena();
        let testStorage420: 'test420 = &mut testArena420 in {
            let mut a = testResolver(testStorage420);
            let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u16 = x;");
            let err = try expectError(&result);
            try expectTypeMismatch(err, super::Type::U16, super::Type::U8);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u16 = 1; let y: u32 = x;");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::U32, super::Type::U16);
        let mut testArena421 = testArena();
        let testStorage421: 'test421 = &mut testArena421 in {
            let mut a = testResolver(testStorage421);
            let result = try resolveBlockStr(&mut a, "let x: u16 = 1; let y: u32 = x;");
            let err = try expectError(&result);
            try expectTypeMismatch(err, super::Type::U32, super::Type::U16);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: i8 = 1; let y: i32 = x;");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::I32, super::Type::I8);
        let mut testArena422 = testArena();
        let testStorage422: 'test422 = &mut testArena422 in {
            let mut a = testResolver(testStorage422);
            let result = try resolveBlockStr(&mut a, "let x: i8 = 1; let y: i32 = x;");
            let err = try expectError(&result);
            try expectTypeMismatch(err, super::Type::I32, super::Type::I8);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = x as u32;");
        try expectNoErrors(&result);
        let mut testArena423 = testArena();
        let testStorage423: 'test423 = &mut testArena423 in {
            let mut a = testResolver(testStorage423);
            let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = x as u32;");
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: i8 = 1; let y: i32 = x as i32;");
        try expectNoErrors(&result);
        let mut testArena424 = testArena();
        let testStorage424: 'test424 = &mut testArena424 in {
            let mut a = testResolver(testStorage424);
            let result = try resolveBlockStr(&mut a, "let x: i8 = 1; let y: i32 = x as i32;");
            try expectNoErrors(&result);
        }
    }
}

/// Mixed-width integer binary ops require an explicit cast.
@test unsafe fn testResolveIntegerWideningBinOpRequiresCast() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = 2; let z: u32 = x | y;");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::U8, super::Type::U32);
        let mut testArena425 = testArena();
        let testStorage425: 'test425 = &mut testArena425 in {
            let mut a = testResolver(testStorage425);
            let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = 2; let z: u32 = x | y;");
            let err = try expectError(&result);
            try expectTypeMismatch(err, super::Type::U8, super::Type::U32);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = 0xFF; let z: u32 = x & y;");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::U8, super::Type::U32);
        let mut testArena426 = testArena();
        let testStorage426: 'test426 = &mut testArena426 in {
            let mut a = testResolver(testStorage426);
            let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = 0xFF; let z: u32 = x & y;");
            let err = try expectError(&result);
            try expectTypeMismatch(err, super::Type::U8, super::Type::U32);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = 2; let z: u32 = x + y;");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::U8, super::Type::U32);
        let mut testArena427 = testArena();
        let testStorage427: 'test427 = &mut testArena427 in {
            let mut a = testResolver(testStorage427);
            let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = 2; let z: u32 = x + y;");
            let err = try expectError(&result);
            try expectTypeMismatch(err, super::Type::U8, super::Type::U32);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u8 = x << 2;");
        try expectNoErrors(&result);
        let mut testArena428 = testArena();
        let testStorage428: 'test428 = &mut testArena428 in {
            let mut a = testResolver(testStorage428);
            let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u8 = x << 2;");
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = 2; let z: u32 = (x as u32) | y;");
        try expectNoErrors(&result);
        let mut testArena429 = testArena();
        let testStorage429: 'test429 = &mut testArena429 in {
            let mut a = testResolver(testStorage429);
            let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = 2; let z: u32 = (x as u32) | y;");
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = 2; let z: u32 = (x as u32) + y;");
        try expectNoErrors(&result);
        let mut testArena430 = testArena();
        let testStorage430: 'test430 = &mut testArena430 in {
            let mut a = testResolver(testStorage430);
            let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = 2; let z: u32 = (x as u32) + y;");
            try expectNoErrors(&result);
        }
    }
}

/// A mutable slice pointer should be assignable to an immutable slice pointer.
@test unsafe fn testResolveMutSliceAssignableToImmutSlice() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveBlockStr(&mut a, "static arr: [i32; 3] = [1, 2, 3]; let p: *mut [i32] = &mut arr[..]; let q: *[i32] = p;");
    try expectNoErrors(&result);
    let mut testArena431 = testArena();
    let testStorage431: 'test431 = &mut testArena431 in {
        let mut a = testResolver(testStorage431);
        let result = try resolveBlockStr(&mut a, "static arr: [i32; 3] = [1, 2, 3]; let p: *mut [i32] = &mut arr[..]; let q: *[i32] = p;");
        try expectNoErrors(&result);
    }
}

/// Comprehensive tests for `as` cast expressions.
@test unsafe fn testResolveAsCasts() throws (testing::TestError) {
    { // Pointer to numeric.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "static x: i32 = 0; let p = &x; p as u32;");
        try expectNoErrors(&result);
        let mut testArena432 = testArena();
        let testStorage432: 'test432 = &mut testArena432 in {
            let mut a = testResolver(testStorage432);
            let result = try resolveBlockStr(&mut a, "static x: i32 = 0; let p = &x; p as u32;");
            try expectNoErrors(&result);
        }
    } { // Function pointer to numeric.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn run(f: fn()) { f as u32; }");
        try expectNoErrors(&result);
        let mut testArena433 = testArena();
        let testStorage433: 'test433 = &mut testArena433 in {
            let mut a = testResolver(testStorage433);
            let result = try resolveProgramStr(&mut a, "fn run(f: fn()) { f as u32; }");
            try expectNoErrors(&result);
        }
    } { // *u8 to *i32 (u8 to i32 is valid).
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "unsafe fn run() { let p: *u8 = undefined; p as *i32; }");
        try expectNoErrors(&result);
        let mut testArena434 = testArena();
        let testStorage434: 'test434 = &mut testArena434 in {
            let mut a = testResolver(testStorage434);
            let result = try resolveProgramStr(&mut a, "unsafe fn run() { let p: *u8 = undefined; p as *i32; }");
            try expectNoErrors(&result);
        }
    } { // **u8 to **i32 (*u8 to *i32 is valid).
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "unsafe fn run() { let p: **u8 = undefined; p as **i32; }");
        try expectNoErrors(&result);
        let mut testArena435 = testArena();
        let testStorage435: 'test435 = &mut testArena435 in {
            let mut a = testResolver(testStorage435);
            let result = try resolveProgramStr(&mut a, "unsafe fn run() { let p: **u8 = undefined; p as **i32; }");
            try expectNoErrors(&result);
        }
    }

    { // *[i32] to *[opaque].
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn run(s: *[i32]) { s as *[opaque]; }");
        try expectNoErrors(&result);
        let mut testArena436 = testArena();
        let testStorage436: 'test436 = &mut testArena436 in {
            let mut a = testResolver(testStorage436);
            let result = try resolveProgramStr(&mut a, "fn run(s: *[i32]) { s as *[opaque]; }");
            try expectNoErrors(&result);
        }
    } { // *[opaque] to *[i32].
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "unsafe fn run() { let s: *[opaque] = undefined; s as *[i32]; }");
        try expectNoErrors(&result);
        let mut testArena437 = testArena();
        let testStorage437: 'test437 = &mut testArena437 in {
            let mut a = testResolver(testStorage437);
            let result = try resolveProgramStr(&mut a, "unsafe fn run() { let s: *[opaque] = undefined; s as *[i32]; }");
            try expectNoErrors(&result);
        }
    }

    { // *[i32] to *[u8].
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "unsafe fn run() { let s: *[i32] = undefined; s as *[u8]; }");
        try expectNoErrors(&result);
        let mut testArena438 = testArena();
        let testStorage438: 'test438 = &mut testArena438 in {
            let mut a = testResolver(testStorage438);
            let result = try resolveProgramStr(&mut a, "unsafe fn run() { let s: *[i32] = undefined; s as *[u8]; }");
            try expectNoErrors(&result);
        }
    } { // *[record] to *[u8].
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "record R { x: i32 } unsafe fn f(s: *[R]) { s as *[u8]; }");
        try expectNoErrors(&result);
        let mut testArena439 = testArena();
        let testStorage439: 'test439 = &mut testArena439 in {
            let mut a = testResolver(testStorage439);
            let result = try resolveProgramStr(&mut a, "record R { x: i32 } unsafe fn f(s: *[R]) { s as *[u8]; }");
            try expectNoErrors(&result);
        }
    }

    { // *[u8] to *[i32].
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "unsafe fn run() { let s: *[u8] = undefined; s as *[i32]; }");
        try expectNoErrors(&result);
        let mut testArena440 = testArena();
        let testStorage440: 'test440 = &mut testArena440 in {
            let mut a = testResolver(testStorage440);
            let result = try resolveProgramStr(&mut a, "unsafe fn run() { let s: *[u8] = undefined; s as *[i32]; }");
            try expectNoErrors(&result);
        }
    } { // *[*u8] to *[*i32]
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "unsafe fn run() { let s: *[*u8] = undefined; s as *[*i32]; }");
        try expectNoErrors(&result);
        let mut testArena441 = testArena();
        let testStorage441: 'test441 = &mut testArena441 in {
            let mut a = testResolver(testStorage441);
            let result = try resolveProgramStr(&mut a, "unsafe fn run() { let s: *[*u8] = undefined; s as *[*i32]; }");
            try expectNoErrors(&result);
        }
    }

    { // Identity cast: *mut [i32] to *mut [i32].
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn run(s: *mut [i32]) { s as *mut [i32]; }");
        try expectNoErrors(&result);
        let mut testArena442 = testArena();
        let testStorage442: 'test442 = &mut testArena442 in {
            let mut a = testResolver(testStorage442);
            let result = try resolveProgramStr(&mut a, "fn run(s: *mut [i32]) { s as *mut [i32]; }");
            try expectNoErrors(&result);
        }
    } { // Identity cast: *i32 to *i32.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn run(p: *i32) { p as *i32; }");
        try expectNoErrors(&result);
        let mut testArena443 = testArena();
        let testStorage443: 'test443 = &mut testArena443 in {
            let mut a = testResolver(testStorage443);
            let result = try resolveProgramStr(&mut a, "fn run(p: *i32) { p as *i32; }");
            try expectNoErrors(&result);
        }
    } { // Identity cast: i32 to i32.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: i32 = 0; x as i32;");
        try expectNoErrors(&result);
        let mut testArena444 = testArena();
        let testStorage444: 'test444 = &mut testArena444 in {
            let mut a = testResolver(testStorage444);
            let result = try resolveBlockStr(&mut a, "let x: i32 = 0; x as i32;");
            try expectNoErrors(&result);
        }
    }
}

/// Tests for invalid `as` casts that should be rejected.
@test unsafe fn testResolveAsCastsInvalid() throws (testing::TestError) {
    { // Pointer to slice is invalid.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn run(p: *i32) { p as *[i32]; }");
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
        let mut testArena445 = testArena();
        let testStorage445: 'test445 = &mut testArena445 in {
            let mut a = testResolver(testStorage445);
            let result = try resolveProgramStr(&mut a, "fn run(p: *i32) { p as *[i32]; }");
            let err = try expectError(&result);
            let case super::ErrorKind::InvalidAsCast(_) = err.kind
                else throw testing::TestError::Failed;
        }
    } { // Slice to pointer is invalid.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn run(s: *[i32]) { s as *i32; }");
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
        let mut testArena446 = testArena();
        let testStorage446: 'test446 = &mut testArena446 in {
            let mut a = testResolver(testStorage446);
            let result = try resolveProgramStr(&mut a, "fn run(s: *[i32]) { s as *i32; }");
            let err = try expectError(&result);
            let case super::ErrorKind::InvalidAsCast(_) = err.kind
                else throw testing::TestError::Failed;
        }
    } { // *T to *i32 is invalid.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "record R { x: i32 } fn f(p: *R) { p as *i32; }");
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
        let mut testArena447 = testArena();
        let testStorage447: 'test447 = &mut testArena447 in {
            let mut a = testResolver(testStorage447);
            let result = try resolveProgramStr(&mut a, "record R { x: i32 } fn f(p: *R) { p as *i32; }");
            let err = try expectError(&result);
            let case super::ErrorKind::InvalidAsCast(_) = err.kind
                else throw testing::TestError::Failed;
        }
    } { // *[T] to *[i32] is invalid.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "record R { x: i32 } fn f(s: *[R]) { s as *[i32]; }");
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
        let mut testArena448 = testArena();
        let testStorage448: 'test448 = &mut testArena448 in {
            let mut a = testResolver(testStorage448);
            let result = try resolveProgramStr(&mut a, "record R { x: i32 } fn f(s: *[R]) { s as *[i32]; }");
            let err = try expectError(&result);
            let case super::ErrorKind::InvalidAsCast(_) = err.kind
                else throw testing::TestError::Failed;
        }
    } { // Slice to numeric is invalid.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn run(s: *[i32]) { s as u32; }");
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
        let mut testArena449 = testArena();
        let testStorage449: 'test449 = &mut testArena449 in {
            let mut a = testResolver(testStorage449);
            let result = try resolveProgramStr(&mut a, "fn run(s: *[i32]) { s as u32; }");
            let err = try expectError(&result);
            let case super::ErrorKind::InvalidAsCast(_) = err.kind
                else throw testing::TestError::Failed;
        }
    } { // *record to *u8 is invalid.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "record R { x: i32 } fn f(p: *R) { p as *u8; }");
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
        let mut testArena450 = testArena();
        let testStorage450: 'test450 = &mut testArena450 in {
            let mut a = testResolver(testStorage450);
            let result = try resolveProgramStr(&mut a, "record R { x: i32 } fn f(p: *R) { p as *u8; }");
            let err = try expectError(&result);
            let case super::ErrorKind::InvalidAsCast(_) = err.kind
                else throw testing::TestError::Failed;
        }
    }
}

/// Test that catch binding is available in catch block scope.
@test unsafe fn testResolveTryCatchBinding() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "union Error { Fail } fn fallible() -> u32 throws (Error) { throw Error::Fail; } fn caller() -> u32 { return try fallible() catch err { return 0; }; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena451 = testArena();
        let testStorage451: 'test451 = &mut testArena451 in {
            let mut a = testResolver(testStorage451);
            let program = "union Error { Fail } fn fallible() -> u32 throws (Error) { throw Error::Fail; } fn caller() -> u32 { return try fallible() catch err { return 0; }; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let program = "union Error { A, B } fn fallible() -> u32 throws (Error) { throw Error::A; } fn caller() -> u32 { return try fallible() catch e { if e == Error::A { return 1; } else { return 2; } }; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena452 = testArena();
        let testStorage452: 'test452 = &mut testArena452 in {
            let mut a = testResolver(testStorage452);
            let program = "union Error { A, B } fn fallible() -> u32 throws (Error) { throw Error::A; } fn caller() -> u32 { return try fallible() catch e { if e == Error::A { return 1; } else { return 2; } }; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let program = "union Error { Fail } fn fallible() -> u32 throws (Error) { throw Error::Fail; } fn caller() -> u32 { return try fallible() catch err { if err == Error::Fail { return 1; } return 0; }; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena453 = testArena();
        let testStorage453: 'test453 = &mut testArena453 in {
            let mut a = testResolver(testStorage453);
            let program = "union Error { Fail } fn fallible() -> u32 throws (Error) { throw Error::Fail; } fn caller() -> u32 { return try fallible() catch err { if err == Error::Fail { return 1; } return 0; }; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        let mut a = testResolver();
        let program = "union Error { Fail(u32) } fn fallible() -> u32 throws (Error) { throw Error::Fail(42); } fn caller() -> u32 { return try fallible() catch err { match err { case Error::Fail(x) => return x, } }; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena454 = testArena();
        let testStorage454: 'test454 = &mut testArena454 in {
            let mut a = testResolver(testStorage454);
            let program = "union Error { Fail(u32) } fn fallible() -> u32 throws (Error) { throw Error::Fail(42); } fn caller() -> u32 { return try fallible() catch err { match err { case Error::Fail(x) => return x, } }; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

/// Test that duplicate union variant patterns are detected.
@test unsafe fn testResolveMatchDuplicateUnionPattern() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "union U { A, B } fn f(u: U) { match u { case U::A => {}, case U::A => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::DuplicateMatchPattern);
        let mut testArena455 = testArena();
        let testStorage455: 'test455 = &mut testArena455 in {
            let mut a = testResolver(testStorage455);
            let program = "union U { A, B } fn f(u: U) { match u { case U::A => {}, case U::A => {}, else => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::DuplicateMatchPattern);
        }
    } {
        // No duplicate: distinct variants are fine.
        let mut a = testResolver();
        let program = "union U { A, B } fn f(u: U) { match u { case U::A => {}, case U::B => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena456 = testArena();
        let testStorage456: 'test456 = &mut testArena456 in {
            let mut a = testResolver(testStorage456);
            let program = "union U { A, B } fn f(u: U) { match u { case U::A => {}, case U::B => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

/// Test that duplicate bool patterns are detected.
@test unsafe fn testResolveMatchDuplicateBoolPattern() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn f(x: bool) { match x { case true => {}, case true => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::DuplicateMatchPattern);
        let mut testArena457 = testArena();
        let testStorage457: 'test457 = &mut testArena457 in {
            let mut a = testResolver(testStorage457);
            let program = "fn f(x: bool) { match x { case true => {}, case true => {}, else => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::DuplicateMatchPattern);
        }
    } {
        let mut a = testResolver();
        let program = "fn f(x: bool) { match x { case false => {}, case false => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::DuplicateMatchPattern);
        let mut testArena458 = testArena();
        let testStorage458: 'test458 = &mut testArena458 in {
            let mut a = testResolver(testStorage458);
            let program = "fn f(x: bool) { match x { case false => {}, case false => {}, else => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::DuplicateMatchPattern);
        }
    }
}

/// Test that duplicate nil patterns in optional match are detected.
@test unsafe fn testResolveMatchDuplicateOptionalPattern() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) { match opt { v => {}, case nil => {}, case nil => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::DuplicateMatchPattern);
        let mut testArena459 = testArena();
        let testStorage459: 'test459 = &mut testArena459 in {
            let mut a = testResolver(testStorage459);
            let program = "fn f(opt: ?i32) { match opt { v => {}, case nil => {}, case nil => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::DuplicateMatchPattern);
        }
    } {
        // Duplicate value binding.
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) { match opt { v => {}, w => {}, case nil => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::DuplicateMatchPattern);
        let mut testArena460 = testArena();
        let testStorage460: 'test460 = &mut testArena460 in {
            let mut a = testResolver(testStorage460);
            let program = "fn f(opt: ?i32) { match opt { v => {}, w => {}, case nil => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::DuplicateMatchPattern);
        }
    }
}

/// Test that guarded match arms are not considered duplicates.
@test unsafe fn testResolveMatchGuardedNotDuplicate() throws (testing::TestError) {
    {
        // Guarded union variant followed by same variant is fine.
        let mut a = testResolver();
        let program = "union U { A, B } fn f(u: U) { match u { case U::A if true => {}, case U::A => {}, case U::B => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena461 = testArena();
        let testStorage461: 'test461 = &mut testArena461 in {
            let mut a = testResolver(testStorage461);
            let program = "union U { A, B } fn f(u: U) { match u { case U::A if true => {}, case U::A => {}, case U::B => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        // Guarded bool pattern followed by same bool is fine.
        let mut a = testResolver();
        let program = "fn f(x: bool) { match x { case true if true => {}, case true => {}, case false => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena462 = testArena();
        let testStorage462: 'test462 = &mut testArena462 in {
            let mut a = testResolver(testStorage462);
            let program = "fn f(x: bool) { match x { case true if true => {}, case true => {}, case false => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        // Guarded nil pattern followed by nil is fine.
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) { match opt { case nil if true => {}, case nil => {}, v => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena463 = testArena();
        let testStorage463: 'test463 = &mut testArena463 in {
            let mut a = testResolver(testStorage463);
            let program = "fn f(opt: ?i32) { match opt { case nil if true => {}, case nil => {}, v => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        // Guarded value binding followed by another binding is fine.
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) { match opt { v if true => {}, w => {}, case nil => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena464 = testArena();
        let testStorage464: 'test464 = &mut testArena464 in {
            let mut a = testResolver(testStorage464);
            let program = "fn f(opt: ?i32) { match opt { v if true => {}, w => {}, case nil => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

/// Test that unreachable else is detected when all union variants are covered.
@test unsafe fn testResolveMatchUnreachableElseUnion() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "union U { A, B } fn f(u: U) { match u { case U::A => {}, case U::B => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnreachableElse);
        let mut testArena465 = testArena();
        let testStorage465: 'test465 = &mut testArena465 in {
            let mut a = testResolver(testStorage465);
            let program = "union U { A, B } fn f(u: U) { match u { case U::A => {}, case U::B => {}, else => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnreachableElse);
        }
    } {
        // Partial coverage with else is fine.
        let mut a = testResolver();
        let program = "union U { A, B } fn f(u: U) { match u { case U::A => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena466 = testArena();
        let testStorage466: 'test466 = &mut testArena466 in {
            let mut a = testResolver(testStorage466);
            let program = "union U { A, B } fn f(u: U) { match u { case U::A => {}, else => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

/// Test that unreachable else is detected when both bool cases are covered.
@test unsafe fn testResolveMatchUnreachableElseBool() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn f(x: bool) { match x { case true => {}, case false => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnreachableElse);
        let mut testArena467 = testArena();
        let testStorage467: 'test467 = &mut testArena467 in {
            let mut a = testResolver(testStorage467);
            let program = "fn f(x: bool) { match x { case true => {}, case false => {}, else => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnreachableElse);
        }
    } {
        // Only one case with else is fine.
        let mut a = testResolver();
        let program = "fn f(x: bool) { match x { case true => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena468 = testArena();
        let testStorage468: 'test468 = &mut testArena468 in {
            let mut a = testResolver(testStorage468);
            let program = "fn f(x: bool) { match x { case true => {}, else => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

/// Test that unreachable else is detected when both optional cases are covered.
@test unsafe fn testResolveMatchUnreachableElseOptional() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) { match opt { v => {}, case nil => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnreachableElse);
        let mut testArena469 = testArena();
        let testStorage469: 'test469 = &mut testArena469 in {
            let mut a = testResolver(testStorage469);
            let program = "fn f(opt: ?i32) { match opt { v => {}, case nil => {}, else => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnreachableElse);
        }
    } {
        // Only value binding with else is fine.
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) { match opt { v => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
        let mut testArena470 = testArena();
        let testStorage470: 'test470 = &mut testArena470 in {
            let mut a = testResolver(testStorage470);
            let program = "fn f(opt: ?i32) { match opt { v => {}, else => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

// --- Multi-error typed catch tests ---

@test unsafe fn testTypedCatchExhaustive() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrA { return 0; } catch e as ErrB { return 1; }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena471 = testArena();
    let testStorage471: 'test471 = &mut testArena471 in {
        let mut a = testResolver(testStorage471);
        let program = "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrA { return 0; } catch e as ErrB { return 1; }; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testTypedCatchNonExhaustive() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrA { return 0; }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TryCatchNonExhaustive);
    let mut testArena472 = testArena();
    let testStorage472: 'test472 = &mut testArena472 in {
        let mut a = testResolver(testStorage472);
        let program = "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrA { return 0; }; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::TryCatchNonExhaustive);
    }
}

@test unsafe fn testTypedCatchDuplicate() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrA { return 0; } catch e as ErrA { return 1; }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TryCatchDuplicateType);
    let mut testArena473 = testArena();
    let testStorage473: 'test473 = &mut testArena473 in {
        let mut a = testResolver(testStorage473);
        let program = "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrA { return 0; } catch e as ErrA { return 1; }; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::TryCatchDuplicateType);
    }
}

@test unsafe fn testTypedCatchWithCatchAll() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrA { return 0; } catch { return 1; }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena474 = testArena();
    let testStorage474: 'test474 = &mut testArena474 in {
        let mut a = testResolver(testStorage474);
        let program = "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrA { return 0; } catch { return 1; }; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testTypedCatchWrongType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union ErrA { A } union ErrB { B } union ErrC { C } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrC { return 0; } catch e as ErrA { return 1; }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TryIncompatibleError);
    let mut testArena475 = testArena();
    let testStorage475: 'test475 = &mut testArena475 in {
        let mut a = testResolver(testStorage475);
        let program = "union ErrA { A } union ErrB { B } union ErrC { C } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrC { return 0; } catch e as ErrA { return 1; }; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::TryIncompatibleError);
    }
}

@test unsafe fn testInferredCatchMultiError() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e { return 0; }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TryCatchMultiError);
    let mut testArena476 = testArena();
    let testStorage476: 'test476 = &mut testArena476 in {
        let mut a = testResolver(testStorage476);
        let program = "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e { return 0; }; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::TryCatchMultiError);
    }
}

@test unsafe fn testResolveInstanceMissingMethod() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "trait S { fn (*S) f() -> i32; } record R { x: i32 } instance S for R {}";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::MissingTraitMethod("f"));
    let mut testArena477 = testArena();
    let testStorage477: 'test477 = &mut testArena477 in {
        let mut a = testResolver(testStorage477);
        let program = "trait S { fn (*S) f() -> i32; } record R { x: i32 } instance S for R {}";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::MissingTraitMethod("f"));
    }
}

@test unsafe fn testResolveInstanceUnknownMethod() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "trait S { fn (*S) f() -> i32; } record R { x: i32 } instance S for R { fn (self: *R) x() -> i32 { return 0; } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("x"));
    let mut testArena478 = testArena();
    let testStorage478: 'test478 = &mut testArena478 in {
        let mut a = testResolver(testStorage478);
        let program = "trait S { fn (*S) f() -> i32; } record R { x: i32 } instance S for R { fn (self: *R) x() -> i32 { return 0; } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("x"));
    }
}

@test unsafe fn testResolveTraitDuplicateMethodRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "trait Adder { fn (*mut Adder) add(n: i32) -> i32; fn (*mut Adder) add(n: i32) -> i32; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("add"));
    let mut testArena479 = testArena();
    let testStorage479: 'test479 = &mut testArena479 in {
        let mut a = testResolver(testStorage479);
        let program = "trait Adder { fn (*mut Adder) add(n: i32) -> i32; fn (*mut Adder) add(n: i32) -> i32; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("add"));
    }
}

@test unsafe fn testResolveInstanceReceiverTypeMustMatchTarget() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Counter { value: i32 } record Wrong { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Wrong) add(n: i32) -> i32 { return n; } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena480 = testArena();
    let testStorage480: 'test480 = &mut testArena480 in {
        let mut a = testResolver(testStorage480);
        let program = "record Counter { value: i32 } record Wrong { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Wrong) add(n: i32) -> i32 { return n; } }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

@test unsafe fn testResolveTraitMethodThrowsRequireTry() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Error { Fail } record Counter { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32 throws (Error); } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 throws (Error) { throw Error::Fail; return n; } } fn caller(a: *mut opaque Adder) -> i32 { return a.add(1); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::MissingTry);
    let mut testArena481 = testArena();
    let testStorage481: 'test481 = &mut testArena481 in {
        let mut a = testResolver(testStorage481);
        let program = "union Error { Fail } record Counter { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32 throws (Error); } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 throws (Error) { throw Error::Fail; return n; } } fn caller(a: *mut opaque Adder) -> i32 { return a.add(1); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::MissingTry);
    }
}

/// Trait declares immutable receiver (*Trait) but instance uses mutable (*mut Type).
/// The instance method could mutate through what was originally an immutable pointer.
@test unsafe fn testResolveInstanceMutReceiverOnImmutableTrait() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Counter { value: i32 } trait Reader { fn (*Reader) read() -> i32; } instance Reader for Counter { fn (c: *mut Counter) read() -> i32 { set c.value = c.value + 1; return c.value; } }";
    let result = try resolveProgramStr(&mut a, program);
    // Should reject: instance declares *mut receiver but trait only requires immutable.
    try expectErrorKind(&result, super::ErrorKind::ReceiverMutabilityMismatch);
    let mut testArena482 = testArena();
    let testStorage482: 'test482 = &mut testArena482 in {
        let mut a = testResolver(testStorage482);
        let program = "record Counter { value: i32 } trait Reader { fn (*Reader) read() -> i32; } instance Reader for Counter { fn (c: *mut Counter) read() -> i32 { set c.value = c.value + 1; return c.value; } }";
        let result = try resolveProgramStr(&mut a, program);
        // Should reject: instance declares *mut receiver but trait only requires immutable.
        try expectErrorKind(&result, super::ErrorKind::ReceiverMutabilityMismatch);
    }
}

/// Instance method declares different parameter types than the trait.
/// The resolver should reject the mismatch rather than silently using the trait's types.
@test unsafe fn testResolveInstanceParamTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Acc { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Acc { fn (a: *mut Acc) add(n: u8) -> i32 { set a.value = a.value + n as i32; return a.value; } }";
    let result = try resolveProgramStr(&mut a, program);
    // Should reject: instance param type u8 doesn't match trait param type i32.
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena483 = testArena();
    let testStorage483: 'test483 = &mut testArena483 in {
        let mut a = testResolver(testStorage483);
        let program = "record Acc { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Acc { fn (a: *mut Acc) add(n: u8) -> i32 { set a.value = a.value + n as i32; return a.value; } }";
        let result = try resolveProgramStr(&mut a, program);
        // Should reject: instance param type u8 doesn't match trait param type i32.
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Duplicate instance declarations for the same (trait, type) pair should be rejected.
@test unsafe fn testResolveInstanceDuplicateRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Counter { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { set c.value = c.value + n; return c.value; } } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { set c.value = c.value + n + 100; return c.value; } }";
    let result = try resolveProgramStr(&mut a, program);
    // Should reject: duplicate instance for (Adder, Counter).
    try expectErrorKind(&result, super::ErrorKind::DuplicateInstance);
    let mut testArena484 = testArena();
    let testStorage484: 'test484 = &mut testArena484 in {
        let mut a = testResolver(testStorage484);
        let program = "record Counter { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { set c.value = c.value + n; return c.value; } } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { set c.value = c.value + n + 100; return c.value; } }";
        let result = try resolveProgramStr(&mut a, program);
        // Should reject: duplicate instance for (Adder, Counter).
        try expectErrorKind(&result, super::ErrorKind::DuplicateInstance);
    }
}

/// Trait method receiver must point to the declaring trait type.
@test unsafe fn testResolveTraitReceiverMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Other { x: i32 } trait Foo { fn (*mut Other) bar() -> i32; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TraitReceiverMismatch);
    let mut testArena485 = testArena();
    let testStorage485: 'test485 = &mut testArena485 in {
        let mut a = testResolver(testStorage485);
        let program = "record Other { x: i32 } trait Foo { fn (*mut Other) bar() -> i32; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::TraitReceiverMismatch);
    }
}

/// Using a trait name as a value expression should be rejected.
@test unsafe fn testResolveTraitNameAsValueRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "trait Foo { fn (*Foo) bar() -> i32; } fn test() -> i32 { let x = Foo; return 0; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnexpectedTraitName);
    let mut testArena486 = testArena();
    let testStorage486: 'test486 = &mut testArena486 in {
        let mut a = testResolver(testStorage486);
        let program = "trait Foo { fn (*Foo) bar() -> i32; } fn test() -> i32 { let x = Foo; return 0; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnexpectedTraitName);
    }
}

/// Cross-module trait: coerce to trait object and dispatch from a different module.
@test unsafe fn testResolveTraitCrossModuleCoercion() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena487 = testArena();
    let testStorage487: 'test487 = &mut testArena487 in {
        let mut a = testResolver(testStorage487);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod defs; mod app;", &mut arena);
    let defsId = try registerModule(&mut MODULE_GRAPH, rootId, "defs", "export record Counter { value: i32 } export trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { set c.value = c.value + n; return c.value; } }", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::defs; fn test() -> i32 { static c: defs::Counter = defs::Counter { value: 10 }; let a: *mut opaque defs::Adder = &mut c; return a.add(5); }", &mut arena);
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod defs; mod app;", &mut arena);
        let defsId = try registerModule(&mut MODULE_GRAPH, rootId, "defs", "export record Counter { value: i32 } export trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { set c.value = c.value + n; return c.value; } }", &mut arena);
        let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::defs; fn test() -> i32 { static c: defs::Counter = defs::Counter { value: 10 }; let a: *mut opaque defs::Adder = &mut c; return a.add(5); }", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    }
}

/// Instance in a different module from trait and type.
@test unsafe fn testResolveInstanceCrossModule() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena488 = testArena();
    let testStorage488: 'test488 = &mut testArena488 in {
        let mut a = testResolver(testStorage488);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod defs; export mod impls; mod app;", &mut arena);
    let defsId = try registerModule(&mut MODULE_GRAPH, rootId, "defs", "export record Counter { value: i32 } export trait Adder { fn (*mut Adder) add(n: i32) -> i32; }", &mut arena);
    let implsId = try registerModule(&mut MODULE_GRAPH, rootId, "impls", "use root::defs; instance defs::Adder for defs::Counter { fn (c: *mut defs::Counter) add(n: i32) -> i32 { set c.value = c.value + n; return c.value; } }", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::defs; fn test() -> i32 { static c: defs::Counter = defs::Counter { value: 10 }; let a: *mut opaque defs::Adder = &mut c; return a.add(5); }", &mut arena);
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod defs; export mod impls; mod app;", &mut arena);
        let defsId = try registerModule(&mut MODULE_GRAPH, rootId, "defs", "export record Counter { value: i32 } export trait Adder { fn (*mut Adder) add(n: i32) -> i32; }", &mut arena);
        let implsId = try registerModule(&mut MODULE_GRAPH, rootId, "impls", "use root::defs; instance defs::Adder for defs::Counter { fn (c: *mut defs::Counter) add(n: i32) -> i32 { set c.value = c.value + n; return c.value; } }", &mut arena);
        let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::defs; fn test() -> i32 { static c: defs::Counter = defs::Counter { value: 10 }; let a: *mut opaque defs::Adder = &mut c; return a.add(5); }", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    }
}

/// Calling a mutable-receiver trait method on an immutable trait object
/// must be rejected.
@test unsafe fn testResolveTraitMutMethodOnImmutableObject() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Counter { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { set c.value = c.value + n; return c.value; } } fn caller(a: *opaque Adder) -> i32 { return a.add(1); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    let mut testArena489 = testArena();
    let testStorage489: 'test489 = &mut testArena489 in {
        let mut a = testResolver(testStorage489);
        let program = "record Counter { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { set c.value = c.value + n; return c.value; } } fn caller(a: *opaque Adder) -> i32 { return a.add(1); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
}

/// Immutable methods on an immutable trait object should be accepted.
@test unsafe fn testResolveTraitImmutableMethodOnImmutableObject() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Counter { value: i32 } trait Reader { fn (*Reader) get() -> i32; } instance Reader for Counter { fn (c: *Counter) get() -> i32 { return c.value; } } fn caller(r: *opaque Reader) -> i32 { return r.get(); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena490 = testArena();
    let testStorage490: 'test490 = &mut testArena490 in {
        let mut a = testResolver(testStorage490);
        let program = "record Counter { value: i32 } trait Reader { fn (*Reader) get() -> i32; } instance Reader for Counter { fn (c: *Counter) get() -> i32 { return c.value; } } fn caller(r: *opaque Reader) -> i32 { return r.get(); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Both mutable and immutable methods on a mutable trait object should work.
@test unsafe fn testResolveTraitMixedMethodsOnMutableObject() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Counter { value: i32 } trait Ops { fn (&mut Ops) inc(); fn (&Ops) get() -> i32; } instance Ops for Counter { fn (c: &mut Counter) inc() { set c.value = c.value + 1; } fn (c: &Counter) get() -> i32 { return c.value; } } fn caller(o: *mut opaque Ops) -> i32 { o.inc(); return o.get(); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena491 = testArena();
    let testStorage491: 'test491 = &mut testArena491 in {
        let mut a = testResolver(testStorage491);
        let program = "record Counter { value: i32 } trait Ops { fn (&mut Ops) inc(); fn (&Ops) get() -> i32; } instance Ops for Counter { fn (c: &mut Counter) inc() { set c.value = c.value + 1; } fn (c: &Counter) get() -> i32 { return c.value; } } fn caller(o: *mut opaque Ops) -> i32 { o.inc(); return o.get(); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Instance method body type must match the trait return type.
/// The trait declares `-> i32` but the body returns `bool`.
@test unsafe fn testResolveInstanceReturnTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record R { x: i32 } trait T { fn (*T) get() -> i32; } instance T for R { fn (r: *R) get() -> bool { return true; } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena492 = testArena();
    let testStorage492: 'test492 = &mut testArena492 in {
        let mut a = testResolver(testStorage492);
        let program = "record R { x: i32 } trait T { fn (*T) get() -> i32; } instance T for R { fn (r: *R) get() -> bool { return true; } }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Diamond supertrait inheritance: traits B and C both extend A.
/// Declaring them independently should work fine.
@test unsafe fn testResolveTraitDiamondSupertrait() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "trait A { fn (*A) f() -> i32; } trait B: A { fn (*B) g() -> i32; } trait C: A { fn (*C) h() -> i32; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena493 = testArena();
    let testStorage493: 'test493 = &mut testArena493 in {
        let mut a = testResolver(testStorage493);
        let program = "trait A { fn (*A) f() -> i32; } trait B: A { fn (*B) g() -> i32; } trait C: A { fn (*C) h() -> i32; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Diamond supertrait with a combined trait that would cause duplicate
/// method names should be detected.
@test unsafe fn testResolveTraitDiamondDuplicateMethod() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "trait A { fn (*A) f() -> i32; } trait B: A { fn (*B) g() -> i32; } trait C: A { fn (*C) h() -> i32; } trait D: B + C { fn (*D) i() -> i32; }";
    let result = try resolveProgramStr(&mut a, program);
    // B inherits `f` from A, C inherits `f` from A. D: B + C sees duplicate `f`.
    try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("f"));
    let mut testArena494 = testArena();
    let testStorage494: 'test494 = &mut testArena494 in {
        let mut a = testResolver(testStorage494);
        let program = "trait A { fn (*A) f() -> i32; } trait B: A { fn (*B) g() -> i32; } trait C: A { fn (*C) h() -> i32; } trait D: B + C { fn (*D) i() -> i32; }";
        let result = try resolveProgramStr(&mut a, program);
        // B inherits `f` from A, C inherits `f` from A. D: B + C sees duplicate `f`.
        try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("f"));
    }
}

/// Supertrait instance must exist when declaring a combined trait instance.
@test unsafe fn testResolveInstanceMissingSupertraitInstance() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "trait Base { fn (*Base) f() -> i32; } trait Child: Base { fn (*Child) g() -> i32; } record R { x: i32 } instance Child for R { fn (r: *R) g() -> i32 { return r.x; } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::MissingSupertraitInstance("Base"));
    let mut testArena495 = testArena();
    let testStorage495: 'test495 = &mut testArena495 in {
        let mut a = testResolver(testStorage495);
        let program = "trait Base { fn (*Base) f() -> i32; } trait Child: Base { fn (*Child) g() -> i32; } record R { x: i32 } instance Child for R { fn (r: *R) g() -> i32 { return r.x; } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::MissingSupertraitInstance("Base"));
    }
}

/// Instance method omits return type when the trait declares `-> i32`.
/// This is rejected -- the return type must be stated explicitly.
@test unsafe fn testResolveInstanceReturnTypeOmitted() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record R { x: i32 } trait T { fn (*T) get() -> i32; } instance T for R { fn (r: *R) get() { } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena496 = testArena();
    let testStorage496: 'test496 = &mut testArena496 in {
        let mut a = testResolver(testStorage496);
        let program = "record R { x: i32 } trait T { fn (*T) get() -> i32; } instance T for R { fn (r: *R) get() { } }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Instance method declares throws but the trait method does not throw.
@test unsafe fn testResolveInstanceThrowsMismatchExtra() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union E { Fail } record R { x: i32 } trait T { fn (*T) get() -> i32; } instance T for R { fn (r: *R) get() -> i32 throws (E) { return r.x; } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::FnThrowCountMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena497 = testArena();
    let testStorage497: 'test497 = &mut testArena497 in {
        let mut a = testResolver(testStorage497);
        let program = "union E { Fail } record R { x: i32 } trait T { fn (*T) get() -> i32; } instance T for R { fn (r: *R) get() -> i32 throws (E) { return r.x; } }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::FnThrowCountMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Instance method declares a different throws type than the trait.
@test unsafe fn testResolveInstanceThrowsMismatchWrongType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union E1 { Fail } union E2 { Oops } record R { x: i32 } trait T { fn (*T) get() -> i32 throws (E1); } instance T for R { fn (r: *R) get() -> i32 throws (E2) { return r.x; } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena498 = testArena();
    let testStorage498: 'test498 = &mut testArena498 in {
        let mut a = testResolver(testStorage498);
        let program = "union E1 { Fail } union E2 { Oops } record R { x: i32 } trait T { fn (*T) get() -> i32 throws (E1); } instance T for R { fn (r: *R) get() -> i32 throws (E2) { return r.x; } }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Instance method omits throws clause when trait declares throws.
/// This is rejected -- the throws clause must match exactly.
@test unsafe fn testResolveInstanceThrowsOmitted() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union E { Fail } record R { x: i32 } trait T { fn (*T) get() -> i32 throws (E); } instance T for R { fn (r: *R) get() -> i32 { throw E::Fail; return r.x; } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::FnThrowCountMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena499 = testArena();
    let testStorage499: 'test499 = &mut testArena499 in {
        let mut a = testResolver(testStorage499);
        let program = "union E { Fail } record R { x: i32 } trait T { fn (*T) get() -> i32 throws (E); } instance T for R { fn (r: *R) get() -> i32 { throw E::Fail; return r.x; } }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::FnThrowCountMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Instance method correctly matches the trait's throws clause.
@test unsafe fn testResolveInstanceThrowsMatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union E { Fail } record R { x: i32 } trait T { fn (*T) get() -> i32 throws (E); } instance T for R { fn (r: *R) get() -> i32 throws (E) { throw E::Fail; return r.x; } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena500 = testArena();
    let testStorage500: 'test500 = &mut testArena500 in {
        let mut a = testResolver(testStorage500);
        let program = "union E { Fail } record R { x: i32 } trait T { fn (*T) get() -> i32 throws (E); } instance T for R { fn (r: *R) get() -> i32 throws (E) { throw E::Fail; return r.x; } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

// Constant expression folding tests //////////////////////////////////////////

/// Resolve a program and verify that the constant at the given statement index
/// has the expected integer magnitude.
unsafe fn expectConstFold(program: *[u8], stmtIdx: u32, expected: u64)
    throws (testing::TestError)
{
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena501 = testArena();
    let testStorage501: 'test501 = &mut testArena501 in {
        let mut a = testResolver(testStorage501);
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, stmtIdx);
    let sym = super::symbolFor(&a, stmt)
        else throw testing::TestError::Failed;
    let case super::SymbolData::Constant { value, .. } = sym.data
        else throw testing::TestError::Failed;
    let val = value else throw testing::TestError::Failed;
    let case super::ConstValue::Int(intVal) = val
        else throw testing::TestError::Failed;
    try testing::expect(intVal.magnitude == expected);
        let stmt = try getBlockStmt(result.root, stmtIdx);
        let sym = super::symbolFor(&a, stmt)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Constant { value, .. } = sym.data
            else throw testing::TestError::Failed;
        let val = value else throw testing::TestError::Failed;
        let case super::ConstValue::Int(intVal) = val
            else throw testing::TestError::Failed;
        try testing::expect(intVal.magnitude == expected);
    }
}

/// Test arithmetic constant folding: add, sub, mul, div.
@test unsafe fn testConstExprArithmetic() throws (testing::TestError) {
    try expectConstFold("constant A: i32 = 10; constant B: i32 = 20; constant C: i32 = A + B;", 2, 30);

    try expectConstFold("constant A: i32 = 10; constant B: i32 = 20; constant C: i32 = A + B; constant D: i32 = C * 2;", 3, 60);
}

/// Test constant expression used as array size.
@test unsafe fn testConstExprAsArraySize() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "constant A: u32 = 2; constant B: u32 = 3; constant SIZE: u32 = A + B; constant ARR: [i32; SIZE] = [1, 2, 3, 4, 5];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena502 = testArena();
    let testStorage502: 'test502 = &mut testArena502 in {
        let mut a = testResolver(testStorage502);
        let program = "constant A: u32 = 2; constant B: u32 = 3; constant SIZE: u32 = A + B; constant ARR: [i32; SIZE] = [1, 2, 3, 4, 5];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let arrStmt = try getBlockStmt(result.root, 3);
    let sym = super::symbolFor(&a, arrStmt)
        else throw testing::TestError::Failed;
    let case super::SymbolData::Constant { type: super::Type::Array(arrType), .. } = sym.data
        else throw testing::TestError::Failed;
    try testing::expect(arrType.length == 5);
        let arrStmt = try getBlockStmt(result.root, 3);
        let sym = super::symbolFor(&a, arrStmt)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Constant { type: super::Type::Array(arrType), .. } = sym.data
            else throw testing::TestError::Failed;
        try testing::expect(arrType.length == 5);
    }
}

/// Test cross-module constant expression: a constant in one module references
/// a constant from another module via scope access.
@test unsafe fn testCrossModuleConstExpr() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena503 = testArena();
    let testStorage503: 'test503 = &mut testArena503 in {
        let mut a = testResolver(testStorage503);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export constant BASE: i32 = 100;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; constant DERIVED: i32 = consts::BASE + 50;", &mut arena);
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
        let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export constant BASE: i32 = 100;", &mut arena);
        let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; constant DERIVED: i32 = consts::BASE + 50;", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    }
}

/// Test cross-module constant expression used as array size.
@test unsafe fn testCrossModuleConstExprArraySize() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut testArena504 = testArena();
    let testStorage504: 'test504 = &mut testArena504 in {
        let mut a = testResolver(testStorage504);
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export constant WIDTH: u32 = 8; export constant HEIGHT: u32 = 4;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; constant TOTAL: u32 = consts::WIDTH * consts::HEIGHT; static BUF: [u8; TOTAL] = [0; TOTAL];", &mut arena);
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
        let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export constant WIDTH: u32 = 8; export constant HEIGHT: u32 = 4;", &mut arena);
        let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; constant TOTAL: u32 = consts::WIDTH * consts::HEIGHT; static BUF: [u8; TOTAL] = [0; TOTAL];", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    }
}

/// Test that non-constant expressions in constant declarations are still rejected.
@test unsafe fn testConstExprNonConstRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn value() -> i32 { return 1; } constant BAD: i32 = value() + 1;";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::ConstExprRequired = err.kind
        else throw testing::TestError::Failed;
    let mut testArena505 = testArena();
    let testStorage505: 'test505 = &mut testArena505 in {
        let mut a = testResolver(testStorage505);
        let program = "fn value() -> i32 { return 1; } constant BAD: i32 = value() + 1;";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::ConstExprRequired = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Test unary negation in constant expressions.
@test unsafe fn testConstExprUnaryNeg() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "constant A: i32 = 10; constant B: i32 = -A;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena506 = testArena();
    let testStorage506: 'test506 = &mut testArena506 in {
        let mut a = testResolver(testStorage506);
        let program = "constant A: i32 = 10; constant B: i32 = -A;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test unary not in constant expressions.
@test unsafe fn testConstExprUnaryNot() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "constant A: bool = true; constant B: bool = not A;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena507 = testArena();
    let testStorage507: 'test507 = &mut testArena507 in {
        let mut a = testResolver(testStorage507);
        let program = "constant A: bool = true; constant B: bool = not A;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test `as` casts in constant expressions: widening, narrowing, sign changes, chaining.
@test unsafe fn testConstExprCast() throws (testing::TestError) {
    try expectConstFold("constant A: i32 = 42; constant B: u64 = A as u64;", 1, 42);

    try expectConstFold("constant A: i32 = (2 as i32) * (3 + 4);", 0, 14);
}

/// Test `as` cast in constant expressions used as array size.
@test unsafe fn testConstExprCastAsArraySize() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "constant LEN: u64 = 4; constant SIZE: u32 = LEN as u32; constant ARR: [i32; SIZE] = [1, 2, 3, 4];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let mut testArena508 = testArena();
    let testStorage508: 'test508 = &mut testArena508 in {
        let mut a = testResolver(testStorage508);
        let program = "constant LEN: u64 = 4; constant SIZE: u32 = LEN as u32; constant ARR: [i32; SIZE] = [1, 2, 3, 4];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

    let arrStmt = try getBlockStmt(result.root, 2);
    let sym = super::symbolFor(&a, arrStmt)
        else throw testing::TestError::Failed;
    let case super::SymbolData::Constant { type: super::Type::Array(arrType), .. } = sym.data
        else throw testing::TestError::Failed;
    try testing::expect(arrType.length == 4);
        let arrStmt = try getBlockStmt(result.root, 2);
        let sym = super::symbolFor(&a, arrStmt)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Constant { type: super::Type::Array(arrType), .. } = sym.data
            else throw testing::TestError::Failed;
        try testing::expect(arrType.length == 4);
    }
}

/// Test unsuffixed integer literals in constant expressions.
@test unsafe fn testConstExprUnsuffixedLiterals() throws (testing::TestError) {
    try expectConstFold("constant A: u32 = 4 * 4;", 0, 16);

    try expectConstFold("constant F: i32 = -(3 + 4);", 0, 7);
}

/// References cannot escape through return types.
@test unsafe fn testRefReturnRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Once {} fn bad(value: &u32) -> &u32 { return value; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
    let mut testArena509 = testArena();
    let testStorage509: 'test509 = &mut testArena509 in {
        let mut a = testResolver(testStorage509);
        let program = "record Marker: Once {} fn bad(value: &u32) -> &u32 { return value; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
    }
}

/// Case-pattern fallbacks must terminate instead of synthesizing bindings.
@test unsafe fn testCaseLetElseFallbackMustTerminate() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Value { Item(u32) } fn run(value: Value) { let case Value::Item(item) = value else value; item; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::LinearLetElseMustTerminate);
    let mut testArena510 = testArena();
    let testStorage510: 'test510 = &mut testArena510 in {
        let mut a = testResolver(testStorage510);
        let program = "union Value { Item(u32) } fn run(value: Value) { let case Value::Item(item) = value else value; item; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::LinearLetElseMustTerminate);
    }
}

/// Case bindings are unavailable on the pattern-failure path.
@test unsafe fn testCaseLetElseFallbackCannotUseBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Value { Item(u32) } fn run(value: Value) { let case Value::Item(item) = value else item; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("item"));
    let mut testArena511 = testArena();
    let testStorage511: 'test511 = &mut testArena511 in {
        let mut a = testResolver(testStorage511);
        let program = "union Value { Item(u32) } fn run(value: Value) { let case Value::Item(item) = value else item; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("item"));
    }
}

/// Unsafe pointer dereference requires an unsafe declaration.
@test unsafe fn testUnsafePointerOperationRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Once {} fn load(pointer: *unsafe u32) -> u32 { return *pointer; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    let mut testArena512 = testArena();
    let testStorage512: 'test512 = &mut testArena512 in {
        let mut a = testResolver(testStorage512);
        let program = "record Marker: Once {} fn load(pointer: *unsafe u32) -> u32 { return *pointer; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    }
}

/// Unsafe pointers remain freely copyable inside an unsafe declaration.
@test unsafe fn testUnsafePointerOperationAllowed() throws (testing::TestError) {
    let program = "record Marker: Once {} unsafe fn load(pointer: *unsafe u32) -> u32 { return *pointer; }";
    try expectAnalyzeOk(program);
}

/// Safe code cannot call a function that accepts unsafe operations.
@test unsafe fn testUnsafeFunctionCallRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Once {} unsafe fn load(pointer: *unsafe u32) -> u32 { return *pointer; } fn run(pointer: *unsafe u32) -> u32 { return load(pointer); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnsafeCall);
    let mut testArena513 = testArena();
    let testStorage513: 'test513 = &mut testArena513 in {
        let mut a = testResolver(testStorage513);
        let program = "record Marker: Once {} unsafe fn load(pointer: *unsafe u32) -> u32 { return *pointer; } fn run(pointer: *unsafe u32) -> u32 { return load(pointer); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeCall);
    }
}

/// Unsafe function values retain their call-site safety requirement.
@test unsafe fn testUnsafeFunctionAliasCallRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "unsafe fn dangerous() -> u32 { return 42; } fn run() -> u32 { let alias = dangerous; return alias(); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnsafeCall);
    let mut testArena514 = testArena();
    let testStorage514: 'test514 = &mut testArena514 in {
        let mut a = testResolver(testStorage514);
        let program = "unsafe fn dangerous() -> u32 { return 42; } fn run() -> u32 { let alias = dangerous; return alias(); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeCall);
    }
}

/// References cannot be embedded in aggregate fields.
@test unsafe fn testRefFieldRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Once {} record Bad { value: &u32 }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
    let mut testArena515 = testArena();
    let testStorage515: 'test515 = &mut testArena515 in {
        let mut a = testResolver(testStorage515);
        let program = "record Marker: Once {} record Bad { value: &u32 }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
    }
}

/// Trait methods may use reference receivers.
@test unsafe fn testTraitRefReceiver() throws (testing::TestError) {
    let program = "record Marker: Once {} record Value { number: i32 } trait Read { fn (&Read) get() -> i32; } instance Read for Value { fn (value: &Value) get() -> i32 { return value.number; } } fn inspect(object: &opaque Read) -> i32 { return object.get(); } fn call(value: &Value) -> i32 { return inspect(value); }";
    try expectAnalyzeOk(program);
}

/// Trait implementations must preserve the receiver pointer class.
@test unsafe fn testTraitReceiverClassMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Value { number: i32 } trait Read { fn (&Read) get() -> i32; } instance Read for Value { fn (value: *Value) get() -> i32 { return value.number; } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TraitReceiverMismatch);
    let mut testArena516 = testArena();
    let testStorage516: 'test516 = &mut testArena516 in {
        let mut a = testResolver(testStorage516);
        let program = "record Value { number: i32 } trait Read { fn (&Read) get() -> i32; } instance Read for Value { fn (value: *Value) get() -> i32 { return value.number; } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::TraitReceiverMismatch);
    }
}

/// Unmarked composite values may be discarded.
@test unsafe fn testAffineCompositeMayBeDiscarded() throws (testing::TestError) {
    let program = "record Value { number: u32 } fn run() { let value = Value { number: 1 }; }";
    try expectAnalyzeOk(program);
}

/// A by-value use moves an unmarked composite value.
@test unsafe fn testAffineCompositeUseAfterMoveRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Value { number: u32 } fn take(value: Value) {} fn run() { let value = Value { number: 1 }; take(value); take(value); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::AffineUseAfterMove("value"));
    let mut testArena517 = testArena();
    let testStorage517: 'test517 = &mut testArena517 in {
        let mut a = testResolver(testStorage517);
        let program = "record Value { number: u32 } fn take(value: Value) {} fn run() { let value = Value { number: 1 }; take(value); take(value); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::AffineUseAfterMove("value"));
    }
}

/// Affine values may move on only one branch when not used later.
@test unsafe fn testAffineConditionalMoveMayBeDiscarded() throws (testing::TestError) {
    let program = "record Value { number: u32 } fn take(value: Value) {} fn run(condition: bool) { let value = Value { number: 1 }; if condition { take(value); } }";

    try expectAnalyzeOk(program);
}

/// A `Copy` composite may contain only copy values.
@test unsafe fn testCopyCompositeRejectsAffineField() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Inner { number: u32 } record Outer: Copy { inner: Inner }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::CopyContainsNonCopy);
    let mut testArena518 = testArena();
    let testStorage518: 'test518 = &mut testArena518 in {
        let mut a = testResolver(testStorage518);
        let program = "record Inner { number: u32 } record Outer: Copy { inner: Inner }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::CopyContainsNonCopy);
    }
}

/// A composite cannot carry conflicting ownership markers.
@test unsafe fn testConflictingOwnershipMarkersRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Value: Copy + Once { number: u32 }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ConflictingOwnershipMarkers);
    let mut testArena519 = testArena();
    let testStorage519: 'test519 = &mut testArena519 in {
        let mut a = testResolver(testStorage519);
        let program = "record Value: Copy + Once { number: u32 }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ConflictingOwnershipMarkers);
    }
}

/// Linear composites still require one consuming use.
@test unsafe fn testLinearCompositeMustBeConsumed() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Token: Once { number: u32 } fn run() { let token = Token { number: 1 }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::LinearNotConsumed("token"));
    let mut testArena520 = testArena();
    let testStorage520: 'test520 = &mut testArena520 in {
        let mut a = testResolver(testStorage520);
        let program = "record Token: Once { number: u32 } fn run() { let token = Token { number: 1 }; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::LinearNotConsumed("token"));
    }
}

/// The compiler-known marker cannot be derived more than once.
@test unsafe fn testDuplicateOnceMarkerRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Token: Once + Once { value: u32 }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("Once"));
    let mut testArena521 = testArena();
    let testStorage521: 'test521 = &mut testArena521 in {
        let mut a = testResolver(testStorage521);
        let program = "record Token: Once + Once { value: u32 }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("Once"));
    }
}

/// Stack storage cannot produce a safe stored pointer or slice.
@test unsafe fn testStackPointerRejected() throws (testing::TestError) {
    let programs = &[

        "record Cell { value: u32 } fn run(value: &Cell) -> *u32 { return &value.value; }",
        "record Cell { value: *u32 } fn run(value: &u32) -> Cell { return Cell { value }; }",
        "fn run(value: &u32) -> *[u32] { return @sliceOf(value, 1); }",
    ];
    for program in programs {
        let mut resolver = testResolver();
        let result = try resolveProgramStr(&mut resolver, program);
        let _ = try expectError(&result);
        let mut testArena522 = testArena();
        let testStorage522: 'test522 = &mut testArena522 in {
            let mut resolver = testResolver(testStorage522);
            let result = try resolveProgramStr(&mut resolver, program);
            let _ = try expectError(&result);
        }
    }
}

/// Stack values can be borrowed for a call.
@test unsafe fn testStackBorrowAllowed() throws (testing::TestError) {

        "fn write(p: &mut [u32]) {} fn run(p: *unsafe mut [u32]) { write(p); }",
        "trait Read { fn (&Read) get(); } fn read(p: &opaque Read) {} fn run(p: *unsafe opaque Read) { read(p); }",
        "fn read(p: &u32) {} fn run(p: *unsafe u32) { unsafe { read(p); } read(p); }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        let mut testArena523 = testArena();
        let testStorage523: 'test523 = &mut testArena523 in {
            let mut a = testResolver(testStorage523);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    }
}

/// Raw borrows preserve mutability, storage type, and ownership constraints.
@test unsafe fn testImplicitRawBorrowPreservesTypes() throws (testing::TestError) {

        "fn take(p: *u32) {} unsafe fn run(p: *unsafe u32) { take(p); }",
        "fn take(p: *[u32]) {} unsafe fn run(p: *unsafe [u32]) { take(p); }",
        "fn read(p: &*u32) {} unsafe fn run(p: *unsafe *unsafe u32) { read(p); }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
        let mut testArena524 = testArena();
        let testStorage524: 'test524 = &mut testArena524 in {
            let mut a = testResolver(testStorage524);
            let result = try resolveProgramStr(&mut a, program);
            let err = try expectError(&result);
            let case super::ErrorKind::TypeMismatch(_) = err.kind
                else throw testing::TestError::Failed;
        }
    }
}

/// Implicit raw borrows retain the call's exclusive-borrow checks.
@test unsafe fn testImplicitRawBorrowConflict() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a,
        "fn useBoth(a: &mut u32, b: &u32) {} unsafe fn run(p: *unsafe mut u32) { useBoth(p, p); }");
    try expectErrorKind(&result, super::ErrorKind::BorrowConflict("p"));
    let mut testArena525 = testArena();
    let testStorage525: 'test525 = &mut testArena525 in {
        let mut a = testResolver(testStorage525);
        let result = try resolveProgramStr(&mut a,
            "fn useBoth(a: &mut u32, b: &u32) {} unsafe fn run(p: *unsafe mut u32) { useBoth(p, p); }");
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("p"));
    }
}

/// Unsafe declarations can store raw pointers to stack values.
@test unsafe fn testUnsafeStackPointerAllowed() throws (testing::TestError) {
    try expectAnalyzeOk("unsafe fn run() { let mut value: u32 = 0; let pointer: *unsafe mut u32 = &mut value as *unsafe mut u32; set *pointer = 7; }");

}

/// References are rejected from every nested or storable type position.
@test unsafe fn testNestedRefPositionsRejected() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "record Marker: Once {} union Bad { Value(&u32) }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
        let mut testArena526 = testArena();
        let testStorage526: 'test526 = &mut testArena526 in {
            let mut a = testResolver(testStorage526);
            let program = "record Marker: Once {} union Bad { Value(&u32) }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
        }
    } {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn bad(value: ?&u32) {}";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
        let mut testArena527 = testArena();
        let testStorage527: 'test527 = &mut testArena527 in {
            let mut a = testResolver(testStorage527);
            let program = "record Marker: Once {} fn bad(value: ?&u32) {}";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
        }
    } {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn bad(value: [&u32; 1]) {}";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
        let mut testArena528 = testArena();
        let testStorage528: 'test528 = &mut testArena528 in {
            let mut a = testResolver(testStorage528);
            let program = "record Marker: Once {} fn bad(value: [&u32; 1]) {}";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
        }
    } {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn bad(value: *&u32) {}";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
        let mut testArena529 = testArena();
        let testStorage529: 'test529 = &mut testArena529 in {
            let mut a = testResolver(testStorage529);
            let program = "record Marker: Once {} fn bad(value: *&u32) {}";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
        }
    } {
        let mut a = testResolver();
        let program = "record Marker: Once {} static BAD: &u32 = undefined;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
        let mut testArena530 = testArena();
        let testStorage530: 'test530 = &mut testArena530 in {
            let mut a = testResolver(testStorage530);
            let program = "record Marker: Once {} static BAD: &u32 = undefined;";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
        }
    } {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn bad(callback: fn() -> &u32) {}";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
        let mut testArena531 = testArena();
        let testStorage531: 'test531 = &mut testArena531 in {
            let mut a = testResolver(testStorage531);
            let program = "record Marker: Once {} fn bad(callback: fn() -> &u32) {}";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
        }
    }
}

/// Function pointer parameter references remain call-scoped and valid.
@test unsafe fn testFunctionPointerRefParameterAllowed() throws (testing::TestError) {

}

/// Pointer and slice casts cannot change reference ownership.
@test unsafe fn testRefCastClassPreserved() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn cast(value: &u32) { value as *u32; }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
        let mut testArena532 = testArena();
        let testStorage532: 'test532 = &mut testArena532 in {
            let mut a = testResolver(testStorage532);
            let program = "record Marker: Once {} fn cast(value: &u32) { value as *u32; }";
            let result = try resolveProgramStr(&mut a, program);
            let err = try expectError(&result);
            let case super::ErrorKind::InvalidAsCast(_) = err.kind
                else throw testing::TestError::Failed;
        }
    } {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn cast(values: &[u32]) { values as *[u32]; }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
        let mut testArena533 = testArena();
        let testStorage533: 'test533 = &mut testArena533 in {
            let mut a = testResolver(testStorage533);
            let program = "record Marker: Once {} fn cast(values: &[u32]) { values as *[u32]; }";
            let result = try resolveProgramStr(&mut a, program);
            let err = try expectError(&result);
            let case super::ErrorKind::InvalidAsCast(_) = err.kind
                else throw testing::TestError::Failed;
        }
    }
}

/// Every operation that interprets an unsafe address requires an unsafe declaration.
@test unsafe fn testUnsafePointerOperationsRejected() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn cast(pointer: *unsafe u32) -> u64 { return pointer as u64; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        let mut testArena534 = testArena();
        let testStorage534: 'test534 = &mut testArena534 in {
            let mut a = testResolver(testStorage534);
            let program = "record Marker: Once {} fn cast(pointer: *unsafe u32) -> u64 { return pointer as u64; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    } {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn compare(pointer: *unsafe u32) -> bool { return pointer == pointer; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        let mut testArena535 = testArena();
        let testStorage535: 'test535 = &mut testArena535 in {
            let mut a = testResolver(testStorage535);
            let program = "record Marker: Once {} fn compare(pointer: *unsafe u32) -> bool { return pointer == pointer; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    } {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn offset(pointer: *unsafe u32) -> *unsafe u32 { return pointer + 1; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        let mut testArena536 = testArena();
        let testStorage536: 'test536 = &mut testArena536 in {
            let mut a = testResolver(testStorage536);
            let program = "record Marker: Once {} fn offset(pointer: *unsafe u32) -> *unsafe u32 { return pointer + 1; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    } {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn index(values: *unsafe [u32]) -> u32 { return values[0]; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        let mut testArena537 = testArena();
        let testStorage537: 'test537 = &mut testArena537 in {
            let mut a = testResolver(testStorage537);
            let program = "record Marker: Once {} fn index(values: *unsafe [u32]) -> u32 { return values[0]; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    } {
        let mut a = testResolver();
        let program = "record Marker: Once {} record Cell { value: u32 } fn field(cell: *unsafe Cell) -> u32 { return cell.value; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        let mut testArena538 = testArena();
        let testStorage538: 'test538 = &mut testArena538 in {
            let mut a = testResolver(testStorage538);
            let program = "record Marker: Once {} record Cell { value: u32 } fn field(cell: *unsafe Cell) -> u32 { return cell.value; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    } {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn store(pointer: *unsafe mut u32) { set *pointer = 1; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        let mut testArena539 = testArena();
        let testStorage539: 'test539 = &mut testArena539 in {
            let mut a = testResolver(testStorage539);
            let program = "record Marker: Once {} fn store(pointer: *unsafe mut u32) { set *pointer = 1; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    } {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn cast() { let value: u32 = 0; let pointer = &value as *unsafe u32; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        let mut testArena540 = testArena();
        let testStorage540: 'test540 = &mut testArena540 in {
            let mut a = testResolver(testStorage540);
            let program = "record Marker: Once {} fn cast() { let value: u32 = 0; let pointer = &value as *unsafe u32; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    }
}

/// Pointer offsets require an unsafe function for either operand order.
@test unsafe fn testPointerArithmeticRequiresUnsafe() throws (testing::TestError) {

        "fn run(p: *u8) -> *u8 { return p - 1; }",
        "fn run(input: *mut u8) { let mut p = input; set p += 1; }",
        "static DATA: [u8; 1] = [42]; fn run() -> u8 { let p = &DATA[0]; return *(p + 1); }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        let mut testArena541 = testArena();
        let testStorage541: 'test541 = &mut testArena541 in {
            let mut a = testResolver(testStorage541);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    }
    try expectAnalyzeOk("unsafe fn run(p: *u8) -> *u8 { return p + 1; }");
    try expectAnalyzeOk("unsafe fn run(p: *u8) -> *u8 { return 1 + p; }");
    try expectAnalyzeOk("unsafe fn run(p: *mut u8) -> *mut u8 { return p - 1; }");
    try expectAnalyzeOk("fn run(value: u32) -> u32 { return value + 1; }");

        "fn run(s: *[opaque]) -> *[u64] { return s as *[u64]; }",
        "fn run(s: &mut [u64]) { let _ = s as &mut [u8]; }",
        "static DATA: [u8; 1] = [42]; fn run() -> u64 { return *(&DATA[0] as *u64); }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        let mut testArena542 = testArena();
        let testStorage542: 'test542 = &mut testArena542 in {
            let mut a = testResolver(testStorage542);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    }
    try expectAnalyzeOk("unsafe fn run(p: *u8) -> *u64 { return p as *u64; }");
    try expectAnalyzeOk("unsafe fn run(p: &u8) -> u64 { return *(p as &u64); }");
    try expectAnalyzeOk("unsafe fn run(s: *[u8]) -> *[u64] { return s as *[u64]; }");
    try expectAnalyzeOk("fn run(p: *u8) -> *u8 { return p as *u8; }");

        "fn run(p: &u8) -> u8 { return @sliceOf(p, 100)[99]; }",
        "fn run(p: &mut u8) { set @sliceOf(p, 100)[99] = 1; }",
        "static DATA: [u8; 1] = [42]; fn run() -> u8 { let s = @sliceOf(&DATA[0], 100); return s[99]; }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        let mut testArena543 = testArena();
        let testStorage543: 'test543 = &mut testArena543 in {
            let mut a = testResolver(testStorage543);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    }
    try expectAnalyzeOk("unsafe fn run(p: *u8) -> *[u8] { return @sliceOf(p, 100); }");
    try expectAnalyzeOk("unsafe fn run(p: *mut u8) -> *mut [u8] { return @sliceOf(p, 0, 100); }");
    try expectAnalyzeOk("unsafe fn run(p: &u8) -> u8 { return @sliceOf(p, 1)[0]; }");
    try expectAnalyzeOk("fn run(s: *[u8]) -> *[u8] { return &s[..]; }");

        "fn change(p: &mut *u8, q: *u8) { set *p = q; } fn run(q: *u8) { let mut s: *[u8] = &[]; change(&mut s.ptr, q); }",
        "fn run(s: &mut *[u8]) { set s.len = 100; }",
        "static DATA: [u8; 1] = [42]; fn run() -> u8 { let mut s = &DATA[..]; set s.len = 100; return s[99]; }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        let mut testArena544 = testArena();
        let testStorage544: 'test544 = &mut testArena544 in {
            let mut a = testResolver(testStorage544);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    }
    try expectAnalyzeOk("unsafe fn run(s: *mut [u8]) { set s.len = 0; set s.cap = 0; }");
    try expectAnalyzeOk("unsafe fn run(s: *mut [u8], p: *mut u8) { set s.ptr = p; }");
    try expectAnalyzeOk("fn change(n: &mut u32) { set *n = 0; } unsafe fn run(s: *mut [u8]) { change(&mut s.len); }");
    try expectAnalyzeOk("fn run(s: *mut [u8]) { set s[0] = 1; }");

        "fn run(p: *u8) -> *u8 { unsafe { let q = p + 1; } return p + 1; }",
        "fn run(p: *u8) -> *u8 { unsafe { unsafe {} } return p + 1; }",
        "unsafe fn first(p: *u8) -> *u8 { return p + 1; } fn second(p: *u8) -> *u8 { return p + 1; }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        let mut testArena545 = testArena();
        let testStorage545: 'test545 = &mut testArena545 in {
            let mut a = testResolver(testStorage545);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    }
    let mut testArena546 = testArena();
    let testStorage546: 'test546 = &mut testArena546 in {
        let mut a = testResolver(testStorage546);
        let result = try resolveProgramStr(&mut a, "unsafe fn act() {} fn run() { unsafe { act(); } act(); }");
        try expectErrorKind(&result, super::ErrorKind::UnsafeCall);
    }
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "unsafe fn act() {} fn run() { unsafe { act(); } act(); }");
    try expectErrorKind(&result, super::ErrorKind::UnsafeCall);
}

/// Resolution errors do not extend an unsafe block's permission.
@test unsafe fn testUnsafeBlockErrorRestoresContext() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn run(p: *u8) { unsafe { missing; } let q = p + 1; }");
    let mut found = false;
    for err in result.diagnostics.errors {
        if let case super::ErrorKind::UnsafeOperation = err.kind {
            set found = true;
    let mut testArena547 = testArena();
    let testStorage547: 'test547 = &mut testArena547 in {
        let mut a = testResolver(testStorage547);
        let result = try resolveProgramStr(&mut a, "fn run(p: *u8) { unsafe { missing; } let q = p + 1; }");
        let mut found = false;
        for err in result.diagnostics.errors {
            if let case super::ErrorKind::UnsafeOperation = err.kind {
                set found = true;
            }
        }
        try testing::expect(found);
    }
    try testing::expect(found);
}

/// Unsafe blocks preserve reference lifetime checks.
@test unsafe fn testUnsafeBlockPreservesReferences() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn run() { let mut n: u32 = 1; let p = &n; unsafe { set n = 2; } }");
    try expectErrorKind(&result, super::ErrorKind::BorrowConflict("n"));
    let mut testArena548 = testArena();
    let testStorage548: 'test548 = &mut testArena548 in {
        let mut a = testResolver(testStorage548);
        let result = try resolveProgramStr(&mut a, "fn run() { let mut n: u32 = 1; let p = &n; unsafe { set n = 2; } }");
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("n"));
    }
}

/// Slice pointer access requires an unsafe context for every slice class.
@test unsafe fn testSlicePointerRequiresUnsafe() throws (testing::TestError) {
    let programs = &[

        "fn run(s: &*[u8]) -> *u8 { return s.ptr; }",
        "static DATA: [u8; 1] = [42]; fn run() -> u8 { let s = &DATA[1..]; return *s.ptr; }",
        "fn run(s: *[u8]) -> u64 { return s.ptr as u64; }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        let mut testArena549 = testArena();
        let testStorage549: 'test549 = &mut testArena549 in {
            let mut a = testResolver(testStorage549);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    }
    try expectAnalyzeOk("unsafe fn run(s: *[u8]) -> *u8 { return s.ptr; }");
    try expectAnalyzeOk("fn run(s: *[u8]) -> u64 { unsafe { return s.ptr as u64; } }");
    try expectAnalyzeOk("fn run(s: *[u8]) -> *u8 { return &s[0]; }");
    try expectAnalyzeOk("fn run(s: *[u8]) -> u32 { return s.len + s.cap; }");

        "unsafe static DATA: [u8; 1] = [42]; fn run() -> u8 { return DATA[0]; }",
        "unsafe static DATA: [u8; 1] = [42]; fn run() -> u32 { return DATA.len; }",
        "record R { value: u32 } unsafe static DATA: R = R { value: 7 }; fn run() -> u32 { return DATA.value; }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        let mut testArena550 = testArena();
        let testStorage550: 'test550 = &mut testArena550 in {
            let mut a = testResolver(testStorage550);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    }
}

/// Unsafe blocks and functions can access unsafe statics.
@test unsafe fn testUnsafeStaticAccessAllowed() throws (testing::TestError) {

    let programs = &[
        "use root::storage; fn run() -> u32 { return storage::VALUE; }",
        "use root::storage::*; fn run() -> u32 { return VALUE; }",
    ];
    for program in programs {
        let mut a = testResolver();
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod storage; mod app;", &mut arena);
        let _ = try registerModule(&mut MODULE_GRAPH, rootId, "storage", "export unsafe static VALUE: u32 = 7;", &mut arena);
        let _ = try registerModule(&mut MODULE_GRAPH, rootId, "app", program, &mut arena);
        let result = try resolveModuleTree(&mut a, rootId);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        let mut testArena551 = testArena();
        let testStorage551: 'test551 = &mut testArena551 in {
            let mut a = testResolver(testStorage551);
            let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
            let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod storage; mod app;", &mut arena);
            let _ = try registerModule(&mut MODULE_GRAPH, rootId, "storage", "export unsafe static VALUE: u32 = 7;", &mut arena);
            let _ = try registerModule(&mut MODULE_GRAPH, rootId, "app", program, &mut arena);
            let result = try resolveModuleTree(&mut a, rootId);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    }
}

/// An invalid unsafe static initializer does not grant permission to other initializers.
@test unsafe fn testUnsafeStaticInitializerRestoresContext() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "unsafe static BAD: u32 = true; static DATA: *[u64] = &[1 as u8] as *[u64];");
    let _ = try expectError(&result);
    try testing::expect(not a.inUnsafeContext);
    let mut testArena552 = testArena();
    let testStorage552: 'test552 = &mut testArena552 in {
        let mut a = testResolver(testStorage552);
        let result = try resolveProgramStr(&mut a, "unsafe static BAD: u32 = true; static DATA: *[u64] = &[1 as u8] as *[u64];");
        let _ = try expectError(&result);
        try testing::expect(not a.inUnsafeContext);

    let mut b = testResolver();
    let next = try resolveProgramStr(&mut b, "constant BYTES: *[u8] = \"x\"; unsafe static VALUE: u32 = 7; static DATA: *[u64] = BYTES as *[u64];");
    try expectErrorKind(&next, super::ErrorKind::UnsafeOperation);
        let mut testArena553 = testArena();
        let testStorage553: 'test553 = &mut testArena553 in {
            let mut b = testResolver(testStorage553);
            let next = try resolveProgramStr(&mut b, "constant BYTES: *[u8] = \"x\"; unsafe static VALUE: u32 = 7; static DATA: *[u64] = BYTES as *[u64];");
            try expectErrorKind(&next, super::ErrorKind::UnsafeOperation);
        }
    }
}

/// Uninitialized values require an explicit unsafe context in every value position.
@test unsafe fn testUndefinedRequiresUnsafe() throws (testing::TestError) {
    let programs = &[

        "constant P: *u8 = undefined;",
        "static DATA: [u8; 4] = undefined;",
        "record R: Copy { p: *u8 } static VALUE: R = R { p: undefined };",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        let mut testArena554 = testArena();
        let testStorage554: 'test554 = &mut testArena554 in {
            let mut a = testResolver(testStorage554);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    }
    try expectAnalyzeOk("unsafe fn run() { let p: *u8 = undefined; }");
    try expectAnalyzeOk("fn run() -> u32 { unsafe { let mut n: u32 = undefined; set n = 7; return n; } }");
    try expectAnalyzeOk("unsafe static P: *u8 = undefined;");
    try expectAnalyzeOk("record R: Copy { p: *u8 } unsafe static VALUE: R = R { p: undefined };");

    try expectAnalyzeOk("static DATA: [u8; 4] = [0; 4];");
}

/// Unsafe initialization does not grant permission to subsequent safe expressions.
@test unsafe fn testUndefinedContextRestored() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn run() { unsafe { let p: *u8 = undefined; } let q: *u8 = undefined; }");
    try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    let mut b = testResolver();
    let next = try resolveProgramStr(&mut b, "unsafe static P: *u8 = undefined; static Q: *u8 = undefined;");
    try expectErrorKind(&next, super::ErrorKind::UnsafeOperation);
    let mut testArena555 = testArena();
    let testStorage555: 'test555 = &mut testArena555 in {
        let mut a = testResolver(testStorage555);
        let result = try resolveProgramStr(&mut a, "fn run() { unsafe { let p: *u8 = undefined; } let q: *u8 = undefined; }");
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        let mut testArena556 = testArena();
        let testStorage556: 'test556 = &mut testArena556 in {
            let mut b = testResolver(testStorage556);
            let next = try resolveProgramStr(&mut b, "unsafe static P: *u8 = undefined; static Q: *u8 = undefined;");
            try expectErrorKind(&next, super::ErrorKind::UnsafeOperation);
        }
    }
}

/// Unsafe declarations may compose unsafe operations and calls.
@test unsafe fn testUnsafePointerOperationsAllowed() throws (testing::TestError) {
    let program = "record Marker: Once {} unsafe fn load(pointer: *unsafe u32) -> u32 { return *pointer; } unsafe fn run(pointer: *unsafe u32) -> u32 { let next = pointer + 1; let same = pointer == next; return load(pointer); }";

    try expectAnalyzeOk(program);
}

/// Dropping a reference to an unsafe pointer cannot add mutability.
@test unsafe fn testUnsafePointerCastCannotAddMutability() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Once {} unsafe fn run(value: &u32) { value as *unsafe mut u32; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::InvalidAsCast(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena557 = testArena();
    let testStorage557: 'test557 = &mut testArena557 in {
        let mut a = testResolver(testStorage557);
        let program = "record Marker: Once {} unsafe fn run(value: &u32) { value as *unsafe mut u32; }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Recursive cast validation cannot hide a checked-to-unsafe transition.
@test unsafe fn testNestedUnsafePointerCastRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Once {} fn run(value: **u32) { value as **unsafe u32; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::InvalidAsCast(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena558 = testArena();
    let testStorage558: 'test558 = &mut testArena558 in {
        let mut a = testResolver(testStorage558);
        let program = "record Marker: Once {} fn run(value: **u32) { value as **unsafe u32; }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Unsafe code may drop a checked slice reference to an unsafe slice.
@test unsafe fn testUnsafeSliceFromReference() throws (testing::TestError) {
    let program = "record Marker: Once {} unsafe fn run(values: &[u32]) { let raw: *unsafe [u32] = values as *unsafe [u32]; }";
    try expectAnalyzeOk(program);
}

/// Slice casts cannot add mutability.
@test unsafe fn testSliceCastCannotAddMutability() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Once {} fn run(values: &[u32]) { values as &mut [u32]; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::InvalidAsCast(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena559 = testArena();
    let testStorage559: 'test559 = &mut testArena559 in {
        let mut a = testResolver(testStorage559);
        let program = "record Marker: Once {} fn run(values: &[u32]) { values as &mut [u32]; }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Mutable unsafe receivers do not create checked exclusive loans.
@test unsafe fn testUnsafeReceiverDoesNotBorrowExclusively() throws (testing::TestError) {
    let program = "record Marker: Once {} record Value { number: u32 } unsafe fn (value: *unsafe mut Value) update(other: *unsafe mut Value) {} unsafe fn run(value: *unsafe mut Value) { value.update(value); }";

    try expectAnalyzeOk(program);
}

/// Unsafe instance methods cannot implement safe trait contracts.
@test unsafe fn testUnsafeInstanceMethodSafetyMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Value {} trait Read { fn (&Read) get(); } instance Read for Value { unsafe fn (value: &Value) get() {} }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TraitMethodSafetyMismatch);
    let mut testArena560 = testArena();
    let testStorage560: 'test560 = &mut testArena560 in {
        let mut a = testResolver(testStorage560);
        let program = "record Value {} trait Read { fn (&Read) get(); } instance Read for Value { unsafe fn (value: &Value) get() {} }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::TraitMethodSafetyMismatch);
    }
}

/// Unsafe trait methods retain their call-site requirement through dispatch.
@test unsafe fn testUnsafeTraitMethodCallRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Once {} record Value { number: u32 } trait Read { unsafe fn (&Read) get() -> u32; } instance Read for Value { unsafe fn (value: &Value) get() -> u32 { return value.number; } } fn inspect(object: &opaque Read) -> u32 { return object.get(); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnsafeCall);
    let mut testArena561 = testArena();
    let testStorage561: 'test561 = &mut testArena561 in {
        let mut a = testResolver(testStorage561);
        let program = "record Marker: Once {} record Value { number: u32 } trait Read { unsafe fn (&Read) get() -> u32; } instance Read for Value { unsafe fn (value: &Value) get() -> u32 { return value.number; } } fn inspect(object: &opaque Read) -> u32 { return object.get(); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeCall);
    }
}

/// An unsafe callback retains its requirement at an indirect call.
@test unsafe fn testUnsafeCallbackCallRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a,
        "fn run(callback: unsafe fn() -> u32) -> u32 { return callback(); }");
    try expectErrorKind(&result, super::ErrorKind::UnsafeCall);
    let mut testArena562 = testArena();
    let testStorage562: 'test562 = &mut testArena562 in {
        let mut a = testResolver(testStorage562);
        let result = try resolveProgramStr(&mut a,
            "fn run(callback: unsafe fn() -> u32) -> u32 { return callback(); }");
        try expectErrorKind(&result, super::ErrorKind::UnsafeCall);
    }
}

/// An unsafe function cannot enter a safe callback slot.
@test unsafe fn testUnsafeCallbackAssignmentRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a,
        "unsafe fn load() -> u32 { return 1; } fn run() { let callback: fn() -> u32 = load; }");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena563 = testArena();
    let testStorage563: 'test563 = &mut testArena563 in {
        let mut a = testResolver(testStorage563);
        let result = try resolveProgramStr(&mut a,
            "unsafe fn load() -> u32 { return 1; } fn run() { let callback: fn() -> u32 = load; }");
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// A safe function can enter an unsafe callback slot.
@test unsafe fn testSafeCallbackIntoUnsafeSlot() throws (testing::TestError) {
    try expectAnalyzeOk(
        "fn load() -> u32 { return 1; } unsafe fn run() -> u32 { let callback: unsafe fn() -> u32 = load; return callback(); }");
}

/// Borrowed callback storage must preserve its function safety type.
@test unsafe fn testBorrowedCallbackSafetyInvariant() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a,
        "fn replace(slot: &mut unsafe fn()) {} fn load() {} fn run() { let mut callback: fn() = load; replace(&mut callback); }");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
    let mut testArena564 = testArena();
    let testStorage564: 'test564 = &mut testArena564 in {
        let mut a = testResolver(testStorage564);
        let result = try resolveProgramStr(&mut a,
            "fn replace(slot: &mut unsafe fn()) {} fn load() {} fn run() { let mut callback: fn() = load; replace(&mut callback); }");
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Referenced storage must preserve its exact element type in every context.
@test unsafe fn testPointerStorageCoercionsRejected() throws (testing::TestError) {
    let programs = &[

        "fn take(p: *[?*u8]) {} fn run(p: *[*u8]) { take(p); }",
        "unsafe fn take(p: *mut [?*u8]) {} unsafe fn run(p: *mut [*u8]) { take(p); }",
        "fn take(p: &mut **u8) {} fn run(p: &mut *mut *u8) { take(p); }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
        let mut testArena565 = testArena();
        let testStorage565: 'test565 = &mut testArena565 in {
            let mut a = testResolver(testStorage565);
            let result = try resolveProgramStr(&mut a, program);
            let err = try expectError(&result);
            let case super::ErrorKind::TypeMismatch(_) = err.kind
                else throw testing::TestError::Failed;
        }
    }
    try expectAnalyzeOk("fn take(p: &mut ?*u8) {} fn run() { let mut p: ?*u8 = nil; take(&mut p); }");
    try expectAnalyzeOk("fn run(p: *mut u8) -> *u8 { return p; }");
    try expectAnalyzeOk("fn run(p: *u8) -> *opaque { return p; }");
}

        "unsafe fn run(p: *mut ?*u8) { p as *mut *u8; }",
        "unsafe fn run(p: *unsafe mut *u8) { p as *unsafe mut ?*u8; }",
        "unsafe fn run(p: *mut [*u8]) { p as *mut [?*u8]; }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
        let mut testArena566 = testArena();
        let testStorage566: 'test566 = &mut testArena566 in {
            let mut a = testResolver(testStorage566);
            let result = try resolveProgramStr(&mut a, program);
            let err = try expectError(&result);
            let case super::ErrorKind::InvalidAsCast(_) = err.kind
                else throw testing::TestError::Failed;
        }
    }
}

/// Pattern references prevent replacement of their source in every context.
@test unsafe fn testPatternLoanMutationRejected() throws (testing::TestError) {

        "union U: Copy { A(u64), B(u64) } fn run() { let mut u = U::A(7); match &mut u { case U::A(p) => { unsafe { set u = U::B(1); } *p; } else => {} } }",
        "union U: Copy { A(u64), B(u64) } fn change(u: &mut U) { set *u = U::B(1); } fn run() { let mut u = U::A(7); match &u { case U::A(p) => { change(&mut u); *p; } else => {} } }",
        "union U: Copy { A(u64), B(u64) } fn run() { let mut u = U::A(7); if let case U::A(p) = &u { set u = U::B(1); *p; } }",
        "union U: Copy { A(u64), B(u64) } fn run() { let mut u = U::A(7); while let case U::A(p) = &u { set u = U::B(1); *p; } }",
        "union U: Copy { A(u64), B(u64) } fn run(u: *mut U) { match u { case U::A(p) => { let moved = u; *p; } else => {} } }",
        "record R: 'r + Copy { p: &'r u32 } fn run 'r (p: &'r u32) { let mut u = R 'r { p }; match &u { case R { p: q } => { set u = R 'r { p }; **q; } else => {} } }",
        "record R: 'r + Copy { p: &'r u32 } unsafe fn run 'r (p: &'r u32) { let mut u = R 'r { p }; match &u { case R { p: q } => { set u = R 'r { p }; **q; } else => {} } }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("u"));
        let mut testArena567 = testArena();
        let testStorage567: 'test567 = &mut testArena567 in {
            let mut a = testResolver(testStorage567);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::BorrowConflict("u"));
        }
    }
}

/// Pattern loans end at their scope and permit writes through mutable payload references.
@test unsafe fn testPatternLoanScopeAllowed() throws (testing::TestError) {

    let programs = &[
        "static DATA: u8 = 7; union U: Copy { A(*u8), B(u64) } fn run() -> u8 { let mut u = U::A(&DATA); match &u { case U::A(p) => { set u = U::B(1); return **p; } else => return 0, } }",
        "static DATA: u8 = 7; union U: Copy { A(*u8), B(u64) } unsafe fn run() -> u8 { let mut u = U::A(&DATA); match &u { case U::A(p) => { set u = U::B(1); return **p; } else => return 0, } }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("u"));
        let mut testArena568 = testArena();
        let testStorage568: 'test568 = &mut testArena568 in {
            let mut a = testResolver(testStorage568);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::BorrowConflict("u"));
        }
    }
}

/// Guards, nested patterns, and unsafe calls must preserve pattern source storage.
@test unsafe fn testPatternLoanIndirectMutationRejected() throws (testing::TestError) {

        "union U: Copy { A(u64), B(u64) } record R: Copy { value: U } fn run() { let mut u = R { value: U::A(7) }; match &u.value { case U::A(p) => { set u.value = U::B(1); *p; } else => {} } }",
        "union U: Copy { A(u64), B(u64) } fn run() { let mut u = [U::A(7)]; match &u[0] { case U::A(p) => { set u[0] = U::B(1); *p; } else => {} } }",
        "union U: Copy { A(u64), B(u64) } unsafe fn (u: *unsafe mut U) change() { set *u = U::B(1); } unsafe fn run(u: *unsafe mut U) { match u { case U::A(p) => { u.change(); *p; } else => {} } }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("u"));
        let mut testArena569 = testArena();
        let testStorage569: 'test569 = &mut testArena569 in {
            let mut a = testResolver(testStorage569);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::BorrowConflict("u"));
        }
    }
}

/// Binding mutability does not permit writes through immutable pointers.
@test unsafe fn testMutableBindingImmutableTargetRejected() throws (testing::TestError) {

        "static DATA: [u8; 1] = [0]; fn run() { let mut p = &DATA; let q = &mut p[0]; }",
        "record R: Copy { n: u8 } fn (r: &mut R) change() { set r.n = 1; } fn run(input: *R) { let mut p = input; p.change(); }",
        "fn run(p: *mut u8, q: *mut u8) { set p = q; }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        let mut testArena570 = testArena();
        let testStorage570: 'test570 = &mut testArena570 in {
            let mut a = testResolver(testStorage570);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        }
    }
}

/// Mutable targets support access through fixed and mutable pointer bindings.
@test unsafe fn testMutablePointerTargetsAllowed() throws (testing::TestError) {

        "union U: Copy { A(u8), B } fn run(p: *unsafe U) { if let case U::A(n) = p { *n; } }",
        "union U: Copy { A(u8), B } fn run(p: *unsafe U) { while let case U::A(n) = p { *n; break; } }",
        "record R: Copy { n: u8 } fn run(p: *unsafe R) { let case R { n } = p else return; }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        let mut testArena571 = testArena();
        let testStorage571: 'test571 = &mut testArena571 in {
            let mut a = testResolver(testStorage571);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    }
}

/// Unsafe contexts permit pattern access through raw pointers.
@test unsafe fn testRawPointerPatternsAllowed() throws (testing::TestError) {

        "record A { func: fn(*mut opaque, u32, u32) -> *opaque, ctx: *mut opaque } fn run(s: *mut [u8], a: A) { s.append(1, a); }",
        "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: u64 } fn run(s: *mut [u8], a: A) { s.append(1, a); }",
        "union E: Copy { Bad } record A { func: fn(*mut opaque, u32, u32) -> *mut opaque throws (E), ctx: *mut opaque } fn run(s: *mut [u8], a: A) { s.append(1, a); }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::InvalidSliceAllocator);
        let mut testArena572 = testArena();
        let testStorage572: 'test572 = &mut testArena572 in {
            let mut a = testResolver(testStorage572);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::InvalidSliceAllocator);
        }
    }
}

/// Slice allocators can use raw context pointers.
@test unsafe fn testSliceAppendRawContextAllowed() throws (testing::TestError) {

        "union U: Copy { A(*u8), B(u64) } fn run(p: *mut U) -> u8 { let q = p; match p { case U::A(n) => { set *q = U::B(1); return **n; } else => return 0, } }",
        "union U: Copy { A(u8), B } fn change(p: &mut U) { set *p = U::B; } fn run(p: *mut U) { let q = p; if let case U::A(n) = p { change(q); *n; } }",
        "union U: Copy { A(u8), B } fn run(p: *mut U) { let q = p; let r = q; while let case U::A(n) = p { set *r = U::B; *n; break; } }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        let _ = try expectError(&result);
        let mut testArena573 = testArena();
        let testStorage573: 'test573 = &mut testArena573 in {
            let mut a = testResolver(testStorage573);
            let result = try resolveProgramStr(&mut a, program);
            let _ = try expectError(&result);
        }
    }
}

/// Every access to a moved safe mutable pointer is rejected.
@test unsafe fn testMutablePointerMovesRejected() throws (testing::TestError) {

        "trait T { fn (&T) read(); } fn run(p: *mut opaque T) { let q = p; p.read(); }",
        "fn run(p: *mut u8, flag: bool) { if flag { let q = p; } *p; }",
        "fn run(p: *mut u8) { loop { let q = p; } }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        let _ = try expectError(&result);
        let mut testArena574 = testArena();
        let testStorage574: 'test574 = &mut testArena574 in {
            let mut a = testResolver(testStorage574);
            let result = try resolveProgramStr(&mut a, program);
            let _ = try expectError(&result);
        }
    }
}

/// Copy composites cannot contain safe mutable owners or their containers.
@test unsafe fn testCopyMutablePointerFieldsRejected() throws (testing::TestError) {

        "record R: Copy { p: *mut [u8] }",
        "trait T {} record R: Copy { p: *mut opaque T }",
        "record Inner { p: *mut u8 } record Outer: Copy { inner: Inner }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::CopyContainsNonCopy);
        let mut testArena575 = testArena();
        let testStorage575: 'test575 = &mut testArena575 in {
            let mut a = testResolver(testStorage575);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::CopyContainsNonCopy);
        }
    }
}

/// Moves transfer safe mutable pointers, and calls can borrow them temporarily.
@test unsafe fn testMutablePointerMovesAllowed() throws (testing::TestError) {

    try expectAnalyzeOk("record R: Copy { p: *unsafe mut u8 } unsafe fn run(p: *unsafe mut u8) { let q = p; set *p = 1; set *q = 2; }");
    try expectAnalyzeOk("record R: Copy { p: *unsafe mut [u8] } unsafe fn run(p: *unsafe mut [u8]) { let q = p; set p[0] = 1; set q[0] = 2; }");
}

/// Function signature inspection uses immutable descriptors in safe code.
fn expectImmutableFunctionSignatures(res: &super::Resolver, root: *ast::Node) throws (testing::TestError) {
fn expectImmutableFunctionSignatures 'arena (res: &super::Resolver 'arena, root: *ast::Node) throws (testing::TestError) {
    let first = try typeOf(res, try getBlockStmt(root, 0));
    let equivalent = try typeOf(res, try getBlockStmt(root, 1));
    let throwing = try typeOf(res, try getBlockStmt(root, 2));
    let unsafeCall = try typeOf(res, try getBlockStmt(root, 3));
    try testing::expect(super::typesEqual(first, equivalent));

    try testing::expect(not super::typesEqual(first, unsafeCall));
}

/// Local analysis state does not change function signature identity.
@test unsafe fn testImmutableFunctionSignatures() throws (testing::TestError) {
    let mut res = testResolver();
    let result = try resolveProgramStr(&mut res,
        "fn first(x: u8) -> u32 { return 0; } fn equivalent(y: u8) -> u32 { let a: u32 = 1; return a; } fn throwing(x: u8) -> u32 throws (u8) { throw x; } unsafe fn unsafeCall(x: u8) -> u32 { return 0; }");
    try expectNoErrors(&result);
    try expectImmutableFunctionSignatures(&res, result.root);
    let mut testArena576 = testArena();
    let testStorage576: 'test576 = &mut testArena576 in {
        let mut res = testResolver(testStorage576);
        let result = try resolveProgramStr(&mut res,
            "fn first(x: u8) -> u32 { return 0; } fn equivalent(y: u8) -> u32 { let a: u32 = 1; return a; } fn throwing(x: u8) -> u32 throws (u8) { throw x; } unsafe fn unsafeCall(x: u8) -> u32 { return 0; }");
        try expectNoErrors(&result);
        try expectImmutableFunctionSignatures(&res, result.root);
    }
}

/// A diagnostic snapshot keeps its contents when the resolver buffer changes.
@test unsafe fn testDiagnosticSnapshotOwnsItsErrors() throws (testing::TestError) {
    let mut res = testResolver();
    let result = try resolveProgramStr(&mut res, "fn run() { missing; }");
    let snapshot = result.diagnostics;
    let original = super::errorAt(snapshot.errors, 0) else throw testing::TestError::Failed;
    set res.errors.entries[0] = super::Error {
        kind: super::ErrorKind::Internal, node: nil, moduleId: 0,
    };
    let later = super::diagnostics(&mut res);
    try testing::expect(snapshot.errors.len == 1);
    try testing::expect(later.errors.len == 1);
    let first = super::errorAt(snapshot.errors, 0) else throw testing::TestError::Failed;
    try testing::expect(first.kind == original.kind);
    try testing::expect(later.errors[0].kind == super::ErrorKind::Internal);
    try testing::expect(super::errorAt(snapshot.errors, 1) == nil);
    let mut testArena577 = testArena();
    let testStorage577: 'test577 = &mut testArena577 in {
        let mut res = testResolver(testStorage577);
        let result = try resolveProgramStr(&mut res, "fn run() { missing; }");
        let snapshot = result.diagnostics;
        let original = super::errorAt(snapshot.errors, 0) else throw testing::TestError::Failed;
        set res.errors.entries[0] = super::Error {
            kind: super::ErrorKind::Internal, node: nil, moduleId: 0,
        };
        let later = super::diagnostics(&mut res);
        try testing::expect(snapshot.errors.len == 1);
        try testing::expect(later.errors.len == 1);
        let first = super::errorAt(snapshot.errors, 0) else throw testing::TestError::Failed;
        try testing::expect(first.kind == original.kind);
        try testing::expect(later.errors[0].kind == super::ErrorKind::Internal);
        try testing::expect(super::errorAt(snapshot.errors, 1) == nil);
    }
}

/// Prefixes, equal fields, and uncertain element locations must conflict.
@test unsafe fn testOverlappingFieldBorrows() throws (testing::TestError) {
    let programs = &[

        "record R: Copy { a: u32, b: u32 } fn take(a: &mut R, b: &u32) {} fn run(r: &mut R) { take(r, &r.b); }",
        "record R: Copy { a: [u8; 2], b: [u8; 2] } fn take(a: &mut u8, b: &u8) {} fn run(r: &mut R) { take(&mut r.a[0], &r.a[1]); }",
        "record R: Copy { a: u32, b: u32 } fn take(a: &mut u32, b: u32) {} fn run(r: &mut R) { take(&mut r.a, r.a); }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("r"));
        let mut testArena578 = testArena();
        let testStorage578: 'test578 = &mut testArena578 in {
            let mut a = testResolver(testStorage578);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::BorrowConflict("r"));
        }
    }
}

/// Local loans exclude writes, competing references, and source reads.
@test unsafe fn testLocalReferenceConflicts() throws (testing::TestError) {

        "fn take(p: &mut u32) {} fn run() { let mut n: u32 = 4; let p = &n; take(&mut n); }",
        "fn run() { let mut n: u32 = 4; let p = &n; unsafe { set n = 1; } }",
        "fn run() { let mut n: u32 = 4; let p = &mut n; let q = &*p; let moved = p; }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("n"));
        let mut testArena579 = testArena();
        let testStorage579: 'test579 = &mut testArena579 in {
            let mut a = testResolver(testStorage579);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::BorrowConflict("n"));
        }
    }
}

/// Reference bindings cannot outlive temporary storage or change their source.
@test unsafe fn testLocalReferenceStorage() throws (testing::TestError) {
    let programs = &[
        "fn f 'r (p: &'r mut u32) { let mut cursor = p; }",
        "unsafe fn f 'r (p: &'r mut u32) { let mut cursor = p; }",
        "fn run() { let n: u32 = 4; let mut p: &u32 = &n; }",
        "record R: Copy { n: u32 } fn make() -> R { return R { n: 4 }; } fn run() { let p: &u32 = &make().n; }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::RefBinding);
        let mut testArena580 = testArena();
        let testStorage580: 'test580 = &mut testArena580 in {
            let mut a = testResolver(testStorage580);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::RefBinding);
        }
    }
}

/// Stored and returned values cannot contain a local reference.
@test unsafe fn testLocalReferenceEscapeRejected() throws (testing::TestError) {

        "fn run() -> *u32 { let n: u32 = 1; let p = &n; return p as *u32; }",
        "static DATA: u32 = 0; static P: *u32 = &DATA; fn run() { let n: u32 = 1; let p = &n; set P = p; }",
        "record R: Copy { p: *u32 } fn run() { let n: u32 = 1; let p = &n; let r = R { p }; }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        let _ = try expectError(&result);
        let mut testArena581 = testArena();
        let testStorage581: 'test581 = &mut testArena581 in {
            let mut a = testResolver(testStorage581);
            let result = try resolveProgramStr(&mut a, program);
            let _ = try expectError(&result);
        }
    }
}

/// Pointer indirection cannot prove that sibling pointees are disjoint.
@test unsafe fn testIndirectFieldBorrowConflict() throws (testing::TestError) {
    let programs = &[
        "record R: Copy { a: *unsafe mut u32, b: *unsafe mut u32 } fn take(a: &mut u32, b: &mut u32) {} unsafe fn run(r: &mut R) { take(&mut *r.a, &mut *r.b); }",
        "record R: Copy { a: *unsafe mut u32, b: *unsafe mut u32 } unsafe fn run(r: &mut R) { let a: &mut u32 = &mut *r.a; let b: &mut u32 = &mut *r.b; }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("r"));
        let mut testArena582 = testArena();
        let testStorage582: 'test582 = &mut testArena582 in {
            let mut a = testResolver(testStorage582);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::BorrowConflict("r"));
        }
    }
}

/// Pattern references protect their field and permit writes to disjoint fields.
@test unsafe fn testDisjointPatternFieldBorrow() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a,
        "union U: Copy { A(u32), B } record R: Copy { u: U, n: u32 } fn run(r: &mut R) { let alias = &mut r.u; match alias { case U::A(p) => { set *alias = U::B; *p; } else => {} } }");
    try expectErrorKind(&result, super::ErrorKind::BorrowConflict("r"));
    let mut testArena583 = testArena();
    let testStorage583: 'test583 = &mut testArena583 in {
        let mut a = testResolver(testStorage583);
        let result = try resolveProgramStr(&mut a,
            "union U: Copy { A(u32), B } record R: Copy { u: U, n: u32 } fn run(r: &mut R) { let alias = &mut r.u; match alias { case U::A(p) => { set *alias = U::B; *p; } else => {} } }");
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("r"));
    }
}

/// Slice mutations must preserve storage held by a local reference.
@test unsafe fn testLocalReferenceSliceMutationRejected() throws (testing::TestError) {
    let programs = &[
        "fn run(s: *mut [u8]) { let p: &u8 = &s[0]; s.delete(0); }",
        "record A: Copy { func: unsafe fn(*unsafe mut opaque, u32, u32) -> *mut opaque, ctx: *unsafe mut opaque } fn run(s: *mut [u8], a: A) { let p: &u8 = &s[0]; s.append(1, a); }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("s"));
        let mut testArena584 = testArena();
        let testStorage584: 'test584 = &mut testArena584 in {
            let mut a = testResolver(testStorage584);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::BorrowConflict("s"));
        }
    }
}

/// Owner moves and mutable methods cannot invalidate a local loan.
@test unsafe fn testLocalReferenceOwnerMutationRejected() throws (testing::TestError) {
    let programs = &[
        "fn run(p: *mut u32) { let r: &u32 = &*p; let moved = p; }",
        "record R: Copy { a: u32 } fn (p: &mut R) change() { set p.a = 1; } fn run(p: &mut R) { let r = &p.a; p.change(); }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("p"));
        let mut testArena585 = testArena();
        let testStorage585: 'test585 = &mut testArena585 in {
            let mut a = testResolver(testStorage585);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::BorrowConflict("p"));
        }
    }
}

/// Reference locals require a function scope and a reachable initializer result.
@test unsafe fn testLocalReferenceDeclarationContext() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let n: u32 = 1; let p: &u32 = &n;");
    try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
    let mut testArena586 = testArena();
    let testStorage586: 'test586 = &mut testArena586 in {
        let mut a = testResolver(testStorage586);
        let result = try resolveProgramStr(&mut a, "let n: u32 = 1; let p: &u32 = &n;");
        try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
    }
}

/// Test-only imports do not require their modules in a normal build.
@test unsafe fn testConditionalUse() throws (testing::TestError) {
    let mut testArena587 = testArena();
    let testStorage587: 'test587 = &mut testArena587 in {
        let mut a = testResolver(testStorage587);
        set a.config.buildTest = false;
        let source = "@test use missing::testing; fn value() -> u32 { return 1; }";
        let result = try resolveProgramStr(&mut a, source);
        try expectNoErrors(&result);
        set a.config.buildTest = true;
        let enabled = try resolveProgramStr(&mut a, source);
        try testing::expect(enabled.diagnostics.errors.len > 0);
    }
}

/// Resolver metadata retains its caller's arena when the context moves.
unsafe fn relocateResolver 'arena (context: super::Resolver 'arena) -> super::Resolver 'arena {
    return context;
}

@test unsafe fn testResolverRelocation() throws (testing::TestError) {
    static DATA: [u8; 65536] = [0; 65536];
    static AST_DATA: [u8; 8192] = [0; 8192];
    static NODES: [super::NodeData; 128] = undefined;
    static ERRORS: [super::Error; 8] = undefined;
    static SCOPE: super::Scope = undefined;
    static POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
    let mut arena = alloc::new(&mut DATA[..]);
    let mut astArena = ast::nodeArena(&mut AST_DATA[..]);
    let root = try! parser::parse(scanner::SourceLoc::String,
        "fn answer() -> u32 { return 42; }", &mut astArena, &mut POOL);
    let storage = super::ResolverStorage {
        nodeData: &mut NODES[..], pkgScope: &mut SCOPE, errors: &mut ERRORS[..],
    };
    let arenaRef: 'arena = &mut arena in {
        let context = super::resolver(arenaRef, storage, super::Config { buildTest: false });
        let initialized = alloc::used(context.arena);
        try testing::expect(initialized > 0);
        let mut moved = relocateResolver(context);
        let diagnostics = try! super::resolveModuleRoot(&mut moved, root);
        try testing::expect(super::success(&diagnostics));
        try testing::expect(alloc::used(moved.arena) > initialized);
        try testing::expect(moved.arena.offset == alloc::used(moved.arena));
        let output = try! alloc::alloc(&mut *moved.arena, @sizeOf(u32), @alignOf(u32)) as *mut u32;
        set *output = 42;
        try testing::expect(*output == 42);
    }
}

lib/std/lang/resolver/tests/regions.rad added +1251 -0

1	+	//! Lexical region resolver tests.
2	+
3	+	use std::mem;
4	+	use std::testing;
5	+	use std::lang::types;
6	+	use std::lang::resolver;
7	+
8	+	/// Equal region spellings in separate functions have distinct identities.
9	+	@test unsafe fn testRegionIdentities() throws (testing::TestError) {
10	+	let mut testArena1 = super::testArena();
11	+	let testStorage1: 'test1 = &mut testArena1 in {
12	+	let mut res = super::testResolver(testStorage1);
13	+	let result = try super::resolveProgramStr(&mut res,
14	+	"fn first 'r (p: &'r u8) -> u8 { return p; }\nfn second 'r (p: &'r u8) -> u8 { return p; }"
15	+	);
16	+	try super::expectNoErrors(&result);
17	+	let first = try super::getBlockStmt(result.root, 0);
18	+	let second = try super::getBlockStmt(result.root, 1);
19	+	let firstType = resolver::typeFor(&res, first) else throw testing::TestError::Failed;
20	+	let secondType = resolver::typeFor(&res, second) else throw testing::TestError::Failed;
21	+	let case resolver::Type::Fn(a) = firstType else throw testing::TestError::Failed;
22	+	let case resolver::Type::Fn(b) = secondType else throw testing::TestError::Failed;
23	+	let case resolver::Type::Pointer { class: types::PointerClass::Region(ar), .. } = *a.paramTypes[0]
24	+	else throw testing::TestError::Failed;
25	+	let case resolver::Type::Pointer { class: types::PointerClass::Region(br), .. } = *b.paramTypes[0]
26	+	else throw testing::TestError::Failed;
27	+	try testing::expect(mem::eq(ar.name, br.name));
28	+	try testing::expect(ar.id <> br.id);
29	+	try testing::expect(not resolver::typesEqual(a.paramTypes[0], b.paramTypes[0]));
30	+	try testing::expect(resolver::getTypeLayout(*a.paramTypes[0]).size == 8);
31	+	}
32	+	}
33	+
34	+	/// Parent links resolve forward declarations and preserve transitive ancestry.
35	+	@test unsafe fn testRegionParents() throws (testing::TestError) {
36	+	let mut testArena2 = super::testArena();
37	+	let testStorage2: 'test2 = &mut testArena2 in {
38	+	let mut res = super::testResolver(testStorage2);
39	+	let result = try super::resolveProgramStr(&mut res,
40	+	"fn read 'child 'middle 'root (p: &'child u8, q: &'root u8) where 'middle: 'child, 'root: 'middle {}"
41	+	);
42	+	try super::expectNoErrors(&result);
43	+	let func = try super::getBlockStmt(result.root, 0);
44	+	let ty = resolver::typeFor(&res, func) else throw testing::TestError::Failed;
45	+	let case resolver::Type::Fn(info) = ty else throw testing::TestError::Failed;
46	+	let case resolver::Type::Pointer { class: types::PointerClass::Region(child), .. } = *info.paramTypes[0]
47	+	else throw testing::TestError::Failed;
48	+	let case resolver::Type::Pointer { class: types::PointerClass::Region(root), .. } = *info.paramTypes[1]
49	+	else throw testing::TestError::Failed;
50	+	try testing::expect(types::regionContains(root, child));
51	+	try testing::expect(types::regionContains(child, child));
52	+	try testing::expect(not types::regionContains(child, root));
53	+	}
54	+	}
55	+
56	+	/// Region declarations reject duplicate names, missing parents, and cycles.
57	+	@test unsafe fn testInvalidRegionDeclarations() throws (testing::TestError) {
58	+	for program in [
59	+	"fn f 'r 'r () {}",
60	+	"fn f 'r () where 'missing: 'r {}",
61	+	"fn f 'r () where 'r: 'r {}",
62	+	"fn f 'a 'b 'c () where 'b: 'a, 'c: 'b, 'a: 'c {}",
63	+	] {
64	+	let mut testArena3 = super::testArena();
65	+	let testStorage3: 'test3 = &mut testArena3 in {
66	+	let mut res = super::testResolver(testStorage3);
67	+	let result = try super::resolveProgramStr(&mut res, program);
68	+	let _ = try super::expectError(&result);
69	+	}
70	+	}
71	+	}
72	+
73	+	/// Regions from another declaration cannot enter a function signature or body.
74	+	@test unsafe fn testUnknownRegionNames() throws (testing::TestError) {
75	+	for program in [
76	+	"fn f(p: &'missing u8) {}",
77	+	"fn f 'r (p: &'r u8) {} fn g(p: &'r u8) {}",
78	+	"unsafe fn f(p: &'missing u8) {}",
79	+	"fn f 'r (p: &'r u8) { let q: &'missing u8 = p; }",
80	+	] {
81	+	let mut testArena4 = super::testArena();
82	+	let testStorage4: 'test4 = &mut testArena4 in {
83	+	let mut res = super::testResolver(testStorage4);
84	+	let result = try super::resolveProgramStr(&mut res, program);
85	+	let err = try super::expectError(&result);
86	+	let case resolver::ErrorKind::UnknownRegion(_) = err.kind
87	+	else throw testing::TestError::Failed;
88	+	}
89	+	}
90	+	}
91	+
92	+	/// An ancestor relation does not make distinct reference regions assignable.
93	+	@test unsafe fn testRegionInvariance() throws (testing::TestError) {
94	+	for program in [
95	+	"fn f 'a 'b (p: &'a u8) where 'a: 'b { let q: &'b u8 = p; }",
96	+	"unsafe fn f 'a 'b (p: &'b u8) where 'a: 'b { let q: &'a u8 = p; }",
97	+	] {
98	+	let mut testArena5 = super::testArena();
99	+	let testStorage5: 'test5 = &mut testArena5 in {
100	+	let mut res = super::testResolver(testStorage5);
101	+	let result = try super::resolveProgramStr(&mut res, program);
102	+	let err = try super::expectError(&result);
103	+	let case resolver::ErrorKind::TypeMismatch(_) = err.kind
104	+	else throw testing::TestError::Failed;
105	+	}
106	+	}
107	+	}
108	+
109	+	/// Nominal region environments diagnose their own invalid parent relations.
110	+	@test unsafe fn testNominalRegionNames() throws (testing::TestError) {
111	+	for program in [
112	+	"record R: 'r where 'missing: 'r { value: u8 }",
113	+	"union U: 'r where 'missing: 'r { Empty }",
114	+	"record R: 'r { value: &'other u8 }",
115	+	"union U: 'r { Value(&'other u8) }",
116	+	] {
117	+	let mut testArena6 = super::testArena();
118	+	let testStorage6: 'test6 = &mut testArena6 in {
119	+	let mut res = super::testResolver(testStorage6);
120	+	let result = try super::resolveProgramStr(&mut res, program);
121	+	let err = try super::expectError(&result);
122	+	let case resolver::ErrorKind::UnknownRegion(_) = err.kind
123	+	else throw testing::TestError::Failed;
124	+	}
125	+	}
126	+	for program in [
127	+	"record R: 'r + 'r { value: u8 }",
128	+	"union U: 'r + 'r { Empty }",
129	+	] {
130	+	let mut testArena7 = super::testArena();
131	+	let testStorage7: 'test7 = &mut testArena7 in {
132	+	let mut res = super::testResolver(testStorage7);
133	+	let result = try super::resolveProgramStr(&mut res, program);
134	+	let _ = try super::expectErrorKind(&result, resolver::ErrorKind::DuplicateBinding("'r"));
135	+	}
136	+	}
137	+	}
138	+
139	+	/// Region declarations restore their environment after a signature error.
140	+	@test unsafe fn testRegionErrorScopeRestoration() throws (testing::TestError) {
141	+	let mut testArena8 = super::testArena();
142	+	let testStorage8: 'test8 = &mut testArena8 in {
143	+	let mut res = super::testResolver(testStorage8);
144	+	let result = try super::resolveProgramStr(&mut res,
145	+	"fn f 'r (p: &'missing u8) {} fn g 'other (p: &'r u8) {}"
146	+	);
147	+	let err = try super::expectError(&result);
148	+	let case resolver::ErrorKind::UnknownRegion(name) = err.kind
149	+	else throw testing::TestError::Failed;
150	+	try testing::expect(mem::eq(name, "'missing"));
151	+	try testing::expect(res.regionScope == nil);
152	+	try testing::expect(res.currentFn == nil);
153	+	try testing::expect(res.currentFnNode == nil);
154	+	}
155	+	}
156	+
157	+	/// Regional exclusive references retain affine ownership and arithmetic checks.
158	+	@test unsafe fn testRegionExclusiveOwnership() throws (testing::TestError) {
159	+	for program in [
160	+	"fn f 'r (p: &'r mut u8) { let q: &'r mut u8 = p; set *p = 3; }",
161	+	"unsafe fn f 'r (p: &'r mut u8) { let q: &'r mut u8 = p; set *p = 3; }",
162	+	"unsafe fn f 'r (p: &'r mut u8) { let q = p + 1; }",
163	+	"unsafe fn f 'r (p: &'r mut u8) { let q = p as *mut u8; }",
164	+	] {
165	+	let mut testArena9 = super::testArena();
166	+	let testStorage9: 'test9 = &mut testArena9 in {
167	+	let mut res = super::testResolver(testStorage9);
168	+	let result = try super::resolveProgramStr(&mut res, program);
169	+	let _ = try super::expectError(&result);
170	+	}
171	+	}
172	+	}
173	+
174	+	/// Callback signatures preserve the same region substitution as data arguments.
175	+	@test unsafe fn testRegionCallbackSubstitution() throws (testing::TestError) {
176	+	let mut testArena10 = super::testArena();
177	+	let testStorage10: 'test10 = &mut testArena10 in {
178	+	let mut res = super::testResolver(testStorage10);
179	+	let result = try super::resolveProgramStr(&mut res, "fn read 'r (p: &'r u32) -> u32 { return *p; } fn useOp 'r (p: &'r u32, op: fn(&'r u32) -> u32) -> u32 { return op(p); } fn relay 'a 'b (p: &'a u32) -> u32 { return useOp(p, read 'b); }");
180	+	let err = try super::expectError(&result);
181	+	let case resolver::ErrorKind::RegionInference(_) = err.kind else throw testing::TestError::Failed;
182	+	}
183	+	}
184	+
185	+	/// A single region parameter requires one consistent named argument.
186	+	@test unsafe fn testRegionCallInferenceFailures() throws (testing::TestError) {
187	+	for program in [
188	+	"fn pair 'r (a: &'r u32, b: &'r u32) {} fn relay 'a 'b (a: &'a u32, b: &'b u32) { pair(a, b); }",
189	+	"fn read 'r (p: &'r u32) {} fn relay(p: &u32) { read(p); }",
190	+	"unsafe fn read 'r (p: &'r u32) {} unsafe fn relay(p: *unsafe u32) { read(p); }",
191	+	"fn answer 'r () -> u32 { return 42; } fn relay() -> u32 { return answer(); }",
192	+	"fn read 'r (p: ?&'r u32) {} fn relay() { read(nil); }",
193	+	"unsafe fn read 'r (p: ?&'r u32) {} unsafe fn relay() { read(nil); }",
194	+	] {
195	+	let mut testArena11 = super::testArena();
196	+	let testStorage11: 'test11 = &mut testArena11 in {
197	+	let mut res = super::testResolver(testStorage11);
198	+	let result = try super::resolveProgramStr(&mut res, program);
199	+	let err = try super::expectError(&result);
200	+	let case resolver::ErrorKind::RegionInference(_) = err.kind else throw testing::TestError::Failed;
201	+	}
202	+	}
203	+	}
204	+
205	+	/// Inferred and explicit region arguments must satisfy declared parent relations.
206	+	@test unsafe fn testRegionCallParents() throws (testing::TestError) {
207	+	for program in [
208	+	"fn pair 'p 'c (p: &'p u32, c: &'c u32) where 'p: 'c {} fn relay 'a 'b (a: &'a u32, b: &'b u32) { pair(a, b); }",
209	+	"fn pair 'p 'c (p: &'p u32, c: &'c u32) where 'p: 'c {} unsafe fn relay 'a 'b (a: &'a u32, b: &'b u32) where 'a: 'b { pair 'b 'a (b, a); }",
210	+	] {
211	+	let mut testArena12 = super::testArena();
212	+	let testStorage12: 'test12 = &mut testArena12 in {
213	+	let mut res = super::testResolver(testStorage12);
214	+	let result = try super::resolveProgramStr(&mut res, program);
215	+	let err = try super::expectError(&result);
216	+	let case resolver::ErrorKind::RegionParent(_) = err.kind else throw testing::TestError::Failed;
217	+	}
218	+	}
219	+	}
220	+
221	+	/// Region applications require the declared arity and accessible names.
222	+	@test unsafe fn testExplicitRegionApplicationErrors() throws (testing::TestError) {
223	+	for program in [
224	+	"fn read 'r (p: &'r u32) {} fn relay 'a 'b (p: &'a u32) { read 'a 'b (p); }",
225	+	"fn read(p: &u32) {} fn relay 'a (p: &'a u32) { read 'a (p); }",
226	+	] {
227	+	let mut testArena13 = super::testArena();
228	+	let testStorage13: 'test13 = &mut testArena13 in {
229	+	let mut res = super::testResolver(testStorage13);
230	+	let result = try super::resolveProgramStr(&mut res, program);
231	+	let err = try super::expectError(&result);
232	+	let case resolver::ErrorKind::RegionArgumentCount(_) = err.kind else throw testing::TestError::Failed;
233	+	}
234	+	}
235	+	let mut testArena14 = super::testArena();
236	+	let testStorage14: 'test14 = &mut testArena14 in {
237	+	let mut res = super::testResolver(testStorage14);
238	+	let result = try super::resolveProgramStr(&mut res, "fn read 'r (p: &'r u32) {} fn relay 'a (p: &'a u32) { read 'missing (p); }");
239	+	let err = try super::expectError(&result);
240	+	let case resolver::ErrorKind::UnknownRegion(_) = err.kind else throw testing::TestError::Failed;
241	+	}
242	+	}
243	+
244	+	/// Region header loans stay active through moves and nested exclusive reborrows.
245	+	@test unsafe fn testConcreteBorrowConflicts() throws (testing::TestError) {
246	+	for program in [
247	+	"fn run() { let mut x: u32 = 1; let p: 'r = &mut x in { set x = 2; } }",
248	+	"unsafe fn run() { let mut x: u32 = 1; let p: 'r = &mut x in { set x = 2; } }",
249	+	"fn run() { let mut x: u32 = 1; let p: 'r = &mut x, q = &mut x in {} }",
250	+	"fn run() { let mut x: u32 = 1; let p: 'r = &x, q = &mut x in {} }",
251	+	"fn run() { let mut x: u32 = 1; let p: 'r = &mut x in { { let q = p; set *q = 2; } set x = 3; } }",
252	+	"fn run() { let mut x: u32 = 1; let p: 'a = &mut x in { let q: 'b = &mut p in { set p = 3; } } }",
253	+	"fn run(i: u32, j: u32) { let mut x: [u32; 2] = [1, 2]; let p: 'r = &mut x[i], q = &mut x[j] in {} }",
254	+	] {
255	+	let mut testArena15 = super::testArena();
256	+	let testStorage15: 'test15 = &mut testArena15 in {
257	+	let mut res = super::testResolver(testStorage15);
258	+	let result = try super::resolveProgramStr(&mut res, program);
259	+	let err = try super::expectError(&result);
260	+	let case resolver::ErrorKind::BorrowConflict(_) = err.kind else throw testing::TestError::Failed;
261	+	}
262	+	}
263	+	}
264	+
265	+	/// Borrow headers require existing places and accessible, distinct region names.
266	+	@test unsafe fn testConcreteRegionNamesAndSources() throws (testing::TestError) {
267	+	for program in [
268	+	"fn run() { let p: 'r = &1 in {} }",
269	+	"fn value() -> u32 { return 1; } fn run() { let p: 'r = &value() in {} }",
270	+	"fn run() { let x: u32 = 1; let p: 'r = &x in { let q: 'r = &x in {} } }",
271	+	"fn run() { let x: u32 = 1; let p: 'r = &x in {} let q: &'r u32 = &x; }",
272	+	"fn run 'a (p: &'a mut u32) { let q: 'b = &mut *p in {} }",
273	+	] {
274	+	let mut testArena16 = super::testArena();
275	+	let testStorage16: 'test16 = &mut testArena16 in {
276	+	let mut res = super::testResolver(testStorage16);
277	+	let result = try super::resolveProgramStr(&mut res, program);
278	+	let _ = try super::expectError(&result);
279	+	}
280	+	}
281	+
282	+	}
283	+
284	+	/// A block-local value cannot supply storage for the whole enclosing region.
285	+	@test unsafe fn testRegionLocalStorageBoundary() throws (testing::TestError) {
286	+	for program in [
287	+	"fn run() { let a: u32 = 1; let p: 'outer = &a in { let mut cursor = p; let b: u32 = 2; let q: 'inner = &b where 'outer: 'inner in { set cursor = q; } } }",
288	+	"unsafe fn run() { let a: u32 = 1; let p: 'outer = &a in { let mut cursor = p; let b: u32 = 2; let q: 'inner = &b where 'outer: 'inner in { set cursor = q; } } }",
289	+	"fn run() { let x: u32 = 1; let p: 'r = &x in { let y: u32 = 2; let q: &'r u32 = &y; } }",
290	+	"unsafe fn run() { let x: u32 = 1; let p: 'r = &x in { let y: u32 = 2; let q: &'r u32 = &y; } }",
291	+	"fn run() { let mut x: u32 = 1; let p: 'a = &mut x in { let q: 'b = &mut *p in { let outer: &'a mut u32 = q; } } }",
292	+	] {
293	+	let mut testArena17 = super::testArena();
294	+	let testStorage17: 'test17 = &mut testArena17 in {
295	+	let mut res = super::testResolver(testStorage17);
296	+	let result = try super::resolveProgramStr(&mut res, program);
297	+	let err = try super::expectError(&result);
298	+	let case resolver::ErrorKind::TypeMismatch(_) = err.kind else throw testing::TestError::Failed;
299	+	}
300	+	}
301	+
302	+	}
303	+
304	+	/// Generic calls keep the exclusive-argument overlap check after substitution.
305	+	@test unsafe fn testRegionCallBorrowOverlap() throws (testing::TestError) {
306	+	let mut testArena18 = super::testArena();
307	+	let testStorage18: 'test18 = &mut testArena18 in {
308	+	let mut res = super::testResolver(testStorage18);
309	+	let result = try super::resolveProgramStr(&mut res, "fn pair 'r (a: &'r mut u32, b: &'r mut u32) {} fn run() { let mut x: u32 = 1; let p: 'r = &mut x in { pair(p, p); } }");
310	+	let err = try super::expectError(&result);
311	+	let case resolver::ErrorKind::BorrowConflict(_) = err.kind else throw testing::TestError::Failed;
312	+	}
313	+	}
314	+
315	+	/// Exact arguments share one descriptor and all applications share the source layout.
316	+	@test unsafe fn testNominalRegionApplications() throws (testing::TestError) {
317	+	let mut testArena19 = super::testArena();
318	+	let testStorage19: 'test19 = &mut testArena19 in {
319	+	let mut res = super::testResolver(testStorage19);
320	+	let result = try super::resolveProgramStr(&mut res,
321	+	"record N: 'r + Copy { value: u32 } fn f 'a 'b (x: N 'a, y: N 'a, z: N 'b) {}"
322	+	);
323	+	try super::expectNoErrors(&result);
324	+	let func = try super::getBlockStmt(result.root, 1);
325	+	let fnType = resolver::typeFor(&res, func) else throw testing::TestError::Failed;
326	+	let case resolver::Type::Fn(info) = fnType else throw testing::TestError::Failed;
327	+	let case resolver::Type::Nominal(x) = *info.paramTypes[0] else throw testing::TestError::Failed;
328	+	let case resolver::Type::Nominal(y) = *info.paramTypes[1] else throw testing::TestError::Failed;
329	+	let case resolver::Type::Nominal(z) = *info.paramTypes[2] else throw testing::TestError::Failed;
330	+	try testing::expect(x == y);
331	+	try testing::expect(x <> z);
332	+	try testing::expect(not resolver::typesEqual(info.paramTypes[0], info.paramTypes[2]));
333	+	let a = resolver::nominalApplication(x) else throw testing::TestError::Failed;
334	+	let b = resolver::nominalApplication(z) else throw testing::TestError::Failed;
335	+	try testing::expect(a.base == b.base);
336	+	try testing::expect(a.arguments[0].id <> b.arguments[0].id);
337	+	let case resolver::NominalType::Record(base) = *a.base else throw testing::TestError::Failed;
338	+	let case resolver::NominalType::Record(first) = *x else throw testing::TestError::Failed;
339	+	let case resolver::NominalType::Record(second) = *z else throw testing::TestError::Failed;
340	+	try testing::expect(base.layout == first.layout);
341	+	try testing::expect(first.layout == second.layout);
342	+	try testing::expect(first.layout.size == 4);
343	+	}
344	+	}
345	+
346	+	/// Recursive fields refer to their own exact applied descriptor.
347	+	@test unsafe fn testRecursiveNominalApplications() throws (testing::TestError) {
348	+	let mut testArena20 = super::testArena();
349	+	let testStorage20: 'test20 = &mut testArena20 in {
350	+	let mut res = super::testResolver(testStorage20);
351	+	let result = try super::resolveProgramStr(&mut res,
352	+	"record N: 'r + Copy { next: ?*N 'r } fn f 'a 'b (x: N 'a, y: N 'b) {}"
353	+	);
354	+	try super::expectNoErrors(&result);
355	+	let func = try super::getBlockStmt(result.root, 1);
356	+	let fnType = resolver::typeFor(&res, func) else throw testing::TestError::Failed;
357	+	let case resolver::Type::Fn(info) = fnType else throw testing::TestError::Failed;
358	+	for parameter in info.paramTypes {
359	+	let case resolver::Type::Nominal(descriptor) = *parameter else throw testing::TestError::Failed;
360	+	let case resolver::NominalType::Record(body) = *descriptor else throw testing::TestError::Failed;
361	+	let case resolver::Type::Optional(inner) = body.fields[0].fieldType else throw testing::TestError::Failed;
362	+	let case resolver::Type::Pointer { target, .. } = *inner else throw testing::TestError::Failed;
363	+	try testing::expect(resolver::typesEqual(target, parameter));
364	+	try testing::expect(body.layout.size == 8);
365	+	}
366	+	}
367	+	}
368	+
369	+	/// An inline union payload retains its enclosing application's region arguments.
370	+	@test unsafe fn testNominalPayloadRegionCapture() throws (testing::TestError) {
371	+	let mut testArena21 = super::testArena();
372	+	let testStorage21: 'test21 = &mut testArena21 in {
373	+	let mut res = super::testResolver(testStorage21);
374	+	let result = try super::resolveProgramStr(&mut res,
375	+	"record N: 'r + Copy { value: u32 } union U: 'r + Copy { Link { node: *N 'r }, Empty } fn f 'a (u: U 'a, n: N 'a) {}"
376	+	);
377	+	try super::expectNoErrors(&result);
378	+	let func = try super::getBlockStmt(result.root, 2);
379	+	let fnType = resolver::typeFor(&res, func) else throw testing::TestError::Failed;
380	+	let case resolver::Type::Fn(info) = fnType else throw testing::TestError::Failed;
381	+	let case resolver::Type::Nominal(resolver::NominalType::Union(body)) = *info.paramTypes[0]
382	+	else throw testing::TestError::Failed;
383	+	let case resolver::Type::Nominal(resolver::NominalType::Record(payload)) = body.variants[0].valueType
384	+	else throw testing::TestError::Failed;
385	+	let case resolver::Type::Pointer { target, .. } = payload.fields[0].fieldType
386	+	else throw testing::TestError::Failed;
387	+	try testing::expect(resolver::typesEqual(target, info.paramTypes[1]));
388	+	let applied = body.application else throw testing::TestError::Failed;
389	+	let case resolver::NominalType::Union(base) = *applied.base else throw testing::TestError::Failed;
390	+	try testing::expect(body.layout == base.layout);
391	+	}
392	+	}
393	+
394	+	/// Nominal applications require exactly the declared number of region arguments.
395	+	@test unsafe fn testNominalRegionArgumentCount() throws (testing::TestError) {
396	+	for program in [
397	+	"record N: 'r { value: u32 } fn f(n: N) {}",
398	+	"record N { value: u32 } fn f 'r (n: N 'r) {}",
399	+	"record N: 'r + 's { value: u32 } fn f 'a (n: N 'a) {}",
400	+	"record N: 'r { value: u32 } fn f 'a 'b (n: N 'a 'b) {}",
401	+	"record N: 'r { value: u32 } fn f() { let n = N { value: 1 }; }",
402	+	"union U: 'r { Empty } fn f() { let u = U::Empty; }",
403	+	] {
404	+	let mut testArena22 = super::testArena();
405	+	let testStorage22: 'test22 = &mut testArena22 in {
406	+	let mut res = super::testResolver(testStorage22);
407	+	let result = try super::resolveProgramStr(&mut res, program);
408	+	let error = try super::expectError(&result);
409	+	let case resolver::ErrorKind::RegionArgumentCount(_) = error.kind else throw testing::TestError::Failed;
410	+	}
411	+	}
412	+	}
413	+
414	+	/// Type arguments are invariant in values, constructor hints, and patterns.
415	+	@test unsafe fn testNominalRegionInvariance() throws (testing::TestError) {
416	+	for program in [
417	+	"record N: 'r + Copy { value: u32 } fn f 'a 'b (n: N 'a) { let x: N 'b = n; }",
418	+	"record N: 'r + Copy { value: u32 } unsafe fn f 'a 'b (n: N 'a) { let x: N 'b = n; }",
419	+	"record N: 'r + Copy { value: u32 } fn f 'a 'b () { let n: N 'a = N 'b { value: 1 }; }",
420	+	"record N: 'r + Copy { value: u32 } fn f 'a 'b (n: N 'a) { let case N 'b { value } = n else panic; }",
421	+	"record N: 'r + Copy (u32); fn f 'a 'b (n: N 'a) { let case N 'b (value) = n else panic; }",
422	+	"record N: 'r + Copy { value: u32 } record M: 'r + Copy { value: u32 } fn f 'a (n: N 'a) { let case M 'a { value } = n else panic; }",
423	+	] {
424	+	let mut testArena23 = super::testArena();
425	+	let testStorage23: 'test23 = &mut testArena23 in {
426	+	let mut res = super::testResolver(testStorage23);
427	+	let result = try super::resolveProgramStr(&mut res, program);
428	+	let error = try super::expectError(&result);
429	+	let case resolver::ErrorKind::TypeMismatch(_) = error.kind else throw testing::TestError::Failed;
430	+	}
431	+	}
432	+	}
433	+
434	+	/// Region inference must agree between an outer reference and its embedded nominal type.
435	+	@test unsafe fn testNominalRegionInferenceConflict() throws (testing::TestError) {
436	+	for program in [
437	+	"record N: 'r + Copy { value: u32 } fn take 'r (n: &'r N 'r) {} fn f 'a 'b (n: &'a N 'b) { take(n); }",
438	+	"record N: 'r + Copy { value: u32 } fn take 'r (n: N 'r, m: N 'r) {} fn f 'a 'b (n: N 'a, m: N 'b) { take(n, m); }",
439	+	] {
440	+	let mut testArena24 = super::testArena();
441	+	let testStorage24: 'test24 = &mut testArena24 in {
442	+	let mut res = super::testResolver(testStorage24);
443	+	let result = try super::resolveProgramStr(&mut res, program);
444	+	let error = try super::expectError(&result);
445	+	let case resolver::ErrorKind::RegionInference(_) = error.kind else throw testing::TestError::Failed;
446	+	}
447	+	}
448	+	}
449	+
450	+	/// Applications must satisfy the source declaration's explicit parent relations.
451	+	@test unsafe fn testNominalRegionParentConstraint() throws (testing::TestError) {
452	+	let mut testArena25 = super::testArena();
453	+	let testStorage25: 'test25 = &mut testArena25 in {
454	+	let mut res = super::testResolver(testStorage25);
455	+	let result = try super::resolveProgramStr(&mut res,
456	+	"record N: 'r + 's where 'r: 's { value: u32 } fn f 'a 'b (n: N 'a 'b) {}"
457	+	);
458	+	let error = try super::expectError(&result);
459	+	let case resolver::ErrorKind::RegionParent(_) = error.kind else throw testing::TestError::Failed;
460	+	}
461	+	}
462	+
463	+	/// An applied affine type retains the source declaration's move rule.
464	+	@test unsafe fn testNominalRegionMoveRule() throws (testing::TestError) {
465	+	let mut testArena26 = super::testArena();
466	+	let testStorage26: 'test26 = &mut testArena26 in {
467	+	let mut res = super::testResolver(testStorage26);
468	+	let result = try super::resolveProgramStr(&mut res,
469	+	"record N: 'r { value: u32 } fn f 'a (n: N 'a) { let first = n; let second = n; }"
470	+	);
471	+	let error = try super::expectError(&result);
472	+	let case resolver::ErrorKind::AffineUseAfterMove(_) = error.kind else throw testing::TestError::Failed;
473	+	}
474	+	}
475	+
476	+	/// By-value cycles have no layout, including cycles through exact applications.
477	+	@test unsafe fn testNominalRegionValueCycle() throws (testing::TestError) {
478	+	for program in [
479	+	"record N: 'r { next: N 'r }",
480	+	"record N: 'r { next: ?N 'r }",
481	+	"union U: 'r { More(U 'r), Empty }",
482	+	"record N: 'r { m: M 'r } record M: 'r { n: N 'r }",
483	+	] {
484	+	let mut testArena27 = super::testArena();
485	+	let testStorage27: 'test27 = &mut testArena27 in {
486	+	let mut res = super::testResolver(testStorage27);
487	+	let result = try super::resolveProgramStr(&mut res, program);
488	+	let error = try super::expectError(&result);
489	+	let case resolver::ErrorKind::RecursiveType = error.kind else throw testing::TestError::Failed;
490	+	}
491	+	}
492	+	}
493	+
494	+	/// Recursive substitutions can permute arguments without expanding the type graph.
495	+	@test unsafe fn testNominalRegionPermutation() throws (testing::TestError) {
496	+	let mut testArena28 = super::testArena();
497	+	let testStorage28: 'test28 = &mut testArena28 in {
498	+	let mut res = super::testResolver(testStorage28);
499	+	let result = try super::resolveProgramStr(&mut res,
500	+	"record N: 'r + 's + Copy { next: ?*N 's 'r } fn f 'a 'b (x: N 'a 'b, y: N 'b 'a) {}"
501	+	);
502	+	try super::expectNoErrors(&result);
503	+	let func = try super::getBlockStmt(result.root, 1);
504	+	let fnType = resolver::typeFor(&res, func) else throw testing::TestError::Failed;
505	+	let case resolver::Type::Fn(info) = fnType else throw testing::TestError::Failed;
506	+	for parameter, i in info.paramTypes {
507	+	let case resolver::Type::Nominal(resolver::NominalType::Record(body)) = *parameter
508	+	else throw testing::TestError::Failed;
509	+	let case resolver::Type::Optional(inner) = body.fields[0].fieldType else throw testing::TestError::Failed;
510	+	let case resolver::Type::Pointer { target, .. } = *inner else throw testing::TestError::Failed;
511	+	try testing::expect(resolver::typesEqual(target, info.paramTypes[1 - i]));
512	+	}
513	+	}
514	+	}
515	+
516	+	/// Calls transfer named exclusive references on normal and error paths.
517	+	@test unsafe fn testRegionalCallOwnershipTransfer() throws (testing::TestError) {
518	+	for program in [
519	+	"fn take 'r (p: &'r mut u32) {} fn run 'r (p: &'r mut u32) { take(p); take(p); }",
520	+	"fn take 'r (p: &'r mut u32) {} unsafe fn run 'r (p: &'r mut u32) { take(p); set *p = 1; }",
521	+	"fn take 'r (p: &'r mut [u32]) {} fn run 'r (p: &'r mut [u32]) { take(p); p[0]; }",
522	+	"fn take 'r (p: &'r mut u32) {} fn run 'r (p: &'r mut u32) { let f = take 'r; f(p); set *p = 1; }",
523	+	"union E { Bad } fn take 'r (p: &'r mut u32) throws (E) { throw E::Bad; } fn run 'r (p: &'r mut u32) { try take(p) catch {}; set *p = 1; }",
524	+	"fn take 'r (p: &'r mut u32) {} fn run 'r (p: &'r mut u32, c: bool) { if c { take(p); } set *p = 1; }",
525	+	] {
526	+	let mut testArena29 = super::testArena();
527	+	let testStorage29: 'test29 = &mut testArena29 in {
528	+	let mut res = super::testResolver(testStorage29);
529	+	let result = try super::resolveProgramStr(&mut res, program);
530	+	let error = try super::expectError(&result);
531	+	let case resolver::ErrorKind::AffineUseAfterMove(_) = error.kind else throw testing::TestError::Failed;
532	+	}
533	+	}
534	+	}
535	+
536	+	/// Full-region projections protect their source after a local binding leaves scope.
537	+	@test unsafe fn testRegionalProjectionLifetime() throws (testing::TestError) {
538	+	for program in [
539	+	"fn f 'r (p: &'r mut u32) { let shared = &p; let copy = shared; set p = 1; }",
540	+	"unsafe fn f 'r (p: &'r mut u32) { let shared = &p; let copy = shared; set p = 1; }",
541	+	"fn f 'r (p: &'r mut u32, q: &'r u32) { let mut cursor = q; set cursor = &p; set p = 1; }",
542	+	"unsafe fn f 'r (p: &'r mut u32, q: &'r u32) { let mut cursor = q; set cursor = &p; set p = 1; }",
543	+	"fn f 'r (p: &'r mut u32) { { let q = &mut p; set q = 1; } set *p = 2; }",
544	+	"fn f 'r (p: &'r mut u32) { { let q = &p; } set p = 2; }",
545	+	"unsafe fn f 'r (p: &'r mut u32) { { let q = &p; } set p = 2; }",
546	+	"fn f 'r (p: &'r mut u32) { { let q = &mut p; let moved = q; } p; }",
547	+	"record P { a: u32, b: u32 } fn f 'r (p: &'r mut P) { { let q = &mut p.a; } p.a; }",
548	+	"record P { a: u32, b: u32 } fn f 'r (p: &'r mut P) { { let q = &p.a; } set p.a = 2; }",
549	+	] {
550	+	let mut testArena30 = super::testArena();
551	+	let testStorage30: 'test30 = &mut testArena30 in {
552	+	let mut res = super::testResolver(testStorage30);
553	+	let result = try super::resolveProgramStr(&mut res, program);
554	+	let error = try super::expectError(&result);
555	+	let case resolver::ErrorKind::BorrowConflict(_) = error.kind else throw testing::TestError::Failed;
556	+	}
557	+	}
558	+	}
559	+
560	+	/// A regional loan on any live branch remains active at the branch join.
561	+	@test unsafe fn testRegionalProjectionBranchJoin() throws (testing::TestError) {
562	+	for program in [
563	+	"fn f 'r (p: &'r mut u32, c: bool) { if c { let q = &mut p; } set p = 2; }",
564	+	"fn f 'r (p: &'r mut u32, c: bool) { if c {} else { let q = &p; } set p = 2; }",
565	+	"fn f 'r (p: &'r mut u32, c: bool) { match c { case true => { let q = &mut p; } else => {} } p; }",
566	+	"fn f 'r (p: &'r mut u32, c: ?u32) { if let n = c { let q = &p; } set p = 2; }",
567	+	] {
568	+	let mut testArena31 = super::testArena();
569	+	let testStorage31: 'test31 = &mut testArena31 in {
570	+	let mut res = super::testResolver(testStorage31);
571	+	let result = try super::resolveProgramStr(&mut res, program);
572	+	let error = try super::expectError(&result);
573	+	let case resolver::ErrorKind::BorrowConflict(_) = error.kind else throw testing::TestError::Failed;
574	+	}
575	+	}
576	+	}
577	+
578	+	/// Loop back edges carry regional loans into later iterations.
579	+	@test unsafe fn testRegionalProjectionLoopBackEdge() throws (testing::TestError) {
580	+	for program in [
581	+	"fn f 'r (p: &'r mut u32) { for i in 0..2 { let q = &mut *p; } }",
582	+	"fn f 'r (p: &'r mut u32) { for i in 0..2 { set p = 1; let q = &p; } }",
583	+	"fn f 'r (p: &'r mut u32) { for i in 0..2 { set p = 1; let q = &p; continue; } }",
584	+	"fn f 'r (p: &'r mut u32, c: bool) { while c { let q = &mut *p; } }",
585	+	"fn f 'r (p: &'r mut u32, c: ?u32) { while let n = c { let q = &mut *p; } }",
586	+	"fn f 'r (p: &'r mut u32) { loop { let q = &mut *p; } }",
587	+	"fn f 'r (p: &'r mut u32, c: bool) { loop { if c { set p = 1; break; } let q = &p; } }",
588	+	] {
589	+	let mut testArena32 = super::testArena();
590	+	let testStorage32: 'test32 = &mut testArena32 in {
591	+	let mut res = super::testResolver(testStorage32);
592	+	let result = try super::resolveProgramStr(&mut res, program);
593	+	let error = try super::expectError(&result);
594	+	let case resolver::ErrorKind::BorrowConflict(_) = error.kind else throw testing::TestError::Failed;
595	+	}
596	+	}
597	+	}
598	+
599	+	/// Loans in caller-supplied regions survive loop and nested-region exits.
600	+	@test unsafe fn testRegionalProjectionLoopExit() throws (testing::TestError) {
601	+	for program in [
602	+	"fn f 'r (p: &'r mut u32) { loop { let q = &mut p; break; } set p = 2; }",
603	+	"fn f 'r (p: &'r mut u32, c: bool) { while c { let q = &p; break; } else {} set p = 2; }",
604	+	"fn f 'r (p: &'r mut u32) { for i in 0..2 { let q = &p; break; } else {} set p = 2; }",
605	+	"fn f 'r (p: &'r mut u32) { let x: u32 = 0; let v: 'child = &x where 'r: 'child in { let q = &p; } set p = 2; }",
606	+	] {
607	+	let mut testArena33 = super::testArena();
608	+	let testStorage33: 'test33 = &mut testArena33 in {
609	+	let mut res = super::testResolver(testStorage33);
610	+	let result = try super::resolveProgramStr(&mut res, program);
611	+	let error = try super::expectError(&result);
612	+	let case resolver::ErrorKind::BorrowConflict(_) = error.kind else throw testing::TestError::Failed;
613	+	}
614	+	}
615	+	}
616	+
617	+	/// Region erasure cannot merge distinct error alternatives in one signature.
618	+	@test unsafe fn testRegionalErrorAmbiguity() throws (testing::TestError) {
619	+	for program in [
620	+	"record E: 'r + Copy {} fn f 'a 'b () throws (E 'a, E 'b) {}",
621	+	"record E: 'r + Copy {} unsafe fn f 'a 'b () throws (E 'a, E 'b) {}",
622	+	"record E: 'r + Copy {} record Callback: 'a + 'b { f: fn() throws (E 'a, E 'b) }",
623	+	"fn f 'a 'b () throws (&'a u32, &'b u32) {}",
624	+	] {
625	+	let mut testArena34 = super::testArena();
626	+	let testStorage34: 'test34 = &mut testArena34 in {
627	+	let mut res = super::testResolver(testStorage34);
628	+	let result = try super::resolveProgramStr(&mut res, program);
629	+	try super::expectErrorKind(&result, resolver::ErrorKind::AmbiguousRegionalError);
630	+	}
631	+	}
632	+	}
633	+
634	+	/// Moving an exclusive reference into an aggregate transfers its ownership.
635	+	@test unsafe fn testRegionalAggregateMove() throws (testing::TestError) {
636	+	for program in [
637	+	"record W: 'r { p: &'r mut u32 } fn f 'r (p: &'r mut u32) { let w = W 'r { p }; set *p = 1; }",
638	+	"record W: 'r { p: &'r mut u32 } unsafe fn f 'r (p: &'r mut u32) { let w = W 'r { p }; set *p = 1; }",
639	+	"record W: 'r { p: &'r mut u32 } fn f 'r (w: W 'r) { let case W { p } = w else panic; let again = w; }",
640	+	"union W: 'r { P { p: &'r mut u32 } } fn f 'r (p: &'r mut u32) { let w = W 'r::P { p }; set *p = 1; }",
641	+	"fn f 'r (p: &'r mut u32) { let a: [&'r mut u32; 1] = [p]; set *p = 1; }",
642	+	"fn f 'r (p: &'r mut u32) { let a: ?&'r mut u32 = p; set *p = 1; }",
643	+	] {
644	+	let mut testArena35 = super::testArena();
645	+	let testStorage35: 'test35 = &mut testArena35 in {
646	+	let mut res = super::testResolver(testStorage35);
647	+	let result = try super::resolveProgramStr(&mut res, program);
648	+	let error = try super::expectError(&result);
649	+	let case resolver::ErrorKind::AffineUseAfterMove(_) = error.kind else throw testing::TestError::Failed;
650	+	}
651	+	}
652	+	}
653	+
654	+	/// Aggregate transfers do not end a projection loan on its source.
655	+	@test unsafe fn testRegionalAggregateLoan() throws (testing::TestError) {
656	+	for program in [
657	+	"record W: 'r { p: &'r mut u32 } fn f 'r (p: &'r mut u32) { { let w = W 'r { p: &mut p }; } set p = 1; }",
658	+	"record R: 'r + Copy { p: &'r u32 } fn f 'r (p: &'r mut u32) { { let r = R 'r { p: &p }; } set p = 1; }",
659	+	"record R: 'r + Copy { p: &'r u32 } fn take 'r (r: R 'r) {} fn f 'r (p: &'r mut u32) { take(R 'r { p: &p }); set p = 1; }",
660	+	"fn id 'r (p: &'r mut u32) -> &'r mut u32 { return p; } fn f 'r (p: &'r mut u32) { let q = id(p); { let other = &mut q; } set q = 1; }",
661	+	] {
662	+	let mut testArena36 = super::testArena();
663	+	let testStorage36: 'test36 = &mut testArena36 in {
664	+	let mut res = super::testResolver(testStorage36);
665	+	let result = try super::resolveProgramStr(&mut res, program);
666	+	let error = try super::expectError(&result);
667	+	let case resolver::ErrorKind::BorrowConflict(_) = error.kind else throw testing::TestError::Failed;
668	+	}
669	+	}
670	+	}
671	+
672	+	/// Local storage cannot acquire a caller region through returns or aggregate hints.
673	+	@test unsafe fn testRegionalStorageEscape() throws (testing::TestError) {
674	+	for program in [
675	+	"fn f 'r () -> &'r u32 { let x: u32 = 1; return &x; }",
676	+	"unsafe fn f 'r () -> &'r u32 { let x: u32 = 1; return &x; }",
677	+	"record R: 'r + Copy { p: &'r u32 } fn f 'r () -> R 'r { let x: u32 = 1; return R 'r { p: &x }; }",
678	+	"record R: 'r + Copy { p: &'r u32 } fn f 'r () -> R 'r { let x: u32 = 1; let p: 'short = &x in { return R 'short { p }; } }",
679	+	"record R: 'r + Copy { p: &'r u32 } fn f 'r (p: &'r u32) -> &'r R 'r { let r = R 'r { p }; return &r; }",
680	+	"record R: 'r + Copy { p: &'r u32 } fn f 'r (p: &'r u32) { let mut outer = R 'r { p }; let x: u32 = 1; let q: 'short = &x in { set outer = R 'short { p: q }; } }",
681	+	] {
682	+	let mut testArena37 = super::testArena();
683	+	let testStorage37: 'test37 = &mut testArena37 in {
684	+	let mut res = super::testResolver(testStorage37);
685	+	let result = try super::resolveProgramStr(&mut res, program);
686	+	let error = try super::expectError(&result);
687	+	let case resolver::ErrorKind::TypeMismatch(_) = error.kind else throw testing::TestError::Failed;
688	+	}
689	+	}
690	+	}
691	+
692	+	/// Reference fields retain their ownership and storage restrictions.
693	+	@test unsafe fn testRegionalFieldRestrictions() throws (testing::TestError) {
694	+	{
695	+	let mut testArena38 = super::testArena();
696	+	let testStorage38: 'test38 = &mut testArena38 in {
697	+	let mut res = super::testResolver(testStorage38);
698	+	let result = try super::resolveProgramStr(&mut res, "record W: 'r { p: &'r mut u32 } fn f 'r (w: W 'r) { let p = w.p; }");
699	+	try super::expectErrorKind(&result, resolver::ErrorKind::LinearPartialMove);
700	+	}
701	+	}
702	+	{
703	+	let mut testArena39 = super::testArena();
704	+	let testStorage39: 'test39 = &mut testArena39 in {
705	+	let mut res = super::testResolver(testStorage39);
706	+	let result = try super::resolveProgramStr(&mut res, "record R: 'r { p: &u32 }");
707	+	try super::expectErrorKind(&result, resolver::ErrorKind::InvalidRefPosition);
708	+	}
709	+	}
710	+	{
711	+	let mut testArena40 = super::testArena();
712	+	let testStorage40: 'test40 = &mut testArena40 in {
713	+	let mut res = super::testResolver(testStorage40);
714	+	let result = try super::resolveProgramStr(&mut res, "fn f 'r (p: &'r u32) { static r: &'r u32 = undefined; }");
715	+	try super::expectErrorKind(&result, resolver::ErrorKind::InvalidRefPosition);
716	+	}
717	+	}
718	+	}
719	+
720	+	/// Regional projection tracking limits simultaneous live projections.
721	+	@test unsafe fn testRegionalLoanCapacity() throws (testing::TestError) {
722	+	let mut reuseArena = super::testArena();
723	+	let reuseStorage: 'reuse = &mut reuseArena in {
724	+	let mut res = super::testResolver(reuseStorage);
725	+	let result = try super::resolveProgramStr(&mut res, "fn f 'r (p: &'r u32) { let outer: 'outer = &p where 'r: 'outer in { let q: 'x = &outer in { &q; } let q: 'x = &outer in { &q; } let q: 'x = &outer in { &q; } let q: 'x = &outer in { &q; } let q: 'x = &outer in { &q; } let q: 'x = &outer in { &q; } let q: 'x = &outer in { &q; } let q: 'x = &outer in { &q; } let q: 'x = &outer in { &q; } let q: 'x = &outer in { &q; } let q: 'x = &outer in { &q; } let q: 'x = &outer in { &q; } let q: 'x = &outer in { &q; } let q: 'x = &outer in { &q; } let q: 'x = &outer in { &q; } let q: 'x = &outer in { &q; } let q: 'x = &outer in { &*q; } } }");
726	+	try super::expectNoErrors(&result);
727	+	}
728	+	let mut testArena41 = super::testArena();
729	+	let testStorage41: 'test41 = &mut testArena41 in {
730	+	let mut res = super::testResolver(testStorage41);
731	+	let result = try super::resolveProgramStr(&mut res, "fn f 'r (p: &'r u32) { [&p, &p, &p, &p, &p, &p, &p, &p, &p, &p, &p, &p, &p, &p, &p, &p, &p, &p, &p, &p, &p, &p, &p, &p, &p, &p, &p, &p, &p, &p, &p, &p, &*p]; }");
732	+	try super::expectErrorKind(&result, resolver::ErrorKind::RegionalLoanOverflow);
733	+	}
734	+	}
735	+
736	+	/// Shared regional parameters consume exclusive arguments that can be retained.
737	+	@test unsafe fn testRegionalSharedCallTransfer() throws (testing::TestError) {
738	+	for program in [
739	+	"fn read 'r (p: &'r u32) -> &'r u32 { return p; } fn f 'r (p: &'r mut u32) -> u32 { let q = read(p); set p = 2; return q; }",
740	+	"fn read 'r (p: &'r u32) -> &'r u32 { return p; } unsafe fn f 'r (p: &'r mut u32) { let q = read(p); set *p = 2; }",
741	+	"fn read 'r (p: &'r [u32]) -> &'r [u32] { return p; } fn f 'r (p: &'r mut [u32]) { let q = read(p); set p[0] = 2; }",
742	+	"fn read 'r (p: &'r u32) -> &'r u32 { return p; } fn f 'r (p: &'r mut u32) { let callback = read 'r; let q = callback(p); set *p = 2; }",
743	+	] {
744	+	let mut testArena42 = super::testArena();
745	+	let testStorage42: 'test42 = &mut testArena42 in {
746	+	let mut res = super::testResolver(testStorage42);
747	+	let result = try super::resolveProgramStr(&mut res, program);
748	+	let error = try super::expectError(&result);
749	+	let case resolver::ErrorKind::AffineUseAfterMove(_) = error.kind else throw testing::TestError::Failed;
750	+	}
751	+	}
752	+	}
753	+
754	+	/// Values stored in a regional destination must cover its full lifetime.
755	+	@test unsafe fn testRegionalStoreLifetime() throws (testing::TestError) {
756	+	for program in [
757	+	"fn f 'a 'b (dst: &'a mut ?&'b u32, p: &'b u32) { set *dst = p; }",
758	+	"unsafe fn f 'a 'b (dst: &'a mut ?&'b u32, p: &'b u32) { set *dst = p; }",
759	+	"fn f 'a 'b (dst: &'a mut ?&'b u32, p: &'b u32) where 'a: 'b { set *dst = p; }",
760	+	"record R: 'r + Copy { p: &'r u32 } fn f 'a 'b (dst: &'a mut R 'b, p: &'b u32) { set *dst = R 'b { p }; }",
761	+	"fn f 'a 'b (dst: &'a mut [&'b u32], p: &'b u32) { set dst[0] = p; }",
762	+	"fn f 'a 'b (dst: &'a mut [&'b u32], p: &'b u32) { set dst[..] = p; }",
763	+	"fn f 'a 'b (dst: &'a mut fn(&'b u32), callback: fn(&'b u32)) { set *dst = callback; }",
764	+	] {
765	+	let mut testArena43 = super::testArena();
766	+	let testStorage43: 'test43 = &mut testArena43 in {
767	+	let mut res = super::testResolver(testStorage43);
768	+	let result = try super::resolveProgramStr(&mut res, program);
769	+	let error = try super::expectError(&result);
770	+	let case resolver::ErrorKind::RegionEscape(_) = error.kind else throw testing::TestError::Failed;
771	+	}
772	+	}
773	+	}
774	+
775	+	/// A session holds the arena loan after the interface is moved or discarded.
776	+	@test unsafe fn testSessionArenaLoan() throws (testing::TestError) {
777	+	for program in [
778	+	"use std::lang::alloc; fn f(arena: &mut alloc::Arena) { use *arena as s in { alloc::reset(arena); } }",
779	+	"use std::lang::alloc; unsafe fn f(arena: &mut alloc::Arena) { use *arena as s in { alloc::reset(arena); } }",
780	+	"use std::lang::alloc; fn f(arena: &mut alloc::Arena) { use *arena as s in { let moved = s; alloc::reset(arena); } }",
781	+	"use std::lang::alloc; fn f(arena: &mut alloc::Arena) { use *arena as s in { let _ = s; set arena.offset = 0; } }",
782	+	"use std::lang::alloc; fn f(arena: &mut alloc::Arena) { use arena as s in { use arena as t in {} } }",
783	+	] {
784	+	let mut testArena44 = super::testArena();
785	+	let testStorage44: 'test44 = &mut testArena44 in {
786	+	let mut res = super::testResolver(testStorage44);
787	+	let result = try super::resolveSessionProgramStr(&mut res, program);
788	+	let error = try super::expectError(&result);
789	+	let case resolver::ErrorKind::BorrowConflict(_) = error.kind else throw testing::TestError::Failed;
790	+	}
791	+	}
792	+	}
793	+
794	+	/// Session interfaces have affine ownership and invariant region arguments.
795	+	@test unsafe fn testSessionOwnership() throws (testing::TestError) {
796	+	for program in [
797	+	"fn f 'r (s: Session 'r) { let moved = s; let again = s; }",
798	+	"unsafe fn f 'r (s: Session 'r) { let moved = s; let again = s; }",
799	+	"fn take 'r (s: Session 'r) {} fn f 'r (s: Session 'r) { take(s); take(s); }",
800	+	] {
801	+	let mut testArena45 = super::testArena();
802	+	let testStorage45: 'test45 = &mut testArena45 in {
803	+	let mut res = super::testResolver(testStorage45);
804	+	let result = try super::resolveProgramStr(&mut res, program);
805	+	let error = try super::expectError(&result);
806	+	let case resolver::ErrorKind::AffineUseAfterMove(_) = error.kind else throw testing::TestError::Failed;
807	+	}
808	+	}
809	+	{
810	+	let mut testArena46 = super::testArena();
811	+	let testStorage46: 'test46 = &mut testArena46 in {
812	+	let mut res = super::testResolver(testStorage46);
813	+	let result = try super::resolveProgramStr(&mut res,
814	+	"fn f 'r 's (s: Session 's) -> Session 'r where 'r: 's { return s; }");
815	+	let error = try super::expectError(&result);
816	+	let case resolver::ErrorKind::TypeMismatch(_) = error.kind else throw testing::TestError::Failed;
817	+	}
818	+	}
819	+	}
820	+
821	+	/// Regional `use` blocks require a mutable allocation trait implementer.
822	+	@test unsafe fn testSessionSource() throws (testing::TestError) {
823	+	for program in [
824	+	"record Arena { data: mut [u8], offset: u32 } fn f(arena: &mut Arena) { use arena as s in {} }",
825	+	"fn f(value: &mut u32) { use *value as s in {} }",
826	+	] {
827	+	let mut testArena47 = super::testArena();
828	+	let testStorage47: 'test47 = &mut testArena47 in {
829	+	let mut res = super::testResolver(testStorage47);
830	+	let result = try super::resolveSessionProgramStr(&mut res, program);
831	+	try super::expectErrorKind(&result, resolver::ErrorKind::InvalidSessionSource);
832	+	}
833	+	}
834	+	let mut customArena = super::testArena();
835	+	let customStorage: 'custom = &mut customArena in {
836	+	let mut res = super::testResolver(customStorage);
837	+	let result = try super::resolveSessionProgramStr(&mut res,
838	+	"use std::lang::alloc; record Wrapper: 'r { arena: &'r mut alloc::Arena } instance alloc::Alloc for Wrapper 'r { unsafe fn (wrapper: &mut Wrapper 'r) reserve(size: u32, alignment: u32) -> unsafe mut opaque throws (alloc::AllocError) { panic; } unsafe fn (wrapper: &mut Wrapper 'r) reserveSlice(size: u32, alignment: u32, count: u32) -> unsafe mut [opaque] throws (alloc::AllocError) { panic; } } fn f 'r (wrapper: &'r mut Wrapper 'r) { use *wrapper as session in { try! session.new(1 as u32); } }");
839	+	try super::expectNoErrors(&result);
840	+	}
841	+	}
842	+
843	+	/// Region-dependent values cannot be manufactured from uninitialized storage.
844	+	@test unsafe fn testRegionalUndefined() throws (testing::TestError) {
845	+	for program in [
846	+	"unsafe fn f 'r () -> Session 'r { return undefined; }",
847	+	"record R: 'r { s: Session 'r } unsafe fn f 'r () -> R 'r { return undefined; }",
848	+	"unsafe fn f 'r () -> *unsafe Session 'r { return undefined; }",
849	+	"unsafe fn f 'r () -> &'r u32 { return undefined; }",
850	+	] {
851	+	let mut testArena48 = super::testArena();
852	+	let testStorage48: 'test48 = &mut testArena48 in {
853	+	let mut res = super::testResolver(testStorage48);
854	+	let result = try super::resolveProgramStr(&mut res, program);
855	+	let error = try super::expectError(&result);
856	+	let case resolver::ErrorKind::TypeMismatch(_) = error.kind else throw testing::TestError::Failed;
857	+	}
858	+	}
859	+	}
860	+
861	+	/// Pointer casts cannot introduce session or aggregate region dependencies.
862	+	@test unsafe fn testRegionalCastForgery() throws (testing::TestError) {
863	+	for program in [
864	+	"unsafe fn f 'r (p: unsafe opaque) -> unsafe Session 'r { return p as *unsafe Session 'r; }",
865	+	"unsafe fn f 'r (p: unsafe [opaque]) -> unsafe [Session 'r] { return p as *unsafe [Session 'r]; }",
866	+	"record R: 'r { s: Session 'r } unsafe fn f 'r (p: unsafe opaque) -> unsafe R 'r { return p as *unsafe R 'r; }",
867	+	"record R: 'r + Copy { p: &'r u32 } unsafe fn f 'r 's (p: unsafe R 'r) -> unsafe R 's { return p as *unsafe R 's; }",
868	+	] {
869	+	let mut testArena49 = super::testArena();
870	+	let testStorage49: 'test49 = &mut testArena49 in {
871	+	let mut res = super::testResolver(testStorage49);
872	+	let result = try super::resolveProgramStr(&mut res, program);
873	+	let error = try super::expectError(&result);
874	+	let case resolver::ErrorKind::InvalidAsCast(_) = error.kind else throw testing::TestError::Failed;
875	+	}
876	+	}
877	+	}
878	+
879	+	/// Bulk allocation rejects resources and values that need ownership cleanup.
880	+	@test unsafe fn testSessionAllocationValue() throws (testing::TestError) {
881	+	for program in [
882	+	"record R: Once { n: u32 } fn f 'r (s: &Session 'r, value: R) { try! s.new(value); }",
883	+	"record R: Once { n: u32 } unsafe fn f 'r (s: &Session 'r, value: R) { try! s.new(value); }",
884	+	"record R: Once { n: u32 } record Outer { value: R } fn f 'r (s: &Session 'r, value: Outer) { try! s.new(value); }",
885	+	"record R: Once { n: u32 } fn f 'r (s: &Session 'r, value: ?R) { try! s.new(value); }",
886	+	"fn f 'r (s: &Session 'r, value: Session 'r) { try! s.new(value); }",
887	+	"record R: Once { n: u32 } fn f 'r (s: &Session 'r, value: [R; 1]) { try! s.new(value); }",
888	+	"fn f 'r (s: &Session 'r, value: &'r mut u32) { try! s.fill(value, 2); }",
889	+	"fn f 'r (s: &Session 'r, value: &[&'r mut u32]) { try! s.copy(value); }",
890	+	] {
891	+	let mut testArena50 = super::testArena();
892	+	let testStorage50: 'test50 = &mut testArena50 in {
893	+	let mut res = super::testResolver(testStorage50);
894	+	let result = try super::resolveSessionProgramStr(&mut res, program);
895	+	try super::expectErrorKind(&result, resolver::ErrorKind::InvalidAllocationValue);
896	+	}
897	+	}
898	+	}
899	+
900	+	/// Allocated values must retain dependencies that cover the destination session.
901	+	@test unsafe fn testSessionAllocationDependency() throws (testing::TestError) {
902	+	for program in [
903	+	"fn f 'r 's (a: &Session 'r, p: &'s u32) where 'r: 's { try! a.new(p); }",
904	+	"unsafe fn f 'r 's (a: &Session 'r, p: &'s u32) where 'r: 's { try! a.new(p); }",
905	+	"record R: 's + Copy { p: &'s u32 } fn f 'r 's (a: &Session 'r, p: R 's) where 'r: 's { try! a.new(p); }",
906	+	"fn f 'r 's (a: &Session 'r, p: &[&'s u32]) where 'r: 's { try! a.copy(p); }",
907	+	] {
908	+	let mut testArena51 = super::testArena();
909	+	let testStorage51: 'test51 = &mut testArena51 in {
910	+	let mut res = super::testResolver(testStorage51);
911	+	let result = try super::resolveSessionProgramStr(&mut res, program);
912	+	let error = try super::expectError(&result);
913	+	let case resolver::ErrorKind::RegionEscape(_) = error.kind else throw testing::TestError::Failed;
914	+	}
915	+	}
916	+	}
917	+
918	+	/// Allocation operations require error handling and exact source region results.
919	+	@test unsafe fn testSessionAllocationContract() throws (testing::TestError) {
920	+	{
921	+	let mut testArena52 = super::testArena();
922	+	let testStorage52: 'test52 = &mut testArena52 in {
923	+	let mut res = super::testResolver(testStorage52);
924	+	let result = try super::resolveSessionProgramStr(&mut res,
925	+	"fn f 'r (s: &Session 'r) { s.new(1 as u32); }");
926	+	try super::expectErrorKind(&result, resolver::ErrorKind::MissingTry);
927	+	}
928	+	}
929	+	{
930	+	let mut testArena53 = super::testArena();
931	+	let testStorage53: 'test53 = &mut testArena53 in {
932	+	let mut res = super::testResolver(testStorage53);
933	+	let result = try super::resolveSessionProgramStr(&mut res,
934	+	"fn f 'r 's (a: &Session 'r) -> &'s mut u32 { return try! a.new(1 as u32); }");
935	+	let error = try super::expectError(&result);
936	+	let case resolver::ErrorKind::TypeMismatch(_) = error.kind else throw testing::TestError::Failed;
937	+	}
938	+	}
939	+	{
940	+	let mut testArena54 = super::testArena();
941	+	let testStorage54: 'test54 = &mut testArena54 in {
942	+	let mut res = super::testResolver(testStorage54);
943	+	let result = try super::resolveSessionProgramStr(&mut res,
944	+	"fn f 'r (a: &Session 'r, p: &u32) { try! a.new(p); }");
945	+	try super::expectErrorKind(&result, resolver::ErrorKind::InvalidRefPosition);
946	+	}
947	+	}
948	+	}
949	+
950	+	/// Typed reservations reject array products, aggregate sums, and field-offset overflow.
951	+	@test unsafe fn testSessionAllocationLayout() throws (testing::TestError) {
952	+	for program in [
953	+	"fn f 'r (s: &Session 'r, value: [u64; 536870913]) { try! s.new(value); }",
954	+	"unsafe fn f 'r (s: &Session 'r, value: [u64; 536870913]) { try! s.new(value); }",
955	+	"record R { a: [u8; 4294967290], b: u64 } fn f 'r (s: &Session 'r, value: R) { try! s.new(value); }",
956	+	"record R { a: [u8; 2147483648], b: u8 } fn f 'r (s: &Session 'r, value: R) { try! s.new(value); }",
957	+	"fn f 'r (s: &Session 'r, value: ?[u8; 4294967295]) { try! s.new(value); }",
958	+	"union R { Data([u8; 4294967295]) } fn f 'r (s: &Session 'r, value: R) { try! s.new(value); }",
959	+	] {
960	+	let mut testArena55 = super::testArena();
961	+	let testStorage55: 'test55 = &mut testArena55 in {
962	+	let mut res = super::testResolver(testStorage55);
963	+	let result = try super::resolveSessionProgramStr(&mut res, program);
964	+	try super::expectErrorKind(&result, resolver::ErrorKind::InvalidAllocationLayout);
965	+	}
966	+	}
967	+	}
968	+
969	+	/// Cell payloads must permit plain value copies.
970	+	@test unsafe fn testCellPointerPayload() throws (testing::TestError) {
971	+	for program in [
972	+	"union State: 'r { Next(&'r cell State 'r) }",
973	+	"union State: 'r { Ready(&'r u32) } fn f 'r (state: &'r cell State 'r) {}",
974	+	"union State: 'r { Ready(&'r u32) } unsafe fn f 'r (state: &'r cell State 'r) {}",
975	+	"fn f(p: cell mut u32) {}",
976	+	"unsafe fn f(p: cell mut u32) {}",
977	+	"record R: Once { n: u32 } fn f(p: *cell R) {}",
978	+	"record R { n: u32 } fn f(p: *cell R) {}",
979	+	"fn f 'r (p: &'r cell &'r mut u32) {}",
980	+	] {
981	+	let mut testArena56 = super::testArena();
982	+	let testStorage56: 'test56 = &mut testArena56 in {
983	+	let mut res = super::testResolver(testStorage56);
984	+	let result = try super::resolveProgramStr(&mut res, program);
985	+	try super::expectErrorKind(&result, resolver::ErrorKind::InvalidCellPayload);
986	+	}
987	+	}
988	+	}
989	+
990	+	/// Cell access cannot expose payload references or restore exclusive pointers.
991	+	@test unsafe fn testCellPointerAccess() throws (testing::TestError) {
992	+	for program in [
993	+	"fn f(p: cell u32) { let r = &p; }",
994	+	"unsafe fn f(p: cell u32) { let r = &p; }",
995	+	"record R: Copy { n: u32 } fn f(p: cell R) { let r = &(p).n; }",
996	+	"fn f(p: cell [u32; 2]) { let r = &(p)[0]; }",
997	+	"record R: Copy { n: u32 } fn f(p: cell R) { set (p).n = 1; }",
998	+	"fn f(p: cell [u32; 2]) { set (p)[0] = 1; }",
999	+	] {
1000	+	let mut testArena57 = super::testArena();
1001	+	let testStorage57: 'test57 = &mut testArena57 in {
1002	+	let mut res = super::testResolver(testStorage57);
1003	+	let result = try super::resolveProgramStr(&mut res, program);
1004	+	try super::expectErrorKind(&result, resolver::ErrorKind::ImmutableBinding);
1005	+	}
1006	+	}
1007	+	for program in [
1008	+	"fn f(p: cell u32) -> mut u32 { return p as *mut u32; }",
1009	+	"unsafe fn f(p: cell u32) -> unsafe mut u32 { return p as *unsafe mut u32; }",
1010	+	"fn f(p: u32) -> cell u32 { return p as *cell u32; }",
1011	+	"unsafe fn f(p: unsafe mut u32) -> cell u32 { return p as *cell u32; }",
1012	+	"fn f(p: mut u64) -> cell u32 { return p as *cell u32; }",
1013	+	"fn f 'r (p: &'r mut u32) -> cell u32 { return p as cell u32; }",
1014	+	] {
1015	+	let mut testArena58 = super::testArena();
1016	+	let testStorage58: 'test58 = &mut testArena58 in {
1017	+	let mut res = super::testResolver(testStorage58);
1018	+	let result = try super::resolveProgramStr(&mut res, program);
1019	+	let error = try super::expectError(&result);
1020	+	let case resolver::ErrorKind::InvalidAsCast(_) = error.kind else throw testing::TestError::Failed;
1021	+	}
1022	+	}
1023	+	}
1024	+
1025	+	/// An exclusive payload borrow cannot be made from shared cell access.
1026	+	@test unsafe fn testCellPointerMutablePayload() throws (testing::TestError) {
1027	+	let mut testArena59 = super::testArena();
1028	+	let testStorage59: 'test59 = &mut testArena59 in {
1029	+	let mut res = super::testResolver(testStorage59);
1030	+	let result = try super::resolveProgramStr(&mut res,
1031	+	"fn f(p: cell u32) { let r = &mut p; }");
1032	+	try super::expectErrorKind(&result, resolver::ErrorKind::ImmutableBinding);
1033	+	}
1034	+	}
1035	+
1036	+	/// Cell conversion consumes exclusive access, including call arguments.
1037	+	@test unsafe fn testCellPointerOwnership() throws (testing::TestError) {
1038	+	for program in [
1039	+	"fn f(p: mut u32) { let c = p as cell u32; set *p = 1; }",
1040	+	"unsafe fn f(p: mut u32) { let c = p as cell u32; set *p = 1; }",
1041	+	"fn read(p: &cell u32) {} fn f(p: &mut u32) { read(p as &cell u32); set *p = 1; }",
1042	+	] {
1043	+	let mut testArena60 = super::testArena();
1044	+	let testStorage60: 'test60 = &mut testArena60 in {
1045	+	let mut res = super::testResolver(testStorage60);
1046	+	let result = try super::resolveProgramStr(&mut res, program);
1047	+	let error = try super::expectError(&result);
1048	+	let case resolver::ErrorKind::AffineUseAfterMove(_) = error.kind else throw testing::TestError::Failed;
1049	+	}
1050	+	}
1051	+	for program in [
1052	+	"fn f() { let mut n: u32 = 0; let c = &mut n as &cell u32; let r = &n; set *c = 1; }",
1053	+	"unsafe fn f() { let mut n: u32 = 0; let c = &mut n as &cell u32; let r = &n; set *c = 1; }",
1054	+	] {
1055	+	let mut testArena61 = super::testArena();
1056	+	let testStorage61: 'test61 = &mut testArena61 in {
1057	+	let mut res = super::testResolver(testStorage61);
1058	+	let result = try super::resolveProgramStr(&mut res, program);
1059	+	let error = try super::expectError(&result);
1060	+	let case resolver::ErrorKind::BorrowConflict(_) = error.kind else throw testing::TestError::Failed;
1061	+	}
1062	+	}
1063	+	}
1064	+
1065	+	/// Cell writes preserve exact payload regions and destination lifetimes.
1066	+	@test unsafe fn testCellPointerRegion() throws (testing::TestError) {
1067	+	for program in [
1068	+	"fn f 'r 's (p: &'r cell &'r u32, value: &'s u32) { set *p = value; }",
1069	+	"unsafe fn f 'r 's (p: &'r cell &'r u32, value: &'s u32) { set *p = value; }",
1070	+	"fn f 'r 's (p: &'r cell u32) -> &'s cell u32 { return p; }",
1071	+	] {
1072	+	let mut testArena62 = super::testArena();
1073	+	let testStorage62: 'test62 = &mut testArena62 in {
1074	+	let mut res = super::testResolver(testStorage62);
1075	+	let result = try super::resolveProgramStr(&mut res, program);
1076	+	let error = try super::expectError(&result);
1077	+	let case resolver::ErrorKind::TypeMismatch(_) = error.kind else throw testing::TestError::Failed;
1078	+	}
1079	+	}
1080	+	for program in [
1081	+	"fn f 'r 's (p: &'r cell &'s u32, value: &'s u32) where 'r: 's { set *p = value; }",
1082	+	"unsafe fn f 'r 's (p: &'r cell &'s u32, value: &'s u32) where 'r: 's { set *p = value; }",
1083	+	] {
1084	+	let mut testArena63 = super::testArena();
1085	+	let testStorage63: 'test63 = &mut testArena63 in {
1086	+	let mut res = super::testResolver(testStorage63);
1087	+	let result = try super::resolveProgramStr(&mut res, program);
1088	+	let error = try super::expectError(&result);
1089	+	let case resolver::ErrorKind::RegionEscape(_) = error.kind else throw testing::TestError::Failed;
1090	+	}
1091	+	}
1092	+	}
1093	+
1094	+	/// Raw cell operations require an unsafe execution context.
1095	+	@test unsafe fn testCellPointerRawAccess() throws (testing::TestError) {
1096	+	for program in [
1097	+	"fn f(p: unsafe cell u32) -> u32 { return p; }",
1098	+	"fn f(p: unsafe cell u32) { set p = 1; }",
1099	+	"fn f(p: &unsafe cell u32) { set *p = 1; }",
1100	+	] {
1101	+	let mut testArena64 = super::testArena();
1102	+	let testStorage64: 'test64 = &mut testArena64 in {
1103	+	let mut res = super::testResolver(testStorage64);
1104	+	let result = try super::resolveProgramStr(&mut res, program);
1105	+	try super::expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation);
1106	+	}
1107	+	}
1108	+	}
1109	+
1110	+	/// A checked buffer context cannot be copied while its exclusive storage is live.
1111	+	@test unsafe fn testCheckedBufferOwnership() throws (testing::TestError) {
1112	+	for program in [
1113	+	"record Buffer: 'r { words: &'r mut [u32] } fn observe 'r (b: &Buffer 'r) {} fn f 'r (b: Buffer 'r) { let moved = b; observe(&b); }",
1114	+	"record Buffer: 'r { words: &'r mut [u32] } unsafe fn observe 'r (b: &Buffer 'r) {} unsafe fn f 'r (b: Buffer 'r) { let moved = b; observe(&b); }",
1115	+	] {
1116	+	let mut testArena65 = super::testArena();
1117	+	let testStorage65: 'test65 = &mut testArena65 in {
1118	+	let mut res = super::testResolver(testStorage65);
1119	+	let result = try super::resolveProgramStr(&mut res, program);
1120	+	let error = try super::expectError(&result);
1121	+	let case resolver::ErrorKind::AffineUseAfterMove(_) = error.kind else throw testing::TestError::Failed;
1122	+	}
1123	+	}
1124	+	}
1125	+
1126	+	/// An iterator's stored shared borrow excludes writes through the buffer owner.
1127	+	@test unsafe fn testCheckedIteratorLoan() throws (testing::TestError) {
1128	+	for program in [
1129	+	"record Buffer: 'r { words: &'r mut [u32] } record Iter: 'r + 'v + Copy where 'r: 'v { source: &'v Buffer 'r } fn f 'r (b: Buffer 'r) { let mut owner = b; let view: 'scan = &owner where 'r: 'scan in { let iterator: Iter 'r 'scan = Iter { source: view }; set owner.words[0] = 1; } }",
1130	+	"record Buffer: 'r { words: &'r mut [u32] } record Iter: 'r + 'v + Copy where 'r: 'v { source: &'v Buffer 'r } unsafe fn f 'r (b: Buffer 'r) { let mut owner = b; let view: 'scan = &owner where 'r: 'scan in { let iterator: Iter 'r 'scan = Iter { source: view }; set owner.words[0] = 1; } }",
1131	+	] {
1132	+	let mut testArena66 = super::testArena();
1133	+	let testStorage66: 'test66 = &mut testArena66 in {
1134	+	let mut res = super::testResolver(testStorage66);
1135	+	let result = try super::resolveProgramStr(&mut res, program);
1136	+	let error = try super::expectError(&result);
1137	+	let case resolver::ErrorKind::BorrowConflict(_) = error.kind else throw testing::TestError::Failed;
1138	+	}
1139	+	}
1140	+	}
1141	+
1142	+	/// An inferred raw pointer argument requires an unsafe address operation.
1143	+	@test unsafe fn testRegionCallRawAddress() throws (testing::TestError) {
1144	+	let mut arena = super::testArena();
1145	+	let storage: 'arena = &mut arena in {
1146	+	let mut res = super::testResolver(storage);
1147	+	let result = try super::resolveProgramStr(&mut res,
1148	+	"record View: 'r + Copy { value: &'r u32 } fn read 'r (view: *unsafe View 'r) {} fn f 'r (view: View 'r) { read(&view); }");
1149	+	try super::expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation);
1150	+	}
1151	+	}
1152	+
1153	+	/// Shared aggregate access cannot expose mutable access to an exclusive field.
1154	+	@test unsafe fn testSharedExclusiveFieldAccess() throws (testing::TestError) {
1155	+	for program in [
1156	+	"record H: 'r { items: &'r mut [u32] } fn f 'r (h: &H 'r) { set h.items[0] = 42; }",
1157	+	"record H: 'r { items: &'r mut [u32] } unsafe fn f 'r (h: &H 'r) { set h.items[0] = 42; }",
1158	+	"record H: 'r { items: &'r mut [u32] } fn f 'r (h: &'r H 'r) { let p = &mut h.items[0]; }",
1159	+	"record H: 'r { items: &'r mut [u32] } unsafe fn f 'r (h: &'r H 'r) { let p = &mut h.items[0]; }",
1160	+	"record H: 'r { items: &'r mut [u32] } fn write(p: &mut [u32]) {} fn f 'r (h: &H 'r) { write(h.items); }",
1161	+	"record H: 'r { items: &'r mut [u32] } fn write(p: &mut [u32]) {} unsafe fn f 'r (h: &H 'r) { write(h.items); }",
1162	+	"record H: 'r { item: &'r mut u32 } fn f 'r (h: &H 'r) { let p: &mut u32 = h.item; }",
1163	+	"record H: 'r { item: &'r mut u32 } unsafe fn f 'r (h: &H 'r) { let p: &mut u32 = h.item; }",
1164	+	"record H { item: mut u32 } fn f(h: &H) { set h.item = 42; }",
1165	+	"record H { item: mut u32 } unsafe fn f(h: &H) { set h.item = 42; }",
1166	+	"record H: 'r { items: [&'r mut u32; 1] } fn f 'r (h: &H 'r) { set *h.items[0] = 42; }",
1167	+	"record H: 'r { items: [&'r mut u32; 1] } unsafe fn f 'r (h: &H 'r) { set *h.items[0] = 42; }",
1168	+	"fn f 'r (items: &'r [&'r mut u32]) { set *items[0] = 42; }",
1169	+	"unsafe fn f 'r (items: &'r [&'r mut u32]) { set *items[0] = 42; }",
1170	+	"fn f 'r (p: &'r &'r mut u32) { set **p = 42; }",
1171	+	"unsafe fn f 'r (p: &'r &'r mut u32) { set **p = 42; }",
1172	+	"record H: 'r { item: &'r mut u32 } fn write(p: &mut u32) {} fn f 'r (h: &H 'r, flag: bool) { write(h.item if flag else h.item); }",
1173	+	"record H: 'r { item: &'r mut u32 } fn write(p: &mut u32) {} unsafe fn f 'r (h: &H 'r, flag: bool) { write(h.item if flag else h.item); }",
1174	+	"record V { n: u32 } record H { item: *mut V } fn (v: &mut V) write() { set v.n = 42; } fn f(h: &H) { h.item.write(); }",
1175	+	"record V { n: u32 } record H { item: *mut V } fn (v: &mut V) write() { set v.n = 42; } unsafe fn f(h: &H) { h.item.write(); }",
1176	+	"trait W { fn (&mut W) write(); } record H: 'r { object: &'r mut opaque W } fn f 'r (h: &H 'r) { h.object.write(); }",
1177	+	"trait W { fn (&mut W) write(); } record H: 'r { object: &'r mut opaque W } unsafe fn f 'r (h: &H 'r) { h.object.write(); }",
1178	+	] {
1179	+	let mut arena = super::testArena();
1180	+	let storage: 'test = &mut arena in {
1181	+	let mut res = super::testResolver(storage);
1182	+	let result = try super::resolveProgramStr(&mut res, program);
1183	+	try super::expectErrorKind(&result, resolver::ErrorKind::ImmutableBinding);
1184	+	}
1185	+	}
1186	+	}
1187	+
1188	+	/// A reference through an exclusive field cannot outlive the owner's borrow.
1189	+	@test unsafe fn testExclusiveOwnerBorrowLifetimes() throws (testing::TestError) {
1190	+	for program in [
1191	+	"record H: 'r { item: &'r mut u32 } fn f 'r 's (h: &'s H 'r) -> &'r u32 where 'r: 's { let p: &'r u32 = h.item; return p; }",
1192	+	"record H: 'r { item: ?&'r mut u32 } fn f 'r 's (h: &'s H 'r) -> ?&'r u32 where 'r: 's { let p: ?&'r u32 = h.item; return p; }",
1193	+	"record H: 'r { item: &'r mut [u32] } fn f 'r 's (h: &'s H 'r) -> &'r [u32] where 'r: 's { let p: &'r [u32] = h.item; return p; }",
1194	+	"record H: 'r { item: &'r mut u32 } unsafe fn f 'r 's (h: &'s H 'r) -> &'r u32 where 'r: 's { let p: &'r u32 = h.item; return p; }",
1195	+	"record H: 'r { item: ?&'r mut u32 } unsafe fn f 'r 's (h: &'s H 'r) -> ?&'r u32 where 'r: 's { let p: ?&'r u32 = h.item; return p; }",
1196	+	"record H: 'r { item: &'r mut [u32] } unsafe fn f 'r 's (h: &'s H 'r) -> &'r [u32] where 'r: 's { let p: &'r [u32] = h.item; return p; }",
1197	+	"record H: 'r { item: &'r mut u32 } fn f 'r 's (h: &'s H 'r) -> &'r u32 where 'r: 's { return &*h.item; }",
1198	+	"record H: 'r { item: &'r mut u32 } unsafe fn f 'r 's (h: &'s H 'r) -> &'r u32 where 'r: 's { return &*h.item; }",
1199	+	"record H: 'r { items: &'r mut [u32] } fn f 'r 's (h: &'s H 'r) -> &'r u32 where 'r: 's { return &h.items[0]; }",
1200	+	"record H: 'r { items: &'r mut [u32] } unsafe fn f 'r 's (h: &'s H 'r) -> &'r u32 where 'r: 's { return &h.items[0]; }",
1201	+	"record H: 'r { item: &'r mut u32 } fn f 'r 's (h: &'s mut H 'r) -> &'r mut u32 where 'r: 's { return &mut *h.item; }",
1202	+	"record H: 'r { item: &'r mut u32 } unsafe fn f 'r 's (h: &'s mut H 'r) -> &'r mut u32 where 'r: 's { return &mut *h.item; }",
1203	+	"record H { item: mut u32 } fn f(h: &H) -> u32 { return &*h.item; }",
1204	+	"record H { item: mut u32 } unsafe fn f(h: &H) -> u32 { return &*h.item; }",
1205	+	"record H: 'r { items: &'r mut [u32] } fn f 'r 's (h: &'s H 'r) -> &'r [u32] where 'r: 's { return &h.items[..]; }",
1206	+	"record H: 'r { items: &'r mut [u32] } unsafe fn f 'r 's (h: &'s H 'r) -> &'r [u32] where 'r: 's { return &h.items[..]; }",
1207	+	] {
1208	+	let mut arena = super::testArena();
1209	+	let storage: 'test = &mut arena in {
1210	+	let mut res = super::testResolver(storage);
1211	+	let result = try super::resolveProgramStr(&mut res, program);
1212	+	let error = try super::expectError(&result);
1213	+	let case resolver::ErrorKind::TypeMismatch(_) = error.kind else throw testing::TestError::Failed;
1214	+	}
1215	+	}
1216	+	}
1217	+
1218	+	/// A shared binding cannot hide a move from an exclusive field.
1219	+	@test unsafe fn testSharedBindingPreservesSourceOwnership() throws (testing::TestError) {
1220	+	for program in [
1221	+	"record H { item: mut u32 } fn f(h: H) -> u32 { let p: *u32 = h.item; return p; }",
1222	+	"record H { item: ?mut u32 } fn f(h: H) -> ?u32 { let p: ?*u32 = h.item; return p; }",
1223	+	"record H: 'r { item: &'r mut u32 } fn f 'r (h: &'r H 'r) -> &'r u32 { let p: &'r u32 = h.item; return p; }",
1224	+	"record H { item: mut u32 } unsafe fn f(h: H) -> u32 { let p: *u32 = h.item; return p; }",
1225	+	"record H { item: ?mut u32 } unsafe fn f(h: H) -> ?u32 { let p: ?*u32 = h.item; return p; }",
1226	+	"record H: 'r { item: &'r mut u32 } unsafe fn f 'r (h: &'r H 'r) -> &'r u32 { let p: &'r u32 = h.item; return p; }",
1227	+	] {
1228	+	let mut arena = super::testArena();
1229	+	let storage: 'test = &mut arena in {
1230	+	let mut res = super::testResolver(storage);
1231	+	let result = try super::resolveProgramStr(&mut res, program);
1232	+	try super::expectErrorKind(&result, resolver::ErrorKind::LinearPartialMove);
1233	+	}
1234	+	}
1235	+	}
1236	+
1237	+	/// Methods and trait instances resolve declaration region parameters.
1238	+	@test unsafe fn testRegionalMethods() throws (testing::TestError) {
1239	+	for program in [
1240	+	"record View: 'r { value: &'r u32 } fn (view: &View 'r) get 'r () -> &'r u32 { return view.value; } fn read 'x (view: &View 'x) -> u32 { return *view.get(); }",
1241	+	"trait Pick { fn (&Pick) pick 'r (value: &'r u32) -> &'r u32; } record Picker {} instance Pick for Picker { fn (picker: &Picker) pick 'r (value: &'r u32) -> &'r u32 { return value; } } fn choose 'x (picker: &opaque Pick, value: &'x u32) -> &'x u32 { return picker.pick(value); }",
1242	+	"trait Read { fn (&Read) read() -> u32; } record Regional: 'r { value: &'r u32 } instance Read for Regional 'r { fn (value: &Regional 'r) read() -> u32 { return *value.value; } } fn inspect(value: &opaque Read) -> u32 { return value.read(); } fn call 'x (value: &Regional 'x) -> u32 { return inspect(value); }",
1243	+	] {
1244	+	let mut arena = super::testArena();
1245	+	let storage: 'method = &mut arena in {
1246	+	let mut res = super::testResolver(storage);
1247	+	let result = try super::resolveProgramStr(&mut res, program);
1248	+	try super::expectNoErrors(&result);
1249	+	}
1250	+	}
1251	+	}

lib/std/lang/scanner.rad +15 -3


    /// Eg. `fnord`
    Ident,
    /// Eg. `@default`
    AtIdent,
    /// Region name with an apostrophe prefix.
    Region,
    /// The `log` keyword.
    Log,

    // Literals.
    String,     // "fnord"

    // Trait-related tokens.
    Trait, Instance,

    // Type-related tokens.
    I8, I16, I32, I64, U8, U16, U32, U64,
    Opaque, Fn, Bool, Union, Record, As, Unsafe
    Opaque, Fn, Bool, Union, Record, As, Unsafe, Where
}

/// A reserved keyword.
record Keyword: Copy {
    /// Keyword string.

    /// Corresponding token.
    tok: TokenKind,
}

/// Sorted keyword table for binary search.
constant KEYWORDS: [Keyword; 52] = [
constant KEYWORDS: [Keyword; 53] = [
    { name: "align", tok: TokenKind::Align },
    { name: "and", tok: TokenKind::And },
    { name: "as", tok: TokenKind::As },
    { name: "assert", tok: TokenKind::Assert },
    { name: "bool", tok: TokenKind::Bool },

    { name: "u8", tok: TokenKind::U8 },
    { name: "undefined", tok: TokenKind::Undefined },
    { name: "union", tok: TokenKind::Union },
    { name: "unsafe", tok: TokenKind::Unsafe },
    { name: "use", tok: TokenKind::Use },
    { name: "where", tok: TokenKind::Where },
    { name: "while", tok: TokenKind::While },
];

/// Describes where source code originated from.
export union SourceLoc: Copy {

        return tok;
    }
    return invalid(s.token, "unterminated string");
}

/// Scan character literal enclosed in single quotes.
/// Scan an apostrophe-prefixed region name or a quoted character literal.
fn scanChar(s: &mut Scanner) -> Token {
    if let ch = current(s); char::isAlpha(ch) or ch == '_' {
        while let ch = current(s); char::isAlpha(ch) or ch == '_' or char::isDigit(ch) {
            advance(s);
        }
        if consume(s, '\'') {
            return tok(s, TokenKind::Char);
        }
        return tok(s, TokenKind::Region);
    }
    if let tok = scanDelimited(s, '\'', TokenKind::Char) {
        return tok;
    }
    return invalid(s.token, "unterminated character");
}

lib/std/lang/scanner/tests.rad +30 -1

        try testing::expect(super::next(&mut s).kind == expectedKind);
    }
}

@test unsafe fn testScanKeywords() throws (testing::TestError) {
    let mut s = testScanner("nil mod not static unsafe");
    let mut s = testScanner("nil mod not static unsafe where");
    let tok1: super::Token = super::next(&mut s);

    try testing::expect(tok1.kind == super::TokenKind::Nil);
    try testing::expect(tok1.source.len == 3);


    try testing::expect(tok4.source.len == 6);

    let tok5: super::Token = super::next(&mut s);
    try testing::expect(tok5.kind == super::TokenKind::Unsafe);
    try testing::expect(tok5.source.len == 6);

    let tok6: super::Token = super::next(&mut s);
    try testing::expect(tok6.kind == super::TokenKind::Where);
    try testing::expect(tok6.source.len == 5);
}

@test unsafe fn testScanVoidAsIdent() throws (testing::TestError) {
    let mut s = testScanner("void");
    let tok: super::Token = super::next(&mut s);

    try testing::expect(super::next(&mut s).kind == super::TokenKind::Ident);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Semicolon);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::RBrace);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Eof);
}

/// Region tokens preserve their names and do not consume character literals.
@test unsafe fn testScanRegions() throws (testing::TestError) {
    let mut s = testScanner("'x 'long_2 'x' '\\n' 'outer<'inner");
    let first = super::next(&mut s);
    try testing::expect(first.kind == super::TokenKind::Region);
    try testing::expect(mem::eq(first.source, "'x"));
    let second = super::next(&mut s);
    try testing::expect(second.kind == super::TokenKind::Region);
    try testing::expect(mem::eq(second.source, "'long_2"));
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Char);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Char);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Region);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Lt);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Region);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Eof);
}

/// An apostrophe without a name or a closing quote is invalid.
@test unsafe fn testScanMalformedRegions() throws (testing::TestError) {
    for text in ["'", "'1", "'\\", "'\n"] {
        let mut s = testScanner(text);
        try testing::expect(super::next(&mut s).kind == super::TokenKind::Invalid);
    }
}

lib/std/lang/types.rad +43 -0

export union PointerClass: Copy {
    /// Owned pointer, eg. `*T`.
    Owned,
    /// Reference, borrowed pointer, eg. `&T`.
    Ref,
    /// Reference retained by one resolved lexical region.
    Region(*unsafe Region),
    /// Unsafe, raw pointer, eg. `*unsafe T`.
    Unsafe,
}

/// Source construct that introduces a region identity.
export union RegionOrigin: Copy {
    /// Caller-supplied declaration parameter.
    Parameter,
    /// Concrete region delimited by a lexical block.
    Block,
}

/// Semantic identity and ancestry of a source region.
export record Region: Copy {
    /// Globally unique AST node ID of the region declaration.
    id: u32,
    /// Source construct that supplies the region lifetime.
    origin: RegionOrigin,
    /// Source spelling used in diagnostics.
    name: *[u8],
    /// Proven enclosing region, if one is declared.
    parent: ?*unsafe Region,
}

/// Return whether a pointer class denotes checked borrowed storage.
export fn isReference(class: PointerClass) -> bool {
    match class {
        case PointerClass::Ref, PointerClass::Region(_) => return true,
        else => return false,
    }
}

/// Return whether a region is equal to, or contains, another region.
/// Parent links must form an acyclic graph within one resolver.
export unsafe fn regionContains(parent: *unsafe Region, child: *unsafe Region) -> bool {
    let mut current: ?*unsafe Region = child;
    while let region = current {
        if region.id == parent.id {
            return true;
        }
        set current = region.parent;
    }
    return false;
}

seed/radiance.rv64 +0 -0

Binary file changed.

seed/radiance.rv64.git +1 -1

1		-	cbc895eb5c6c569c7648e51c5e4ff0579de8b925415ceb368100d07370b9fd7e
	1	+	4a24fa5e2f0b82d0aa1f922caa85dcf831d22cb8828365820197f8ebb13f55b4

std.lib +1 -0

lib/std/lang/gen/regalloc.rad
lib/std/lang/gen/regalloc/liveness.rad
lib/std/lang/gen/regalloc/spill.rad
lib/std/lang/gen/regalloc/assign.rad
lib/std/arch/rv64/shared.rad
lib/std/arch/rv64/shared/catalog.rad
lib/std/arch/rv64/atomics.rad

std.lib.test +4 -1

lib/std/char/tests.rad
lib/std/arch/rv64/tests.rad
lib/std/arch/rv64/asm/tests.rad
lib/std/arch/rv64/asm/scanner/tests.rad
lib/std/lang/alloc/tests.rad
lib/std/lang/gen/bitset/tests.rad
lib/std/lang/gen/regalloc/liveness/tests.rad
lib/std/lang/il/tests.rad
lib/std/lang/parser/tests.rad
lib/std/lang/module/tests.rad
lib/std/lang/scanner/tests.rad
lib/std/lang/resolver/tests.rad
lib/std/lang/gen/bitset/tests.rad
lib/std/lang/il/binary/tests.rad
lib/std/lang/il/binary/decodeTests.rad
lib/std/arch/rv64/image/tests.rad
lib/std/arch/rv64/shared/tests.rad
lib/std/arch/rv64/bounds.rad
lib/std/arch/rv64/atomicTests.rad
lib/std/lang/resolver/tests/regions.rad

test/runner.rad +30 -28

        io::printLn("error: parsing failed");
        return false;
    };

    // Run resolver.
    let mut resolverArena = alloc::new(&mut RESOLVER_ARENA_STORAGE[..]);
    let storage = resolver::ResolverStorage {
        arena: alloc::new(&mut RESOLVER_ARENA_STORAGE[..]),
        nodeData: &mut NODE_DATA_STORAGE[..],
        pkgScope: &mut pkgScope,
        errors: &mut ERROR_STORAGE[..],
    };
    let config = resolver::Config { buildTest: false };
    let mut res = resolver::resolver(storage, config);
    let diag = try resolver::resolveModuleRoot(&mut res, root) catch {
        io::printLn("error: resolver failed");
        return false;
    };
    if not resolver::success(&diag) {
        io::printLn("error: resolver failed");
        return false;
    }
    let arenaRef: 'arena = &mut resolverArena in {
        let mut res = resolver::resolver(arenaRef, storage, config);
        let diag = try resolver::resolveModuleRoot(&mut res, root) catch {
            io::printLn("error: resolver failed");
            return false;
        };
        if not resolver::success(&diag) {
            io::printLn("error: resolver failed");
            return false;
        }

    // Lower to IL.
    let mut ilArena = alloc::new(&mut IL_ARENA_STORAGE[..]);
    let program = try lower::lower(&res, root, "test", &mut ilArena) catch err {
        io::print("error: lowering failed: ");
        lower::printError(err);
        io::printLn("");
        return false;
    };
        // Lower to IL.
        let mut ilArena = alloc::new(&mut IL_ARENA_STORAGE[..]);
        let program = try lower::lower(&res, root, "test", &mut ilArena) catch err {
            io::print("error: lowering failed: ");
            lower::printError(err);
            io::printLn("");
            return false;
        };

    // Print IL to buffer.
    let actual = printer::printProgramToBuffer(&program, &mut OUTPUT_BUF[..]);
        // Print IL to buffer.
        let actual = printer::printProgramToBuffer(&program, &mut OUTPUT_BUF[..]);

    // Compare ignoring comments.
    if not stringsEqual(actual, expected) {
        io::printLn("FAILED");
        printDiff(expected, actual);
        return false;
    }
    io::printLn("ok");
        // Compare ignoring comments.
        if not stringsEqual(actual, expected) {
            io::printLn("FAILED");
            printDiff(expected, actual);
            return false;
        }
        io::printLn("ok");

    return true;
        return true;
    }
}

/// Run a single test specified as an argument.
@default unsafe fn main(env: *sys::Env) -> i32 {
    let args = env.args;

test/tests/const.record.mutcopy.ril +5 -2

  @then1
    copy %6 $SCRATCH2;
    blit %2 %6 1;
    jmp @merge2;
  @merge2
    load w64 %8 %2 0;
    ret %8;
    reserve %8 8 8;
    store w64 0 %8 0;
    blit %8 %2 1;
    load w64 %9 %8 0;
    ret %9;
}

test/tests/field.aggregate.ril +5 -2

    store w8 1 %2 0;
    add w64 %3 %2 4;
    blit %3 %1 4;
    blit %0 %2 8;
    store w32 99 %0 8;
    load w64 %4 %0 0;
    ret %4;
    reserve %4 8 8;
    store w64 0 %4 0;
    blit %4 %0 8;
    load w64 %5 %4 0;
    ret %5;
}

fn w32 $accessSliceField() {
  @entry0
    reserve %0 12 4;

test/tests/let.copy.semantics.ril +5 -2

fn w64 $makePoint() {
  @entry0
    reserve %0 8 4;
    store w32 1 %0 0;
    store w32 2 %0 4;
    load w64 %1 %0 0;
    ret %1;
    reserve %1 8 8;
    store w64 0 %1 0;
    blit %1 %0 8;
    load w64 %2 %1 0;
    ret %2;
}

fn w32 $letFromCall() {
  @entry0
    call w64 %0 $makePoint();

test/tests/record.ctor.tuple.ril +5 -2

fn w64 $make() {
  @entry0
    reserve %0 8 4;
    store w32 1 %0 0;
    store w32 2 %0 4;
    load w64 %1 %0 0;
    ret %1;
    reserve %1 8 8;
    store w64 0 %1 0;
    blit %1 %0 8;
    load w64 %2 %1 0;
    ret %2;
}

test/tests/slice.append.rad +1 -1


fn newArena(data: *mut [u8]) -> Arena {
    return Arena { data, offset: 0 };
}

fn arenaAlloc(arena: &mut Arena, size: u32, al: u32) -> *mut opaque {
unsafe fn arenaAlloc(arena: *unsafe mut Arena, size: u32, al: u32) -> *mut opaque {
    let aligned = (arena.offset + al - 1) / al * al;
    let newOffset = aligned + size;

    assert newOffset <= arena.data.len as u32;


test/tests/union.ctor.ril +10 -4

    store w32 7 %0 0;
    reserve %1 8 4;
    store w8 1 %1 0;
    add w64 %2 %1 4;
    blit %2 %0 4;
    load w64 %3 %1 0;
    ret %3;
    reserve %3 8 8;
    store w64 0 %3 0;
    blit %3 %1 8;
    load w64 %4 %3 0;
    ret %4;
}

fn w64 $makeNone() {
  @entry0
    reserve %0 8 4;
    store w8 0 %0 0;
    load w64 %1 %0 0;
    ret %1;
    reserve %1 8 8;
    store w64 0 %1 0;
    blit %1 %0 8;
    load w64 %2 %1 0;
    ret %2;
}

test/tests/union.variant.access.ril +15 -6


fn w64 $makeNone() {
  @entry0
    reserve %0 8 4;
    store w8 0 %0 0;
    load w64 %1 %0 0;
    ret %1;
    reserve %1 8 8;
    store w64 0 %1 0;
    blit %1 %0 8;
    load w64 %2 %1 0;
    ret %2;
}

fn w64 $makeSome(w32 %0) {
  @entry0
    reserve %1 4 4;
    store w32 %0 %1 0;
    reserve %2 8 4;
    store w8 1 %2 0;
    add w64 %3 %2 4;
    blit %3 %1 4;
    load w64 %4 %2 0;
    ret %4;
    reserve %4 8 8;
    store w64 0 %4 0;
    blit %4 %2 8;
    load w64 %5 %4 0;
    ret %5;
}

fn w64 $assignNone() {
  @entry0
    reserve %0 8 4;
    store w8 0 %0 0;
    load w64 %1 %0 0;
    ret %1;
    reserve %1 8 8;
    store w64 0 %1 0;
    blit %1 %0 8;
    load w64 %2 %1 0;
    ret %2;
}

vim/radiance.vim +7 -2


" Keywords
syntax keyword radianceKeyword mod fn return if else while true false and or not case align static
syntax keyword radianceKeyword export break continue use loop in for match nil undefined
syntax keyword radianceKeyword let mut set as register device constant log record union trait instance
syntax keyword radianceKeyword throws throw try catch panic assert super unsafe
syntax keyword radianceKeyword throws throw try catch panic assert super unsafe where
syntax keyword radianceType i8 i16 i32 i64 u8 u16 u32 u64 f32 void bool bit opaque Copy Once

" Double-quoted strings
syntax region radianceString start=/"/ skip=/\\"/ end=/"/ contains=radianceEscape
" Characters
syntax region radianceCharacter start=/'/ skip=/\\'|\\\\/ end=/'/ oneline contains=radianceEscape
syntax match radianceCharacter /'\h\w*'/ contains=radianceEscape
syntax region radianceCharacter start=/'\%(\h\)\@!/ skip=/\\'|\\\\/ end=/'/ oneline contains=radianceEscape
" Lexical regions
syntax match radianceRegion "'\h\w*\%('\)\@!"
" String escapes
syntax match radianceEscape contained /\\["'nrtvfab\\]/
" Compiler built-in
syntax match radianceBuiltin "@\h\w\+"


syntax match radianceNumber "\<\d\+\>"
syntax match radiancePlaceholder "\<_\>"

" Function names
syntax match radianceFunction "\<\h\w*\>\s*?("
syntax match radianceFunction "\<\h\w*\>\ze\s*\%('\h\w*\s*\)*("

" Operators
syntax match radianceOperator "[:!?&\-+*/=<>]"
syntax match radianceOperator "/"  contains=radianceComment


highlight default link radianceBraces Delimiter
highlight default link radianceParens Delimiter
highlight default link radianceBrackets Delimiter
highlight default link radianceString String
highlight default link radianceCharacter Character
highlight default link radianceRegion Type
highlight default link radianceEscape SpecialChar
highlight default link radianceNamespaceAccess Normal

let b:current_syntax = "radiance"

1253	1385		try generateTestRunner(&mut ctx, &mut arena) catch {
1254	1386		return 1;
1255	1387		};
1256	1388		}
1257	1389		// Run resolution phase.
1258		-	let mut res = try runResolver(&mut ctx, arena.nextId) catch {
1259		-	return 1;
1260		-	};
1261		-	let mut fnArena = alloc::new(&mut FN_ARENA[..]);
	1390	+	let mut mainArena = alloc::new(&mut MAIN_ARENA[..]);
	1391	+	let arenaRef: 'arena = &mut mainArena in {
	1392	+	let mut res = try runResolver(&mut ctx, arenaRef, arena.nextId) catch {
	1393	+	return 1;
	1394	+	};
	1395	+	let mut fnArena = alloc::new(&mut FN_ARENA[..]);
1262	1396
1263		-	// Lower, dump, and/or generate output.
1264		-	try compile(&mut ctx, &mut res, &mut fnArena) catch {
1265		-	return 1;
1266		-	};
1267		-	return 0;
	1397	+	// Lower, dump, and/or generate output.
	1398	+	try compile(&mut ctx, &mut res, &mut fnArena) catch {
	1399	+	return 1;
	1400	+	};
	1401	+	return 0;
	1402	+	}
1268	1403		}

14	14		use std::lang::package;
15	15		use std::lang::il;
16	16		use std::lang::lower;
17	17		use std::arch::rv64;
18	18		use std::arch::rv64::asm;
	19	+	use std::arch::rv64::emit;
19	20		use std::arch::rv64::printer;
20	21		use std::lang::sexpr;
21	22		use std::lang::gen::data;
22	23		use std::lang::il::binary;
23	24		use std::lang::il::binary::collect;
24	25		use std::lang::il::binary::program;
	26	+	use std::lang::gen::labels;
25	27		use std::lang::gen::types;
26	28		use std::sys;
27	29		use std::sys::unix;
28	30		use std::collections::dict;
29	31
30	32		/// Maximum number of modules we can load per package.
31		-	constant MAX_LOADED_MODULES: u32 = module::MAX_MODULES;
	33	+	constant MAX_LOADED_MODULES: u32 = 128;
32	34		/// Maximum number of packages we can compile.
33	35		constant MAX_PACKAGES: u32 = 4;
34		-	/// Total module entries across all packages.
35		-	constant MAX_TOTAL_MODULES: u32 = 192;
36		-	/// Source code buffer arena (2 MB).
37		-	constant MAX_SOURCES_SIZE: u32 = 2097152;
	36	+	/// Source code buffer arena (4 MB).
	37	+	constant MAX_SOURCES_SIZE: u32 = 4194304;
38	38		/// Maximum number of test functions we can discover.
39	39		constant MAX_TESTS: u32 = 1024;
40	40		/// Maximum number of assembly source paths we can load per package.
41	41		constant MAX_ASM_MODULES: u32 = 64;
42	42
43	43		/// AST arena size (64 MB) - retains parsed nodes throughout compilation.
44	44		constant TEMP_ARENA_SIZE: u32 = 67108864;
45	45		/// Per-function lowering and register-allocation arena size (16 MB).
46	46		constant FN_ARENA_SIZE: u32 = 16777216;
47		-	/// Main arena size (96 MB) - lives throughout compilation.
	47	+	/// Main arena size (160 MB) - lives throughout compilation.
48	48		/// Used for: resolver data, types, symbols, global IL data, and codegen output.
49		-	constant MAIN_ARENA_SIZE: u32 = 100663296;
	49	+	constant MAIN_ARENA_SIZE: u32 = 167772160;
50	50
51	51		/// AST storage arena.
52	52		static TEMP_ARENA: [u8; TEMP_ARENA_SIZE] = [0; TEMP_ARENA_SIZE];
53	53		/// Scratch storage reclaimed after each generated function.
54	54		static FN_ARENA: [u8; FN_ARENA_SIZE] = [0; FN_ARENA_SIZE];

56	56		static MAIN_ARENA: [u8; MAIN_ARENA_SIZE] = [0; MAIN_ARENA_SIZE];
57	57
58	58		/// Module source code.
59	59		static MODULE_SOURCES: [u8; MAX_SOURCES_SIZE] = [0; MAX_SOURCES_SIZE];
60	60		/// Module entries for all packages.
61		-	unsafe static MODULE_ENTRIES: [module::ModuleEntry; MAX_TOTAL_MODULES] = undefined;
	61	+	unsafe static MODULE_ENTRIES: [?*module::ModuleEntry; module::MAX_MODULES] = [nil; module::MAX_MODULES];
62	62		/// String pool.
63	63		unsafe static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
64	64
65	65		/// Package scope.
66	66		unsafe static RESOLVER_PKG_SCOPE: resolver::Scope = undefined;

69	69
70	70		/// Code generation storage.
71	71		unsafe static CODEGEN_DATA_SYMS: [data::DataSym; data::MAX_DATA_SYMS] = undefined;
72	72		/// Hash table entries for data symbol lookup.
73	73		unsafe static CODEGEN_DATA_SYM_ENTRIES: [dict::Entry; data::DATA_SYM_TABLE_SIZE] = undefined;
	74	+	/// Emitted instruction storage.
	75	+	static CODEGEN_INSTRUCTIONS: [u32; emit::MAX_INSTRS] = [0; emit::MAX_INSTRS];
	76	+	/// Local branch patch storage.
	77	+	unsafe static CODEGEN_PENDING_BRANCHES: [emit::PendingBranch; emit::MAX_PENDING] = undefined;
	78	+	/// Function call patch storage.
	79	+	unsafe static CODEGEN_PENDING_CALLS: [emit::PendingCall; emit::MAX_PENDING] = undefined;
	80	+	/// Assembly jump patch storage.
	81	+	unsafe static CODEGEN_PENDING_JUMPS: [emit::PendingJump; emit::MAX_PENDING] = undefined;
	82	+	/// Address load patch storage.
	83	+	unsafe static CODEGEN_PENDING_ADDR_LOADS: [emit::PendingAddrLoad; emit::MAX_PENDING] = undefined;
	84	+	/// Per-function block offset storage.
	85	+	static CODEGEN_BLOCK_OFFSETS: [i32; labels::MAX_BLOCKS_PER_FN] = [0; labels::MAX_BLOCKS_PER_FN];
	86	+	/// Function label hash table storage.
	87	+	unsafe static CODEGEN_FUNC_ENTRIES: [dict::Entry; labels::FUNC_TABLE_SIZE] = undefined;
	88	+	/// Printed function address storage.
	89	+	unsafe static CODEGEN_FUNCS: [types::FuncAddr; emit::MAX_FUNCS] = undefined;
	90	+	/// Debug location storage.
	91	+	unsafe static CODEGEN_DEBUG_ENTRIES: [types::DebugEntry; emit::MAX_DEBUG_ENTRIES] = undefined;
74	92
75	93		/// Maximum number of exported definitions in one binary package.
76	94		constant MAX_PACKAGE_EXPORTS: u32 = 8192;
77	95		/// Maximum number of indexed names in one binary package.
78	96		constant MAX_PACKAGE_SYMBOLS: u32 = 16384;

265	283
266	284		let moduleId = try package::registerModule(pkg, graph, &mut STRING_POOL, path) catch {
267	285		throw error(&["error registering module"]);
268	286		};
269	287		// Read file into remaining arena space.
270		-	let buffer = alloc::remainingBuf(sourceArena);
	288	+	let buffer = alloc::remainingBuf(&mut *sourceArena);
271	289		if buffer.len == 0 {
272	290		throw error(&["fatal:", "source arena exhausted"]);
273	291		}
274	292		let sourceLen = unix::readFile(path, buffer) else {
275	293		throw error(&["error reading file"]);

487	505		throw error(&["no root module found"]);
488	506		};
489	507		let rootEntry = module::get(graph, rootId) else {
490	508		throw error(&["root module entry not found"]);
491	509		};
492		-	let rootAst = rootEntry.ast else {
	510	+	let rootAst = module::astFor(rootEntry) else {
493	511		throw error(&["root module has no AST"]);
494	512		};
495	513		return RootModule { entry: rootEntry, ast: rootAst };
496	514		}
497	515

510	528		ast::printer::printTree(root.ast, &mut arena);
511	529		}
512	530
513	531		/// Lower all packages into a single IL program.
514	532		/// Dependencies are lowered first, then the entry package.
515		-	unsafe fn lowerAllPackages(
	533	+	unsafe fn lowerAllPackages 'arena (
516	534		ctx: *unsafe mut CompileContext,
517		-	res: *unsafe mut resolver::Resolver
	535	+	res: *unsafe mut resolver::Resolver 'arena
518	536		) -> il::Program throws (Error) {
519	537		let entryIdx = ctx.entryPkgIdx else {
520	538		panic "lowerAllPackages: no entry package";
521	539		};
522	540		let entryPkg = &ctx.packages[entryIdx];
523	541
524	542		// Create the lowerer accumulator using entry package's name.
525	543		let options = lower::LowerOptions { debug: ctx.debug, buildTest: ctx.config.buildTest };
526		-	let mut low = lower::lowerer(
527		-	res, &ctx.graph, entryPkg.name, &mut res.arena, &mut res.arena, options
528		-	);
529		-	try lowerAllPackagesInto(ctx, res, &mut low);
	544	+	let arena = (&mut res.arena) as unsafe mut alloc::Arena;
	545	+	let resolved: 'phase = &*res, graph = &ctx.graph where 'arena: 'phase in {
	546	+	let mut low = lower::lowerer(
	547	+	resolved, graph, entryPkg.name, arena, options
	548	+	);
	549	+	try lowerAllPackagesInto(ctx, &mut low, &mut *arena);
530	550
531		-	// Finalize and return the unified program.
532		-	return lower::finalize(low);
	551	+	// Finalize and return the unified program.
	552	+	return lower::finalize(low);
	553	+	}
533	554		}
534	555
535	556		/// Lower all packages into an existing lowerer.
536		-	unsafe fn lowerAllPackagesInto(
537		-	ctx: *unsafe mut CompileContext,
538		-	res: *unsafe mut resolver::Resolver,
539		-	low: &mut lower::Lowerer
540		-	) throws (Error) {
	557	+	unsafe fn lowerAllPackagesInto 'arena 'phase (
	558	+	ctx: &CompileContext,
	559	+	low: &mut lower::Lowerer 'arena 'phase,
	560	+	functionArena: &mut alloc::Arena
	561	+	) throws (Error) where 'arena: 'phase {
541	562		let entryIdx = ctx.entryPkgIdx else {
542	563		panic "lowerAllPackagesInto: no entry package";
543	564		};
544	565		// Lower all packages except entry.
545	566		for i in 0..ctx.packageCount {
546	567		if i <> entryIdx {
547		-	try lowerPackage(ctx, res, low, &ctx.packages[i], false);
	568	+	try lowerPackage(ctx, low, &ctx.packages[i], false, functionArena);
548	569		}
549	570		}
550	571		// Lower entry package.
551		-	try lowerPackage(ctx, res, low, &ctx.packages[entryIdx], true);
	572	+	try lowerPackage(ctx, low, &ctx.packages[entryIdx], true, functionArena);
552	573		}
553	574
554	575		/// Lower all modules in a package into the lowerer accumulator.
555		-	unsafe fn lowerPackage(
	576	+	unsafe fn lowerPackage 'arena 'phase (
556	577		ctx: &CompileContext,
557		-	res: *unsafe mut resolver::Resolver,
558		-	low: &mut lower::Lowerer,
	578	+	low: &mut lower::Lowerer 'arena 'phase,
559	579		pkg: &package::Package,
560		-	isEntry: bool
561		-	) throws (Error) {
	580	+	isEntry: bool,
	581	+	functionArena: &mut alloc::Arena
	582	+	) throws (Error) where 'arena: 'phase {
562	583		let rootId = pkg.rootModuleId else {
563	584		throw error(&["no root module found"]);
564	585		};
565	586		// Set lowerer's package context for qualified name generation.
566	587		// TODO: We shouldn't have to call this manually.
567		-	lower::setPackage(low, &ctx.graph, pkg.name);
	588	+	lower::setPackage(low, pkg.name);
568	589
569		-	try lowerModuleTreeInto(ctx, low, &ctx.graph, rootId, isEntry, pkg);
	590	+	try lowerModuleTreeInto(ctx, low, &ctx.graph, rootId, isEntry, pkg, functionArena);
570	591		}
571	592
572	593		/// Recursively lower a module and all its children into the accumulator.
573		-	unsafe fn lowerModuleTreeInto(
	594	+	unsafe fn lowerModuleTreeInto 'arena 'phase (
574	595		ctx: &CompileContext,
575		-	low: &mut lower::Lowerer,
	596	+	low: &mut lower::Lowerer 'arena 'phase,
576	597		graph: &module::ModuleGraph,
577	598		modId: u16,
578	599		isRoot: bool,
579		-	pkg: &package::Package
580		-	) throws (Error) {
	600	+	pkg: &package::Package,
	601	+	functionArena: &mut alloc::Arena
	602	+	) throws (Error) where 'arena: 'phase {
581	603		let entry = module::get(graph, modId) else {
582	604		throw error(&["module entry not found"]);
583	605		};
584		-	let modAst = entry.ast else {
	606	+	let modAst = module::astFor(entry) else {
585	607		throw error(&["module has no AST"]);
586	608		};
587	609		pkgLog(pkg, &["lowering", "(", entry.filePath, ")", ".."]);
588	610
589		-	try lower::lowerModule(low, modId, modAst, isRoot) catch err {
	611	+	try lower::lowerModule(low, modId, modAst, isRoot, functionArena) catch err {
590	612		io::printError("radiance: ");
591	613		io::printError("internal error during lowering: ");
592	614		lower::printError(err);
593	615		io::printError("\n");
594	616
595	617		throw Error::Other;
596	618		};
597	619		// Recurse into children.
598		-	for i in 0..entry.childrenLen {
	620	+	for i in 0..module::childCount(entry) {
599	621		let childId = module::childAt(entry, i);
600		-	try lowerModuleTreeInto(ctx, low, graph, childId, false, pkg);
	622	+	try lowerModuleTreeInto(ctx, low, graph, childId, false, pkg, functionArena);
601	623		}
602	624		}
603	625
604	626		/// Build a scope access chain: a::b::c from a slice of identifiers.
605	627		unsafe fn synthScopeAccess(arena: &mut ast::NodeArena, path: &[[u8]]) -> ast::Node {

635	657		fn collectModuleTests(
636	658		entry: *module::ModuleEntry,
637	659		tests: &mut [TestDesc],
638	660		testCount: &mut u32
639	661		) {
640		-	let modAst = entry.ast else {
	662	+	let modAst = module::astFor(entry) else {
641	663		return;
642	664		};
643	665		let case ast::NodeValue::Block(block) = modAst.value else {
644	666		return;
645	667		};

687	709		return ast::synthNode(arena, ast::NodeValue::Call(ast::Call { callee, args }));
688	710		}
689	711
690	712		/// Inject a test runner into the entry package's root module.
691	713		///
692		-	/// Scans all parsed modules for `@test fn` declarations, then appends
	714	+	/// Scans the entry package for `@test fn` declarations, then appends
693	715		/// a synthetic entry point to the root module's AST block:
694	716		///
695	717		/// ```
696	718		/// @default fn #testMain() -> i32 {
697	719		/// return testing::runAllTests(&[

707	729		arena: &mut ast::NodeArena
708	730		) throws (Error) {
709	731		let entryPkg = try getEntryPackage(ctx);
710	732		let root = try getRootModule(&entryPkg, &ctx.graph);
711	733
712		-	// Collect all test functions across all modules.
	734	+	// Collect test functions from the entry package's modules.
713	735		let mut tests: [TestDesc; MAX_TESTS] = undefined;
714	736		let mut testCount: u32 = 0;
715	737
716	738		for modIdx in 0..ctx.graph.entriesLen {
717	739		if let entry = module::get(&ctx.graph, modIdx as u16) {
718		-	collectModuleTests(entry, &mut tests[..], &mut testCount);
	740	+	if entry.packageId == entryPkg.id {
	741	+	collectModuleTests(entry, &mut tests[..], &mut testCount);
	742	+	}
719	743		}
720	744		}
721	745		if testCount == 0 {
722	746		throw error(&["fatal:", "no test functions found"]);
723	747		}

781	805		let unsafeAttr = ast::synthNode(arena, ast::NodeValue::Attribute(ast::Attribute::Unsafe));
782	806		let attrList = ast::nodeSlice(arena, 2).append(attrNode, a).append(unsafeAttr, a);
783	807		let fnAttrs = ast::Attributes { list: attrList };
784	808
785	809		return ast::synthNode(arena, ast::NodeValue::FnDecl(ast::FnDecl {
786		-	name: fnName, sig: fnSig, body: fnBody, attrs: fnAttrs,
	810	+	name: fnName, regions: &[], sig: fnSig, body: fnBody, attrs: fnAttrs,
787	811		}));
788	812		}
789	813
790	814		/// Build a block node with a declaration appended to its statement list.
791	815		unsafe fn injectIntoBlock(

856	880		) throws (Error) {
857	881		if entries.len == 0 {
858	882		return;
859	883		}
860	884		// Use remaining arena space as serialization buffer.
861		-	let buf = alloc::remainingBuf(arena);
	885	+	let buf = alloc::remainingBuf(&mut *arena);
862	886		let mut pos: u32 = 0;
863	887
864	888		for i in 0..entries.len {
865	889		let entry = &entries[i];
866	890		let modEntry = module::get(graph, entry.moduleId) else {

875	899		}
876	900		try writeDataWithExt(&buf[..pos], basePath, DEBUG_EXT);
877	901		}
878	902
879	903		/// Run the resolver on the parsed modules.
880		-	unsafe fn runResolver(ctx: *unsafe mut CompileContext, nodeCount: u32) -> resolver::Resolver throws (Error) {
881		-	let mut mainArena = alloc::new(&mut MAIN_ARENA[..]);
	904	+	unsafe fn runResolver 'arena (ctx: *unsafe mut CompileContext, mainArena: &'arena mut alloc::Arena, nodeCount: u32) -> resolver::Resolver 'arena throws (Error) {
882	905		let entryPkg = try getEntryPackage(ctx);
883	906
884	907		pkgLog(&entryPkg, &["resolving", ".."]);
885	908
886	909		let nodeDataSize = nodeCount * @sizeOf(resolver::NodeData);
887		-	let nodeDataPtr = try! alloc::alloc(&mut mainArena, nodeDataSize, @alignOf(resolver::NodeData));
	910	+	let nodeDataPtr = try! alloc::alloc(&mut *mainArena, nodeDataSize, @alignOf(resolver::NodeData));
888	911		let nodeData = @sliceOf(nodeDataPtr as *mut resolver::NodeData, nodeCount);
889	912		let storage = resolver::ResolverStorage {
890		-	arena: mainArena,
891	913		nodeData,
892	914		pkgScope: &mut RESOLVER_PKG_SCOPE,
893	915		errors: &mut RESOLVER_ERRORS[..],
894	916		};
895		-	let mut res = resolver::resolver(storage, ctx.config);
	917	+	let mut res = resolver::resolver(mainArena, storage, ctx.config);
896	918
897	919		// Build the semantic package list consumed by the resolver.
898	920		let mut resolverPkgs: [resolver::Pkg; MAX_PACKAGES] = undefined;
899	921		let mut resolverPackageCount: u32 = 0;
900	922		for i in 0..ctx.packageCount {

942	964		pkgLog(pkg, &["asm:", "parsing", "(", path, ")", ".."]);
943	965
944	966		let sourceLen = unix::readFile(path, &mut ASM_SOURCE_BUF[..]) else {
945	967		throw error(&["error reading assembly file"]);
946	968		};
947		-	let source = &ASM_SOURCE_BUF[..sourceLen];
948		-	if source.len == ASM_SOURCE_BUF.len {
	969	+	let input = &ASM_SOURCE_BUF[..sourceLen];
	970	+	if input.len == ASM_SOURCE_BUF.len {
949	971		throw error(&["fatal:", "assembly source too large:", path]);
950	972		}
	973	+	// Assembly symbols borrow source bytes until final linking.
	974	+	let buffer = try alloc::allocSlice(arena, 1, 1, input.len) catch {
	975	+	throw error(&["assembly source workspace exhausted"]);
	976	+	};
	977	+	let source = buffer as *mut [u8];
	978	+	try! mem::copy(source, input);
951	979		let program = try asm::assemble(
952	980		asm::scanner::SourceKind::File { path },
953	981		source,
954	982		&mut ASM_TEXT_BUF[..],
955	983		&mut ASM_DATA_BUF[..],

1011	1096		case CodegenEntryMode::DefaultEntry => {
1012	1097		set entryPatch = rv64::EntryPatch::Reserved(nil);
1013	1098		}
1014	1099		else => {}
1015	1100		}
1016		-	let mut generator = try rv64::beginProgram(
1017		-	rv64::ProgramOptions { entryPatch, debug: codegenOptions.debug, placement: rv64::image::Placement::Hosted },
1018		-	&mut res.arena
1019		-	) catch { throw error(&["code generation workspace exhausted"]); };
1020		-	let mut codegenCtx = codegen::Context {
1021		-	generator: &mut generator,
1022		-	fnArena: (&mut fnArena) as unsafe mut alloc::Arena,
	1101	+	let emitterStorage = emit::Storage {
	1102	+	code: &mut CODEGEN_INSTRUCTIONS[..],
	1103	+	pendingBranches: &mut CODEGEN_PENDING_BRANCHES[..],
	1104	+	pendingCalls: &mut CODEGEN_PENDING_CALLS[..],
	1105	+	pendingJumps: &mut CODEGEN_PENDING_JUMPS[..],
	1106	+	pendingAddrLoads: &mut CODEGEN_PENDING_ADDR_LOADS[..],
	1107	+	blockOffsets: &mut CODEGEN_BLOCK_OFFSETS[..],
	1108	+	funcEntries: &mut CODEGEN_FUNC_ENTRIES[..],
	1109	+	funcs: &mut CODEGEN_FUNCS[..],
	1110	+	debugEntries: &mut CODEGEN_DEBUG_ENTRIES[..],
1023	1111		};
1024		-	let mut low = lower::lowerer(
1025		-	res, &ctx.graph, entryPkg.name, &mut res.arena, fnArena as *unsafe mut alloc::Arena, options
	1112	+	let mut generator = rv64::beginProgramWithStorage(
	1113	+	rv64::ProgramOptions {
	1114	+	entryPatch,
	1115	+	debug: codegenOptions.debug,
	1116	+	placement: rv64::image::Placement::Hosted,
	1117	+	},
	1118	+	emitterStorage
1026	1119		);
1027		-	set low.output = lower::FnOutput::Stream(lower::FnSink {
1028		-	ctx: &mut codegenCtx as *unsafe mut opaque,
1029		-	emitFn: codegen::emit,
1030		-	});
1031		-	let mut asmDataLen: u32 = 0;
1032		-	if let path = startupPath {
1033		-	try assembleAsmModule(&mut generator, entryPkg, path, &mut asmDataLen, &mut res.arena);
1034		-	}
1035		-	try lowerAllPackagesInto(ctx, res, &mut low);
1036		-	let asmData = try assembleAsmInputs(ctx, &mut generator, &mut asmDataLen, &mut res.arena);
	1120	+	let arena = (&mut res.arena) as unsafe mut alloc::Arena;
	1121	+	let resolved: 'phase = &*res, graph = &ctx.graph where 'arena: 'phase in {
	1122	+	let mut low = lower::lowerer(
	1123	+	resolved, graph, entryPkg.name, arena, options
	1124	+	);
	1125	+	let mut asmDataLen: u32 = 0;
	1126	+	if let path = startupPath {
	1127	+	try assembleAsmModule(&mut generator, entryPkg, path, &mut asmDataLen, arena);
	1128	+	}
	1129	+	try generateAllPackagesInto(ctx, &mut low, &mut generator, fnArena);
	1130	+	let asmData = try assembleAsmInputs(ctx, &mut generator, &mut asmDataLen, arena);
1037	1131
1038		-	match generator.entryPatch {
1039		-	case rv64::EntryPatch::Reserved(targetName) => {
1040		-	if targetName == nil {
1041		-	throw error(&["fatal:", "no default function found"]);
	1132	+	match generator.entryPatch {
	1133	+	case rv64::EntryPatch::Reserved(targetName) => {
	1134	+	if targetName == nil {
	1135	+	throw error(&["fatal:", "no default function found"]);
	1136	+	}
	1137	+	}
	1138	+	else => {
1042	1139		}
1043	1140		}
1044		-	else => {}
1045		-	}
1046		-	if let path = codegenOptions.logPath {
1047		-	pkgLog(entryPkg, &["generating code", "(", path, ")", ".."]);
	1141	+	if let path = codegenOptions.logPath {
	1142	+	pkgLog(entryPkg, &["generating code", "(", path, ")", ".."]);
	1143	+	}
	1144	+	return try rv64::finishProgram(
	1145	+	generator, low.data, storage, asmData,
	1146	+	&mut RO_DATA_BUF[..], &mut RW_DATA_BUF[..]
	1147	+	) catch err {
	1148	+	match err {
	1149	+	case rv64::Error::Allocation => throw error(&["code generation workspace exhausted"]),
	1150	+	case rv64::Error::Capacity => throw error(&["code generation output capacity exceeded"]),
	1151	+	case rv64::Error::Symbol => throw error(&["code generation has an unresolved symbol"]),
	1152	+	case rv64::Error::Relocation => throw error(&["code generation relocation is out of range"]),
	1153	+	case rv64::Error::Image(_) => throw error(&["code generation image layout is invalid"]),
	1154	+	case rv64::Error::Data(_) => throw error(&["code generation data layout is invalid"]),
	1155	+	}
	1156	+	};
1048	1157		}
1049		-	return try rv64::finishProgram(&mut generator, low.data, storage, asmData, &mut RO_DATA_BUF[..], &mut RW_DATA_BUF[..]) catch {
1050		-	throw error(&["code generation failed: capacity, symbol, relocation, or image layout"]);
1051		-	};
1052	1158		}
1053	1159
1054	1160		/// Source exports selected for one binary RIL package.
1055	1161		record PackageExports: Copy {
1056	1162		/// Number of initialized entries in the caller's export table.

1069	1175		) -> PackageExports throws (Error) {
1070	1176		let mut count: u32 = 0;
1071	1177		let mut entryName: ?*[u8] = nil;
1072	1178		for i in 0..ctx.graph.entriesLen {
1073	1179		let modEntry = module::get(&ctx.graph, i as u16) else continue;
1074		-	if modEntry.packageId <> pkg.id { continue; }
1075		-	let root = modEntry.ast else continue;
	1180	+	if modEntry.packageId <> pkg.id {
	1181	+	continue;
	1182	+	}
	1183	+	let root = module::astFor(modEntry) else continue;
1076	1184		let case ast::NodeValue::Block(block) = root.value else continue;
1077	1185		for node in block.statements {
1078	1186		let mut ident: ?*ast::Node = nil;
1079	1187		let mut attrs: ?ast::Attributes = nil;
1080	1188		let mut kind = binary::ExportKind::Function;
1081	1189		match node.value {
1082		-	case ast::NodeValue::FnDecl(decl) => { set ident = decl.name; set attrs = decl.attrs; },
	1190	+	case ast::NodeValue::FnDecl(decl) => {
	1191	+	set ident = decl.name;
	1192	+	set attrs = decl.attrs;
	1193	+	},
1083	1194		case ast::NodeValue::ConstDecl(decl) => {
1084	1195		set ident = decl.ident; set attrs = decl.attrs; set kind = binary::ExportKind::Data;
1085	1196		},
1086	1197		case ast::NodeValue::StaticDecl(decl) => {
1087	1198		set ident = decl.ident; set attrs = decl.attrs; set kind = binary::ExportKind::Data;
1088	1199		},
1089	1200		else => continue,
1090	1201		}
1091	1202		let attributes = attrs else continue;
	1203	+	if ast::attributesContains(&attributes, ast::Attribute::Intrinsic) {
	1204	+	continue;
	1205	+	}
1092	1206		let isDefault = ast::attributesContains(&attributes, ast::Attribute::Default)
1093	1207		and pkg.rootModuleId == modEntry.id;
1094	1208		if not isDefault and not ast::attributesContains(&attributes, ast::Attribute::Export) {
1095	1209		continue;
1096	1210		}

1099	1213		let qualified = il::formatQualifiedName(arena, module::moduleQualifiedPath(modEntry), name);
1100	1214		let mut present = false;
1101	1215		match kind {
1102	1216		case binary::ExportKind::Function => {
1103	1217		for func in ilProgram.fns {
1104		-	if mem::eq(func.name, qualified) { set present = true; }
	1218	+	if mem::eq(func.name, qualified) {
	1219	+	set present = true;
	1220	+	}
1105	1221		}
1106	1222		},
1107	1223		case binary::ExportKind::Data => {
1108	1224		for item in ilProgram.data {
1109		-	if mem::eq(item.name, qualified) { set present = true; }
	1225	+	if mem::eq(item.name, qualified) {
	1226	+	set present = true;
	1227	+	}
1110	1228		}
1111	1229		},
1112	1230		}
1113		-	if not present { continue; }
1114		-	if count == exports.len { throw error(&["too many package exports"]); }
	1231	+	if not present {
	1232	+	continue;
	1233	+	}
	1234	+	if count == exports.len {
	1235	+	throw error(&["too many package exports"]);
	1236	+	}
1115	1237		set exports[count] = binary::Export { name: qualified, kind };
1116	1238		set count += 1;
1117		-	if isDefault { set entryName = qualified; }
	1239	+	if isDefault {
	1240	+	set entryName = qualified;
	1241	+	}
1118	1242		}
1119	1243		}
1120	1244		return PackageExports { count, entry: entryName };
1121	1245		}
1122	1246
1123	1247		/// Emit one binary RIL file per package into an existing directory.
1124		-	unsafe fn emitPackages(ctx: unsafe mut CompileContext, res: unsafe mut resolver::Resolver, directory: *[u8]) throws (Error) {
	1248	+	unsafe fn emitPackages 'arena (
	1249	+	ctx: *unsafe mut CompileContext,
	1250	+	res: *unsafe mut resolver::Resolver 'arena,
	1251	+	directory: *[u8]
	1252	+	) throws (Error) {
1125	1253		for i in 0..ctx.packageCount {
1126	1254		if ctx.inputs[i].asmPathCount > 0 or ctx.inputs[i].startupPath <> nil {
1127	1255		throw error(&["binary RIL output requires Radiance source modules"]);
1128	1256		}
1129	1257		}
1130	1258		let unified = try lowerAllPackages(ctx, res);
1131		-	let allocator = alloc::arenaAllocator(&mut res.arena);
	1259	+	let allocator = alloc::arenaAllocator(&mut *res.arena);
1132	1260		for i in 0..ctx.packageCount {
1133	1261		let pkg = &ctx.packages[i];
1134	1262		let mut dataItems: *mut [il::Data] = &mut [];
1135	1263		let mut functions: unsafe mut [unsafe il::Fn] = &mut [];
1136	1264		for item in unified.data {
1137		-	if ownsSymbol(pkg.name, item.name) { dataItems.append(item, allocator); }
	1265	+	if ownsSymbol(pkg.name, item.name) {
	1266	+	dataItems.append(item, allocator);
	1267	+	}
1138	1268		}
1139	1269		for func in unified.fns {
1140		-	if ownsSymbol(pkg.name, func.name) { functions.append(func, allocator); }
	1270	+	if ownsSymbol(pkg.name, func.name) {
	1271	+	functions.append(func, allocator);
	1272	+	}
1141	1273		}
1142	1274		let local = il::Program { data: &dataItems[..], fns: functions };
1143		-	let selected = try packageExports(ctx, pkg, &local, &mut PACKAGE_EXPORTS[..], &mut res.arena);
	1275	+	let selected = try packageExports(ctx, pkg, &local, &mut PACKAGE_EXPORTS[..], &mut *res.arena);
1144	1276		let mut dependencies: [*[u8]; MAX_PACKAGES] = undefined;
1145	1277		let mut names = collect::new(&mut PACKAGE_SYMBOLS[..], &mut dependencies[..]);
1146	1278		let image = try collect::package(&mut names, pkg.name, local, &PACKAGE_EXPORTS[..selected.count], selected.entry) catch {
1147	1279		throw error(&["cannot collect binary RIL package", pkg.name]);
1148	1280		};

1168	1300		let suffix = mem::stripPrefix(owner, name) else return false;
1169	1301		return suffix.len > 2 and suffix[0] == ':' and suffix[1] == ':';
1170	1302		}
1171	1303
1172	1304		/// Lower, optionally dump, and optionally generate binary output.
1173		-	unsafe fn compile(
	1305	+	unsafe fn compile 'arena (
1174	1306		ctx: *unsafe mut CompileContext,
1175		-	res: *unsafe mut resolver::Resolver,
	1307	+	res: *unsafe mut resolver::Resolver 'arena,
1176	1308		fnArena: &mut alloc::Arena
1177	1309		) throws (Error) {
1178	1310		let entryPkg = try getEntryPackage(ctx);
1179	1311		if let directory = ctx.rilDirectory {
1180	1312		try emitPackages(ctx, res, directory);

1193	1325		let result = try lowerAndGenerateAllPackages(ctx, res, fnArena, CodegenOptions {
1194	1326		logPath: nil,
1195	1327		debug: false,
1196	1328		entryMode: CodegenEntryMode::None,
1197	1329		});
1198		-	printer::printCodeTo(&mut out, entryPkg.name, result.code, result.funcs, &mut res.arena);
	1330	+	printer::printCodeTo(&mut out, entryPkg.name, result.code, result.funcs, res.arena);
1199	1331		io::print("\n");
1200	1332
1201	1333		return;
1202	1334		}
1203	1335		// Generate binary output if path specified.

1223	1355		throw error(&["fatal:", "failed to write output file"]);
1224	1356		}
1225	1357
1226	1358		// Write debug info file if enabled.
1227	1359		if ctx.debug {
1228		-	try writeDebugInfo(result.debugEntries, &ctx.graph, outPath, &mut res.arena);
	1360	+	try writeDebugInfo(result.debugEntries, &ctx.graph, outPath, res.arena);
1229	1361		}
1230	1362		pkgLog(&entryPkg, &["ok", "(", outPath, ")"]);
1231	1363		}
1232	1364
1233	1365		@default unsafe fn main(env: *sys::Env) -> i32 {

10	10		//! * isel: Instruction selection (IL to RV64 instructions)
11	11		//! * printer: Assembly text output
12	12
13	13		export mod image;
14	14		export mod atomics;
15		-	export mod shared;
16	15		export mod encode;
17	16		export mod decode;
18	17		export mod emit;
19	18		export mod isel;
20	19		export mod printer;
21	20		export mod asm;
	21	+	export mod shared;
22	22
23	23		@test mod tests;
24	24		@test mod bounds;
25	25		@test mod atomicTests;
26	26

110	110		export constant INSTR_SIZE: i32 = 4;
111	111		/// Stack alignment requirement in bytes.
112	112		export constant STACK_ALIGNMENT: i32 = 16;
113	113
114	114		/// Minimum blit size (in bytes) to use a loop instead of inline copy.
115		-	/// Blits below this threshold are fully unrolled as LD/SD pairs.
116		-	export constant BLIT_LOOP_THRESHOLD: i32 = 256;
	115	+	/// Blits below this threshold use unrolled byte loads and stores.
	116	+	export constant BLIT_LOOP_THRESHOLD: i32 = 33;
117	117
118	118		/////////////////////////
119	119		// Codegen Allocation //
120	120		/////////////////////////
121	121

247	247		let mut e = try emit::emitter(arena, options.debug) catch {
248	248		alloc::restore(arena, checkpoint);
249	249		throw Error::Allocation;
250	250		};
251	251
	252	+	return beginProgramWithEmitter(options, e);
	253	+	}
	254	+
	255	+	/// Begin RV64 code generation with caller-owned emitter storage.
	256	+	export fn beginProgramWithStorage(
	257	+	options: ProgramOptions,
	258	+	storage: emit::Storage
	259	+	) -> Generator {
	260	+	let e = emit::emitterWithStorage(storage, options.debug);
	261	+	return beginProgramWithEmitter(options, e);
	262	+	}
	263	+
	264	+	/// Initialize a program generator from an emitter.
	265	+	fn beginProgramWithEmitter(options: ProgramOptions, input: emit::Emitter) -> Generator {
	266	+	let mut e = input;
	267	+
252	268		// Emit placeholder entry jump when requested.
253	269		// We'll patch this at the end once we know where the function is.
254	270		match options.entryPatch {
255	271		case EntryPatch::Reserved(_) => {
256	272		emit::emit(&mut e, encode::nop()); // Placeholder for two-instruction jump.

268	284
269	285		/// Generate code for one IL function.
270	286		/// Record failures in the emitter and restore the function arena offset.
271	287		export unsafe fn generateFunction(
272	288		generator: &mut Generator,
273		-	func: *unsafe il::Fn,
	289	+	func: &il::Fn,
274	290		arena: &mut alloc::Arena
275	291		) {
276	292		if generator.e.error <> nil or func.isExtern {
277	293		return;
278	294		}
279	295		let checkpoint = alloc::save(arena);
280	296		let config = targetConfig();
281		-	let ralloc = try regalloc::allocate(func, &config, arena) catch {
282		-	alloc::restore(arena, checkpoint);
283		-	set generator.e.error = Error::Allocation;
284		-	return;
285		-	};
286		-
287		-	isel::selectFn(&mut generator.e, &ralloc, func);
	297	+	use *arena as scratch in {
	298	+	try generateFunctionWithStorage(generator, func, &config, &scratch) catch {
	299	+	set generator.e.error = Error::Allocation;
	300	+	};
	301	+	}
288	302
289	303		// Reclaim unused memory after instruction selection.
290	304		alloc::restore(arena, checkpoint);
291	305		}
292	306
	307	+	/// Allocate registers and select one function within a scratch session.
	308	+	unsafe fn generateFunctionWithStorage 'scratch (
	309	+	generator: &mut Generator,
	310	+	func: &il::Fn,
	311	+	config: &regalloc::TargetConfig,
	312	+	storage: &Session 'scratch
	313	+	) throws (alloc::AllocError) {
	314	+	let ralloc = try regalloc::allocate(func, config, storage);
	315	+	isel::selectFn(&mut generator.e, &ralloc, func);
	316	+	}
	317	+
293	318		/// Record an alternate name for the next function emitted.
294	319		export fn recordFunctionAlias(generator: &mut Generator, name: *[u8]) {
295	320		let codeLen = generator.e.codeLen;
296	321		emit::recordFuncOffsetAt(&mut generator.e, name, codeLen);
297	322		}

336	361		}
337	362		}
338	363
339	364		/// Finish RV64 code generation and return the emitted program.
340	365		export unsafe fn finishProgram(
341		-	generator: &mut Generator,
	366	+	input: Generator,
342	367		globalData: &[il::Data],
343	368		storage: Storage,
344	369		roDataPrefix: *[u8],
345	370		roDataBuf: &mut [u8],
346	371		rwDataBuf: &mut [u8]
347	372		) -> Program throws (Error) {
	373	+	let mut generator = input;
348	374		try emit::check(&generator.e);
349	375		let mut roBase: u64 = RO_DATA_BASE as u64;
350	376		let mut rwBase: u64 = RW_DATA_BASE as u64;
351	377		match generator.placement {
352	378		case image::Placement::Physical { roData, rwData, .. } => {
353	379		set roBase = roData;
354	380		set rwBase = rwData;
355	381		},
356		-	else => {},
	382	+	else => {
	383	+	},
357	384		}
358	385		// Build data map after function lowering. Function-local literals can add
359	386		// global data while functions are lowered, so final layout belongs here.
360	387		let case Storage { dataSyms: symbolBuf, dataSymEntries } = storage
361	388		else panic "expected code generation storage";
362	389		let mut dataSymCount: u32 = 0;
363	390		let roLayoutSize = try data::layoutSectionAtOffset(
364	391		globalData, symbolBuf, &mut dataSymCount, roBase, roDataPrefix.len, true
365		-	) catch err { throw Error::Data(err); };
366		-	let rwLayoutSize = try data::layoutSection(globalData, symbolBuf, &mut dataSymCount, rwBase, false) catch err { throw Error::Data(err); };
	392	+	) catch err {
	393	+	throw Error::Data(err);
	394	+	};
	395	+	let rwLayoutSize = try data::layoutSection(globalData, symbolBuf, &mut dataSymCount, rwBase, false) catch err {
	396	+	throw Error::Data(err);
	397	+	};
367	398
368	399		let dataSyms = &symbolBuf[..dataSymCount];
369		-	let dataSymMap = try data::buildMap(dataSyms, dataSymEntries) catch err { throw Error::Data(err); };
	400	+	let dataSymMap = try data::buildMap(dataSyms, dataSymEntries) catch err {
	401	+	throw Error::Data(err);
	402	+	};
370	403		if roBase > 0xffffffffffffffff - roLayoutSize as u64 - 7 {
371	404		throw Error::Image(image::Error::Overflow);
372	405		}
373	406		let mut codeBase: u64 = (roBase + roLayoutSize as u64 + 7) & ~7;
374	407		let mut entry = codeBase;
375	408		match generator.placement {
376	409		case image::Placement::Physical { code, entry: address, .. } => {
377	410		set codeBase = code;
378	411		set entry = address;
379	412		},
380		-	else => {},
	413	+	else => {
	414	+	},
381	415		}
382	416		let codeBytes = generator.e.codeLen * 4;
383	417		let mut layout = image::Layout {
384	418		entry,
385	419		code: image::Segment { address: codeBase, initialized: codeBytes, memory: codeBytes },
386	420		roData: image::Segment { address: roBase, initialized: 0, memory: roLayoutSize },
387	421		rwData: image::Segment { address: rwBase, initialized: 0, memory: rwLayoutSize },
388	422		};
389		-	try image::validate(layout) catch err { throw Error::Image(err); };
	423	+	try image::validate(layout) catch err {
	424	+	throw Error::Image(err);
	425	+	};
390	426
391	427		match generator.entryPatch {
392	428		case EntryPatch::Reserved(targetName) => {
393	429		let target = targetName else {
394	430		throw Error::Symbol;

407	443		try emit::patchAddrLoads(&mut generator.e, &dataSymMap, codeBase);
408	444
409	445		try emit::check(&generator.e);
410	446
411	447		// Emit data sections.
412		-	if roDataPrefix.len > roDataBuf.len { throw Error::Capacity; }
	448	+	if roDataPrefix.len > roDataBuf.len {
	449	+	throw Error::Capacity;
	450	+	}
413	451		try! mem::copy(roDataBuf, roDataPrefix);
414	452
415	453		let roDataSize = try data::emitSectionAtOffset(
416	454		globalData, &dataSymMap, &generator.e.labels, codeBase, roDataBuf, true, roDataPrefix.len
417		-	) catch err { throw Error::Data(err); };
	455	+	) catch err {
	456	+	throw Error::Data(err);
	457	+	};
418	458		let rwDataSize = try data::emitSection(
419	459		globalData, &dataSymMap, &generator.e.labels, codeBase, rwDataBuf, false
420		-	) catch err { throw Error::Data(err); };
	460	+	) catch err {
	461	+	throw Error::Data(err);
	462	+	};
421	463		set layout.roData.initialized = roDataSize;
422	464		set layout.rwData.initialized = rwDataSize;
423		-	try image::validate(layout) catch err { throw Error::Image(err); };
	465	+	try image::validate(layout) catch err {
	466	+	throw Error::Image(err);
	467	+	};
	468	+	let case Generator { e, .. } = generator else panic "expected program generator";
	469	+	let case emit::Emitter {
	470	+	code, codeLen, funcs, funcsLen, debugEntries, debugEntriesLen, ..
	471	+	} = e else panic "expected program emitter";
424	472		return Program {
425		-	code: emit::getCode(&generator.e),
426		-	funcs: &generator.e.funcs[..],
	473	+	code: &code[..codeLen],
	474	+	funcs: &funcs[..funcsLen],
427	475		roDataSize,
428	476		rwDataSize,
429		-	debugEntries: emit::getDebugEntries(&generator.e),
	477	+	debugEntries: &debugEntries[..debugEntriesLen],
430	478		layout,
431	479		};
432	480		}

406	406		{ name: "tp", reg: rv64::TP },
407	407		{ name: "zero", reg: rv64::ZERO },
408	408		];
409	409
410	410		/// Sorted CSR-name lookup table used by the assembler parser.
411		-	export constant CSRS: [CsrEntry; 9] = [
	411	+	export constant CSRS: [CsrEntry; 10] = [
	412	+	{ name: "instret", csr: 0xC02 },
412	413		{ name: "mcause", csr: 0x342 },
413	414		{ name: "mepc", csr: 0x341 },
414	415		{ name: "mhartid", csr: 0xF14 },
415	416		{ name: "mie", csr: 0x304 },
416	417		{ name: "mip", csr: 0x344 },

460	461		arena: *unsafe mut alloc::Arena,
461	462		/// Assembler lexical scanner.
462	463		scan: scanner::Scanner,
463	464		/// Output text buffer.
464	465		text: *mut [u32],
	466	+	/// Number of emitted text words.
	467	+	textLen: u32,
465	468		/// Output data buffer.
466	469		data: *mut [u8],
	470	+	/// Number of emitted data bytes.
	471	+	dataLen: u32,
467	472		/// Current output section.
468	473		section: Section,
469	474		/// Defined symbols.
470	475		symbols: *mut [Symbol],
	476	+	/// Number of defined symbols.
	477	+	symbolsLen: u32,
471	478		/// Name-to-symbol index map.
472	479		symbolMap: dict::Dict,
473	480		/// Name-to-integer map.
474	481		constMap: dict::Dict,
475	482		/// Names marked by `.export`.
476	483		exportMap: dict::Dict,
477	484		/// Pending fixups.
478	485		fixups: *mut [Fixup],
	486	+	/// Number of pending fixups.
	487	+	fixupsLen: u32,
479	488		/// Fixups that reference text outside this assembly fragment.
480	489		externalFixups: *mut [Fixup],
	490	+	/// Number of external fixups.
	491	+	externalFixupsLen: u32,
481	492		/// Absolute runtime address of data-section offset zero.
482	493		dataBase: u32,
483	494		}
484	495
485	496		/// Assemble source using `dataBase` as the runtime address of the data-section.

490	501		dataBuf: *mut [u8],
491	502		arena: &mut alloc::Arena,
492	503		pool: *unsafe mut strings::Pool,
493	504		dataBase: u32
494	505		) -> Program throws (Error) {
495		-	let slotCap = source.len + SOURCE_CAP_PADDING;
	506	+	let slotCap = tokenCapacity(sourceKind, source, pool);
496	507		let tableCap = nextPowerOfTwo(slotCap * TABLE_CAPACITY_SCALE);
497	508
498	509		let symbols = try! alloc::allocSlice(arena, @sizeOf(Symbol), @alignOf(Symbol), slotCap);
499	510		let fixups = try! alloc::allocSlice(arena, @sizeOf(Fixup), @alignOf(Fixup), slotCap);
500	511		let externalFixups = try! alloc::allocSlice(arena, @sizeOf(Fixup), @alignOf(Fixup), slotCap);

506	517		let fixupBuf = fixups as *mut [Fixup];
507	518		let externalBuf = externalFixups as *mut [Fixup];
508	519		let mut a = Assembler {
509	520		arena: arena as *unsafe mut alloc::Arena,
510	521		scan: scanner::scanner(sourceKind, source, pool),
511		-	text: &mut textBuf[..0],
512		-	data: &mut dataBuf[..0],
	522	+	text: textBuf,
	523	+	textLen: 0,
	524	+	data: dataBuf,
	525	+	dataLen: 0,
513	526		section: Section::Text,
514		-	symbols: &mut symbolBuf[..0],
	527	+	symbols: symbolBuf,
	528	+	symbolsLen: 0,
515	529		symbolMap: dict::init(entries as *mut [dict::Entry]),
516	530		constMap: dict::init(constEntries as *mut [dict::Entry]),
517	531		exportMap: dict::init(exportEntries as *mut [dict::Entry]),
518		-	fixups: &mut fixupBuf[..0],
519		-	externalFixups: &mut externalBuf[..0],
	532	+	fixups: fixupBuf,
	533	+	fixupsLen: 0,
	534	+	externalFixups: externalBuf,
	535	+	externalFixupsLen: 0,
520	536		dataBase,
521	537		};
522	538		// Parse assembly source and emit instructions.
523	539		try parser::parseProgram(&mut a);
524	540		// Resolve fixups and finalize program.
525	541		try emit::finishProgram(&mut a);
526	542
527		-	let case Assembler { text, data, symbols: definedSymbols, externalFixups: pendingFixups, .. } = a
	543	+	let case Assembler {
	544	+	text, textLen, data, dataLen, symbols: definedSymbols, symbolsLen,
	545	+	externalFixups: pendingFixups, externalFixupsLen, ..
	546	+	} = a
528	547		else panic "expected assembler state";
529		-	return Program { text, data, symbols: definedSymbols, externalFixups: pendingFixups };
	548	+	return Program {
	549	+	text: &text[..textLen],
	550	+	data: &data[..dataLen],
	551	+	symbols: &definedSymbols[..symbolsLen],
	552	+	externalFixups: &pendingFixups[..externalFixupsLen],
	553	+	};
	554	+	}
	555	+
	556	+	/// Bound symbol and fixup counts by lexical tokens, including one spare slot.
	557	+	unsafe fn tokenCapacity(kind: scanner::SourceKind, source: [u8], pool: unsafe mut strings::Pool) -> u32 {
	558	+	let mut scan = scanner::scanner(kind, source, pool);
	559	+	let mut count = SOURCE_CAP_PADDING;
	560	+	while true {
	561	+	let token = scanner::next(&mut scan);
	562	+	if token.kind == scanner::TokenKind::Eof {
	563	+	break;
	564	+	}
	565	+	set count += 1;
	566	+	if token.kind == scanner::TokenKind::Invalid {
	567	+	break;
	568	+	}
	569	+	}
	570	+	return count;
530	571		}
531	572
532	573		/// Return the next power of two at least as large as `value`.
533	574		fn nextPowerOfTwo(value: u32) -> u32 {
534	575		let mut n: u32 = MIN_TABLE_CAPACITY;

3	3		use std::arch::rv64::encode;
4	4		use std::arch::rv64;
5	5		use std::fmt;
6	6
7	7		use std::collections::dict;
8		-	use std::lang::alloc;
9	8		use std::lang::gen;
10	9
11	10		/// Define a symbol at the current text or data offset.
12	11		export unsafe fn defineSymbol(a: &mut super::Assembler, name: *[u8]) {
13		-	let idx = a.symbols.len;
14		-	let offset: i32 = a.data.len as i32
	12	+	let idx = a.symbolsLen;
	13	+	let offset: i32 = a.dataLen as i32
15	14		if a.section == super::Section::Data
16		-	else a.text.len as i32 * rv64::INSTR_SIZE;
	15	+	else a.textLen as i32 * rv64::INSTR_SIZE;
17	16
18		-	a.symbols.append(super::Symbol {
	17	+	assert a.symbolsLen < a.symbols.len, "defineSymbol: symbol buffer full";
	18	+	set a.symbols[a.symbolsLen] = super::Symbol {
19	19		name,
20	20		section: a.section,
21	21		offset,
22	22		isExported: dict::get(&a.exportMap, name) <> nil,
23		-	}, alloc::arenaAllocator(a.arena));
	23	+	};
	24	+	set a.symbolsLen += 1;
24	25		dict::insert(&mut a.symbolMap, name, idx as i32);
25	26		}
26	27
27	28		/// Append one encoded instruction word to the text section.
28	29		export unsafe fn emitText(a: &mut super::Assembler, word: u32) throws (super::Error) {
29		-	a.text.append(word, alloc::arenaAllocator(a.arena));
	30	+	if a.textLen >= a.text.len {
	31	+	throw super::Error::TextOverflow;
	32	+	}
	33	+	set a.text[a.textLen] = word;
	34	+	set a.textLen += 1;
30	35		}
31	36
32	37		/// Append `words` no-op instructions to the text section.
33	38		export unsafe fn emitTextPadding(a: &mut super::Assembler, words: u32) throws (super::Error) {
34	39		for _ in 0..words {