radiance · commit

Enforce move semantics for safe mutable pointers

27ce65c61e48bbadad9bf415f1c80ccedacd3220b63120c4d7e46d8a8176c407

Treat safe mutable pointers, slices, and trait objects as move-only values.
Reject Copy implementations that contain them and preserve temporary call
borrows. Use raw pointers for shared mutable compiler graphs and owned or
immutable storage for tables, signatures, and diagnostic snapshots.

Validate the slice.append allocator contract and use implicit raw borrows
throughout compiler call sites.

Assisted-by: Codex:gpt-6-astra

Alexis Sellier committed 14 days ago 1 parent 3b15770b

compiler/radiance.rad +50 -40

    /// Number of assembly source paths.
    asmPathCount: u32,
}

/// Compilation context.
record CompileContext: Copy {
record CompileContext {
    /// Array of packages to compile.
    packages: [package::Package; MAX_PACKAGES],
    /// Driver inputs for each package slot.
    inputs: [PackageInput; MAX_PACKAGES],
    /// Number of packages.

}

/// Root module info for a package.
record RootModule: Copy {
    entry: *module::ModuleEntry,
    ast: *mut ast::Node,
    ast: *ast::Node,
}

/// Entry handling for streamed code generation.
union CodegenEntryMode: Copy {
    /// Do not reserve an entry jump.

    graph: &mut module::ModuleGraph,
    path: *[u8],
    nodeArena: &mut ast::NodeArena,
    sourceArena: &mut alloc::Arena
) throws (Error) {
    pkgLog(&*pkg, &["parsing", "(", path, ")", ".."]);
    pkgLog(pkg, &["parsing", "(", path, ")", ".."]);

    let moduleId = try package::registerModule(&mut *pkg, graph, path) catch {
    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);
    if buffer.len == 0 {

    for i in 0..pkgCount {
        if i <> entryIdx and inputs[i].startupPath <> nil {
            throw error(&["`-start` is only supported on the entry package"]);
        }
    }
    let graph = module::moduleGraph(&mut MODULE_ENTRIES[..], &mut STRING_POOL, arena);
    let graph = module::moduleGraph(&mut MODULE_ENTRIES[..], arena);
    let mut ctx = CompileContext {
        packages: undefined,
        inputs,
        packageCount: pkgCount,
        entryPkgIdx,

    }
    return ctx;
}

/// Get the entry package from the context.
unsafe fn getEntryPackage(ctx: *unsafe CompileContext) -> *unsafe package::Package throws (Error) {
fn getEntryPackage(ctx: &CompileContext) -> package::Package throws (Error) {
    let entryIdx = ctx.entryPkgIdx else {
        throw error(&["no entry package specified"]);
    };
    return &ctx.packages[entryIdx];
    return ctx.packages[entryIdx];
}

/// Return the startup assembly path for the entry package, if one was supplied.
fn getEntryStartupPath(ctx: &CompileContext) -> ?*[u8] {
    let entryIdx = ctx.entryPkgIdx else {

    let mut arena = alloc::new(&mut MAIN_ARENA[..]);
    module::printer::printGraph(&ctx.graph, &mut arena);
}

/// Dump the parsed AST.
unsafe fn dumpAst(ctx: *unsafe CompileContext) throws (Error) {
unsafe fn dumpAst(ctx: &CompileContext) throws (Error) {
    let pkg = try getEntryPackage(ctx);
    let root = try getRootModule(&*pkg, &ctx.graph);
    let root = try getRootModule(&pkg, &ctx.graph);
    let mut arena = alloc::new(&mut MAIN_ARENA[..]);

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


        res, &ctx.graph, entryPkg.name, &mut res.arena, &mut res.arena, options
    );
    try lowerAllPackagesInto(ctx, res, &mut low);

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

/// Lower all packages into an existing lowerer.
unsafe fn lowerAllPackagesInto(
    ctx: *unsafe mut CompileContext,

        panic "lowerAllPackagesInto: no entry package";
    };
    // Lower all packages except entry.
    for i in 0..ctx.packageCount {
        if i <> entryIdx {
            try lowerPackage(ctx, res, &mut *low, &mut ctx.packages[i], false);
            try lowerPackage(ctx, res, low, &ctx.packages[i], false);
        }
    }
    // Lower entry package.
    try lowerPackage(ctx, res, &mut *low, &mut ctx.packages[entryIdx], true);
    try lowerPackage(ctx, res, low, &ctx.packages[entryIdx], true);
}

/// Lower all modules in a package into the lowerer accumulator.
unsafe fn lowerPackage(
    ctx: *unsafe CompileContext,
    ctx: &CompileContext,
    res: *unsafe mut resolver::Resolver,
    low: &mut lower::Lowerer,
    pkg: &mut package::Package,
    pkg: &package::Package,
    isEntry: bool
) throws (Error) {
    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(&mut *low, &ctx.graph, pkg.name);
    lower::setPackage(low, &ctx.graph, pkg.name);

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

/// Recursively lower a module and all its children into the accumulator.
unsafe fn lowerModuleTreeInto(
    ctx: *unsafe CompileContext,
    ctx: &CompileContext,
    low: &mut lower::Lowerer,
    graph: &module::ModuleGraph,
    modId: u16,
    isRoot: bool,
    pkg: &package::Package

        throw error(&["module entry not found"]);
    };
    let modAst = entry.ast else {
        throw error(&["module has no AST"]);
    };
    pkgLog(&*pkg, &["lowering", "(", entry.filePath, ")", ".."]);
    pkgLog(pkg, &["lowering", "(", entry.filePath, ")", ".."]);

    try lower::lowerModule(&mut *low, modId, modAst, isRoot) catch err {
    try lower::lowerModule(low, modId, modAst, isRoot) 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 {
        let childId = module::childAt(entry, i);
        try lowerModuleTreeInto(ctx, &mut *low, graph, childId, false, pkg);
        try lowerModuleTreeInto(ctx, low, graph, childId, false, pkg);
    }
}

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

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

    // Collect all test functions across all modules.
    let mut tests: [TestDesc; MAX_TESTS] = undefined;
    let mut testCount: u32 = 0;


    io::printError(" test(s)\n");

    // Synthesize the `@default` function and append to the root module.
    let fnDecl = synthTestMainFn(arena, &tests[..testCount]);

    injectIntoBlock(root.ast, arena, fnDecl);
    let updatedRoot = injectIntoBlock(root.ast, arena, fnDecl);
    try module::setAst(&mut ctx.graph, root.entry.id, updatedRoot) catch {
        throw error(&["failed to set test runner AST"]);
    };
}

/// Synthesize the test entry point.
unsafe fn synthTestMainFn(arena: &mut ast::NodeArena, tests: &[TestDesc]) -> *ast::Node {
    // Build array literal: `[testing::test(...), ...]`.

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

/// Append a declaration to a block node's statement list.
/// Build a block node with a declaration appended to its statement list.
unsafe fn injectIntoBlock(
    blockNode: *mut ast::Node,
    blockNode: *ast::Node,
    arena: &mut ast::NodeArena,
    decl: *ast::Node
) {
) -> *ast::Node {
    let case ast::NodeValue::Block(block) = blockNode.value else {
        panic "injectIntoBlock: expected Block node";
    };
    let stmts = block.statements.append(decl, alloc::arenaAllocator(&mut arena.arena));
    set blockNode.value = ast::NodeValue::Block(ast::Block { statements: stmts, isUnsafe: block.isUnsafe });
    let allocator = alloc::arenaAllocator(&mut arena.arena);
    let mut stmts = ast::nodeSlice(arena, block.statements.len + 1);
    for stmt in block.statements {
        stmts.append(stmt, allocator);
    }
    stmts.append(decl, allocator);
    return ast::allocNode(arena, blockNode.span, ast::NodeValue::Block(
        ast::Block { statements: stmts, isUnsafe: block.isUnsafe }
    ));
}

/// Write a self-contained RV64 image containing text and data sections.
unsafe fn writeImage(
    code: *[u32],

    let headerBytes: *unsafe [u8] = @sliceOf(&header[0] as *unsafe u8, header.len * rv64::WORD_SIZE as u32);
    let codeBytes = @sliceOf(code.ptr as *u8, code.len * rv64::INSTR_SIZE as u32);

    let fd = unix::openOpts(path, unix::OpenFlags(*unix::O_WRONLY | *unix::O_CREAT | *unix::O_TRUNC), 420);
    if fd < 0 { return false; }
    let written = unix::writeAll(fd, &headerBytes[..]) and unix::writeAll(fd, codeBytes)
    let written = unix::writeAll(fd, headerBytes) and unix::writeAll(fd, codeBytes)
        and unix::writeAll(fd, roData) and unix::writeAll(fd, rwData);
    let closed = unix::close(fd) == 0;
    return written and closed;
}


/// 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[..]);
    let entryPkg = try getEntryPackage(ctx);

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

    let nodeDataSize = nodeCount * @sizeOf(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 {

    // 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 {
        let pkg = &ctx.packages[i];
        let root = try getRootModule(&*pkg, &ctx.graph);
        let root = try getRootModule(pkg, &ctx.graph);

        set resolverPkgs[resolverPackageCount] = resolver::Pkg {
            rootEntry: root.entry,
            rootAst: root.ast,
        };

    }

    // Resolve all packages.
    // TODO: Fix this error printing dance.
    let diags = try resolver::resolve(&mut res, &ctx.graph, &resolverPkgs[..resolverPackageCount]) catch {
        let diags = resolver::Diagnostics { errors: res.errors };
        let diags = resolver::diagnostics(&mut res);
        resolver::printer::printDiagnostics(&diags, &res);
        throw Error::Other;
    };
    if not resolver::success(&diags) {
        resolver::printer::printDiagnostics(&diags, &res);

    pkg: &package::Package,
    path: *[u8],
    asmDataLen: &mut u32,
    arena: &mut alloc::Arena
) throws (Error) {
    pkgLog(&*pkg, &["asm:", "parsing", "(", path, ")", ".."]);
    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];

) -> rv64::Program throws (Error) {
    let entryIdx = ctx.entryPkgIdx else {
        panic "lowerAndGenerateAllPackages: no entry package";
    };
    let entryPkg = &ctx.packages[entryIdx];
    let startupPath = getEntryStartupPath(&*ctx);
    let startupPath = getEntryStartupPath(ctx);
    let options = lower::LowerOptions { debug: ctx.debug, buildTest: ctx.config.buildTest };
    let storage = rv64::Storage {
        dataSyms: &mut CODEGEN_DATA_SYMS[..],
        dataSymEntries: &mut CODEGEN_DATA_SYM_ENTRIES[..],
    };

        rv64::ProgramOptions { entryPatch, debug: codegenOptions.debug },
        &mut res.arena
    );
    let mut codegenCtx = codegen::Context {
        generator: &mut generator,
        fnArena: fnArena as *unsafe mut alloc::Arena,
        fnArena: (&mut *fnArena) as *unsafe mut alloc::Arena,
    };
    let mut low = lower::lowerer(
        res, &ctx.graph, entryPkg.name, &mut res.arena, fnArena as *unsafe mut alloc::Arena, options
    );
    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 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 asmData = try assembleAsmInputs(ctx, &mut generator, &mut asmDataLen, &mut res.arena);

    match generator.entryPatch {
        case rv64::EntryPatch::Reserved(targetName) => {
            if targetName == nil {
                throw error(&["fatal:", "no default function found"]);
            }
        }
        else => {}
    }
    if let path = codegenOptions.logPath {
        pkgLog(&*entryPkg, &["generating code", "(", path, ")", ".."]);
        pkgLog(entryPkg, &["generating code", "(", path, ")", ".."]);
    }
    return rv64::finishProgram(&mut generator, &low.data[..], storage, asmData, &mut RO_DATA_BUF[..], &mut RW_DATA_BUF[..]);
    return rv64::finishProgram(&mut generator, low.data, storage, asmData, &mut RO_DATA_BUF[..], &mut RW_DATA_BUF[..]);
}

/// Lower, optionally dump, and optionally generate binary output.
unsafe fn compile(
    ctx: *unsafe mut CompileContext,

    // Generate binary output if path specified.
    let outPath = ctx.outputPath else {
        try lowerAllPackages(ctx, res);
        return;
    };
    let startupPath = getEntryStartupPath(&*ctx);
    let startupPath = getEntryStartupPath(ctx);
    let result = try lowerAndGenerateAllPackages(ctx, res, fnArena, CodegenOptions {
        logPath: outPath,
        debug: ctx.debug,
        entryMode: CodegenEntryMode::None
            if startupPath <> nil


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

@default unsafe fn main(env: *sys::Env) -> i32 {
    let mut arena = ast::nodeArena(&mut TEMP_ARENA[..]);
    let mut ctx = try processCommand(env.args, &mut arena) catch {

compiler/radiance/codegen.rad +4 -4

    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: *il::Fn, role: lower::FnRole) {
export unsafe fn emit(ctxPtr: *unsafe mut opaque, func: *unsafe il::Fn, role: lower::FnRole) {
    let ctx = ctxPtr as *unsafe mut Context;

    match role {
        case lower::FnRole::Default => {
            rv64::recordFunctionAlias(&mut *ctx.generator, super::DEFAULT_ENTRY_SYMBOL);
            rv64::recordFunctionAlias(ctx.generator, super::DEFAULT_ENTRY_SYMBOL);
            match ctx.generator.entryPatch {
                case rv64::EntryPatch::Reserved(_) => {
                    set ctx.generator.entryPatch = rv64::EntryPatch::Reserved(func.name);
                }
                // Startup assembly calls the default function through its

        }
        else => {}
    }
    let generator = ctx.generator;
    let arena = ctx.fnArena;
    rv64::generateFunction(&mut *generator, func, &mut *arena);
    alloc::reset(&mut *ctx.fnArena);
    rv64::generateFunction(generator, func, arena);
    alloc::reset(ctx.fnArena);
}

lib/std/arch/rv64.rad +13 -11

export fn imageHeader(codeBytes: u32, roDataBytes: u32, rwDataBytes: u32) -> [u32; 5] {
    return [IMAGE_MAGIC, IMAGE_VERSION, codeBytes, roDataBytes, rwDataBytes];
}

/// Storage buffers passed from driver for code generation.
export record Storage: Copy {
export record Storage {
    /// Buffer for data symbols.
    dataSyms: *mut [data::DataSym],
    /// Hash table entries for data symbol lookup.
    dataSymEntries: *mut [dict::Entry],
}

/// State for incremental RV64 program generation.
///
/// The generator owns global codegen state that must survive across function
/// emission. Function-local scratch stays outside this record so callers can
/// reclaim it after each function.
export record Generator: Copy {
export record Generator {
    /// Binary emitter and relocation state.
    e: emit::Emitter,
    /// Entry jump patching state.
    entryPatch: EntryPatch,
}

}

/// Generate code for one IL function.
export unsafe fn generateFunction(
    generator: &mut Generator,
    func: *il::Fn,
    func: *unsafe il::Fn,
    arena: &mut alloc::Arena
) {
    if func.isExtern {
        return;
    }

}

/// Finish RV64 code generation and return the emitted program.
export unsafe fn finishProgram(
    generator: &mut Generator,
    globalData: *[il::Data],
    globalData: &[il::Data],
    storage: Storage,
    roDataPrefix: *[u8],
    roDataBuf: *mut [u8],
    rwDataBuf: *mut [u8]
    roDataBuf: &mut [u8],
    rwDataBuf: &mut [u8]
) -> Program {
    // 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 = data::layoutSectionAtOffset(
        globalData, storage.dataSyms, &mut dataSymCount, RO_DATA_BASE, roDataPrefix.len, true
        globalData, symbolBuf, &mut dataSymCount, RO_DATA_BASE, roDataPrefix.len, true
    );
    data::layoutSection(globalData, storage.dataSyms, &mut dataSymCount, RW_DATA_BASE, false);
    data::layoutSection(globalData, symbolBuf, &mut dataSymCount, RW_DATA_BASE, false);

    let dataSyms = &storage.dataSyms[..dataSymCount];
    let dataSymMap = data::buildMap(dataSyms, storage.dataSymEntries);
    let dataSyms = &symbolBuf[..dataSymCount];
    let dataSymMap = data::buildMap(dataSyms, dataSymEntries);
    let codeBase = mem::alignUp(RO_DATA_BASE + roLayoutSize, DWORD_SIZE as u32);

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

    let rwDataSize = data::emitSection(
        globalData, &dataSymMap, &generator.e.labels, codeBase, rwDataBuf, false
    );
    return Program {
        code: emit::getCode(&generator.e),
        funcs: generator.e.funcs,
        funcs: &generator.e.funcs[..],
        roDataSize,
        rwDataSize,
        debugEntries: emit::getDebugEntries(&generator.e),
    };
}

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

    /// Fixup payload.
    info: FixupInfo,
}

/// Parser and emission state.
export record Assembler: Copy {
export record Assembler {
    /// Allocation arena for temporary assembler state.
    arena: *unsafe mut alloc::Arena,
    /// Assembler lexical scanner.
    scan: scanner::Scanner,
    /// Output text buffer.

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


    let externalFixups = try! alloc::allocSlice(arena, @sizeOf(Fixup), @alignOf(Fixup), slotCap);
    let entries = try! alloc::allocSlice(arena, @sizeOf(dict::Entry), @alignOf(dict::Entry), tableCap);
    let constEntries = try! alloc::allocSlice(arena, @sizeOf(dict::Entry), @alignOf(dict::Entry), tableCap);
    let exportEntries = try! alloc::allocSlice(arena, @sizeOf(dict::Entry), @alignOf(dict::Entry), tableCap);

    let symbolBuf = symbols as *mut [Symbol];
    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: @sliceOf(textBuf.ptr, 0, textBuf.len),
        data: @sliceOf(dataBuf.ptr, 0, dataBuf.len),
        text: &mut textBuf[..0],
        data: &mut dataBuf[..0],
        section: Section::Text,
        symbols: @sliceOf((symbols as *mut [Symbol]).ptr, 0, (symbols as *mut [Symbol]).len),
        symbols: &mut symbolBuf[..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: @sliceOf((fixups as *mut [Fixup]).ptr, 0, (fixups as *mut [Fixup]).len),
        externalFixups: @sliceOf((externalFixups as *mut [Fixup]).ptr, 0, (externalFixups as *mut [Fixup]).len),
        fixups: &mut fixupBuf[..0],
        externalFixups: &mut externalBuf[..0],
        dataBase,
    };
    // Parse assembly source and emit instructions.
    try parser::parseProgram(&mut a);
    // Resolve fixups and finalize program.
    try emit::finishProgram(&mut a);

    return Program {
        text: a.text,
        data: a.data,
        symbols: a.symbols,
        externalFixups: a.externalFixups,
    };
    let case Assembler { text, data, symbols: definedSymbols, externalFixups: pendingFixups, .. } = a
        else panic "expected assembler state";
    return Program { text, data, symbols: definedSymbols, externalFixups: pendingFixups };
}

/// 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 +5 -5

    a.symbols.append(super::Symbol {
        name,
        section: a.section,
        offset,
        isExported: dict::get(&a.exportMap, name) <> nil,
    }, alloc::arenaAllocator(&mut *a.arena));
    }, alloc::arenaAllocator(a.arena));
    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(&mut *a.arena));
    a.text.append(word, alloc::arenaAllocator(a.arena));
}

/// 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(&mut *a.arena));
    a.data.append(byte, alloc::arenaAllocator(a.arena));
}

/// 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 pending symbol fixup.
unsafe fn recordFixup(a: &mut super::Assembler, symbol: *[u8], info: super::FixupInfo) {
    a.fixups.append(super::Fixup { symbol, info }, alloc::arenaAllocator(&mut *a.arena));
    a.fixups.append(super::Fixup { symbol, info }, alloc::arenaAllocator(a.arena));
}

/// 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(&mut *a.arena));
    a.externalFixups.append(fixup, alloc::arenaAllocator(a.arena));
}

/// 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);

lib/std/arch/rv64/asm/parser.rad +25 -24

    }
    return mem::alignUp(value, alignment);
}

/// Advance the parser by one token, preserving the previous token.
fn advance(a: &mut super::Assembler) {
unsafe fn advance(a: &mut super::Assembler) {
    set a.scan.previous = a.scan.current;
    set a.scan.current = scanner::next(&mut a.scan);
}

/// Consume the current token when it has `kind`.
fn consume(a: &mut super::Assembler, kind: scanner::TokenKind) -> bool {
unsafe fn consume(a: &mut super::Assembler, kind: scanner::TokenKind) -> bool {
    if a.scan.current.kind == kind {
        advance(a);
        return true;
    }
    return false;

        throw failOnToken(tok, "data directive is only valid in the data section");
    }
}

/// Consume `kind` or throw `message` at the current token.
fn expect(a: &mut super::Assembler, kind: scanner::TokenKind, message: *[u8]) throws (super::Error) {
unsafe fn expect(a: &mut super::Assembler, kind: scanner::TokenKind, message: *[u8]) throws (super::Error) {
    if not consume(a, kind) {
        throw fail(a, message);
    }
}

/// Consume `kind` and return the consumed token.
fn expectToken(a: &mut super::Assembler, kind: scanner::TokenKind, message: *[u8]) -> scanner::Token throws (super::Error) {
unsafe fn expectToken(a: &mut super::Assembler, kind: scanner::TokenKind, message: *[u8]) -> scanner::Token throws (super::Error) {
    try expect(a, kind, message);
    return a.scan.previous;
}

/// Require that the current item has reached its semicolon terminator.

            try emit::emitDataValue(a, value, width),
    }
}

/// Parse a possibly scoped name from one or more `::`-separated segments.
fn parseScopedName(
unsafe fn parseScopedName(
    a: &mut super::Assembler,
    kind: scanner::TokenKind,
    message: *[u8],
    trimPrefix: u32
) -> *[u8] throws (super::Error) {


    while consume(a, scanner::TokenKind::ColonColon) {
        let segment = try expectToken(a, scanner::TokenKind::Ident, "expected identifier after `::`");
        set end = segment.offset + segment.source.len;
    }
    return strings::intern(a.scan.pool, &a.scan.source[start..end]);
    let source = &a.scan.source[start..end];
    return strings::intern(a.scan.pool, source);
}

/// Parse a bare symbol name.
fn parseSymbolName(a: &mut super::Assembler) -> *[u8] throws (super::Error) {
unsafe fn parseSymbolName(a: &mut super::Assembler) -> *[u8] throws (super::Error) {
    return try parseScopedName(a, scanner::TokenKind::Ident, "expected symbol name", 0);
}

/// Return `true` when [`tok`] is any label token form.
fn isLabel(tok: scanner::TokenKind) -> bool {

/// Parse the contents of a quoted label token, decoding escapes as needed.
unsafe fn parseQuotedLabelName(a: &mut super::Assembler) -> *[u8] throws (super::Error) {
    let tok = try expectToken(a, scanner::TokenKind::QuotedLabel, "expected label name");
    let rawStart = super::LABEL_SIGIL_LEN + super::QUOTE_DELIM_LEN;
    let raw = &tok.source[rawStart..tok.source.len - super::QUOTE_DELIM_LEN];
    let storage = try alloc::allocSlice(&mut *a.arena, 1, 1, raw.len) catch {
    let storage = try alloc::allocSlice(a.arena, 1, 1, raw.len) catch {
        panic "asm: out of memory allocating quoted label";
    } as *mut [u8];
    let len = fmt::unescapeString(raw, storage);

    return strings::intern(a.scan.pool, &storage[..len]);

    }
    return try parseScopedName(a, scanner::TokenKind::Label, "expected label name", super::LABEL_SIGIL_LEN);
}

/// Parse a directive name without its leading `.`.
fn parseDirectiveName(a: &mut super::Assembler) -> *[u8] throws (super::Error) {
unsafe fn parseDirectiveName(a: &mut super::Assembler) -> *[u8] throws (super::Error) {
    let name = try expectToken(a, scanner::TokenKind::Directive, "expected directive name");
    return &name.source[super::DIRECTIVE_SIGIL_LEN..];
}

/// Parse one top-level assembler item.

        }
    }
}

/// Parse a `.constant` directive.
fn parseConstantDirective(a: &mut super::Assembler) throws (super::Error) {
unsafe fn parseConstantDirective(a: &mut super::Assembler) throws (super::Error) {
    let name = try parseSymbolName(a);
    let value = try expectI32Value(a, try parseExpr(a), "constant out of range");

    dict::insert(&mut a.constMap, name, value);
}

        }
    }
}

/// Parse and resolve a register operand.
fn parseRegister(a: &mut super::Assembler) -> gen::Reg throws (super::Error) {
unsafe fn parseRegister(a: &mut super::Assembler) -> gen::Reg throws (super::Error) {
    let tok = try expectToken(a, scanner::TokenKind::Register, "expected register");
    let reg = lookupRegister(&tok.source[1..]) else {
        throw super::Error::Invalid { offset: tok.offset, message: "unknown register" };
    };
    return reg;
}

/// Parse a simple signed immediate or constant value.
fn parseValue(a: &mut super::Assembler) -> i64 throws (super::Error) {
unsafe fn parseValue(a: &mut super::Assembler) -> i64 throws (super::Error) {
    if consume(a, scanner::TokenKind::Minus) {
        return -(try parseValuePrimary(a));
    }
    return try parseValuePrimary(a);
}

/// Parse the primary form used by simple immediate values.
fn parseValuePrimary(a: &mut super::Assembler) -> i64 throws (super::Error) {
unsafe fn parseValuePrimary(a: &mut super::Assembler) -> i64 throws (super::Error) {
    if a.scan.current.kind == scanner::TokenKind::Number {
        return try parseInteger(a);
    }
    if a.scan.current.kind == scanner::TokenKind::Ident {
        return try parseConstantValue(a);
    }
    throw fail(a, "expected number or constant");
}

/// Parse an additive constant expression.
fn parseExpr(a: &mut super::Assembler) -> i64 throws (super::Error) {
unsafe fn parseExpr(a: &mut super::Assembler) -> i64 throws (super::Error) {
    let mut value = try parseExprMul(a);

    while a.scan.current.kind == scanner::TokenKind::Plus or a.scan.current.kind == scanner::TokenKind::Minus {
        let op = a.scan.current.kind;
        advance(a);

    }
    return value;
}

/// Parse multiplicative expression operators.
fn parseExprMul(a: &mut super::Assembler) -> i64 throws (super::Error) {
unsafe fn parseExprMul(a: &mut super::Assembler) -> i64 throws (super::Error) {
    let mut value = try parseExprUnary(a);

    while a.scan.current.kind == scanner::TokenKind::Star or a.scan.current.kind == scanner::TokenKind::Slash {
        let op = a.scan.current.kind;
        advance(a);

    }
    return value;
}

/// Parse unary expression operators.
fn parseExprUnary(a: &mut super::Assembler) -> i64 throws (super::Error) {
unsafe fn parseExprUnary(a: &mut super::Assembler) -> i64 throws (super::Error) {
    if consume(a, scanner::TokenKind::Minus) {
        return -(try parseExprUnary(a));
    }
    if consume(a, scanner::TokenKind::Plus) {
        return try parseExprUnary(a);
    }
    return try parseExprPrimary(a);
}

/// Parse expression atoms.
fn parseExprPrimary(a: &mut super::Assembler) -> i64 throws (super::Error) {
unsafe fn parseExprPrimary(a: &mut super::Assembler) -> i64 throws (super::Error) {
    if consume(a, scanner::TokenKind::LParen) {
        let value = try parseExpr(a);
        try expect(a, scanner::TokenKind::RParen, "expected `)`");
        return value;
    }

    }
    throw fail(a, "expected expression");
}

/// Parse and resolve a named assembler constant.
fn parseConstantValue(a: &mut super::Assembler) -> i64 throws (super::Error) {
unsafe fn parseConstantValue(a: &mut super::Assembler) -> i64 throws (super::Error) {
    let name = try parseSymbolName(a);
    let value = dict::get(&a.constMap, name) else {
        throw super::Error::Invalid { offset: a.scan.previous.offset, message: "undefined constant" };
    };
    return value as i64;
}

/// Parse and resolve a CSR operand.
fn parseCsr(a: &mut super::Assembler) -> u32 throws (super::Error) {
unsafe fn parseCsr(a: &mut super::Assembler) -> u32 throws (super::Error) {
    let name = try parseSymbolName(a);
    let csr = lookupCsr(name) else {
        throw super::Error::Invalid { offset: a.scan.previous.offset, message: "unknown CSR" };
    };
    return csr;
}

/// Parse an offset(base) memory operand.
fn parseMemory(a: &mut super::Assembler) -> MemOperand throws (super::Error) {
unsafe fn parseMemory(a: &mut super::Assembler) -> MemOperand throws (super::Error) {
    let mut offset: i32 = 0;
    if a.scan.current.kind <> scanner::TokenKind::LParen {
        set offset = try expectSmallImmValue(a, try parseValue(a));
    }
    try expect(a, scanner::TokenKind::LParen, "expected `(`");


    return MemOperand { base, offset };
}

/// Parse an immediate value that fits in a signed 12-bit field.
fn parseSmallImm(a: &mut super::Assembler) -> i32 throws (super::Error) {
unsafe fn parseSmallImm(a: &mut super::Assembler) -> i32 throws (super::Error) {
    return try expectSmallImmValue(a, try parseValue(a));
}

/// Parse and validate a branch immediate.
fn parseBranchImm(a: &mut super::Assembler) -> i32 throws (super::Error) {
unsafe fn parseBranchImm(a: &mut super::Assembler) -> i32 throws (super::Error) {
    let value = try expectI32Value(a, try parseValue(a), "branch immediate out of range");
    if not encode::isBranchImm(value) {
        throw fail(a, "branch immediate out of range");
    }
    return value;
}

/// Parse and validate a jump immediate.
fn parseJumpImm(a: &mut super::Assembler) -> i32 throws (super::Error) {
unsafe fn parseJumpImm(a: &mut super::Assembler) -> i32 throws (super::Error) {
    let value = try expectI32Value(a, try parseValue(a), "jump immediate out of range");
    if not encode::isJumpImm(value) {
        throw fail(a, "jump immediate out of range");
    }
    return value;
}

/// Parse an integer token as an i64.
fn parseInteger(a: &mut super::Assembler) -> i64 throws (super::Error) {
unsafe fn parseInteger(a: &mut super::Assembler) -> i64 throws (super::Error) {
    let tok = try expectToken(a, scanner::TokenKind::Number, "expected number");
    let value = parseIntegerText(tok.source) else {
        throw failOnToken(tok, "invalid integer literal");
    };
    return value;

lib/std/arch/rv64/asm/scanner.rad +12 -10

    cursor: u32,
    /// Current token observed by the parser.
    current: Token,
    /// Previously consumed token observed by the parser.
    previous: Token,
    /// Intern pool for identifier-shaped token text.
    pool: *mut strings::Pool,
    /// Intern pool for identifier-shaped token text. It must remain valid while scanning.
    pool: *unsafe mut strings::Pool,
}

/// Individual token with kind, source text, and byte offset.
export record Token: Copy {
    /// Token kind.

    /// Byte offset of `source` in the input buffer.
    offset: u32,
}

/// Create a new assembler scanner.
export fn scanner(sourceKind: SourceKind, source: *[u8], pool: *mut strings::Pool) -> Scanner {
export fn scanner(sourceKind: SourceKind, source: *[u8], pool: *unsafe mut strings::Pool) -> Scanner {
    let invalidToken = invalid(0, "");
    return Scanner {
        sourceKind,
        source,
        token: 0,

            else => return,
        }
    }
}

/// Return the next assembler token.
export fn next(s: &mut Scanner) -> Token {
/// Return the next assembler token. The retained pool must be valid and writable.
export unsafe fn next(s: &mut Scanner) -> Token {
    skipWhitespace(s);
    set s.token = s.cursor;

    if isEof(s) {
        return tok(s, TokenKind::Eof);

    }
    return invalid(s.token, "unterminated character");
}

/// Scan an identifier-shaped token of the given kind.
fn scanIdentToken(s: &mut Scanner, kind: TokenKind) -> Token {
unsafe fn scanIdentToken(s: &mut Scanner, kind: TokenKind) -> Token {
    scanIdentifierBody(s);
    let source = &s.source[s.token..s.cursor];

    return Token {
        kind,
        source: strings::intern(s.pool, &s.source[s.token..s.cursor]),
        source: strings::intern(s.pool, source),
        offset: s.token,
    };
}

/// Scan a sigil-prefixed identifier-shaped token.
fn scanPrefixedToken(s: &mut Scanner, kind: TokenKind, message: *[u8]) -> Token {
unsafe fn scanPrefixedToken(s: &mut Scanner, kind: TokenKind, message: *[u8]) -> Token {
    let ch = current(s) else {
        return invalid(s.token, message);
    };
    if not char::isAlpha(ch) and ch <> '_' {
        return invalid(s.token, message);
    }
    scanIdentifierBody(s);
    let source = &s.source[s.token..s.cursor];

    return Token {
        kind,
        source: strings::intern(s.pool, &s.source[s.token..s.cursor]),
        source: strings::intern(s.pool, source),
        offset: s.token,
    };
}

/// Scan an assembler label token, accepting either `@name` or `@"quoted"` syntax.
fn scanLabelToken(s: &mut Scanner) -> Token {
unsafe fn scanLabelToken(s: &mut Scanner) -> Token {
    let ch = current(s) else {
        return invalid(s.token, "expected label after `@`");
    };
    if ch == '"' {
        advance(s);

lib/std/arch/rv64/asm/scanner/tests.rad +7 -7

        return super::scanner(super::SourceKind::String, source, &mut TEST_STRING_POOL);
    }
}

/// Scanner recognizes assembler-specific sigils and scoped names.
@test fn testScanRegisterDirectiveAndLabelTokens() throws (testing::TestError) {
@test unsafe fn testScanRegisterDirectiveAndLabelTokens() throws (testing::TestError) {
    let mut s = testScanner(
        ".text %sp @entry name::tail 42"
    );
    let directive = super::next(&mut s);
    try testing::expect(directive.kind == super::TokenKind::Directive);

    try testing::expect(super::next(&mut s).kind == super::TokenKind::Number);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Eof);
}

/// Keyword-shaped text remains plain assembler identifiers.
@test fn testScanKeywordShapedAsmNamesRemainAsmTokens() throws (testing::TestError) {
@test unsafe fn testScanKeywordShapedAsmNamesRemainAsmTokens() throws (testing::TestError) {
    let mut s = testScanner(
        "and or not align addi .text @label"
    );
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Ident);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Ident);

    try testing::expect(super::next(&mut s).kind == super::TokenKind::Label);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Eof);
}

/// Quoted labels can spell symbol names that are not identifier-shaped.
@test fn testScanQuotedLabelToken() throws (testing::TestError) {
@test unsafe fn testScanQuotedLabelToken() throws (testing::TestError) {
    let mut s = testScanner(
        "@\"foo.bar.baz\""
    );
    let label = super::next(&mut s);
    try testing::expect(label.kind == super::TokenKind::QuotedLabel);
    try testing::expect(mem::eq(label.source, "@\"foo.bar.baz\""));
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Eof);
}

/// Sigil-prefixed tokens require the name to start immediately after the sigil.
@test fn testScanSigilsRequireAdjacency() throws (testing::TestError) {
@test unsafe fn testScanSigilsRequireAdjacency() throws (testing::TestError) {
    let mut regScan = testScanner("% a0");
    try testing::expect(super::next(&mut regScan).kind == super::TokenKind::Invalid);

    let mut labelScan = testScanner("@ entry");
    try testing::expect(super::next(&mut labelScan).kind == super::TokenKind::Invalid);

    let mut directiveScan = testScanner(". text");
    try testing::expect(super::next(&mut directiveScan).kind == super::TokenKind::Invalid);
}

/// Scanner reaches EOF after trailing whitespace and comments.
@test fn testScanProgramEndingWithNewline() throws (testing::TestError) {
@test unsafe fn testScanProgramEndingWithNewline() throws (testing::TestError) {
    let mut s = testScanner(
        ".text;\n@start\naddi %a0 %zero 42;\nsd %a0 8(%sp);\n// comment\nbeq %a0 %zero @done;\n@done\nret;\n"
    );
    loop {
        let tok = super::next(&mut s);

        }
    }
}

/// Signed numbers scan only the numeric formats supported by the assembler scanner.
@test fn testScanSignedHexAndUnsupportedNumericForms() throws (testing::TestError) {
@test unsafe fn testScanSignedHexAndUnsupportedNumericForms() throws (testing::TestError) {
    let mut s = testScanner(
        "+0x2a -0b10 45.5"
    );
    let mut tok = super::next(&mut s);
    try testing::expect(tok.kind == super::TokenKind::Number);

    try testing::expect(tok.kind == super::TokenKind::Number);
    try testing::expect(mem::eq(tok.source, "5"));
}

/// Unterminated string and character literals report invalid tokens.
@test fn testScanUnterminatedDelimitedLiterals() throws (testing::TestError) {
@test unsafe fn testScanUnterminatedDelimitedLiterals() throws (testing::TestError) {
    let mut stringScan = testScanner("\"unterminated");
    let stringTok = super::next(&mut stringScan);
    try testing::expect(stringTok.kind == super::TokenKind::Invalid);
    try testing::expect(mem::eq(stringTok.source, "unterminated string"));


lib/std/arch/rv64/emit.rad +12 -7

    /// Offset from SP.
    offset: i32,
}

/// Emission context. Tracks state during code generation.
export record Emitter: Copy {
export record Emitter {
    /// Allocator for growing append-backed emitter lists.
    allocator: alloc::Allocator,
    /// Emitted instructions storage.
    code: *mut [u32],
    /// Current number of emitted instructions.

    if debug {
        set debugEntries = try alloc::allocSlice(
            arena, @sizeOf(types::DebugEntry), @alignOf(types::DebugEntry), MAX_DEBUG_ENTRIES
        ) as *mut [types::DebugEntry];
    }
    let pendingBranchesBuf = pendingBranches as *mut [PendingBranch];
    let pendingCallsBuf = pendingCalls as *mut [PendingCall];
    let pendingJumpsBuf = pendingJumps as *mut [PendingJump];
    let pendingAddrLoadsBuf = pendingAddrLoads as *mut [PendingAddrLoad];
    let funcsBuf = funcs as *mut [types::FuncAddr];
    return Emitter {
        allocator: alloc::arenaAllocator(arena),
        code: code as *mut [u32],
        codeLen: 0,
        pendingBranches: @sliceOf((pendingBranches as *mut [PendingBranch]).ptr, 0, MAX_PENDING),
        pendingCalls: @sliceOf((pendingCalls as *mut [PendingCall]).ptr, 0, MAX_PENDING),
        pendingJumps: @sliceOf((pendingJumps as *mut [PendingJump]).ptr, 0, MAX_PENDING),
        pendingAddrLoads: @sliceOf((pendingAddrLoads as *mut [PendingAddrLoad]).ptr, 0, MAX_PENDING),
        pendingBranches: &mut pendingBranchesBuf[..0],
        pendingCalls: &mut pendingCallsBuf[..0],
        pendingJumps: &mut pendingJumpsBuf[..0],
        pendingAddrLoads: &mut pendingAddrLoadsBuf[..0],
        labels: labels::init(blockOffsets as *mut [i32], funcEntries as *mut [dict::Entry]),
        funcs: @sliceOf((funcs as *mut [types::FuncAddr]).ptr, 0, MAX_FUNCS),
        funcs: &mut funcsBuf[..0],
        debugEntries,
        debugEntriesLen: 0,
    };
}


                assert encode::isJumpImm(offset), "patchLocalBranches: jump offset too large";
                patch(e, p.index, encode::jal(super::ZERO, offset));
            },
        }
    }
    set e.pendingBranches = @sliceOf(e.pendingBranches.ptr, 0, e.pendingBranches.cap);
    set e.pendingBranches = &mut e.pendingBranches[..0];
}

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

lib/std/arch/rv64/isel.rad +129 -129

/// 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 {
    if let slot = regalloc::spill::spillSlot(&s.ralloc.spill, ssa) {
        emit::emitLd(&mut *s.e, scratch, spillBase(s), spillOffset(s, slot));
        emit::emitLd(s.e, scratch, spillBase(s), spillOffset(s, slot));
        return scratch;
    }
    return getReg(s, ssa);
}


        },
        case il::Val::Imm(imm) => {
            if imm == 0 {
                return super::ZERO;
            }
            emit::loadImm(&mut *s.e, scratch, imm);
            emit::loadImm(s.e, scratch, imm);
            return scratch;
        },
        case il::Val::DataSym(name) => {
            emit::recordDataAddrLoad(&mut *s.e, name, scratch);
            emit::recordDataAddrLoad(s.e, name, scratch);
            return scratch;
        },
        case il::Val::FnAddr(name) => {
            emit::recordAddrLoad(&mut *s.e, name, scratch);
            emit::recordAddrLoad(s.e, name, scratch);
            return scratch;
        },
        case il::Val::Undef => {
            return scratch;
        }

}

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

/// Emit zero-extension from a sub-word type to the full register width.
fn emitZext(e: &mut emit::Emitter, rd: gen::Reg, rs: gen::Reg, typ: il::Type) {

    if let case il::Val::Imm(imm) = b {
        set divisor = il::Val::Imm(canonicalCmpImm(imm, typ, signed));
    }
    let rs2 = resolveVal(s, super::SCRATCH2, divisor);
    if not isExtendedImm(divisor, typ, signed) {
        emitCmpExt(&mut *s.e, rs2, rs2, typ, signed);
        emitCmpExt(s.e, rs2, rs2, typ, signed);
    }
    let mut knownNonZero = false;
    if let case il::Val::Imm(imm) = divisor {
        set knownNonZero = imm <> 0;
    }
    if not knownNonZero {
        emit::emit(&mut *s.e, encode::bne(rs2, super::ZERO, super::INSTR_SIZE * 2));
        emit::emit(&mut *s.e, encode::ebreak());
        emit::emit(s.e, encode::bne(rs2, super::ZERO, super::INSTR_SIZE * 2));
        emit::emit(s.e, encode::ebreak());
    }
    return rs2;
}

////////////////////////

    isDynamic: bool,
}

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

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


/// Select instructions for a function.
export unsafe fn selectFn(
    e: &mut emit::Emitter,
    ralloc: &regalloc::AllocResult,
    func: *il::Fn
    func: *unsafe il::Fn
) {
    // 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);

        reserveOffset: 0, pendingSpill: nil,
        nextSynthBlock: func.blocks.len + 1,
        isDynamic: frame.isDynamic,
    };
    // Record function name for printing.
    emit::recordFunc(&mut *s.e, func.name);
    emit::recordFunc(s.e, func.name);
    // Record function code offset for call patching.
    emit::recordFuncOffset(&mut *s.e, func.name);
    emit::recordFuncOffset(s.e, func.name);
    // Emit prologue.
    emit::emitPrologue(&mut *s.e, &frame);
    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.

            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(&mut *s.e, argReg, spillBase(&s), spillOffset(&s, 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 {
        selectBlock(&mut s, i, &func.blocks[i], &frame, func);
    }
    // Emit epilogue.
    emit::emitEpilogue(&mut *s.e, &frame);
    emit::emitEpilogue(s.e, &frame);
    // Patch local branches now that all blocks are emitted.
    emit::patchLocalBranches(&mut *s.e);
    emit::patchLocalBranches(s.e);
}

/// Select instructions for a block.
unsafe fn selectBlock(s: &mut Selector, blockIdx: u32, block: *il::Block, frame: &emit::Frame, func: *il::Fn) {
unsafe fn selectBlock(s: &mut Selector, blockIdx: u32, block: *unsafe il::Block, frame: &emit::Frame, func: *unsafe il::Fn) {
    // Record block address for branch patching.
    emit::recordBlock(&mut *s.e, blockIdx);
    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 {
        // Record debug location before emitting machine instructions.
        if hasLocs {
            emit::recordSrcLoc(&mut *s.e, block.locs[i]);
            emit::recordSrcLoc(s.e, block.locs[i]);
        }
        set s.pendingSpill = nil;
        selectInstr(s, blockIdx, instr, frame, func);

        // Flush the pending spill store, if any.
        if let p = s.pendingSpill {
            if let slot = regalloc::spill::spillSlot(&s.ralloc.spill, p.ssa) {
                emit::emitSd(&mut *s.e, p.rd, spillBase(s), spillOffset(s, slot));
                emit::emitSd(s.e, p.rd, spillBase(s), spillOffset(s, slot));
            }
            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: *il::Fn) {
unsafe fn selectInstr(s: &mut Selector, blockIdx: u32, instr: il::Instr, frame: &emit::Frame, func: *unsafe il::Fn) {
    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);

            selectAluUnOp(s, op, typ, rd, rs);
        },
        case il::Instr::Load { typ, dst, src, offset } => {
            let rd = getDstReg(s, dst, super::SCRATCH1);
            let base = getSrcReg(s, src, super::SCRATCH2);
            emit::emitLoad(&mut *s.e, rd, base, offset, typ);
            emit::emitLoad(s.e, rd, base, offset, typ);
        },
        case il::Instr::Sload { typ, dst, src, offset } => {
            let rd = getDstReg(s, dst, super::SCRATCH1);
            let base = getSrcReg(s, src, super::SCRATCH2);
            emit::emitSload(&mut *s.e, rd, base, offset, typ);
            emit::emitSload(s.e, rd, base, offset, typ);
        },
        case il::Instr::Store { typ, src, dst, offset } => {
            let base = getSrcReg(s, dst, super::SCRATCH2);
            let rs = resolveVal(s, super::SCRATCH1, src);
            emit::emitStore(&mut *s.e, rs, base, offset, typ);
            emit::emitStore(s.e, rs, base, offset, typ);
        },
        case il::Instr::Copy { dst, val } => {
            let rd = getDstReg(s, dst, super::SCRATCH1);
            let rs = resolveVal(s, super::SCRATCH1, val);
            emitMv(s, rd, rs);

                    let aligned: i32 = mem::alignUpI32(s.reserveOffset, alignment as i32);
                    let base = spillBase(s);
                    let offset = s.ralloc.spill.frameSize + aligned
                        - (s.frameSize if s.isDynamic else 0);

                    emit::emitAddImm(&mut *s.e, rd, base, offset);
                    emit::emitAddImm(s.e, rd, base, offset);
                    set s.reserveOffset = aligned + (sz as i32);
                },
                case il::Val::Reg(r) => {
                    // Dynamic-sized reserve: runtime SP adjustment.
                    let rd = getDstReg(s, dst, super::SCRATCH1);
                    let rs = getSrcReg(s, r, super::SCRATCH2);

                    emit::emit(&mut *s.e, encode::sub(super::SP, super::SP, rs));
                    emit::emit(s.e, encode::sub(super::SP, super::SP, rs));

                    if alignment > 1 {
                        let mask = 0 - alignment as i32;
                        assert encode::isSmallImm(mask);

                        emit::emit(&mut *s.e, encode::andi(super::SP, super::SP, mask));
                        emit::emit(s.e, encode::andi(super::SP, super::SP, mask));
                    }
                    emit::emit(&mut *s.e, encode::mv(rd, super::SP));
                    emit::emit(s.e, encode::mv(rd, super::SP));
                },
                else =>
                    panic "selectInstr: invalid reserve operand",
            }
        },

                    panic "selectInstr: blit dst not spilled";
                };
                let srcSlot = regalloc::spill::spillSlot(&s.ralloc.spill, src) else {
                    panic "selectInstr: blit src not spilled";
                };
                emit::emitLd(&mut *s.e, super::SCRATCH2, spillBase(s), spillOffset(s, dstSlot));
                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 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(&mut *s.e, super::SCRATCH1, rsrc, dwordBytes);
                emit::emitAddImm(s.e, super::SCRATCH1, rsrc, dwordBytes);

                let loopStart = s.e.codeLen;

                emit::emitLd(&mut *s.e, super::SCRATCH2, rsrc, 0);
                emit::emitSd(&mut *s.e, super::SCRATCH2, rdst, 0);
                emit::emit(&mut *s.e, encode::addi(rsrc, rsrc, super::DWORD_SIZE));
                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(&mut *s.e, encode::addi(rdst, rdst, super::DWORD_SIZE));
                    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(&mut *s.e, encode::bne(rsrc, super::SCRATCH1, brOff));
                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(&mut *s.e, rsrc, rsrc, offset);
                    emit::emitAddImm(s.e, rsrc, rsrc, offset);
                    if *rdst <> *rsrc {
                        emit::emitAddImm(&mut *s.e, rdst, rdst, offset);
                        emit::emitAddImm(s.e, rdst, rdst, offset);
                    }
                    set offset = 0;
                }
                if let off = srcReload {
                    emit::emitLd(&mut *s.e, super::SCRATCH1, spillBase(s), off);
                    emit::emitLd(&mut *s.e, super::SCRATCH1, super::SCRATCH1, offset);
                    emit::emitLd(s.e, super::SCRATCH1, spillBase(s), off);
                    emit::emitLd(s.e, super::SCRATCH1, super::SCRATCH1, offset);
                } else {
                    emit::emitLd(&mut *s.e, super::SCRATCH1, rsrc, offset);
                    emit::emitLd(s.e, super::SCRATCH1, rsrc, offset);
                }
                emit::emitSd(&mut *s.e, super::SCRATCH1, rdst, 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(&mut *s.e, rsrc, rsrc, offset);
                    emit::emitAddImm(s.e, rsrc, rsrc, offset);
                    if *rdst <> *rsrc {
                        emit::emitAddImm(&mut *s.e, rdst, rdst, offset);
                        emit::emitAddImm(s.e, rdst, rdst, offset);
                    }
                    set offset = 0;
                }
                if let off = srcReload {
                    emit::emitLd(&mut *s.e, super::SCRATCH1, spillBase(s), off);
                    emit::emitLw(&mut *s.e, super::SCRATCH1, super::SCRATCH1, offset);
                    emit::emitLd(s.e, super::SCRATCH1, spillBase(s), off);
                    emit::emitLw(s.e, super::SCRATCH1, super::SCRATCH1, offset);
                } else {
                    emit::emitLw(&mut *s.e, super::SCRATCH1, rsrc, offset);
                    emit::emitLw(s.e, super::SCRATCH1, rsrc, offset);
                }
                emit::emitSw(&mut *s.e, super::SCRATCH1, rdst, offset);
                emit::emitSw(s.e, super::SCRATCH1, rdst, offset);
                set offset += super::WORD_SIZE;
                set remaining -= super::WORD_SIZE;
            }
            while remaining > 0 {
                if offset > super::MAX_IMM - 1 {
                    emit::emitAddImm(&mut *s.e, rsrc, rsrc, offset);
                    emit::emitAddImm(s.e, rsrc, rsrc, offset);
                    if *rdst <> *rsrc {
                        emit::emitAddImm(&mut *s.e, rdst, rdst, offset);
                        emit::emitAddImm(s.e, rdst, rdst, offset);
                    }
                    set offset = 0;
                }
                if let off = srcReload {
                    emit::emitLd(&mut *s.e, super::SCRATCH1, spillBase(s), off);
                    emit::emitLb(&mut *s.e, super::SCRATCH1, super::SCRATCH1, offset);
                    emit::emitLd(s.e, super::SCRATCH1, spillBase(s), off);
                    emit::emitLb(s.e, super::SCRATCH1, super::SCRATCH1, offset);
                } else {
                    emit::emitLb(&mut *s.e, super::SCRATCH1, rsrc, offset);
                    emit::emitLb(s.e, super::SCRATCH1, rsrc, offset);
                }
                emit::emitSb(&mut *s.e, super::SCRATCH1, rdst, offset);
                emit::emitSb(s.e, super::SCRATCH1, rdst, offset);
                set offset += 1;
                set remaining -= 1;
            }
            // 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(&mut *s.e, rsrc, rsrc, 0 - advanced);
                    emit::emitAddImm(s.e, rsrc, rsrc, 0 - advanced);
                    if *rdst <> *rsrc {
                        emit::emitAddImm(&mut *s.e, rdst, rdst, 0 - advanced);
                        emit::emitAddImm(s.e, rdst, rdst, 0 - advanced);
                    }
                }
            }
        },
        case il::Instr::Zext { typ, dst, val } => {
            let rd = getDstReg(s, dst, super::SCRATCH1);
            let rs = resolveVal(s, super::SCRATCH1, val);
            emitZext(&mut *s.e, rd, rs, typ);
            emitZext(s.e, rd, rs, typ);
        },
        case il::Instr::Sext { typ, dst, val } => {
            let rd = getDstReg(s, dst, super::SCRATCH1);
            let rs = resolveVal(s, super::SCRATCH1, val);
            emitSext(&mut *s.e, rd, rs, typ);
            emitSext(s.e, rd, rs, typ);
        },
        case il::Instr::Ret { val } => {
            if let v = val {
                let rs = resolveVal(s, super::SCRATCH1, v);
                emitMv(s, super::A0, rs);

            // Skip the jump to epilogue if this RET is in the last block,
            // since the epilogue immediately follows.
            if frame.totalSize <> 0 and blockIdx + 1 == frame.epilogueBlock {
                // Epilogue is the next block; fallthrough is sufficient.
            } else {
                emit::emitReturn(&mut *s.e, frame);
                emit::emitReturn(s.e, frame);
            }
        },
        case il::Instr::Jmp { target, args } => {
            // Move arguments to target block's parameter registers.
            emitBlockArgs(s, func, target, args);
            // Skip branch if target is the next block (fallthrough).
            if target <> blockIdx + 1 {
                emit::recordBranch(&mut *s.e, target, emit::BranchKind::Jump);
                emit::recordBranch(s.e, target, emit::BranchKind::Jump);
            }
        },
        case il::Instr::Br { op, typ, a, b, thenTarget, thenArgs, elseTarget, elseArgs } => {
            // Use zero register directly for immediate `0` operands.
            let aIsZero = isZeroImm(a);

            if let case il::CmpOp::Slt = op {
                set signed = true;
            }
            let useSext = cmpUsesSext(typ, signed);
            if not aIsZero and not isExtendedImm(a, typ, useSext) {
                emitCmpExt(&mut *s.e, rs1, rs1, typ, useSext);
                emitCmpExt(s.e, rs1, rs1, typ, useSext);
            }
            if not bIsZero and not isExtendedImm(b, typ, useSext) {
                emitCmpExt(&mut *s.e, rs2, rs2, typ, useSext);
                emitCmpExt(s.e, rs2, rs2, typ, useSext);
            }
            // Block-argument moves must only execute on the taken path.
            // When `thenArgs` is non-empty, invert the branch so that the
            // then-moves land on the fall-through (taken) side.
            //

            // conditional branch to skip to the *other* target and letting
            // execution fall through.
            if thenArgs.len > 0 and elseArgs.len > 0 {
                panic "selectInstr: both `then` and `else` have block arguments";
            } else if thenArgs.len > 0 {
                emit::recordBranch(&mut *s.e, elseTarget, emit::BranchKind::InvertedCond { op, rs1, rs2 });
                emit::recordBranch(s.e, elseTarget, emit::BranchKind::InvertedCond { op, rs1, rs2 });
                emitBlockArgs(s, func, thenTarget, thenArgs);
                // Skip trailing jump if then is the next block (fallthrough).
                if thenTarget <> blockIdx + 1 {
                    emit::recordBranch(&mut *s.e, thenTarget, emit::BranchKind::Jump);
                    emit::recordBranch(s.e, thenTarget, emit::BranchKind::Jump);
                }
            } else if thenTarget == blockIdx + 1 and elseArgs.len == 0 {
                // Then is the next block and no else args: invert the
                // condition to branch to else and fall through to then.
                emit::recordBranch(&mut *s.e, elseTarget, emit::BranchKind::InvertedCond { op, rs1, rs2 });
                emit::recordBranch(s.e, elseTarget, emit::BranchKind::InvertedCond { op, rs1, rs2 });
            } else {
                emit::recordBranch(&mut *s.e, thenTarget, emit::BranchKind::Cond { op, rs1, rs2 });
                emit::recordBranch(s.e, thenTarget, emit::BranchKind::Cond { op, rs1, rs2 });
                emitBlockArgs(s, func, elseTarget, elseArgs);
                // Skip trailing jump if else is the next block (fallthrough).
                if elseTarget <> blockIdx + 1 {
                    emit::recordBranch(&mut *s.e, elseTarget, emit::BranchKind::Jump);
                    emit::recordBranch(s.e, elseTarget, emit::BranchKind::Jump);
                }
            }
        },
        case il::Instr::Switch { val, defaultTarget, defaultArgs, cases } => {
            let rs1 = resolveVal(s, super::SCRATCH1, val);
            // When a case has block args, invert the branch to skip past
            // the arg moves.
            for c in cases {
                emit::loadImm(&mut *s.e, super::SCRATCH2, c.value);
                emit::loadImm(s.e, super::SCRATCH2, c.value);

                if c.args.len > 0 {
                    let skip = s.nextSynthBlock;
                    set s.nextSynthBlock = skip + 1;

                    emit::recordBranch(&mut *s.e, skip, emit::BranchKind::InvertedCond {
                    emit::recordBranch(s.e, skip, emit::BranchKind::InvertedCond {
                        op: il::CmpOp::Eq, rs1, rs2: super::SCRATCH2,
                    });
                    emitBlockArgs(s, func, c.target, c.args);
                    emit::recordBranch(&mut *s.e, c.target, emit::BranchKind::Jump);
                    emit::recordBlock(&mut *s.e, skip);
                    emit::recordBranch(s.e, c.target, emit::BranchKind::Jump);
                    emit::recordBlock(s.e, skip);
                } else {
                    emit::recordBranch(&mut *s.e, c.target, emit::BranchKind::Cond {
                    emit::recordBranch(s.e, c.target, emit::BranchKind::Cond {
                        op: il::CmpOp::Eq, rs1, rs2: super::SCRATCH2,
                    });
                }
            }
            // Fall through to default.
            emitBlockArgs(s, func, defaultTarget, defaultArgs);
            emit::recordBranch(&mut *s.e, defaultTarget, emit::BranchKind::Jump);
            emit::recordBranch(s.e, defaultTarget, emit::BranchKind::Jump);
        },
        case il::Instr::Unreachable => {
            emit::emit(&mut *s.e, encode::ebreak());
            emit::emit(s.e, encode::ebreak());
        },
        case il::Instr::Call { retTy, dst, func, args } => {
            // For indirect calls, save target to scratch register before arg
            // setup can clobber it.
            if let case il::Val::Reg(r) = func {

            emitParallelMoves(s, &super::ARG_REGS[..], args);

            // Emit call.
            match func {
                case il::Val::FnAddr(name) => {
                    emit::recordCall(&mut *s.e, name);
                    emit::recordCall(s.e, name);
                },
                case il::Val::Reg(_) => {
                    emit::emit(&mut *s.e, encode::jalr(super::RA, super::SCRATCH2, 0));
                    emit::emit(s.e, encode::jalr(super::RA, super::SCRATCH2, 0));
                },
                else => {
                    panic "selectInstr: invalid call target";
                }
            }

            // support constant-evaluating struct/union values in them.
            let ecallDsts: [gen::Reg; 5] = [super::A7, super::A0, super::A1, super::A2, super::A3];
            let ecallArgs: [il::Val; 5] = [num, a0, a1, a2, a3];

            emitParallelMoves(s, &ecallDsts[..], &ecallArgs[..]);
            emit::emit(&mut *s.e, encode::ecall());
            emit::emit(s.e, encode::ecall());

            // Result in A0.
            let ecallRd = getDstReg(s, dst, super::SCRATCH1);
            emitMv(s, ecallRd, super::A0);
        },
        case il::Instr::Ebreak => {
            emit::emit(&mut *s.e, encode::ebreak());
            emit::emit(s.e, encode::ebreak());
        },
        case il::Instr::MemoryFence => {
            emit::emit(&mut *s.e, encode::fence());
            emit::emit(s.e, encode::fence());
        },
    }
}

/// Choose the cheapest canonical representation that preserves the comparison.

        case il::BinOp::Add => {
            if typ == il::Type::W32 {
                // Inline W32 ADD with immediate optimization.
                if let case il::Val::Imm(imm) = b {
                    if encode::isSmallImm64(imm) {
                        emit::emit(&mut *s.e, encode::addiw(rd, rs1, imm as i32));
                        emit::emit(s.e, encode::addiw(rd, rs1, imm as i32));
                        return;
                    }
                }
                let rs2 = resolveVal(s, super::SCRATCH2, b);
                emit::emit(&mut *s.e, encode::addw(rd, rs1, rs2));
                emit::emit(s.e, encode::addw(rd, rs1, rs2));
            } else {
                selectBinOp(s, rd, rs1, b, BinOp::Add, super::SCRATCH2);
            }
        }
        case il::BinOp::Sub => {
            // Optimize subtraction by small immediate: use ADDI with negated value.
            if let case il::Val::Imm(imm) = b {
                let neg = -imm;
                if neg >= super::MIN_IMM as i64 and neg <= super::MAX_IMM as i64 {
                    emit::emit(&mut *s.e,
                    emit::emit(s.e,
                        encode::addiw(rd, rs1, neg as i32)
                            if typ == il::Type::W32 else
                        encode::addi(rd, rs1, neg as i32));
                    return;
                }
            }
            let rs2 = resolveVal(s, super::SCRATCH2, b);

            emit::emit(&mut *s.e,
            emit::emit(s.e,
                encode::subw(rd, rs1, rs2)
                    if typ == il::Type::W32 else
                encode::sub(rd, rs1, rs2));
        }
        case il::BinOp::Mul => {
            // Strength-reduce multiplication by known constants.
            if let case il::Val::Imm(imm) = b {
                if imm == 0 {
                    emit::emit(&mut *s.e, encode::mv(rd, super::ZERO));
                    emit::emit(s.e, encode::mv(rd, super::ZERO));
                    return;
                } else if imm == 1 {
                    emitMv(s, rd, rs1);
                    return;
                } else if imm == 2 {
                    emit::emit(&mut *s.e, encode::slli(rd, rs1, 1));
                    emit::emit(s.e, encode::slli(rd, rs1, 1));
                    return;
                } else if imm == 4 {
                    emit::emit(&mut *s.e, encode::slli(rd, rs1, 2));
                    emit::emit(s.e, encode::slli(rd, rs1, 2));
                    return;
                } else if imm == 8 {
                    emit::emit(&mut *s.e, encode::slli(rd, rs1, 3));
                    emit::emit(s.e, encode::slli(rd, rs1, 3));
                    return;
                }
            }
            let rs2 = resolveVal(s, super::SCRATCH2, b);
            emit::emit(&mut *s.e,
            emit::emit(s.e,
                encode::mulw(rd, rs1, rs2)
                    if typ == il::Type::W32 else
                encode::mul(rd, rs1, rs2));
        }
        case il::BinOp::Sdiv => {
            let rs2 = resolveAndTrapIfZero(s, b, typ, true);
            emit::emit(&mut *s.e,
            emit::emit(s.e,
                encode::divw(rd, rs1, rs2)
                    if typ == il::Type::W32 else
                encode::div(rd, rs1, rs2));
        }
        case il::BinOp::Udiv => {
            let rs2 = resolveAndTrapIfZero(s, b, typ, false);
            emit::emit(&mut *s.e,
            emit::emit(s.e,
                encode::divuw(rd, rs1, rs2)
                    if typ == il::Type::W32 else
                encode::divu(rd, rs1, rs2));
        }
        case il::BinOp::Srem => {
            let rs2 = resolveAndTrapIfZero(s, b, typ, true);
            emit::emit(&mut *s.e,
            emit::emit(s.e,
                encode::remw(rd, rs1, rs2)
                    if typ == il::Type::W32 else
                encode::rem(rd, rs1, rs2));
        }
        case il::BinOp::Urem => {
            let rs2 = resolveAndTrapIfZero(s, b, typ, false);
            emit::emit(&mut *s.e,
            emit::emit(s.e,
                encode::remuw(rd, rs1, rs2)
                    if typ == il::Type::W32 else
                encode::remu(rd, rs1, rs2));
        }
        case il::BinOp::And =>

        case il::BinOp::Ushr =>
            selectShift(s, rd, rs1, b, ShiftOp::Srl, typ, super::SCRATCH2),
        case il::BinOp::Eq, il::BinOp::Ne => {
            let rs2 = resolveVal(s, super::SCRATCH2, b);
            let useSext = cmpUsesSext(typ, false);
            emitCmpExt(&mut *s.e, rs1, rs1, typ, useSext);
            emitCmpExt(s.e, rs1, rs1, typ, useSext);
            if not isExtendedImm(b, typ, useSext) {
                emitCmpExt(&mut *s.e, rs2, rs2, typ, useSext);
                emitCmpExt(s.e, rs2, rs2, typ, useSext);
            }
            emit::emit(&mut *s.e, encode::xor(rd, rs1, rs2));
            emit::emit(s.e, encode::xor(rd, rs1, rs2));
            if let case il::BinOp::Eq = op {
                emit::emit(&mut *s.e, encode::sltiu(rd, rd, 1));
                emit::emit(s.e, encode::sltiu(rd, rd, 1));
            } else {
                emit::emit(&mut *s.e, encode::sltu(rd, super::ZERO, rd));
                emit::emit(s.e, encode::sltu(rd, super::ZERO, rd));
            }
        }
        case il::BinOp::Slt =>
            selectCmp(s, typ, rd, rs1, b, CmpOp::Slt, false, super::SCRATCH2),
        case il::BinOp::Ult =>

/// Select a unary ALU operation.
unsafe fn selectAluUnOp(s: &mut Selector, op: il::UnOp, typ: il::Type, rd: gen::Reg, rs: gen::Reg) {
    match op {
        case il::UnOp::Neg => {
            if typ == il::Type::W32 {
                emit::emit(&mut *s.e, encode::subw(rd, super::ZERO, rs));
                emit::emit(s.e, encode::subw(rd, super::ZERO, rs));
            } else {
                emit::emit(&mut *s.e, encode::neg(rd, rs));
                emit::emit(s.e, encode::neg(rd, rs));
            }
        }
        case il::UnOp::Not =>
            emit::emit(&mut *s.e, encode::not_(rd, rs)),
            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) {
    // Try immediate optimization first.
    if let case il::Val::Imm(imm) = b {
        if encode::isSmallImm64(imm) {
            let simm = imm as i32;
            match op {
                case BinOp::Add => emit::emit(&mut *s.e, encode::addi(rd, rs1, simm)),
                case BinOp::And => emit::emit(&mut *s.e, encode::andi(rd, rs1, simm)),
                case BinOp::Or  => emit::emit(&mut *s.e, encode::ori(rd, rs1, simm)),
                case BinOp::Xor => emit::emit(&mut *s.e, encode::xori(rd, rs1, simm)),
                case BinOp::Add => emit::emit(s.e, encode::addi(rd, rs1, simm)),
                case BinOp::And => emit::emit(s.e, encode::andi(rd, rs1, simm)),
                case BinOp::Or  => emit::emit(s.e, encode::ori(rd, rs1, simm)),
                case BinOp::Xor => emit::emit(s.e, encode::xori(rd, rs1, simm)),
            }
            return;
        }
    }
    // Fallback: load into register.
    let rs2 = resolveVal(s, scratch, b);
    match op {
        case BinOp::Add => emit::emit(&mut *s.e, encode::add(rd, rs1, rs2)),
        case BinOp::And => emit::emit(&mut *s.e, encode::and_(rd, rs1, rs2)),
        case BinOp::Or  => emit::emit(&mut *s.e, encode::or_(rd, rs1, rs2)),
        case BinOp::Xor => emit::emit(&mut *s.e, encode::xor(rd, rs1, rs2)),
        case BinOp::Add => emit::emit(s.e, encode::add(rd, rs1, rs2)),
        case BinOp::And => emit::emit(s.e, encode::and_(rd, rs1, rs2)),
        case BinOp::Or  => emit::emit(s.e, encode::or_(rd, rs1, rs2)),
        case BinOp::Xor => emit::emit(s.e, encode::xor(rd, rs1, rs2)),
    }
}

/// Select shift operation with immediate optimization.
/// For 32-bit operations, uses the `*w` variants that operate on the lower 32 bits

        // Otherwise fall back to register shifts, which naturally mask the count.
        if shamt >= 0 and ((isW32 and shamt < 32) or (not isW32 and shamt < 64)) {
            let sa = shamt as i32;
            if isW32 {
                match op {
                    case ShiftOp::Sll => emit::emit(&mut *s.e, encode::slliw(rd, rs1, sa)),
                    case ShiftOp::Srl => emit::emit(&mut *s.e, encode::srliw(rd, rs1, sa)),
                    case ShiftOp::Sra => emit::emit(&mut *s.e, encode::sraiw(rd, rs1, sa)),
                    case ShiftOp::Sll => emit::emit(s.e, encode::slliw(rd, rs1, sa)),
                    case ShiftOp::Srl => emit::emit(s.e, encode::srliw(rd, rs1, sa)),
                    case ShiftOp::Sra => emit::emit(s.e, encode::sraiw(rd, rs1, sa)),
                }
            } else {
                match op {
                    case ShiftOp::Sll => emit::emit(&mut *s.e, encode::slli(rd, rs1, sa)),
                    case ShiftOp::Srl => emit::emit(&mut *s.e, encode::srli(rd, rs1, sa)),
                    case ShiftOp::Sra => emit::emit(&mut *s.e, encode::srai(rd, rs1, sa)),
                    case ShiftOp::Sll => emit::emit(s.e, encode::slli(rd, rs1, sa)),
                    case ShiftOp::Srl => emit::emit(s.e, encode::srli(rd, rs1, sa)),
                    case ShiftOp::Sra => emit::emit(s.e, encode::srai(rd, rs1, sa)),
                }
            }
            return;
        }
    }
    // Fallback: load into register.
    let rs2 = resolveVal(s, scratch, b);
    if isW32 {
        match op {
            case ShiftOp::Sll => emit::emit(&mut *s.e, encode::sllw(rd, rs1, rs2)),
            case ShiftOp::Srl => emit::emit(&mut *s.e, encode::srlw(rd, rs1, rs2)),
            case ShiftOp::Sra => emit::emit(&mut *s.e, encode::sraw(rd, rs1, rs2)),
            case ShiftOp::Sll => emit::emit(s.e, encode::sllw(rd, rs1, rs2)),
            case ShiftOp::Srl => emit::emit(s.e, encode::srlw(rd, rs1, rs2)),
            case ShiftOp::Sra => emit::emit(s.e, encode::sraw(rd, rs1, rs2)),
        }
    } else {
        match op {
            case ShiftOp::Sll => emit::emit(&mut *s.e, encode::sll(rd, rs1, rs2)),
            case ShiftOp::Srl => emit::emit(&mut *s.e, encode::srl(rd, rs1, rs2)),
            case ShiftOp::Sra => emit::emit(&mut *s.e, encode::sra(rd, rs1, rs2)),
            case ShiftOp::Sll => emit::emit(s.e, encode::sll(rd, rs1, rs2)),
            case ShiftOp::Srl => emit::emit(s.e, encode::srl(rd, rs1, rs2)),
            case ShiftOp::Sra => emit::emit(s.e, encode::sra(rd, rs1, rs2)),
        }
    }
}

/// Resolve parallel moves from IL values to physical destination registers.

/// 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: *il::Fn, target: u32, args: &[il::Val]) {
unsafe fn emitBlockArgs(s: &mut Selector, func: *unsafe il::Fn, target: u32, args: &[il::Val]) {
    if args.len == 0 {
        return;
    }
    let block = &func.blocks[target];
    assert args.len == block.params.len, "emitBlockArgs: argument/parameter count mismatch";

        if let slot = regalloc::spill::spillSlot(&s.ralloc.spill, param) {
            if let case il::Val::Undef = arg {
                // Undefined values don't need any move.
            } else {
                let rs = resolveVal(s, super::SCRATCH1, arg);
                emit::emitSd(&mut *s.e, rs, spillBase(s), spillOffset(s, slot));
                emit::emitSd(s.e, rs, spillBase(s), spillOffset(s, slot));
            }
        } else {
            set dsts[i] = getReg(s, param);
        }
    }

    let mut signed = false;
    if let case CmpOp::Slt = op {
        set signed = true;
    }
    let useSext = cmpUsesSext(typ, signed);
    emitCmpExt(&mut *s.e, rs1, rs1, typ, useSext);
    emitCmpExt(s.e, rs1, rs1, typ, useSext);

    // Canonicalizing the immediate can expose an immediate instruction even
    // when the IL value used a different representation for the same width.
    let mut rhs = b;
    if let case il::Val::Imm(imm) = b {
        let canonical = canonicalCmpImm(imm, typ, useSext);
        set rhs = il::Val::Imm(canonical);
        if encode::isSmallImm64(canonical) {
            let simm = canonical as i32;
            match op {
                case CmpOp::Slt => emit::emit(&mut *s.e, encode::slti(rd, rs1, simm)),
                case CmpOp::Ult => emit::emit(&mut *s.e, encode::sltiu(rd, rs1, simm)),
                case CmpOp::Slt => emit::emit(s.e, encode::slti(rd, rs1, simm)),
                case CmpOp::Ult => emit::emit(s.e, encode::sltiu(rd, rs1, simm)),
            }
            if invert {
                emit::emit(&mut *s.e, encode::xori(rd, rd, 1));
                emit::emit(s.e, encode::xori(rd, rd, 1));
            }
            return;
        }
    }

    let rs2 = resolveVal(s, scratch, rhs);
    if not isExtendedImm(rhs, typ, useSext) {
        emitCmpExt(&mut *s.e, rs2, rs2, typ, useSext);
        emitCmpExt(s.e, rs2, rs2, typ, useSext);
    }
    match op {
        case CmpOp::Slt => emit::emit(&mut *s.e, encode::slt(rd, rs1, rs2)),
        case CmpOp::Ult => emit::emit(&mut *s.e, encode::sltu(rd, rs1, rs2)),
        case CmpOp::Slt => emit::emit(s.e, encode::slt(rd, rs1, rs2)),
        case CmpOp::Ult => emit::emit(s.e, encode::sltu(rd, rs1, rs2)),
    }
    if invert {
        emit::emit(&mut *s.e, encode::xori(rd, rd, 1));
        emit::emit(s.e, encode::xori(rd, rd, 1));
    }
}

lib/std/arch/rv64/tests.rad +1 -1

@test unsafe fn testAddAssemblyExportsOnlyGlobalTextSymbols() throws (testing::TestError) {
    let mut arena = alloc::new(&mut ASSEMBLY_ARENA_STORAGE[..]);
    let symbols = try alloc::allocSlice(&mut arena, @sizeOf(asm::Symbol), @alignOf(asm::Symbol), 2) catch {
        throw testing::TestError::Failed;
    };
    let mut symbolSlice = @sliceOf((symbols as *mut [asm::Symbol]).ptr, 2, 2);
    let symbolSlice = symbols as *mut [asm::Symbol];
    set symbolSlice[0] = asm::Symbol {
        name: "local",
        section: asm::Section::Text,
        offset: 0,
        isExported: false,

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

    /// Associated value.
    value: i32,
}

/// Open-addressed hash map with caller-provided storage.
export record Dict: Copy {
export record Dict {
    /// Hash table entries.
    entries: *mut [Entry],
    /// Number of occupied entries.
    count: u32,
}

lib/std/lang/alloc.rad +19 -2


/// Bump allocator backed by a byte slice.
///
/// Allocations are made by advancing an offset pointer. Individual allocations
/// cannot be freed; instead, the entire arena is reset at once via [`reset`].
export record Arena: Copy {
export record Arena {
    /// Backing storage.
    data: *mut [u8],
    /// Current allocation offset in bytes.
    offset: u32,
}

}

/// 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(&mut *arena, size, alignment);
    return try! alloc(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 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);
    return @sliceOf(raw, count);
}

lib/std/lang/ast.rad +27 -25

export constant MAX_TRAIT_METHODS: u32 = 8;

/// Arena for all parser allocations.
///
/// Uses a bump allocator for both AST nodes and node pointer arrays.
export record NodeArena: Copy {
export record NodeArena {
    /// Bump allocator for all allocations.
    arena: alloc::Arena,
    /// Next node ID to assign. Incremented on each node allocation.
    nextId: u32,
}

    if capacity == 0 {
        return &mut [];
    }
    let ptr = try! alloc::allocSlice(&mut arena.arena, @sizeOf(*Node), @alignOf(*Node), capacity);

    return @sliceOf(ptr.ptr as *mut *Node, 0, capacity);
    let nodes = ptr as *mut [*Node];
    return &mut nodes[..0];
}

/// Attribute bit set applied to declarations or fields.
export union Attribute: Copy {
    /// Public visibility attribute.

    Unsafe = 0b100000,
}

/// Ordered collection of attribute nodes applied to a declaration.
export record Attributes: Copy {
    list: *mut [*Node],
    /// Attribute nodes in declaration order.
    list: *[*Node],
}

/// Check if an attributes list contains an attribute.
export fn attributesContains(self: &Attributes, attr: Attribute) -> bool {
    for node in self.list {

    /// Nominal type, points to identifier node.
    Nominal(*Node),
    /// Inline record type for union variant payloads.
    Record {
        /// Field declaration nodes.
        fields: *mut [*Node],
        fields: *[*Node],
        /// Whether this record has labeled fields.
        labeled: bool,
    },
    /// Anonymous function type.
    Fn {

}

/// Function signature.
export record FnSig: Copy {
    /// Parameter type nodes in declaration order.
    params: *mut [*Node],
    params: *[*Node],
    /// Optional return type node.
    returnType: ?*Node,
    /// Throwable type nodes declared in the signature.
    throwList: *mut [*Node],
    throwList: *[*Node],
}

/// Address-of expression metadata.
export record AddressOf: Copy {
    /// Target expression being referenced.

}

/// Compound statement block with optional dedicated scope.
export record Block: Copy {
    /// Statements that belong to this block.
    statements: *mut [*Node],
    statements: *[*Node],
    /// Whether this block permits unsafe operations.
    isUnsafe: bool,
}

/// Function call expression.
export record Call: Copy {
    /// Callee expression.
    callee: *Node,
    /// Argument expressions in source order.
    args: *mut [*Node],
    args: *[*Node],
}

/// Single argument to a function or record literal, optionally labeled.
export record Arg: Copy {
    /// Optional label applied to the argument.

/// Try expression metadata.
export record Try: Copy {
    /// Expression evaluated with implicit error propagation.
    expr: *Node,
    /// Catch clauses. Empty for propagation (`try`), `try!`, or `try?`.
    catches: *mut [*Node],
    catches: *[*Node],
    /// Whether the try should panic instead of returning an error.
    shouldPanic: bool,
    /// Whether the try should return an optional instead of propagating error.
    returnsOptional: bool,
}

}

/// Prong arm.
export union ProngArm: Copy {
    /// Case arm with pattern list.
    Case(*mut [*Node]),
    Case(*[*Node]),
    /// Binding arm with single identifier or placeholder.
    Binding(*Node),
    /// Else arm.
    Else,
}

/// `match` statement metadata.
export record Match: Copy {
    /// Expression whose value controls the match.
    subject: *Node,
    /// Prong nodes evaluated in order.
    prongs: *mut [*Node],
    prongs: *[*Node],
}

/// `match` prong metadata.
export record MatchProng: Copy {
    /// Prong arm.

export record RecordLit: Copy {
    /// Type name associated with the literal.
    /// If `nil`, it's an anonymous record literal.
    typeName: ?*Node,
    /// Field initializer nodes.
    fields: *mut [*Node],
    fields: *[*Node],
    /// When true, remaining fields are discarded (`{ x, .. }`).
    ignoreRest: bool,
}

/// Record declaration.
export record RecordDecl: Copy {
    /// Identifier naming the record.
    name: *Node,
    /// Field declaration nodes.
    fields: *mut [*Node],
    fields: *[*Node],
    /// Optional attribute list applied to the record.
    attrs: ?Attributes,
    /// Trait derivations attached to the record.
    derives: *mut [*Node],
    derives: *[*Node],
    /// Whether this record has labeled fields.
    labeled: bool,
}

/// Union declarations.
export record UnionDecl: Copy {
    /// Identifier naming the union.
    name: *Node,
    /// Variant nodes making up the union.
    variants: *mut [*Node],
    variants: *[*Node],
    /// Optional attribute list applied to the union.
    attrs: ?Attributes,
    /// Trait derivations attached to the union.
    derives: *mut [*Node],
    derives: *[*Node],
}

/// Union variant declaration.
export record UnionDeclVariant: Copy {
    /// Identifier naming the variant.

    /// Numeric literal such as `42` or `0xFF`.
    Number(fmt::IntLiteral),
    /// Range expression such as `0..10` or `..`.
    Range(Range),
    /// Array literal expression.
    ArrayLit(*mut [*Node]),
    ArrayLit(*[*Node]),
    /// Array repeat literal expression.
    ArrayRepeatLit(ArrayRepeatLit),
    /// Array subscript expression.
    Subscript {
        /// Array or slice.

    /// Builtin function call (e.g. `@sizeOf(T)`).
    BuiltinCall {
        /// Builtin function kind.
        kind: Builtin,
        /// Argument list.
        args: *mut [*Node],
        args: *[*Node],
    },
    /// Block expression or statement body.
    Block(Block),
    /// Call expression, eg. `f(x)`.
    Call(Call),

    /// Trait declaration.
    TraitDecl {
        /// Trait name identifier.
        name: *Node,
        /// Supertrait name nodes.
        supertraits: *mut [*Node],
        supertraits: *[*Node],
        /// Method signature nodes ([`TraitMethodSig`]).
        methods: *mut [*Node],
        methods: *[*Node],
        /// Optional attributes.
        attrs: ?Attributes,
    },
    /// Method signature inside a trait declaration.
    TraitMethodSig {

        /// Trait name identifier.
        traitName: *Node,
        /// Target type identifier.
        targetType: *Node,
        /// Method definition nodes ([`MethodDecl`]).
        methods: *mut [*Node],
        methods: *[*Node],
    },
    /// Method definition with a receiver.
    /// Used both inside `instance` blocks and as standalone methods.
    MethodDecl {
        /// Method name identifier.

    fnBody: *Node
}

/// Synthesize a module with a function in it with the given name and statements.
export unsafe fn synthFnModule(
    arena: &mut NodeArena, name: *[u8], bodyStmts: *mut [*Node]
    arena: &mut NodeArena, name: *[u8], bodyStmts: *[*Node]
) -> SynthFnMod {
    let a = alloc::arenaAllocator(&mut arena.arena);
    let fnName = synthNode(arena, NodeValue::Ident(name));
    let params: *mut [*Node] = &mut [];
    let throwList: *mut [*Node] = &mut [];
    let params: *[*Node] = &[];
    let throwList: *[*Node] = &[];
    let fnSig = FnSig { params, returnType: nil, throwList };
    let fnBody = synthNode(arena, NodeValue::Block(Block { statements: bodyStmts, isUnsafe: false }));
    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,
    }));
    let mut rootStmts: *mut [*Node] = &mut [];
    rootStmts.append(fnDecl, a);

lib/std/lang/ast/printer.rad +21 -21

        }
        case super::TypeSig::Optional { valueType } =>
            return sexpr::list(a, "?", &[toExpr(a, valueType)]),
        case super::TypeSig::Nominal(name) => return toExpr(a, name),
        case super::TypeSig::Record { fields, .. } =>
            return sexpr::list(a, "record", nodeListToExprs(a, &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 {
                set ret = toExpr(a, rt);
            }
            let head = "unsafe-fn" if isUnsafe else "fn";
            return sexpr::list(a, head, &[sexpr::list(a, "params", nodeListToExprs(a, &sig.params[..])), ret]);
            return sexpr::list(a, head, &[sexpr::list(a, "params", nodeListToExprs(a, sig.params)), ret]);
        }
        case super::TypeSig::TraitObject { class, traitName, mutable } => {
            let head = pointerClassHead(class, "obj", "obj-ref", "unsafe-obj");
            return sexpr::list(a, head, &[sexpr::sym("mut"), toExpr(a, traitName)]) if mutable
                else sexpr::list(a, head, &[toExpr(a, traitName)]);
        }
    }
}

/// Convert a node slice to a slice of expressions.
unsafe fn nodeListToExprs(a: &mut alloc::Arena, nodes: *[*super::Node]) -> *[sexpr::Expr] {
unsafe fn nodeListToExprs(a: &mut alloc::Arena, nodes: &[*super::Node]) -> *[sexpr::Expr] {
    if nodes.len == 0 {
        return &[];
    }
    let buf = try! sexpr::allocExprs(a, nodes.len as u32);
    for node, i in nodes {


/// Convert optional attributes to an attribute list expression.
unsafe fn attributesToExpr(a: &mut alloc::Arena, attrs: ?super::Attributes) -> sexpr::Expr {
    let mut exprs: *[sexpr::Expr] = &[];
    if let list = attrs {
        set exprs = nodeListToExprs(a, &list.list[..]);
        set exprs = nodeListToExprs(a, list.list);
    }
    return sexpr::list(a, "attrs", exprs);
}

/// Convert an optional node to an expression, or return placeholder.

    }
    return sexpr::Expr::Null;
}

/// Convert a list of match prongs to expressions.
unsafe fn prongListToExprs(a: &mut alloc::Arena, nodes: *[*super::Node]) -> *[sexpr::Expr] {
unsafe fn prongListToExprs(a: &mut alloc::Arena, nodes: &[*super::Node]) -> *[sexpr::Expr] {
    if nodes.len == 0 {
        return &[];
    }
    let buf = try! sexpr::allocExprs(a, nodes.len as u32);
    for prong, i in nodes {

/// Convert a match prong to an S-expression.
unsafe fn prongToExpr(a: &mut alloc::Arena, p: super::MatchProng) -> sexpr::Expr {
    match p.arm {
        case super::ProngArm::Case(patterns) => {
            return sexpr::block(a, "case", &[
                sexpr::list(a, "patterns", nodeListToExprs(a, &patterns[..])),
                sexpr::list(a, "patterns", nodeListToExprs(a, patterns)),
                guardExpr(a, p.guard)
            ], &[toExpr(a, p.body)]);
        }
        case super::ProngArm::Else => {
            return sexpr::block(a, "else", &[guardExpr(a, p.guard)], &[toExpr(a, p.body)]);

) -> sexpr::Expr {
    return sexpr::list(a, ":", &[toExprOpt(a, field), toExpr(a, type), toExprOrNull(a, value)]);
}

/// Convert a list of record fields to expressions.
unsafe fn fieldListToExprs(a: &mut alloc::Arena, nodes: *[*super::Node]) -> *[sexpr::Expr] {
unsafe fn fieldListToExprs(a: &mut alloc::Arena, nodes: &[*super::Node]) -> *[sexpr::Expr] {
    if nodes.len == 0 {
        return &[];
    }
    let buf = try! sexpr::allocExprs(a, nodes.len as u32);
    for node, i in nodes {

unsafe fn variantToExpr(a: &mut alloc::Arena, name: *super::Node, type: ?*super::Node) -> sexpr::Expr {
    return sexpr::list(a, "variant", &[toExpr(a, name), toExprOrNull(a, type)]);
}

/// Convert a list of union variants to expressions.
unsafe fn variantListToExprs(a: &mut alloc::Arena, nodes: *[*super::Node]) -> *[sexpr::Expr] {
unsafe fn variantListToExprs(a: &mut alloc::Arena, nodes: &[*super::Node]) -> *[sexpr::Expr] {
    if nodes.len == 0 {
        return &[];
    }
    let buf = try! sexpr::allocExprs(a, nodes.len as u32);
    for node, i in nodes {

            set buf[0] = toExpr(a, c.callee);
            for arg, i in c.args { set buf[i + 1] = toExpr(a, arg); }
            return sexpr::Expr::List { head: "call", tail: buf, multiline: false };
        }
        case super::NodeValue::BuiltinCall { kind, args } =>
            return sexpr::list(a, builtinName(kind), nodeListToExprs(a, &args[..])),
            return sexpr::list(a, builtinName(kind), nodeListToExprs(a, args)),
        case super::NodeValue::Subscript { container, index } =>
            return sexpr::list(a, "[]", &[toExpr(a, container), toExpr(a, index)]),
        case super::NodeValue::FieldAccess(acc) =>
            return sexpr::list(a, ".", &[toExpr(a, acc.parent), toExpr(a, acc.child)]),
        case super::NodeValue::ScopeAccess(acc) =>

        case super::NodeValue::Deref(target) =>
            return sexpr::list(a, "deref", &[toExpr(a, target)]),
        case super::NodeValue::As(cast) =>
            return sexpr::list(a, "as", &[toExpr(a, cast.value), toExpr(a, cast.type)]),
        case super::NodeValue::ArrayLit(elems) =>
            return sexpr::list(a, "array", nodeListToExprs(a, &elems[..])),
            return sexpr::list(a, "array", nodeListToExprs(a, elems)),
        case super::NodeValue::ArrayRepeatLit(rep) =>
            return sexpr::list(a, "array-repeat", &[toExpr(a, rep.item), toExpr(a, rep.count)]),
        case super::NodeValue::RecordLit(lit) => {
            let mut total: u32 = lit.fields.len as u32;
            if let _ = lit.typeName {

        }
        case super::NodeValue::Try(t) => {
            let mut head = "try";
            if t.shouldPanic { set head = "try!"; }
            if t.catches.len > 0 {
                let catches = nodeListToExprs(a, &t.catches[..]);
                let catches = nodeListToExprs(a, t.catches);
                return sexpr::list(a, head, &[toExpr(a, t.expr), sexpr::block(a, "catches", &[], catches)]);
            }
            return sexpr::list(a, head, &[toExpr(a, t.expr)]);
        }
        case super::NodeValue::CatchClause(clause) => {

            set children[len] = toExpr(a, clause.body);
            set len += 1;
            return sexpr::list(a, head, &children[..len]);
        }
        case super::NodeValue::Block(blk) => {
            let children = nodeListToExprs(a, &blk.statements[..]);
            let children = nodeListToExprs(a, blk.statements);
            let name = "unsafe" if blk.isUnsafe else "block";
            return sexpr::block(a, name, &[], children);
        }
        case super::NodeValue::Let(decl) => {
            let mut head = "let";

                toExpr(a, f.iterable)
            ], &[toExpr(a, f.body), toExprOrNull(a, f.elseBranch)]),
        case super::NodeValue::Loop { body } =>
            return sexpr::block(a, "loop", &[], &[toExpr(a, body)]),
        case super::NodeValue::Match(m) => {
            let children = prongListToExprs(a, &m.prongs[..]);
            let children = prongListToExprs(a, m.prongs);
            return sexpr::block(a, "match", &[toExpr(a, m.subject)], children);
        }
        case super::NodeValue::MatchProng(p) => {
            return prongToExpr(a, p);
        }
        case super::NodeValue::FnDecl(f) => {
            let params = sexpr::list(a, "params", nodeListToExprs(a, &f.sig.params[..]));
            let params = sexpr::list(a, "params", nodeListToExprs(a, f.sig.params));
            let ret = toExprOrNull(a, f.sig.returnType);
            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[..]);
            let children = fieldListToExprs(a, r.fields);
            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[..]);
            let children = variantListToExprs(a, u_.variants);
            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::ExprStmt(e) => return toExpr(a, e),
        case super::NodeValue::TraitDecl { name, supertraits, methods, .. } => {
            let children = nodeListToExprs(a, &methods[..]);
            let supers = sexpr::list(a, "supertraits", nodeListToExprs(a, &supertraits[..]));
            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 } => {
            let params = sexpr::list(a, "params", nodeListToExprs(a, &sig.params[..]));
            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],
            );
        }
        case super::NodeValue::InstanceDecl { traitName, targetType, methods } => {
            let children = nodeListToExprs(a, &methods[..]);
            let children = nodeListToExprs(a, methods);
            return sexpr::block(a, "instance", &[toExpr(a, traitName), toExpr(a, targetType)], children);
        }
        case super::NodeValue::MethodDecl {
            name, receiverName, receiverType, sig, body, attrs,
        } => {
            let params = sexpr::list(a, "params", nodeListToExprs(a, &sig.params[..]));
            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,
                "method",

lib/std/lang/gen/bitset.rad +3 -2

}

/// 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 {
    return Bitset { bits: bits as *unsafe mut [u32], len: bits.len * 32 };
    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 {

}

/// 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::allocSlice(arena, @sizeOf(u32), @alignOf(u32), numWords) as *mut [u32];
    let bits = try alloc::allocRawSlice(arena, @sizeOf(u32), @alignOf(u32), numWords) as *unsafe mut [u32];

    return init(bits);
}

/// Set bit `n` in the bitset.

lib/std/lang/gen/data.rad +12 -12

    /// Absolute address, including data base address.
    addr: u32,
}

/// Hash-indexed data symbol map.
export record DataSymMap: Copy {
export record DataSymMap {
    /// Underlying hash table.
    dict: dict::Dict,
    /// Fallback linear array for edge cases.
    syms: *[DataSym],
}

/// Lay out data symbols for a single section.
/// Data with sidecar image bytes is placed first, then zero-initialized data,
/// so that only meaningful bytes need to be written to the output file.
/// Returns the updated offset past all placed symbols.
export fn layoutSection(
    items: *[il::Data],
    syms: *mut [DataSym],
    items: &[il::Data],
    syms: &mut [DataSym],
    count: &mut u32,
    base: u32,
    readOnly: bool
) -> u32 {
    return layoutSectionAtOffset(items, syms, count, base, 0, readOnly);
}

/// Lay out data symbols for a single section starting at [`startOffset`].
export fn layoutSectionAtOffset(
    items: *[il::Data],
    syms: *mut [DataSym],
    items: &[il::Data],
    syms: &mut [DataSym],
    count: &mut u32,
    base: u32,
    startOffset: u32,
    readOnly: bool
) -> u32 {
    let mut offset: u32 = startOffset;

    // Data requiring sidecar image bytes first.
    for i in 0..items.len {
        let data = &items[i];
        let data = items[i];
        if data.readOnly == readOnly and not data.isZeroInit {
            set offset = mem::alignUp(offset, data.alignment);
            set syms[*count] = DataSym { name: data.name, addr: base + offset };
            set *count += 1;
            set offset += data.size;
        }
    }
    // Zero-initialized data after.
    for i in 0..items.len {
        let data = &items[i];
        let data = items[i];
        if data.readOnly == readOnly and data.isZeroInit {
            set offset = mem::alignUp(offset, data.alignment);
            set syms[*count] = DataSym { name: data.name, addr: base + offset };
            set *count += 1;
            set offset += data.size;


/// Emit data bytes for a single section (read-only or read-write) into `buf`.
/// Iterates data requiring sidecar image bytes, serializing each data item.
/// Returns the total number of bytes written.
export unsafe fn emitSection(
    items: *[il::Data],
    items: &[il::Data],
    dataSymMap: &DataSymMap,
    fnLabels: &labels::Labels,
    codeBase: u32,
    buf: *mut [u8],
    buf: &mut [u8],
    readOnly: bool
) -> u32 {
    return emitSectionAtOffset(items, dataSymMap, fnLabels, codeBase, buf, readOnly, 0);
}

/// Emit data bytes for a single section starting at `startOffset`.
export unsafe fn emitSectionAtOffset(
    items: *[il::Data],
    items: &[il::Data],
    dataSymMap: &DataSymMap,
    fnLabels: &labels::Labels,
    codeBase: u32,
    buf: *mut [u8],
    buf: &mut [u8],
    readOnly: bool,
    startOffset: u32
) -> u32 {
    let mut offset: u32 = startOffset;

    for i in 0..items.len {
        let data = &items[i];
        let data = items[i];
        if data.readOnly == readOnly and not data.isZeroInit {
            set offset = mem::alignUp(offset, data.alignment);
            assert offset + data.size <= buf.len, "emitSectionAtOffset: buffer overflow";
            for j in 0..data.values.len {
                let v = &data.values[j];

lib/std/lang/gen/labels.rad +1 -1

export constant MAX_FUNCS: u32 = 8192;
/// Size of the function hash table. Must be a power of two.
export constant FUNC_TABLE_SIZE: u32 = MAX_FUNCS * 2;

/// Label tracking for code emission.
export record Labels: Copy {
export record Labels {
    /// Block offsets indexed by block index.
    /// Per-function, reset each function.
    blockOffsets: *mut [i32],
    /// Number of blocks recorded in current function.
    blockCount: u32,

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

}

/// Complete register allocation result.
export record AllocResult: Copy {
    /// SSA register to physical register mapping.
    assignments: *[?super::Reg],
    assignments: *unsafe [?super::Reg],
    /// Spill slot information.
    spill: spill::SpillInfo,
    /// 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: *il::Fn,
    func: *unsafe il::Fn,
    config: &TargetConfig,
    arena: &mut alloc::Arena
) -> AllocResult throws (alloc::AllocError) {
    // Phase 1: Liveness analysis.
    let live = try liveness::analyze(func, arena);

lib/std/lang/gen/regalloc/assign.rad +18 -17

/// 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: Copy {
export record RegMap {
    /// SSA (virtual) registers that have mappings.
    virtRegs: *mut [u32],
    /// Physical register for each virtual register.
    physRegs: *mut [gen::Reg],
    /// Number of active mappings.

}

/// Register assignment result, per function.
export record AssignInfo: Copy {
    /// SSA register -> physical register mapping.
    assignments: *mut [?gen::Reg],
    assignments: *unsafe mut [?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,
    /// Last operand-use index for each register used in the current block.
    lastUse: *[u32],
    lastUse: *unsafe [u32],
    live: *unsafe liveness::LiveInfo,
    blockIdx: u32,
    instrIdx: u32,
    allocatable: *[gen::Reg],
    calleeSaved: *[gen::Reg],
    assignments: *mut [?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: *mut [u32],
    lastUse: *unsafe mut [u32],
    /// Index of the instruction whose operands are being recorded.
    index: u32,
}

/// Compute register assignment.
export unsafe fn assign(
    func: *il::Fn,
    func: *unsafe il::Fn,
    live: &liveness::LiveInfo,
    spillInfo: &spill::SpillInfo,
    config: &super::TargetConfig,
    arena: &mut alloc::Arena
) -> AssignInfo throws (alloc::AllocError) {

            usedCalleeSaved: 0,
        };
    }

    // Allocate output structures.
    let assignments = try alloc::allocSlice(arena, @sizeOf(?gen::Reg), @alignOf(?gen::Reg), maxReg) as *mut [?gen::Reg];
    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::allocSlice(arena, @sizeOf(u32), @alignOf(u32), maxReg) as *mut [u32];
    let lastUse = try alloc::allocRawSlice(arena, @sizeOf(u32), @alignOf(u32), maxReg) as *unsafe mut [u32];
    // 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 {

                set assignments[param.value.n] = config.argRegs[i];
            }
        }
    }
    // Allocate used registers bitset (32 physical registers per 32-bit word).
    let usedRegsBits = try alloc::allocSlice(arena, @sizeOf(u32), @alignOf(u32), 1) as *mut [u32];
    let usedRegsBits = try alloc::allocRawSlice(arena, @sizeOf(u32), @alignOf(u32), 1) as *unsafe mut [u32];
    let mut usedRegs = bitset::init(usedRegsBits);

    // Current register mapping.
    let mut current = try createRegMap(arena);


    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) {
    recordLastUse(reg, ctxPtr as &mut LastUseCtx);
    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, ctx: &mut LastUseCtx) {
    set ctx.lastUse[reg.n] = ctx.index;
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) {
        if let phys = rmapRemove(&mut *ctx.current, reg.n) {
            bitset::clear(&mut *ctx.usedRegs, *phys as u32);
        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";
    if spill::isSpilled(&*ctx.spillInfo, reg) {
    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(
            &mut *current, &mut *usedRegs, reg.n, ctx.allocatable,
            ctx.calleeSaved, &*ctx.spillInfo
            current, usedRegs, reg.n, ctx.allocatable,
            ctx.calleeSaved, ctx.spillInfo
        );
    }
}

lib/std/lang/gen/regalloc/liveness.rad +19 -19

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: *mut [bitset::Bitset],
    liveIn: *unsafe mut [bitset::Bitset],
    /// Per-block live-out sets (indexed by block index).
    liveOut: *mut [bitset::Bitset],
    liveOut: *unsafe mut [bitset::Bitset],
    /// Per-block defs sets (registers defined in block).
    defs: *mut [bitset::Bitset],
    defs: *unsafe mut [bitset::Bitset],
    /// Per-block uses sets (registers used before defined in block).
    uses: *mut [bitset::Bitset],
    uses: *unsafe mut [bitset::Bitset],
    /// Number of blocks.
    blockCount: u32,
    /// Maximum register number used.
    maxReg: u32,
}

/// Context for collecting defs and uses during block analysis.
record DefsUses: Copy {
    defs: *bitset::Bitset,
    uses: *mut bitset::Bitset,
    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: *il::Fn, arena: &mut alloc::Arena) -> LiveInfo throws (alloc::AllocError) {
export unsafe fn analyze(func: *unsafe il::Fn, arena: &mut alloc::Arena) -> LiveInfo throws (alloc::AllocError) {
    let blockCount = func.blocks.len;
    if blockCount == 0 {
        return LiveInfo {
            liveIn: &mut [],
            liveOut: &mut [],

            }
        }
    }
    assert maxReg <= MAX_SSA_REGS, "analyze: maximum SSA registers exceeded";
    // Allocate per-block bitsets.
    let liveIn = try alloc::allocSlice(arena, @sizeOf(bitset::Bitset), @alignOf(bitset::Bitset), blockCount) as *mut [bitset::Bitset];
    let liveOut = try alloc::allocSlice(arena, @sizeOf(bitset::Bitset), @alignOf(bitset::Bitset), blockCount) as *mut [bitset::Bitset];
    let defs = try alloc::allocSlice(arena, @sizeOf(bitset::Bitset), @alignOf(bitset::Bitset), blockCount) as *mut [bitset::Bitset];
    let uses = try alloc::allocSlice(arena, @sizeOf(bitset::Bitset), @alignOf(bitset::Bitset), blockCount) as *mut [bitset::Bitset];
    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);

}

/// Compute `liveIn = uses | (liveOut - defs)` and update `dst`.
/// Returns `true` if `dst` changed. Combined loop avoids multiple passes.
unsafe fn computeAndUpdateLiveIn(
    dst: *mut bitset::Bitset,
    liveOut: *bitset::Bitset,
    defs: *bitset::Bitset,
    uses: *bitset::Bitset
    dst: *unsafe mut bitset::Bitset,
    liveOut: *unsafe bitset::Bitset,
    defs: *unsafe bitset::Bitset,
    uses: *unsafe bitset::Bitset
) -> 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]);

    }
    return changed;
}

/// Compute local defs and uses for a single block.
unsafe fn computeLocalDefsUses(block: *il::Block, defs: *mut bitset::Bitset, uses: *mut bitset::Bitset) {
unsafe fn computeLocalDefsUses(block: *unsafe il::Block, defs: *unsafe mut bitset::Bitset, uses: *unsafe mut bitset::Bitset) {
    for p in block.params {
        bitset::put(defs, p.value.n);
    }
    for i in 0..block.instrs.len {
        let instr = block.instrs[i];

    }
    return current;
}

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


        else => {},
    }
}

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

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

    if bitset::contains(&info.liveOut[blockIdx], reg.n) {
        return true;
    }

lib/std/lang/gen/regalloc/spill.rad +13 -12

}

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

    cost: u32,
}

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

/// Analyze a function and determine which values need spill slots.
export unsafe fn analyze(
    func: *il::Fn,
    func: *unsafe il::Fn,
    live: &liveness::LiveInfo,
    numRegs: u32,
    numCalleeSaved: u32,
    slotSize: u32,
    arena: &mut alloc::Arena

    let slots = try alloc::allocSlice(arena, @sizeOf(i32), @alignOf(i32), maxReg) as *mut [i32];
    for i in 0..maxReg {
        set slots[i] = -1;
    }
    // Allocate cost array.
    let costs = try alloc::allocSlice(arena, @sizeOf(SpillCost), @alignOf(SpillCost), maxReg) as *mut [SpillCost];
    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 };
    }
    // Phase 1: Calculate spill costs.
    fillCosts(func, costs);

    }
    return SpillInfo { slots, frameSize, calleeClass, maxReg };
}

/// Calculate spill costs for all registers, weighted by loop depth.
unsafe fn fillCosts(func: *il::Fn, costs: *mut [SpillCost]) {
unsafe fn fillCosts(func: *unsafe il::Fn, costs: *unsafe 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;

        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: *[SpillCost]) -> Candidates {
unsafe fn collectCandidates(bs: &bitset::Bitset, costs: *unsafe [SpillCost]) -> Candidates {
    let mut c = Candidates { entries: undefined, n: 0 };
    let mut it = bitset::iter(bs);
    while let reg = bitset::iterNext(&mut it) {
        assert c.n < MAX_CANDIDATES, "collectCandidates: too many live values";
        if reg < costs.len {


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

/// register. If the count exceeds `numCalleeSaved`, spill the cheapest
/// crossing values.
unsafe fn limitCrossCallPressure(
    live: &mut bitset::Bitset,
    spilled: &mut bitset::Bitset,
    costs: *[SpillCost],
    costs: *unsafe [SpillCost],
    calleeClass: &mut bitset::Bitset,
    numCalleeSaved: u32,
    callDst: ?il::Reg
) {
    // Collect crossing candidates: live values excluding the call destination.

    }
}

/// Callback for [`il::forEachReg`]: increments use count for register.
unsafe fn countRegUseCallback(reg: il::Reg, ctxPtr: &mut opaque) {
    countRegUse(reg, ctxPtr as &mut CountCtx);
    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, ctx: &mut CountCtx) {
    assert reg.n < ctx.costs.len, "countRegUseCallback: register out of bounds";
    set ctx.costs[reg.n].uses = ctx.costs[reg.n].uses + ctx.weight;
fn countRegUse(reg: il::Reg, costs: &mut [SpillCost], weight: u32) {
    assert reg.n < costs.len, "countRegUseCallback: 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);

lib/std/lang/il.rad +14 -14


/// Separator for qualified symbol names.
export constant PATH_SEPARATOR: *[u8] = "::";

/// Format a qualified symbol name: `pkg::mod::path::name`.
export unsafe fn formatQualifiedName(arena: &mut alloc::Arena, path: *[*[u8]], name: *[u8]) -> *[u8] {
export unsafe fn formatQualifiedName(arena: &mut alloc::Arena, path: &[*[u8]], name: *[u8]) -> *[u8] {
    let mut totalLen: u32 = name.len;
    for segment in path {
        set totalLen += segment.len + PATH_SEPARATOR.len;
    }
    let buf = try! alloc::allocSlice(arena, 1, 1, totalLen) as *mut [u8];

    /// The constant value to match against.
    value: i64,
    /// The target block index.
    target: u32,
    /// Arguments to pass to the target block.
    args: *mut [Val],
    args: *unsafe mut [Val],
}

/// IL instruction.
/// SSA registers are represented as `Reg`, values as `Val`.
export union Instr: Copy {

        /// Holds return value, for non-void function.
        dst: ?Reg,
        /// Function value, either a symbol or an address in a register.
        func: Val,
        /// Function arguments.
        args: *[Val]
        args: *unsafe [Val]
    },

    /////////////////
    // Terminators //
    /////////////////

    /// Return from function: `ret <val>;` or `ret;`
    Ret { val: ?Val },
    /// Unconditional jump: `jmp @block(<arg>...);`
    Jmp { target: u32, args: *mut [Val] },
    Jmp { target: u32, args: *unsafe mut [Val] },
    /// Compare-and-branch: `br.<op> <type> <a> <b> @then @else;`
    Br { op: CmpOp, typ: Type, a: Val, b: Val, thenTarget: u32, thenArgs: *mut [Val], elseTarget: u32, elseArgs: *mut [Val] },
    Br { op: CmpOp, typ: Type, a: Val, b: Val, thenTarget: u32, thenArgs: *unsafe mut [Val], elseTarget: u32, elseArgs: *unsafe mut [Val] },
    /// Multi-way branch: `switch <val> (<n> @block) ... @default;`
    Switch { val: Val, defaultTarget: u32, defaultArgs: *mut [Val], cases: *mut [SwitchCase] },
    Switch { val: Val, defaultTarget: u32, defaultArgs: *unsafe mut [Val], cases: *unsafe mut [SwitchCase] },
    /// Unreachable code marker: `unreachable;`
    /// Indicates control flow cannot reach this point to allow for optimizations.
    Unreachable,

    /////////////////

/// to another sequence.
export record Block: Copy {
    /// Block label.
    label: *[u8],
    /// Block parameters.
    params: *[Param],
    params: *unsafe [Param],
    /// Instructions in the block. The last instruction must be a terminator.
    instrs: *mut [Instr],
    instrs: *unsafe mut [Instr],
    /// Source locations for debugging and error reporting.
    /// One entry per instruction when debug info is enabled, empty otherwise.
    locs: *[SrcLoc],
    locs: *unsafe [SrcLoc],
    /// Predecessor block indices. Used for control flow analysis.
    preds: *[u32],
    preds: *unsafe [u32],
    /// Loop nesting depth.
    /// Used for spill cost weighting in register allocation.
    loopDepth: u32,
}

/// An IL function.
export record Fn: Copy {
    /// Qualified function name (e.g. `$mod$path$func`).
    name: *[u8],
    /// Function parameters.
    params: *[Param],
    params: *unsafe [Param],
    /// Return type.
    returnType: Type,
    /// Whether the function is extern (no body).
    isExtern: bool,
    /// Whether the function is a leaf (contains no call or ecall instructions).
    isLeaf: bool,
    /// Basic blocks. Empty for extern functions.
    blocks: *[Block],
    blocks: *unsafe [Block],
}

/////////////
// Program //
/////////////

    values: *[DataValue],
}

/// An IL program (compilation unit).
export record Program: Copy {
    /// Global data.
    /// Immutable global data.
    data: *[Data],
    /// Functions.
    fns: *[*Fn],
    fns: *unsafe [*unsafe Fn],
}

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

lib/std/lang/il/printer.rad +7 -6

    set buffer[start] = '%';
    write(out, &buffer[start..]);
}

/// Write a comma-separated argument list in parentheses.
unsafe fn writeArgs(out: &mut sexpr::Output, args: *[super::Val]) {
unsafe fn writeArgs(out: &mut sexpr::Output, args: *unsafe [super::Val]) {
    write(out, "(");
    for arg, i in args {
        if i > 0 {
            write(out, ", ");
        }

    write(out, " ");
    writeReg(out, param.value);
}

/// Write a comma-separated parameter list.
unsafe fn writeParams(out: &mut sexpr::Output, params: *[super::Param]) {
unsafe fn writeParams(out: &mut sexpr::Output, params: *unsafe [super::Param]) {
    for param, i in params {
        if i > 0 {
            write(out, ", ");
        }
        writeParam(out, param);

//////////////////////////
// Instruction printing //
//////////////////////////

/// Write an instruction.
unsafe fn writeInstr(out: &mut sexpr::Output, blocks: *[super::Block], inst: super::Instr) {
unsafe fn writeInstr(out: &mut sexpr::Output, blocks: *unsafe [super::Block], inst: super::Instr) {
    match inst {
        // Memory operations.
        case super::Instr::Reserve { dst, size, alignment } => {
            write(out, "reserve ");
            writeReg(out, dst);

////////////////////
// Block printing //
////////////////////

/// Write a basic block.
unsafe fn writeBlock(out: &mut sexpr::Output, blocks: *[super::Block], block: *super::Block) {
unsafe fn writeBlock(out: &mut sexpr::Output, blocks: *unsafe [super::Block], block: *unsafe super::Block) {
    // Block label.
    write(out, "  @");
    write(out, block.label);

    // Block parameters.

///////////////////////
// Function printing //
///////////////////////

/// Write a function.
unsafe fn writeFn(out: &mut sexpr::Output, f: *super::Fn) {
unsafe fn writeFn(out: &mut sexpr::Output, f: *unsafe super::Fn) {
    // Function signature.
    if f.isExtern {
        write(out, "extern ");
    }
    write(out, "fn ");

export unsafe fn printProgramToBuffer(
    program: &super::Program,
    buf: *mut [u8]
) -> *[u8] {
    let mut pos: u32 = 0;
    let mut out = sexpr::Output::Buffer { buf, pos: &mut pos };
    let raw: *unsafe mut [u8] = &mut buf[..];
    let mut out = sexpr::Output::Buffer { buf: raw, pos: &mut pos };
    printProgram(&mut out, program);

    return &buf[..pos];
}

lib/std/lang/lower.rad +241 -233

/// 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, *il::Fn, FnRole),
    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(*mut [*il::Fn]),
    Accumulate(*unsafe mut [*unsafe il::Fn]),
    /// Send lowered functions to an external consumer immediately.
    Stream(FnSink),
}

/// 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: Copy {
export record Lowerer {
    /// 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.

    options: LowerOptions,
}

/// Entry mapping a function symbol to its qualified name.
record FnSymEntry: Copy {
    sym: *resolver::Symbol,
    sym: *unsafe resolver::Symbol,
    qualName: *[u8],
}

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

    /// The globally unique tag assigned to this error type (non-zero).
    tag: u32,
}

/// Compute the maximum size of any error type in a throw list.
fn maxErrSize(throwList: *[*resolver::Type]) -> u32 {
unsafe fn maxErrSize(throwList: *[*resolver::Type]) -> u32 {
    let mut maxSize: u32 = 0;
    for ty in throwList {
        let size = resolver::getTypeLayout(*ty).size;
        if size > maxSize {
            set maxSize = size;

}

/// 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 {
    for entry in self.errTags {
    for entry in &self.errTags[..] {
        if entry.ty == errType {
            return entry.tag;
        }
    }
    let tag = self.errTagCounter;


    return tag;
}

/// Emit one function to the active output.
unsafe fn emitFunction(self: &mut Lowerer, func: *il::Fn, role: FnRole) {
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);

    }
    return FnRole::Normal;
}

/// Builder for accumulating data values during constant lowering.
record DataValueBuilder: Copy {
record DataValueBuilder {
    /// Allocator used to grow the value storage.
    allocator: alloc::Allocator,
    /// Owned values under construction.
    values: *mut [il::DataValue],
    /// Whether all pushed values can be represented by zero-filled memory.
    zeroInit: bool,
}

/// Result of lowering constant data.
record ConstDataResult: Copy {
    /// Immutable initializer values.
    values: *[il::DataValue],
    /// Whether the values can be represented by zero-filled memory.
    zeroInit: bool,
}

/// Create a new builder.
fn dataBuilder(allocator: alloc::Allocator) -> DataValueBuilder {

        set b.zeroInit = false;
    }
}

/// Return the accumulated values.
fn dataBuilderFinish(b: &DataValueBuilder) -> ConstDataResult {
    return ConstDataResult {
        values: &b.values[..],
        zeroInit: b.zeroInit,
    };
fn dataBuilderFinish(b: DataValueBuilder) -> ConstDataResult {
    let case DataValueBuilder { values, zeroInit, .. } = b
        else panic "expected data builder";
    return ConstDataResult { values, zeroInit };
}

///////////////////////////
// SSA Variable Tracking //
///////////////////////////

record BlockData: Copy {
    /// Block label for debugging and IL printing.
    label: *[u8],
    /// Block parameters for merging values at control flow joins. These
    /// receive values from predecessor edges when control flow merges.
    params: *mut [il::Param],
    params: *unsafe mut [il::Param],
    /// Variable ids in parameter order. Before sealing, these are the variables
    /// whose predecessor arguments must be resolved.
    paramVars: *mut [u32],
    paramVars: *unsafe mut [u32],
    /// Instructions accumulated so far. The last instruction should eventually
    /// be a terminator.
    instrs: *mut [il::Instr],
    instrs: *unsafe mut [il::Instr],
    /// Debug source locations, one per instruction. Only populated when
    /// debug info is enabled.
    locs: *mut [il::SrcLoc],
    locs: *unsafe mut [il::SrcLoc],
    /// Predecessor block ids. Used for SSA construction to propagate values
    /// from predecessors when a variable is used before being defined locally.
    preds: *mut [u32],
    preds: *unsafe mut [u32],
    /// The current SSA value of each variable in this block. Indexed by variable
    /// id. A `nil` means the variable wasn't assigned in this block. Updated by
    /// [`defVar`], queried by [`useVarInBlock`].
    vars: *mut [?il::Val],
    vars: *unsafe mut [?il::Val],
    /// Sealing state. Once sealed, all predecessors are known and we can resolve
    /// variable uses that need to pull values from predecessors.
    sealState: Sealed,
    /// Loop nesting depth when this block was created.
    loopDepth: u32,

    /// Union type: tag compared against variant indices.
    Union(resolver::UnionType),
}

/// Determine the kind of a match subject from its type.
fn matchSubjectKind(type: resolver::Type) -> MatchSubjectKind {
unsafe fn matchSubjectKind(type: resolver::Type) -> MatchSubjectKind {
    if resolver::isOptionalPointer(type) {
        return MatchSubjectKind::OptionalPtr;
    }
    if resolver::isOptionalAggregate(type) {
        return MatchSubjectKind::OptionalAggregate;

    low: *unsafe mut Lowerer,
    /// Allocator for IL allocations.
    allocator: alloc::Allocator,
    /// 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.
    fnName: *[u8],

    // ~ SSA variable tracking ~ //

    /// 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: *mut [VarData],
    vars: *unsafe mut [VarData],
    /// Parameter-to-variable bindings, initialized in the entry block.
    params: *mut [FnParamBinding],
    params: *unsafe mut [FnParamBinding],

    // ~ Basic block management ~ //

    /// Block storage array, indexed by block id.
    blockData: *mut [BlockData],
    blockData: *unsafe mut [BlockData],
    /// The entry block for this function.
    entryBlock: ?BlockId,
    /// The block currently receiving new instructions.
    currentBlock: ?BlockId,

    // ~ Loop management ~ //

    /// Stack of loop contexts for break/continue resolution.
    loopStack: *mut [LoopCtx],
    loopStack: *unsafe mut [LoopCtx],
    /// Current nesting depth (index into loopStack).
    loopDepth: u32,

    // ~ Counters ~ //


    root: *ast::Node,
    pkgName: *[u8],
    arena: &mut alloc::Arena
) -> il::Program throws (LowerError) {
    let mut low = Lowerer {
        arena: arena as *unsafe mut alloc::Arena,
        fnArena: arena as *unsafe mut alloc::Arena,
        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,

        errTagCounter: 1,
        options: LowerOptions { debug: false, buildTest: false },
    };
    try lowerDecls(&mut low, root, true);

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

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

    arena: *unsafe mut alloc::Arena,
    fnArena: *unsafe mut alloc::Arena,
    options: LowerOptions
) -> Lowerer {
    return Lowerer {
        arena: arena as *unsafe mut alloc::Arena,
        fnArena: fnArena as *unsafe mut alloc::Arena,
        allocator: alloc::arenaAllocator(&mut *arena),
        resolver: res as *unsafe resolver::Resolver,
        arena,
        fnArena,
        allocator: alloc::arenaAllocator(arena),
        resolver: res,
        moduleGraph: graph as *unsafe module::ModuleGraph,
        pkgName,
        currentMod: nil,
        data: &mut [],
        output: FnOutput::Accumulate(&mut []),

            else => {},
        }
    }
}

/// Finalize lowering and return the unified IL program.
export fn finalize(low: &Lowerer) -> il::Program {
    match low.output {
/// 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
        else panic "expected lowerer";
    match output {
        case FnOutput::Accumulate(accumulated) => {
            return il::Program {
                data: &low.data[..],
                fns: &accumulated[..],
                data,
                fns: accumulated,
            };
        }
        case FnOutput::Stream(_) => {
            panic "finalize: cannot finalize streaming lowerer";
        }

        set id = self.currentMod;
    }
    let actualId = id else {
        return &[];
    };
    let entry = module::get(&*graph, actualId) else {
    let entry = module::get(graph, actualId) else {
        return &[];
    };
    return module::moduleQualifiedPath(entry);
}


unsafe fn qualifyName(self: &mut Lowerer, modId: ?u16, name: *[u8]) -> *[u8] {
    let path = getModulePath(self, modId);
    if path.len == 0 {
        return name;
    }
    return il::formatQualifiedName(&mut *self.arena, path, 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: *resolver::Symbol, qualName: *[u8]) {
fn registerFnSym(self: &mut Lowerer, sym: *unsafe resolver::Symbol, qualName: *[u8]) {
    self.fnSyms.append(FnSymEntry { sym, qualName }, self.allocator);
}

/// 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).
// 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?
fn lookupFnSym(self: &Lowerer, sym: *resolver::Symbol) -> ?*[u8] {
    for entry in self.fnSyms {
unsafe fn lookupFnSym(self: &Lowerer, sym: *unsafe resolver::Symbol) -> ?*[u8] {
    for entry in &self.fnSyms[..] {
        if entry.sym == sym {
            return entry.qualName;
        }
    }
    return nil;

    self: &mut Lowerer,
    node: *ast::Node,
    fnType: *resolver::FnType,
    qualName: *[u8]
) -> FnLowerer {
    let loopStack = try! alloc::allocSlice(&mut *self.fnArena, @sizeOf(LoopCtx), @alignOf(LoopCtx), MAX_LOOP_DEPTH) as *mut [LoopCtx];
    let loopStack = try! alloc::allocRawSlice(self.fnArena, @sizeOf(LoopCtx), @alignOf(LoopCtx), MAX_LOOP_DEPTH) as *unsafe mut [LoopCtx];

    let mut fnLow = FnLowerer {
        low: self as *unsafe mut Lowerer,
        allocator: alloc::arenaAllocator(&mut *self.fnArena),
        low: (&mut *self) as *unsafe mut Lowerer,
        allocator: alloc::arenaAllocator(self.fnArena),
        fnType: fnType,
        localCount: resolver::nodeData(self.resolver, node).localCount,
        fnName: qualName,
        vars: &mut [],
        params: &mut [],
        blockData: &mut [],
        entryBlock: nil,

/// 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) -> ?*il::Fn throws (LowerError) {
unsafe fn lowerFnDecl(self: &mut Lowerer, node: *ast::Node, decl: ast::FnDecl) -> ?*unsafe il::Fn throws (LowerError) {
    if not shouldLowerFn(&decl, self.options.buildTest) {
        return nil;
    }
    let case ast::NodeValue::Ident(name) = decl.name.value else {
        throw LowerError::ExpectedIdentifier;
    };
    let data = resolver::nodeData(&*self.resolver, node);
    let data = resolver::nodeData(self.resolver, node);
    let case resolver::Type::Fn(fnType) = data.ty else {
        throw LowerError::ExpectedFunction;
    };
    let isExtern = checkAttr(decl.attrs, ast::Attribute::Extern);


    // 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::alloc(&mut *self.fnArena, @sizeOf(il::Fn), @alignOf(il::Fn)) as *mut il::Fn;
    let func = try! alloc::allocRaw(self.fnArena, @sizeOf(il::Fn), @alignOf(il::Fn)) as *unsafe mut il::Fn;

    set *func = il::Fn {
        name: qualName,
        params: lowParams,
        returnType: undefined,


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

    set pos += try! mem::copy(&mut buf[pos..], typeName);
    set pos += try! mem::copy(&mut buf[pos..], "::");
    set pos += try! mem::copy(&mut buf[pos..], methodName);

/// 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] {
    let prefix = "vtable::";
    let sepLen: u32 = 2; // "::"
    let totalLen = prefix.len + typeName.len + sepLen + traitName.len;
    let buf = try! alloc::allocSlice(&mut *self.arena, 1, 1, totalLen) as *mut [u8];
    let buf = try! alloc::allocSlice(self.arena, 1, 1, totalLen) as *mut [u8];
    let mut pos: u32 = 0;

    set pos += try! mem::copy(&mut buf[pos..], prefix);
    set pos += try! mem::copy(&mut buf[pos..], typeName);
    set pos += try! mem::copy(&mut buf[pos..], "::");

unsafe fn lowerInstanceDecl(
    self: &mut Lowerer,
    node: *ast::Node,
    traitNameNode: *ast::Node,
    targetTypeNode: *ast::Node,
    methods: *mut [*ast::Node]
    methods: *[*ast::Node]
) throws (LowerError) {
    // Look up the trait and type from the resolver.
    let traitSym = resolver::nodeData(&*self.resolver, traitNameNode).sym
    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
    let typeSym = resolver::nodeData(self.resolver, targetTypeNode).sym
        else throw LowerError::MissingSymbol(targetTypeNode);

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


    }

    // Create v-table in data section, used for dynamic dispatch.
    let vName = vtableName(self, nil, typeName, tName);
    let values = try! alloc::allocSlice(
        &mut *self.arena, @sizeOf(il::DataValue), @alignOf(il::DataValue), traitInfo.methods.len as u32
        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]),

    node: *ast::Node,
    qualName: *[u8],
    receiverName: *ast::Node,
    sig: ast::FnSig,
    body: *ast::Node,
) -> ?*il::Fn throws (LowerError) {
    let data = resolver::nodeData(&*self.resolver, node);
) -> ?*unsafe il::Fn throws (LowerError) {
    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::alloc(&mut *self.fnArena, @sizeOf(il::Fn), @alignOf(il::Fn)) as *mut il::Fn;
    let func = try! alloc::allocRaw(self.fnArena, @sizeOf(il::Fn), @alignOf(il::Fn)) as *unsafe mut il::Fn;

    set *func = il::Fn {
        name: qualName,
        params: lowParams,
        returnType: ilType(self, *fnType.returnType),

    node: *ast::Node,
    name: *ast::Node,
    receiverName: *ast::Node,
    sig: ast::FnSig,
    body: *ast::Node,
) -> ?*il::Fn throws (LowerError) {
    let sym = resolver::nodeData(&*self.resolver, node).sym
) -> ?*unsafe il::Fn throws (LowerError) {
    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)
    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);
}

/// This ensures unique labels like `@then0`, `@then1`, etc.
unsafe fn labelWithSuffix(self: &mut FnLowerer, base: *[u8], suffix: u32) -> *[u8] throws (LowerError) {
    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(&mut *self.low.fnArena, 1, 1, totalLen) as *mut [u8];
    let buf = try! alloc::allocSlice(self.low.fnArena, 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];

    }
    return il::Val::Imm(constToScalar(val));
}

/// Convert a resolver constant value to an IL data initializer item.
fn constValueToDataItem(self: &mut Lowerer, val: resolver::ConstValue, typ: resolver::Type) -> il::DataItem {
unsafe fn constValueToDataItem(self: &mut Lowerer, val: resolver::ConstValue, typ: resolver::Type) -> il::DataItem {
    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;

    node: *ast::Node,
    ty: resolver::Type,
    dataPrefix: *[u8],
    b: &mut DataValueBuilder
) throws (LowerError) {
    let val = resolver::constValueEntry(&*self.resolver, node) else {
        if let idx = voidVariantIndex(&*self.resolver, node) {
    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
            });
            return;

    self: &mut Lowerer,
    node: *ast::Node,
    value: *ast::Node,
    readOnly: bool
) throws (LowerError) {
    let data = resolver::nodeData(&*self.resolver, node);
    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);
    try lowerConstDataInto(self, value, data.ty, layout.size, qualName, &mut b);
    let result = dataBuilderFinish(&b);
    let result = dataBuilderFinish(b);

    self.data.append(il::Data {
        name: qualName,
        size: layout.size,
        alignment: layout.alignment,

    dataPrefix: *[u8],
    b: &mut DataValueBuilder
) throws (LowerError) {
    let case resolver::Type::Slice { mutable, .. } = ty
        else throw LowerError::ExpectedSliceOrArray;
    let targetTy = resolver::typeFor(&*self.resolver, addr.target)
    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 layout = resolver::getTypeLayout(targetTy);
    try lowerConstDataInto(self, addr.target, targetTy, layout.size, dataPrefix, &mut nested);

    let backing = dataBuilderFinish(&nested);
    let backing = dataBuilderFinish(nested);
    let readOnly = not mutable;
    let mut dataName: *[u8] = undefined;
    if readOnly {
        if let found = findConstData(self, backing.values, layout.alignment) {
            set dataName = found;

    dataPrefix: *[u8],
    b: &mut DataValueBuilder
) throws (LowerError) {
    // Function pointer references in constant data.
    if let case resolver::Type::Fn(_) = ty {
        let sym = resolver::nodeData(&*self.resolver, node).sym
        let sym = resolver::nodeData(self.resolver, node).sym
            else throw LowerError::MissingSymbol(node);
        let modId = resolver::moduleIdForSymbol(&*self.resolver, sym);
        let modId = resolver::moduleIdForSymbol(self.resolver, sym);
        let qualName = qualifyName(self, modId, sym.name);
        dataBuilderPush(b, il::DataValue {
            item: il::DataItem::Fn(qualName), count: 1,
        });
        return;
    }
    // In constant data, a void variant of a mixed union still occupies the
    // full tagged-union slot. Emitting only the tag corrupts following fields.
    if let sym = resolver::nodeData(&*self.resolver, node).sym {
    if let sym = resolver::nodeData(self.resolver, node).sym {
        if let case resolver::SymbolData::Variant { type: resolver::Type::Void, .. } = sym.data {
            if let case resolver::Type::Nominal(resolver::NominalType::Union(_)) = ty {
                try lowerConstUnionVariantInto(self, node, sym, ty, &mut [], dataPrefix, b);
                return;
            }

        case ast::NodeValue::ArrayRepeatLit(repeat) =>
            try lowerConstArrayRepeatInto(self, repeat, ty, dataPrefix, b),
        case ast::NodeValue::RecordLit(recLit) =>
            try lowerConstRecordLitInto(self, node, recLit, ty, dataPrefix, b),
        case ast::NodeValue::Call(call) => {
            let calleeSym = resolver::nodeData(&*self.resolver, call.callee).sym
            let calleeSym = resolver::nodeData(self.resolver, call.callee).sym
                else throw LowerError::MissingSymbol(call.callee);
            match calleeSym.data {
                case resolver::SymbolData::Variant { .. } =>
                    try lowerConstUnionVariantInto(self, node, calleeSym, ty, call.args, dataPrefix, b),
                case resolver::SymbolData::Type(resolver::NominalType::Record(recInfo)) => {

        case ast::NodeValue::AddressOf(addr) => {
            try lowerConstAddressSliceInto(self, addr, ty, dataPrefix, b);
        }
        case ast::NodeValue::Ident(_) => {
            // Identifier referencing a constant.
            let sym = resolver::nodeData(&*self.resolver, node).sym
            let sym = resolver::nodeData(self.resolver, node).sym
                else throw LowerError::MissingSymbol(node);
            let case ast::NodeValue::ConstDecl(decl) = sym.node.value
                else throw LowerError::MissingConst(node);

            try lowerConstDataPayloadInto(self, decl.value, ty, dataPrefix, b);
        },
        case ast::NodeValue::ScopeAccess(_) => {
            let sym = resolver::nodeData(&*self.resolver, node).sym
            let sym = resolver::nodeData(self.resolver, node).sym
                else throw LowerError::MissingSymbol(node);
            if let case ast::NodeValue::ConstDecl(decl) = sym.node.value {
                try lowerConstDataPayloadInto(self, decl.value, ty, dataPrefix, b);
            } else {
                try lowerConstScalarDataInto(self, node, ty, dataPrefix, b);


/// 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,
    elems: *mut [*ast::Node],
    elems: *[*ast::Node],
    ty: resolver::Type,
    dataPrefix: *[u8],
    b: &mut DataValueBuilder
) throws (LowerError) {
    let case resolver::Type::Array(arrInfo) = ty

        let elemLayout = resolver::getTypeLayout(elemTy);
        dataBuilderPush(b, il::DataValue {
            item: il::DataItem::Undef,
            count: elemLayout.size * length
        });
    } else if let val = resolver::constValueEntry(&*self.resolver, repeat.item) {
    } else if let val = resolver::constValueEntry(self.resolver, repeat.item) {
        if let case resolver::ConstValue::String(_) = val {
            // A string used as a slice is represented by a three-word slice
            // header, not by the bytes of the string itself.
            for _ in 0..length {
                try lowerConstDataPayloadInto(self, repeat.item, elemTy, dataPrefix, b);

        }
        case resolver::Type::Nominal(resolver::NominalType::Union(_)) => {
            let typeName = recLit.typeName else {
                throw LowerError::ExpectedVariant;
            };
            let sym = resolver::nodeData(&*self.resolver, typeName).sym else {
            let sym = resolver::nodeData(self.resolver, typeName).sym else {
                throw LowerError::MissingSymbol(typeName);
            };
            try lowerConstUnionVariantInto(self, node, sym, ty, recLit.fields, dataPrefix, b);
        }
        else => throw LowerError::ExpectedRecord,

}

/// Build data values for record constants.
unsafe fn lowerConstRecordCtorInto(
    self: &mut Lowerer,
    args: *mut [*ast::Node],
    args: *[*ast::Node],
    recInfo: resolver::RecordType,
    dataPrefix: *[u8],
    b: &mut DataValueBuilder
) throws (LowerError) {
    let layout = recInfo.layout;


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

}

/// 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 {
    for d in &self.data[..] {
        if d.values.len == 1 {
            if let case il::DataItem::Str(existing) = d.values[0].item {
                if mem::eq(existing, s) {
                    return d.name;
                }

        set totalLen += segment.len;
    }
    if segments.len > 1 {
        set totalLen += segments.len - 1;
    }
    let buf = try! alloc::allocSlice(&mut *self.arena, 1, 1, totalLen) as *mut [u8];
    let buf = try! alloc::allocSlice(self.arena, 1, 1, totalLen) as *mut [u8];
    let mut pos: u32 = 0;

    for segment, i in segments {
        set pos += try! mem::copy(&mut buf[pos..], segment);
        if i + 1 <> segments.len {

    count: u32,
    namespace: *[u8]
) -> *[u8] throws (LowerError) {
    let mut digits: [u8; fmt::U32_STR_LEN] = undefined;
    let start = fmt::formatU32(count, &mut digits[..]);
    let suffix = try! alloc::allocSlice(&mut *self.arena, 1, 1, digits.len - start) as *mut [u8];
    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[..]);
}

) -> *[u8] throws (LowerError) {
    if let existing = findStringData(self, s) {
        return existing;
    }
    let values = try! alloc::allocSlice(
        &mut *self.arena, @sizeOf(il::DataValue), @alignOf(il::DataValue), 1
        self.arena, @sizeOf(il::DataValue), @alignOf(il::DataValue), 1
    ) as *mut [il::DataValue];

    set values[0] = il::DataValue {
        item: il::DataItem::Str(s),
        count: 1

}

/// 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 {
    for d in &self.data[..] {
        if d.alignment == alignment and d.readOnly and dataValuesEq(d.values, values) {
            return d.name;
        }
    }
    return nil;

    let elemLayout = resolver::getTypeLayout(*elemTy);
    let size = elemLayout.size * length;
    let mut dataName: *[u8] = undefined;
    let mut found: ?*[u8] = nil;
    if readOnly {
        set found = findConstData(&mut *self.low, values, alignment);
        set found = findConstData(self.low, values, alignment);
    }
    if let name = found {
        set dataName = name;
    } else {
        set dataName = try nextDataName(self);

/// Generate a unique data name for inline literals, eg. `fnName$literal$N`.
unsafe fn nextDataName(self: &mut FnLowerer) -> *[u8] throws (LowerError) {
    let counter = self.dataCounter;
    set self.dataCounter += 1;
    let fnName = self.fnName;
    return try nextDeclDataName(&mut *self.low, fnName, counter, "literal");
    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) {
    let sym = resolver::nodeData(&*self.low.resolver, node).sym
    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(&mut *self.low, &segments[..]);
    let name = try buildSegmentedName(self.low, &segments[..]);

    set sym.name = name;
}

/// Get the next available SSA register.

    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) {
    let ty = resolver::typeFor(&*self.low.resolver, node)
    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) -> *mut resolver::Symbol throws (LowerError) {
    let sym = resolver::nodeData(&*self.low.resolver, node).sym
unsafe fn symOf(self: &mut FnLowerer, node: *ast::Node) -> *unsafe mut resolver::Symbol throws (LowerError) {
    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.

/// 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.
fn rewriteCachedVarValue(self: &mut FnLowerer, v: Var, from: il::Val, to: il::Val) {
unsafe fn rewriteCachedVarValue(self: &mut FnLowerer, v: Var, from: il::Val, to: il::Val) {
    for i in 0..self.blockData.len {
        let blk = getBlockMut(self, BlockId(i));
        if blk.vars[*v] == from {
            set blk.vars[*v] = to;
        }

        }
    }
}

/// Replace all occurrences of `from` with `to` in an args slice.
fn rewriteValInSlice(args: *mut [il::Val], from: il::Val, to: il::Val) {
unsafe fn rewriteValInSlice(args: *unsafe mut [il::Val], from: il::Val, to: il::Val) {
    for i in 0..args.len {
        if args[i] == from {
            set args[i] = to;
        }
    }

/// 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) {
    let label = try nextLabel(self, labelBase);
    let id = BlockId(self.blockData.len);
    let varCount = self.fnType.localCount;
    let vars = try! alloc::allocSlice(&mut *self.low.fnArena, @sizeOf(?il::Val), @alignOf(?il::Val), varCount) as *mut [?il::Val];
    let varCount = self.localCount;
    let vars = try! alloc::allocRawSlice(self.low.fnArena, @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 {

    try sealBlock(self, block);
    switchToBlock(self, block);
}

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

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

/// Get the current block being built.
fn currentBlock(self: &FnLowerer) -> BlockId {

            let operandTy = scalarComparisonType(leftTy, rightTy);
            let unsigned = isUnsignedType(operandTy);
            if let op = cmpOpFrom(binop.op, unsigned) {
                let a = try lowerExpr(self, binop.left);
                let b = try lowerExpr(self, binop.right);
                let typ = ilType(&mut *self.low, operandTy);
                let typ = ilType(self.low, operandTy);

                // Swap operands if needed.
                match binop.op {
                    case ast::BinaryOp::Gt => // `a > b` = `b < a`
                        try emitBrCmp(self, op, typ, b, a, thenBlock, elseBlock),


/// 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 {
    let dst = nextReg(self);
    let ilTyp = ilType(&mut *self.low, typ);
    let ilTyp = ilType(self.low, typ);

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

    }
    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: *resolver::Symbol) -> il::Reg {
unsafe fn emitDataAddr(self: &mut FnLowerer, sym: *unsafe resolver::Symbol) -> il::Reg {
    let dst = nextReg(self);
    let modId = resolver::moduleIdForSymbol(&*self.low.resolver, sym);
    let qualName = qualifyName(&mut *self.low, modId, sym.name);
    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::DataSym(qualName) });

    return dst;
}

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

        }
        case MatchSubjectKind::Union(unionInfo) => {
            assert not isNil;

            let case resolver::NodeExtra::UnionVariant { tag: variantTag, .. } =
                resolver::nodeData(&*self.low.resolver, pattern).extra
                resolver::nodeData(self.low.resolver, pattern).extra
            else {
                throw LowerError::ExpectedVariant;
            };
            // Void unions are passed by value (the tag itself).
            // Non-void unions are passed by reference (need to load tag).

    }
    try sealBlock(self, target);
}

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

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

/// Add a predecessor edge from `pred` to `target`.
/// Must be called before the target block is sealed. Duplicates are ignored.
fn addPredecessor(self: &mut FnLowerer, target: BlockId, pred: BlockId) {
unsafe fn addPredecessor(self: &mut FnLowerer, target: BlockId, pred: BlockId) {
    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.

    }
    preds.append(*pred, self.allocator);
}

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

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

        set blocks[i] = il::Block {

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

/// Enter a loop context for break/continue handling.
/// `continueBlock` is `nil` when the continue target is created lazily.
fn enterLoop(self: &mut FnLowerer, breakBlock: BlockId, continueBlock: ?BlockId) {
unsafe fn enterLoop(self: &mut FnLowerer, breakBlock: BlockId, continueBlock: ?BlockId) {
    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;

    assert self.loopDepth <> 0, "exitLoop: loopDepth is zero";
    set self.loopDepth -= 1;
}

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

    set ctx.continueTarget = block;
    return block;
}

/// Allocate a slice of values in the lowering arena.
unsafe fn allocVals(self: &mut FnLowerer, len: u32) -> *mut [il::Val] throws (LowerError) {
    return try! alloc::allocSlice(&mut *self.low.fnArena, @sizeOf(il::Val), @alignOf(il::Val), len) as *mut [il::Val];
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];
}

/// Allocate a single-value slice in the lowering arena.
unsafe fn allocVal(self: &mut FnLowerer, val: il::Val) -> *mut [il::Val] throws (LowerError) {
unsafe fn allocVal(self: &mut FnLowerer, val: il::Val) -> *unsafe mut [il::Val] throws (LowerError) {
    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.
fn newVar(
unsafe fn newVar(
    self: &mut FnLowerer,
    name: ?*[u8],
    type: il::Type,
    mutable: bool,
    val: il::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.
fn defVar(self: &mut FnLowerer, v: Var, val: il::Val) {
unsafe fn defVar(self: &mut FnLowerer, v: Var, val: il::Val) {
    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.

    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.
fn lookupVarByName(self: &FnLowerer, name: *[u8]) -> ?Var {
unsafe fn lookupVarByName(self: &FnLowerer, name: *[u8]) -> ?Var {
    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.
fn lookupLocalVar(self: &FnLowerer, node: *ast::Node) -> ?Var {
unsafe fn lookupLocalVar(self: &FnLowerer, node: *ast::Node) -> ?Var {
    let case ast::NodeValue::Ident(name) = node.value else {
        return nil;
    };
    return lookupVarByName(self, name);
}

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

/// Restore lexical variable scope depth.
unsafe fn exitVarScope(self: &mut FnLowerer, savedVarsLen: u32) {
    set self.vars = @sliceOf(self.vars.ptr, savedVarsLen, self.vars.cap);
}

/// Get the metadata for a variable.
fn getVar(self: &FnLowerer, v: Var) -> *VarData {
unsafe fn getVar(self: &FnLowerer, v: Var) -> *unsafe VarData {
    assert *v < self.vars.len;
    return &self.vars[*v];
}

/// Create a block parameter to merge a variable's value from multiple

        }
    }
}

/// Grow an args array to hold at least the given capacity.
unsafe fn growArgs(self: &mut FnLowerer, args: *mut [il::Val], capacity: u32) -> *mut [il::Val] {
unsafe fn growArgs(self: &mut FnLowerer, args: *unsafe mut [il::Val], capacity: u32) -> *unsafe mut [il::Val] {
    if args.len >= capacity {
        return args;
    }
    let newArgs = try! alloc::allocSlice(
        &mut *self.low.fnArena, @sizeOf(il::Val), @alignOf(il::Val), capacity
    ) as *mut [il::Val];
    let newArgs = try! alloc::allocRawSlice(
        self.low.fnArena, @sizeOf(il::Val), @alignOf(il::Val), capacity
    ) as *unsafe mut [il::Val];

    for arg, i in args {
        set newArgs[i] = arg;
    }
    for i in args.len..capacity {

/// 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,
    fnType: resolver::FnType,
    astParams: *mut [*ast::Node],
    astParams: *[*ast::Node],
    receiverName: ?*ast::Node
) -> *[il::Param] throws (LowerError) {
) -> *unsafe [il::Param] throws (LowerError) {
    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::allocSlice(
        &mut *self.low.fnArena, @sizeOf(il::Param), @alignOf(il::Param), totalLen
    ) as *mut [il::Param];
    let params = try! alloc::allocRawSlice(
        self.low.fnArena, @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 };
    }
    for i in 0..fnType.paramTypes.len as u32 {
        let type = ilType(&mut *self.low, *fnType.paramTypes[i]);
        let type = ilType(self.low, *fnType.paramTypes[i]);
        let reg = nextReg(self);

        set params[i + offset] = il::Param { value: reg, type };

        // Declare the parameter variable. For the receiver, the name comes


    let mut bindType = unwrapped.effectiveTy;
    if let case resolver::Type::Optional(inner) = unwrapped.effectiveTy {
        set bindType = *inner;
    }
    let ilType = ilType(&mut *self.low, unwrapped.effectiveTy);
    let ilType = ilType(self.low, unwrapped.effectiveTy);
    let kind = matchSubjectKind(unwrapped.effectiveTy);

    return MatchSubject { val, type: unwrapped.effectiveTy, ilType, bindType, kind, by: unwrapped.by };
}


        case resolver::MatchBy::Value =>
            set payload = tvalPayloadVal(self, base, bindType, valOffset),
        case resolver::MatchBy::Ref, resolver::MatchBy::MutRef =>
            set payload = tvalPayloadAddr(self, base, valOffset),
    };
    return newVar(self, name, ilType(&mut *self.low, bindType), mutable, payload);
    return newVar(self, name, ilType(self.low, bindType), mutable, payload);
}

/// Bind an identifier from a matched subject.
unsafe fn bindMatchVariable(
    self: &mut FnLowerer,

    if let case MatchSubjectKind::OptionalAggregate = subject.kind {
        let valOffset = resolver::getOptionalValOffset(subject.bindType) as i32;
        return try bindPayloadVariable(self, name, subject.val, subject.bindType, subject.by, valOffset, mutable);
    }
    // Declare the variable in the current block's scope.
    return newVar(self, name, ilType(&mut *self.low, subject.bindType), mutable, subject.val);
    return newVar(self, name, ilType(self.low, subject.bindType), mutable, subject.val);
}

/// 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) {
    for pattern in patterns {

        // Handle simple variant patterns like `Variant(x)`.
        if let arg = resolver::variantPatternBinding(&*self.low.resolver, pattern) {
        if let arg = resolver::variantPatternBinding(self.low.resolver, pattern) {
            let case MatchSubjectKind::Union(unionInfo) = subject.kind
                else panic "bindPatternVariables: expected union subject";
            let valOffset = unionInfo.valOffset as i32;

            // Get the actual field type from the variant's record info.
            // This preserves the original data layout type (e.g. `*T`) even when
            // the resolver resolved the pattern against a dereferenced type (`T`).
            let variantExtra = resolver::nodeData(&*self.low.resolver, pattern).extra;
            let variantExtra = resolver::nodeData(self.low.resolver, pattern).extra;
            let case resolver::NodeExtra::UnionVariant { ordinal, .. } = variantExtra
                else panic "bindPatternVariables: expected variant extra";
            let payloadType = unionInfo.variants[ordinal].valueType;
            let payloadRec = resolver::getRecord(payloadType)
                else panic "bindPatternVariables: expected record payload";

/// 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,
    subject: &MatchSubject,
    items: *mut [*ast::Node],
    items: *[*ast::Node],
    failBlock: BlockId
) throws (LowerError) {
    let case resolver::Type::Array(arrInfo) = subject.type
        else throw LowerError::ExpectedSliceOrArray;


    let case MatchSubjectKind::Union(unionInfo) = subject.kind
        else panic "bindRecordPatternFields: expected union subject";

    // Get the variant index from the pattern node.
    let case resolver::NodeExtra::UnionVariant { ordinal: variantOrdinal, .. } =
        resolver::nodeData(&*self.low.resolver, pattern).extra
        resolver::nodeData(self.low.resolver, pattern).extra
    else throw LowerError::MissingMetadata;

    // Get the record type from the variant's payload type.
    let payloadType = unionInfo.variants[variantOrdinal].valueType;
    let recInfo = resolver::getRecord(payloadType)

    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));
            newVar(self, name, ilType(&mut *self.low, fieldInfo.fieldType), false, val);
            newVar(self, name, ilType(self.low, fieldInfo.fieldType), false, val);
        }
        case ast::NodeValue::Placeholder => {}
        case ast::NodeValue::RecordLit(lit) => {
            // Check if this record literal is a union variant pattern.
            if let keyNode = resolver::patternVariantKeyNode(binding) {
                if let case resolver::NodeExtra::UnionVariant { .. } = resolver::nodeData(&*self.low.resolver, keyNode).extra {
                if let case resolver::NodeExtra::UnionVariant { .. } = resolver::nodeData(self.low.resolver, keyNode).extra {
                    try emitNestedFieldTest(self, binding, base, fieldInfo, matchBy, failBlock);
                    return;
                }
            }
            // Plain nested record destructuring pattern.

            set derefBase = ptrReg;
            set fieldType = *target;
        }
    }
    // Build a MatchSubject for the nested field.
    let ilTy = ilType(&mut *self.low, fieldType);
    let ilTy = ilType(self.low, fieldType);
    let kind = matchSubjectKind(fieldType);

    // Determine the subject value.
    let mut val: il::Val = undefined;
    if let reg = derefBase {

) throws (LowerError) {
    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)
        let fieldIdx = resolver::recordFieldIndexFor(self.low.resolver, fieldNode)
            else throw LowerError::MissingMetadata;
        if fieldIdx >= recInfo.fields.len {
            throw LowerError::MissingMetadata;
        }
        let fieldInfo = recInfo.fields[fieldIdx];

        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) -> *[il::Block] throws (LowerError) {
unsafe fn lowerFnBody(self: &mut FnLowerer, body: *ast::Node) -> *unsafe [il::Block] throws (LowerError) {
    // Create and switch to entry block.
    let entry = try createBlock(self, "entry");
    set self.entryBlock = entry;
    switchToBlock(self, entry);


    }
    return try finalizeBlocks(self);
}

/// Lower a scalar match as a switch instruction.
unsafe fn lowerMatchSwitch(self: &mut FnLowerer, prongs: *mut [*ast::Node], subject: &MatchSubject, mergeBlock: &mut ?BlockId) throws (LowerError) {
unsafe fn lowerMatchSwitch(self: &mut FnLowerer, prongs: *[*ast::Node], subject: &MatchSubject, mergeBlock: &mut ?BlockId) throws (LowerError) {
    let mut blocks: [BlockId; 32] = undefined;
    let mut cases: *mut [il::SwitchCase] = &mut [];
    let mut cases: *unsafe mut [il::SwitchCase] = &mut [];
    let mut defaultIdx: u32 = 0;
    let entry = currentBlock(self);

    for p, i in prongs {
        let case ast::NodeValue::MatchProng(prong) = p.value

                set defaultIdx = i;
            }
            case ast::ProngArm::Case(pats) => {
                set blocks[i] = try createBlock(self, "case");
                for pat in pats {
                    let cv = resolver::constValueEntry(&*self.low.resolver, pat)
                    let cv = resolver::constValueEntry(self.low.resolver, pat)
                        else throw LowerError::MissingConst(pat);

                    cases.append(il::SwitchCase {
                        value: constToScalar(cv),
                        target: *blocks[i],

    let subject = try lowerMatchSubject(self, m.subject);
    // Merge block created lazily if any arm needs it (i.e., doesn't diverge).
    let mut mergeBlock: ?BlockId = nil;

    // Use `switch` instruction for matches with constant patterns.
    if resolver::isMatchConst(&*self.low.resolver, node) {
    if resolver::isMatchConst(self.low.resolver, node) {
        try lowerMatchSwitch(self, prongs, &subject, &mut mergeBlock);
        return;
    }
    // Fallback: chained branches.
    let firstArm = try createBlock(self, "arm");

        let case ast::NodeValue::MatchProng(prong) = prongNode.value
            else panic "lowerMatch: expected match prong";

        let isLastArm = i + 1 == prongs.len;
        let hasGuard = prong.guard <> nil;
        let catchAll = resolver::isProngCatchAll(&*self.low.resolver, prongNode);
        let catchAll = resolver::isProngCatchAll(self.low.resolver, prongNode);

        // Entry block: guard block if present, otherwise the body block.
        // The guard block must be created before the body block so that
        // block indices are in reverse post-order (RPO), which the register
        // allocator requires.

        // Emit pattern test: branch to entry block on match, next arm on fail.
        match prong.arm {
            case ast::ProngArm::Binding(_) if not catchAll =>
                try emitBindingTest(self, &subject, entryBlock, nextArm),
            case ast::ProngArm::Case(patterns) if not catchAll =>
                try emitPatternMatches(self, &subject, &patterns[..], entryBlock, nextArm),
                try emitPatternMatches(self, &subject, patterns, entryBlock, nextArm),
            else =>
                try emitJmp(self, entryBlock),
        }
        // Switch to entry block, where any variable bindings need to be created.
        try switchToAndSeal(self, entryBlock);

        // block.
        match prong.arm {
            case ast::ProngArm::Binding(pat) =>
                try bindMatchVariable(self, &subject, pat, false),
            case ast::ProngArm::Case(patterns) =>
                try bindPatternVariables(self, &subject, &patterns[..], nextArm),
                try bindPatternVariables(self, &subject, patterns, nextArm),
            else => {},
        }

        // Evaluate guard if present; can still fail to next arm.
        if let g = prong.guard {

            try lowerLet(self, node, l);
        }
        case ast::NodeValue::ConstDecl(decl) => {
            // Local constants lower to data declarations and emit no runtime code.
            try registerLocalDataDeclName(self, node);
            try lowerDataDecl(&mut *self.low, node, decl.value, true);
            try lowerDataDecl(self.low, node, decl.value, true);
        }
        case ast::NodeValue::StaticDecl(decl) => {
            // Local statics lower to data declarations and emit no runtime code.
            try registerLocalDataDeclName(self, node);
            try lowerDataDecl(&mut *self.low, node, decl.value, false);
            try lowerDataDecl(self.low, node, decl.value, false);
        }
        case ast::NodeValue::If(i) => {
            try lowerIf(self, i);
        }
        case ast::NodeValue::IfLet(i) => {

///////////////////////////////////////
// Record and Aggregate Type Helpers //
///////////////////////////////////////

/// Extract the nominal record info from a resolver type.
fn recordInfoFromType(typ: resolver::Type) -> ?resolver::RecordType {
unsafe fn recordInfoFromType(typ: resolver::Type) -> ?resolver::RecordType {
    let case resolver::Type::Nominal(resolver::NominalType::Record(recInfo)) = typ
        else return nil;

    return recInfo;
}

/// Extract the nominal union info from a resolver type.
fn unionInfoFromType(typ: resolver::Type) -> ?resolver::UnionType {
unsafe fn unionInfoFromType(typ: resolver::Type) -> ?resolver::UnionType {
    let case resolver::Type::Nominal(resolver::NominalType::Union(unionInfo)) = typ
        else return nil;

    return unionInfo;
}

/// 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) {
    let ty = try typeOf(self, node);
    if let coerce = resolver::coercionFor(&*self.low.resolver, node) {
    if let coerce = resolver::coercionFor(self.low.resolver, node) {
        if let case resolver::Coercion::OptionalLift(optTy) = coerce {
            return optTy;
        }
    }
    return ty;
}

/// Check if a resolver type lowers to an aggregate in memory.
fn isAggregateType(typ: resolver::Type) -> bool {
unsafe fn isAggregateType(typ: resolver::Type) -> bool {
    match typ {
        case resolver::Type::Slice { .. },
             resolver::Type::TraitObject { .. } => return true,
        case resolver::Type::Optional(resolver::Type::Pointer { .. }) => {
            // Optional pointers are scalar due to NPO.

    }
}

/// Check if a resolver type is a small aggregate that can be
/// passed or returned by value in a register.
fn isSmallAggregate(typ: resolver::Type) -> bool {
unsafe fn isSmallAggregate(typ: resolver::Type) -> bool {
    match typ {
        case resolver::Type::Nominal(_) => {
            if resolver::isVoidUnion(typ) {
                return false;
            }

/// Whether a function needs a hidden return parameter.
///
/// This is the case for throwing functions, which return a result aggregate,
/// and for functions returning large aggregates that cannot be passed in
/// registers.
fn requiresReturnParam(fnType: *resolver::FnType) -> bool {
unsafe fn requiresReturnParam(fnType: *resolver::FnType) -> bool {
    return fnType.throwList.len > 0
        or (isAggregateType(*fnType.returnType)
        and not isSmallAggregate(*fnType.returnType));
}

/// 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.
fn voidVariantIndex(res: &resolver::Resolver, node: *ast::Node) -> ?i64 {
unsafe fn voidVariantIndex(res: &resolver::Resolver, node: *ast::Node) -> ?i64 {
    let data = resolver::nodeData(res, node);
    let sym = data.sym else {
        return nil;
    };
    let case resolver::SymbolData::Variant { type: payloadType, index, .. } = sym.data else {

        let layout = resolver::getTypeLayout(typ);

        emit(self, il::Instr::Blit { dst, src, size: il::Val::Imm(layout.size as i64) });
    } else {
        emit(self, il::Instr::Store {
            typ: ilType(&mut *self.low, typ),
            typ: ilType(self.low, typ),
            src,
            dst: base,
            offset,
        });
    }


/// Build a trait object fat pointer from a data pointer and a v-table.
unsafe fn buildTraitObject(
    self: &mut FnLowerer,
    dataVal: il::Val,
    traitInfo: *resolver::TraitType,
    traitInfo: *unsafe resolver::TraitType,
    inst: &resolver::InstanceEntry
) -> il::Val throws (LowerError) {
    let vName = vtableName(&mut *self.low, inst.moduleId, inst.concreteTypeName, traitInfo.name);
    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,
        alignment: resolver::PTR_SIZE,

    }
    // For scalar types, load and compare directly.
    let a = emitLoad(self, left, offset, fieldType);
    let b = emitLoad(self, right, offset, fieldType);
    let dst = nextReg(self);
    emit(self, il::Instr::BinOp { op: il::BinOp::Eq, typ: ilType(&mut *self.low, fieldType), dst, a, b });
    emit(self, il::Instr::BinOp { op: il::BinOp::Eq, typ: ilType(self.low, fieldType), dst, a, b });

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

/// Compare two record values for equality.

    addPredecessor(self, mergeBlock, currentBlock(self));

    // 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::allocSlice(
        &mut *self.low.fnArena, @sizeOf(il::SwitchCase), @alignOf(il::SwitchCase), unionInfo.variants.len as u32
    ) as *mut [il::SwitchCase];
    let cases = try! alloc::allocRawSlice(
        self.low.fnArena, @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 {
            set cases[i] = il::SwitchCase {

/// The `offset` is added to each field's offset when storing.
unsafe fn lowerRecordFields(
    self: &mut FnLowerer,
    dst: il::Reg,
    recInfo: &resolver::RecordType,
    fields: *mut [*ast::Node],
    fields: *[*ast::Node],
    offset: i32
) throws (LowerError) {
    for fieldNode, i in fields {
        let case ast::NodeValue::RecordLitField(field) = fieldNode.value else {
            throw LowerError::UnexpectedNodeValue(fieldNode);
        };
        let mut fieldIdx: u32 = i;
        if recInfo.labeled {
            let idx = resolver::recordFieldIndexFor(&*self.low.resolver, fieldNode) else {
            let idx = resolver::recordFieldIndexFor(self.low.resolver, fieldNode) else {
                throw LowerError::MissingMetadata;
            };
            set fieldIdx = idx;
        }
        // Skip `undefined` fields, they need no initialization.

        }
    }
}

/// Lower an unlabeled record constructor call.
unsafe fn lowerRecordCtor(self: &mut FnLowerer, nominal: *resolver::NominalType, args: *mut [*ast::Node]) -> il::Val throws (LowerError) {
unsafe fn lowerRecordCtor(self: &mut FnLowerer, nominal: *unsafe resolver::NominalType, args: *[*ast::Node]) -> il::Val throws (LowerError) {
    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: *mut [*ast::Node]) -> il::Val
unsafe fn lowerArrayLit(self: &mut FnLowerer, node: *ast::Node, elements: *[*ast::Node]) -> il::Val
    throws (LowerError)
{
    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: *mut resolver::Symbol, call: ast::Call) -> il::Val
unsafe fn lowerUnionCtor(self: &mut FnLowerer, node: *ast::Node, sym: *unsafe mut resolver::Symbol, call: ast::Call) -> il::Val
    throws (LowerError)
{
    let unionTy = try typeOf(self, node);
    let case resolver::SymbolData::Variant { type: payloadType, index, .. } = sym.data else {
        throw LowerError::ExpectedVariant;


/// Lower a field access into a pointer to the field.
unsafe fn lowerFieldRef(self: &mut FnLowerer, access: ast::Access) -> FieldRef throws (LowerError) {
    let parentTy = try typeOf(self, access.parent);
    let subjectTy = resolver::autoDeref(parentTy);
    let fieldIdx = resolver::recordFieldIndexFor(&*self.low.resolver, access.child) else {
    let fieldIdx = resolver::recordFieldIndexFor(self.low.resolver, access.child) else {
        throw LowerError::MissingMetadata;
    };
    let fieldInfo = resolver::getRecordField(subjectTy, fieldIdx) else {
        throw LowerError::FieldNotFound;
    };

    self: &mut FnLowerer,
    container: *ast::Node,
    range: ast::Range,
    sliceNode: *ast::Node
) -> il::Val throws (LowerError) {
    let info = resolver::sliceRangeInfoFor(&*self.low.resolver, sliceNode) else {
    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

                // Already address-taken; return existing stack pointer.
                return val;
            }
            // Materialize a stack slot using the declaration's resolved
            // layout so `align(N)` on locals is honored.
            let layout = resolver::getLayout(&*self.low.resolver, addr.target, typ);
            let layout = resolver::getLayout(self.low.resolver, addr.target, typ);
            let slot = emitReserveLayout(self, layout);
            try emitStore(self, slot, 0, typ, val);
            let stackVal = il::Val::Reg(slot);

            set self.vars[*v].addressTaken = true;
            defVar(self, v, stackVal);

            return stackVal;
        }
        // Fall back to symbol lookup for constants/statics.
        if let sym = resolver::nodeData(&*self.low.resolver, addr.target).sym {
        if let sym = resolver::nodeData(self.low.resolver, addr.target).sym {
            return il::Val::Reg(emitDataAddr(self, sym));
        } else {
            throw LowerError::MissingSymbol(node);
        }
    }

    if length == 0 {
        return try buildSliceValue(
            self, item, mutable, il::Val::Imm(0), il::Val::Imm(0), il::Val::Imm(0)
        );
    }
    if resolver::isConstExpr(&*self.low.resolver, arrayNode) {
    if resolver::isConstExpr(self.low.resolver, arrayNode) {
        let fnName = self.fnName;
        let mut b = dataBuilder(self.low.allocator);
        match arrayNode.value {
            case ast::NodeValue::ArrayLit(elements) =>
                try lowerConstArrayLitInto(&mut *self.low, elements, arrayTy, fnName, &mut b),
                try lowerConstArrayLitInto(self.low, elements, arrayTy, fnName, &mut b),
            case ast::NodeValue::ArrayRepeatLit(repeat) =>
                try lowerConstArrayRepeatInto(&mut *self.low, repeat, arrayTy, fnName, &mut b),
                try lowerConstArrayRepeatInto(self.low, repeat, arrayTy, fnName, &mut b),
            else => throw LowerError::UnexpectedNodeValue(arrayNode),
        }
        let result = dataBuilderFinish(&b);
        let result = dataBuilderFinish(b);
        let alignment = resolver::getTypeLayout(*item).alignment;
        return try lowerConstDataAsSlice(
            self, &result, alignment, not mutable,
            item, mutable, length
        );

        case resolver::Type::Array(arrInfo) => {
            set elemType = *arrInfo.item;
            // Runtime safety check: index must be strictly less than array length.
            // Skip when the index is a compile-time constant, since we check
            // that in the resolver.
            if not resolver::isConstExpr(&*self.low.resolver, index) {
            if not resolver::isConstExpr(self.low.resolver, index) {
                let arrLen = il::Val::Imm(arrInfo.length as i64);
                try emitTrapUnlessCmp(self, il::CmpOp::Ult, il::Type::W32, indexVal, arrLen);
            }
        }
        else => throw LowerError::ExpectedSliceOrArray,

    }
    let case ast::NodeValue::Ident(name) = l.ident.value else {
        throw LowerError::ExpectedIdentifier;
    };
    let typ = try typeOf(self, l.value);
    let ilType = ilType(&mut *self.low, typ);
    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.
    // This is because aggregates are represented as memory addresses

    // 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
        voidVariantIndex(&*self.low.resolver, l.value) == nil {
        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
    // anywhere in the function, allocate a stack slot immediately so the
    // SSA value is always a pointer. This avoids mixing integer and pointer
    // values in loop phis when `&var` or `&mut var` appears inside a loop.
    if not isAggregateType(typ) {
        if let sym = resolver::nodeData(&*self.low.resolver, node).sym {
        if let sym = resolver::nodeData(self.low.resolver, node).sym {
            if let case resolver::SymbolData::Value { addressTaken, .. } = sym.data; addressTaken {
                let layout = resolver::getLayout(&*self.low.resolver, node, typ);
                let layout = resolver::getLayout(self.low.resolver, node, typ);
                let slot = emitReserveLayout(self, layout);
                try emitStore(self, slot, 0, typ, varVal);

                let v = newVar(self, name, ilType, l.mutable, il::Val::Reg(slot));
                set self.vars[*v].addressTaken = true;

    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);
    let result = emitScalarBinOp(
        self, binop.op, ilType(&mut *self.low, exprType), left, right, isUnsignedType(exprType)
        self, binop.op, ilType(self.low, exprType), left, right, isUnsignedType(exprType)
    );
    let assigned = try applyCoercion(self, expr, result);
    try emitStore(self, place.base, place.offset, place.fieldType, assigned);

    return true;
}

/// Lower an assignment statement.
unsafe fn lowerAssign(self: &mut FnLowerer, node: *ast::Node, a: ast::Assign) throws (LowerError) {
    // Slice assignment: `slice[range] = value`.
    if let info = resolver::sliceRangeInfoFor(&*self.low.resolver, node) {
    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
            else panic "lowerAssign: slice assign without range";
        try lowerSliceAssign(self, a.right, container, range, info);

}

/// Lower a `for` loop over a range, array, or slice.
unsafe fn lowerFor(self: &mut FnLowerer, node: *ast::Node, f: ast::For) throws (LowerError) {
    let savedVarsLen = enterVarScope(self);
    let info = resolver::forLoopInfoFor(&*self.low.resolver, node) else {
    let info = resolver::forLoopInfoFor(self.low.resolver, node) else {
        throw LowerError::MissingMetadata;
    };
    match info {
        case resolver::ForLoopInfo::Range { valType, range, bindingName, indexName } => {
            let endExpr = range.end else {

            let mut startVal = il::Val::Imm(0);
            if let start = range.start {
                set startVal = try lowerExpr(self, start);
            }
            let endVal = try lowerExpr(self, endExpr);
            let iterType = ilType(&mut *self.low, *valType);
            let iterType = ilType(self.low, *valType);
            let valVar = newVar(self, bindingName, iterType, false, startVal);

            let mut indexVar: ?Var = nil;
            if indexName <> nil { // Optional index always starts at zero.
                set indexVar = newVar(self, indexName, il::Type::W32, false, il::Val::Imm(0));

            let mut valVar: ?Var = nil;
            if bindingName <> nil {
                set valVar = newVar(
                    self,
                    bindingName,
                    ilType(&mut *self.low, *elemType),
                    ilType(self.low, *elemType),
                    false,
                    il::Val::Undef
                );
            }
            let iter = ForIter::Collection { valVar, idxVar, dataReg, lengthVal, elemType };

unsafe fn lowerThrowStmt(self: &mut FnLowerer, expr: *ast::Node) throws (LowerError) {
    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(&mut *self.low, errType) as i64;
    let tag = getOrAssignErrorTag(self.low, errType) as i64;
    let errVal = try lowerExpr(self, expr);
    let resultVal = try buildResult(self, tag, errVal, errType);

    try emitRetVal(self, resultVal);
}


        return il::Val::Reg(dst);
    } else {
        try emitCondBranch(self, cond.condition, thenBlock, elseBlock);

        let resultType = ilType(&mut *self.low, typ);
        let resultType = ilType(self.low, typ);
        let resultReg = nextReg(self);
        let mergeBlock = try createBlockWithParam(
            self, "cond#merge", il::Param { value: resultReg, type: resultType }
        );
        try switchToAndSeal(self, thenBlock);


    if isComparison {
        let leftTy = try effectiveType(self, binop.left);
        let rightTy = try effectiveType(self, binop.right);
        // Optimize: comparing with a void variant just needs tag comparison.
        if let idx = voidVariantIndex(&*self.low.resolver, binop.left) {
        if let idx = voidVariantIndex(self.low.resolver, binop.left) {
            return try emitTagCmp(self, binop.op, b, idx, rightTy);
        } else if let idx = voidVariantIndex(&*self.low.resolver, binop.right) {
        } else if let idx = voidVariantIndex(self.low.resolver, binop.right) {
            return try emitTagCmp(self, binop.op, a, idx, leftTy);
        }
        // Aggregate types require element-wise comparison.
        // When comparing `?T` with `T`, wrap the scalar side.
        if isAggregateType(leftTy) {

            let lhs = try wrapInOptional(self, a, rightTy);
            return try emitAggregateEqOp(self, binop.op, rightTy, lhs, b);
        }
        set resultTy = scalarComparisonType(leftTy, rightTy);
    }
    return emitScalarBinOp(self, binop.op, ilType(&mut *self.low, resultTy), a, b, isUnsignedType(resultTy));
    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,

            return il::Val::Imm((0 - lit.magnitude) as i64);
        }
    }
    let val = try lowerExpr(self, unop.value);
    let t = try typeOf(self, node);
    let typ = ilType(&mut *self.low, t);
    let typ = ilType(self.low, t);
    let dst = nextReg(self);
    let mut needsExt: bool = false;

    match unop.op {
        case ast::UnaryOp::Not => {

    let sliceTy = try typeOf(self, node);
    let case resolver::Type::Slice { item, mutable, .. } = sliceTy
        else throw LowerError::ExpectedSliceOrArray;
    // Build the string data value.
    let ptr = try! alloc::alloc(
        &mut *self.low.arena, @sizeOf(il::DataValue), @alignOf(il::DataValue)
        self.low.arena, @sizeOf(il::DataValue), @alignOf(il::DataValue)
    ) as *mut il::DataValue;

    set *ptr = il::DataValue { item: il::DataItem::Str(s), count: 1 };
    let result = ConstDataResult { values: @sliceOf(ptr, 1), zeroInit: false };


        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: *mut [*ast::Node]) -> il::Val throws (LowerError) {
unsafe fn lowerBuiltinCall(self: &mut FnLowerer, node: *ast::Node, kind: ast::Builtin, args: *[*ast::Node]) -> il::Val throws (LowerError) {
    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 {
            let constVal = resolver::constValueEntry(self.low.resolver, node) else {
                throw LowerError::MissingConst(node);
            };
            return try constValueToVal(self, constVal, node);
        }
    }
}

/// Lower a `@sliceOf(ptr, len)` or `@sliceOf(ptr, len, cap)` builtin call.
unsafe fn lowerSliceOf(self: &mut FnLowerer, node: *ast::Node, args: *mut [*ast::Node]) -> il::Val throws (LowerError) {
unsafe fn lowerSliceOf(self: &mut FnLowerer, node: *ast::Node, args: *[*ast::Node]) -> il::Val throws (LowerError) {
    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

    // 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 callNodeExtra = resolver::nodeData(&*self.low.resolver, t.expr).extra;
    let callNodeExtra = resolver::nodeData(self.low.resolver, t.expr).extra;
    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);
        set resVal = try lowerMethodCall(self, t.expr, callExpr, method);
    } else {
        set resVal = try lowerCall(self, t.expr, callExpr);
    }
    let base = emitValToReg(self, resVal); // The result value.
    let tagReg = resultTagReg(self, base); // The result tag.

                let case ast::NodeValue::Ident(name) = binding.value else {
                    throw LowerError::ExpectedIdentifier;
                };
                let errTy = *calleeInfo.throwList[0];
                let errVal = tvalPayloadVal(self, base, errTy, RESULT_VAL_OFFSET);
                let _ = newVar(self, name, ilType(&mut *self.low, errTy), false, errVal);
                let _ = newVar(self, name, ilType(self.low, errTy), false, errVal);
            }
            try lowerBlock(self, first.body);
            try emitMergeIfUnterminated(self, &mut mergeBlock);
            exitVarScope(self, savedVarsLen);
        }

/// 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,
    catches: *mut [*ast::Node],
    catches: *[*ast::Node],
    calleeInfo: *resolver::FnType,
    base: il::Reg,
    tagReg: il::Reg,
    mergeBlock: &mut ?BlockId
) throws (LowerError) {
    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;
    let mut cases: *mut [il::SwitchCase] = &mut [];
    let mut cases: *unsafe mut [il::SwitchCase] = &mut [];
    let mut defaultIdx: ?u32 = nil;

    for clauseNode, i in catches {
        let case ast::NodeValue::CatchClause(clause) = clauseNode.value
            else panic "lowerMultiCatch: expected CatchClause";

        if let typeNode = clause.typeNode {
            let errTy = try typeOf(self, typeNode);
            set errTypes[i] = errTy;

            cases.append(il::SwitchCase {
                value: getOrAssignErrorTag(&mut *self.low, errTy) as i64,
                value: getOrAssignErrorTag(self.low, errTy) as i64,
                target: *blocks[i],
                args: &mut []
            }, self.allocator);
        } else {
            set errTypes[i] = nil;

                throw LowerError::ExpectedIdentifier;
            };
            let errTy = errTypes[i] else panic "lowerMultiCatch: catch-all with binding";
            let errVal = tvalPayloadVal(self, base, errTy, RESULT_VAL_OFFSET);

            newVar(self, name, ilType(&mut *self.low, errTy), false, errVal);
            newVar(self, name, ilType(self.low, errTy), false, errVal);
        }
        try lowerBlock(self, clause.body);
        try emitMergeIfUnterminated(self, mergeBlock);

        exitVarScope(self, savedVarsLen);

    emitStoreW32At(self, newLen, sliceReg, SLICE_LEN_OFFSET);
}

/// 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) {
    let nodeData = resolver::nodeData(&*self.low.resolver, node).extra;
    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);
    }

    if let case resolver::NodeExtra::TraitMethodCall { traitInfo, methodIndex } = nodeData {
        return try lowerTraitMethodCall(self, node, call, traitInfo, methodIndex);
    }
    // Check for standalone method call.
    if let case resolver::NodeExtra::MethodCall { method } = nodeData {
        return try lowerMethodCall(self, node, call, &*method);
        return try lowerMethodCall(self, node, call, method);
    }
    if let sym = resolver::nodeData(&*self.low.resolver, call.callee).sym {
    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;
            };
            return try lowerRecordCtor(self, nominal, call.args);

///
unsafe fn lowerTraitMethodCall(
    self: &mut FnLowerer,
    node: *ast::Node,
    call: ast::Call,
    traitInfo: *resolver::TraitType,
    traitInfo: *unsafe resolver::TraitType,
    methodIndex: u32
) -> il::Val throws (LowerError) {
    // Method calls look like field accesses.
    let case ast::NodeValue::FieldAccess(access) = call.callee.value
        else throw LowerError::MissingMetadata;

/// return parameter; that slot is filled by this function.
unsafe fn emitCallValue(
    self: &mut FnLowerer,
    callee: il::Val,
    fnInfo: *resolver::FnType,
    args: *mut [il::Val],
    args: *unsafe mut [il::Val],
) -> il::Val throws (LowerError) {
    let retTy = *fnInfo.returnType;

    if requiresReturnParam(fnInfo) {
        if fnInfo.throwList.len > 0 {

    let mut dst: ?il::Reg = nil;
    if retTy <> resolver::Type::Void {
        set dst = nextReg(self);
    }
    emit(self, il::Instr::Call {
        retTy: ilType(&mut *self.low, retTy),
        retTy: ilType(self.low, retTy),
        dst,
        func: callee,
        args,
    });


    let val = try lowerExpr(self, parent);
    if isAggregateType(parentTy) {
        return val;
    }
    // Scalar value: store to a stack slot and return the slot pointer.
    let layout = resolver::getLayout(&*self.low.resolver, parent, parentTy);
    let layout = resolver::getLayout(self.low.resolver, parent, parentTy);
    let slot = emitReserveLayout(self, layout);
    try emitStore(self, slot, 0, parentTy, val);

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


    // Get the receiver as a pointer.
    let parentTy = try typeOf(self, access.parent);
    let receiverVal = try lowerReceiver(self, access.parent, parentTy);

    let qualName = instanceMethodName(&mut *self.low, nil, method.concreteTypeName, method.name);
    let qualName = instanceMethodName(self.low, nil, method.concreteTypeName, method.name);
    let case resolver::SymbolData::Value { type: resolver::Type::Fn(fnInfo), .. } = method.symbol.data
        else panic "lowerMethodCall: expected Fn type on method symbol";

    // Build args: optional return param slot + receiver + user args.
    let argOffset: u32 = 1 if requiresReturnParam(fnInfo) else 0;

}

/// 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) {
    // Get the callee symbol and check if it's marked as an intrinsic.
    let sym = resolver::nodeData(&*self.low.resolver, call.callee).sym else {
    let sym = resolver::nodeData(self.low.resolver, call.callee).sym else {
        // Expressions or function pointers may not have an associated symbol.
        return nil;
    };
    if not ast::hasAttribute(sym.attrs, ast::Attribute::Intrinsic) {
        return nil;


/// 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) {
    if let sym = resolver::nodeData(&*self.low.resolver, callee).sym {
    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(&mut *self.low, sym) {
            if let qualName = lookupFnSym(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 {
            let modId = resolver::moduleIdForSymbol(self.low.resolver, sym) else {
                throw LowerError::MissingMetadata;
            };
            return il::Val::FnAddr(qualifyName(&mut *self.low, modId, sym.name));
            return il::Val::FnAddr(qualifyName(self.low, modId, sym.name));
        }
    }
    return try lowerExpr(self, 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) {
    let coerce = resolver::coercionFor(&*self.low.resolver, node) else {
    let coerce = resolver::coercionFor(self.low.resolver, node) else {
        return val;
    };
    match coerce {
        case resolver::Coercion::OptionalLift(optType) => {
            if let case ast::NodeValue::Nil = node.value {

        case resolver::Coercion::ResultWrap => {
            let payloadType = *self.fnType.returnType;
            return try buildResult(self, 0, val, payloadType);
        }
        case resolver::Coercion::TraitObject { traitInfo, inst } => {
            return try buildTraitObject(self, val, traitInfo, &*inst);
            return try buildTraitObject(self, val, traitInfo, inst);
        }
        case resolver::Coercion::Identity => return val,
    }
}


        return val;
    }
    // Widening: extend based on source signedness.
    // Narrowing: truncate and normalize to destination width.
    let widening = srcLayout.size < dstLayout.size;
    let extType = ilType(&mut *self.low, srcType) if widening else ilType(&mut *self.low, dstType);
    let extType = ilType(self.low, srcType) if widening else ilType(self.low, dstType);
    let signed = isSignedType(srcType) if widening else isSignedType(dstType);
    let dst = nextReg(self);

    if signed {
        emit(self, il::Instr::Sext { typ: extType, dst, val });

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

/// Lower a global value symbol.
unsafe fn lowerGlobalValue(self: &mut FnLowerer, sym: *resolver::Symbol, ty: resolver::Type) -> il::Val {
unsafe fn lowerGlobalValue(self: &mut FnLowerer, sym: *unsafe resolver::Symbol, ty: resolver::Type) -> il::Val {
    // 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));
    }

}

/// Lower an identifier that refers to a global symbol.
unsafe fn lowerGlobalSymbol(self: &mut FnLowerer, node: *ast::Node) -> il::Val throws (LowerError) {
    // First try to get a compile-time constant value.
    if let constVal = resolver::constValueEntry(&*self.low.resolver, node) {
    if let constVal = resolver::constValueEntry(self.low.resolver, node) {
        return try constValueToVal(self, constVal, node);
    }
    // Otherwise get the symbol.
    let sym = try symOf(self, node);



/// 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) {
    // First try to get a compile-time constant value.
    if let constVal = resolver::constValueEntry(&*self.low.resolver, node) {
    if let constVal = resolver::constValueEntry(self.low.resolver, node) {
        return try constValueToVal(self, constVal, node);
    }
    // Otherwise get the associated symbol.
    let data = resolver::nodeData(&*self.low.resolver, node);
    let data = resolver::nodeData(self.low.resolver, node);
    let sym = data.sym else {
        throw LowerError::MissingSymbol(node);
    };
    match sym.data {
        case resolver::SymbolData::Variant { index, .. } => {
            let mut indexValue = index as i64;
            if let idx = voidVariantIndex(&*self.low.resolver, node) {
            if let idx = voidVariantIndex(self.low.resolver, node) {
                set indexValue = idx;
            }
            // Void union variant like `Option::None`.
            if data.ty == resolver::Type::Unknown {
                throw LowerError::MissingType(node);

        case ast::NodeValue::Try(t) => {
            set val = try lowerTry(self, node, t);
        }
        case ast::NodeValue::FieldAccess(access) => {
            // Check for compile-time constant (e.g., `arr.len` on fixed-size arrays).
            if let constVal = resolver::constValueEntry(&*self.low.resolver, node) {
            if let constVal = resolver::constValueEntry(self.low.resolver, node) {
                match constVal {
                    // TODO: Handle `u32` values that don't fit in an `i32`.
                    //       Perhaps just store the `ConstInt`.
                    case resolver::ConstValue::Int(i) => set val = il::Val::Imm(constIntToI64(i)),
                    else => set val = try lowerFieldAccess(self, access),

            set val = il::Val::Undef;
        }
        // Lower these as statements.
        case ast::NodeValue::ConstDecl(decl) => {
            try registerLocalDataDeclName(self, node);
            try lowerDataDecl(&mut *self.low, node, decl.value, true);
            try lowerDataDecl(self.low, node, decl.value, true);
            set val = il::Val::Undef;
        }
        case ast::NodeValue::StaticDecl(decl) => {
            try registerLocalDataDeclName(self, node);
            try lowerDataDecl(&mut *self.low, node, decl.value, false);
            try lowerDataDecl(self.low, node, decl.value, false);
            set val = il::Val::Undef;
        }
        case ast::NodeValue::Throw { .. },
             ast::NodeValue::Return { .. },
             ast::NodeValue::Continue,

/// 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).
fn ilType(self: &mut Lowerer, typ: resolver::Type) -> il::Type {
unsafe fn ilType(self: &mut Lowerer, typ: resolver::Type) -> il::Type {
    match typ {
        case resolver::Type::Bool,
             resolver::Type::I8,
             resolver::Type::U8 => return il::Type::W8,
        case resolver::Type::I16,

lib/std/lang/module.rad +18 -22

    /// Child module identifiers declared directly inside this module.
    children: [u16; MAX_MODULES],
    /// Number of entries stored in `children`.
    childrenLen: u32,
    /// Parsed AST root for this module when available.
    ast: ?*mut ast::Node,
    ast: ?*ast::Node,
    /// Source text for this module (for error reporting).
    source: ?*[u8],
}

/// Dense storage for all modules referenced by the compilation unit.
export record ModuleGraph: Copy {
export record ModuleGraph {
    /// Permanent storage for module entries.
    entries: *mut [ModuleEntry],
    /// Number of initialized entries.
    entriesLen: u32,
    /// Permanent storage for interned names.
    pool: *mut strings::Pool,
    /// AST arena. It must outlive the graph.
    arena: ?*unsafe ast::NodeArena,
}

/// Initialize an empty module graph backed by the provided storage.
/// The AST arena must outlive the returned graph.
export unsafe fn moduleGraph(
    storage: *mut [ModuleEntry],
    pool: *mut strings::Pool,
    arena: &mut ast::NodeArena
) -> ModuleGraph {
    return ModuleGraph {
        entries: storage,
        entriesLen: 0,
        pool,
        arena: arena as *unsafe ast::NodeArena,
    };
}

/// Register a root module residing at `path` for a package.
export fn registerRoot(graph: &mut ModuleGraph, packageId: u16, filePath: *[u8]) -> u16 throws (ModuleError) {
export 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, packageId, name, 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(
    graph: &mut ModuleGraph,
    graph: &mut ModuleGraph, pool: &mut strings::Pool,
    packageId: u16,
    name: *[u8],
    filePath: *[u8]
) -> u16 throws (ModuleError) {
    let m = try allocModule(graph, packageId, name, filePath);
    try appendPathSegment(m, m.name);
    let m = try allocModule(graph, pool, packageId, name, filePath);
    try appendPathSegment(m, name);

    set m.state = ModuleState::Registered;

    return m.id;
}

/// Register a child module.
/// Returns the module identifier.
export fn registerChild(
    graph: &mut ModuleGraph,
    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";

    // 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, parent.packageId, name, filePath);
    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, m.name);
    try appendPathSegment(m, name);

    return try addChild(parent, m.id);
}

/// Fetch a read-only view of the module identified by `id`.

    };
    return m.state;
}

/// Record the parsed AST root for `id`.
export fn setAst(graph: &mut ModuleGraph, id: u16, root: *mut ast::Node) throws (ModuleError) {
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;
}



/// 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, packageId: u16, rootId: ?u16, filePath: *[u8]) -> u16 throws (ModuleError) {
export 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, packageId, filePath);
        return try registerRoot(graph, pool, packageId, filePath);
    };
    let rootEntry = get(graph, root) else {
        panic "registerFromPath: root is missing from storage";
    };


        let child = findChild(graph, part, parentId) else {
            throw ModuleError::MissingParent;
        };
        set parentId = child.id;
    }
    return try registerChild(graph, parentId, childName, filePath);
    return try registerChild(graph, pool, parentId, childName, filePath);
}

/// Allocate a fresh entry in the graph.
fn allocModule(graph: &mut ModuleGraph, packageId: u16, name: *[u8], filePath: *[u8]) -> *mut ModuleEntry throws (ModuleError) {
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;

        id: idx as u16,
        packageId,
        parent: nil,
        filePath,
        dirLen: 0,
        name: strings::intern(graph.pool, name),
        name: strings::intern(pool, name),
        path: [""; MAX_MODULE_PATH_DEPTH],
        pathDepth: 0,
        state: ModuleState::Vacant,
        children: [0; MAX_MODULES],
        childrenLen: 0,


    return m;
}

/// Append a logical path segment (module identifier) to the entry.
fn appendPathSegment(entry: *mut ModuleEntry, segment: *[u8]) throws (ModuleError) {
fn appendPathSegment(entry: &mut ModuleEntry, segment: *[u8]) throws (ModuleError) {
    if entry.pathDepth >= entry.path.len {
        throw ModuleError::PathTooDeep;
    }
    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) {
fn addChild(parent: &mut ModuleEntry, childId: u16) -> u16 throws (ModuleError) {
    if parent.childrenLen >= parent.children.len {
        throw ModuleError::CapacityExceeded;
    }
    set parent.children[parent.childrenLen] = childId;
    set parent.childrenLen += 1;

lib/std/lang/module/tests.rad +24 -24

}

@test unsafe fn testRegisterChildren() throws (testing::TestError) {
    static storage: [super::ModuleEntry; 4] = undefined;
    let mut arena = ast::nodeArena(&mut TEST_ARENA[..]);
    let mut graph = super::moduleGraph(&mut storage[..], &mut STRING_POOL, &mut arena);
    let mut graph = super::moduleGraph(&mut storage[..], &mut arena);

    let rootId = try super::registerFromPath(&mut graph, 0, nil, "src/root.rad") catch {
    let rootId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, nil, "src/root.rad") catch {
        throw testing::TestError::Failed;
    };
    let root = super::get(&graph, rootId) else {
        throw testing::TestError::Failed;
    };
    try expectPathSegments(root, &["root"]);

    // First child.
    let firstId = try super::registerFromPath(&mut graph, 0, rootId, "src/root/first.rad") catch {
    let firstId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, rootId, "src/root/first.rad") catch {
        throw testing::TestError::Failed;
    };
    let first = super::get(&graph, firstId) else {
        throw testing::TestError::Failed;
    };
    try expectSliceEq(first.filePath, "src/root/first.rad");
    try expectSliceEq(first.name, "first");
    try expectPathSegments(first, &["root", "first"]);

    // Second child.
    let secondId = try super::registerFromPath(&mut graph, 0, rootId, "src/root/second.rad") catch {
    let secondId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, rootId, "src/root/second.rad") catch {
        throw testing::TestError::Failed;
    };
    let second = super::get(&graph, secondId) else {
        throw testing::TestError::Failed;
    };

}

@test unsafe fn testRegisterChildReusesExisting() throws (testing::TestError) {
    static storage: [super::ModuleEntry; 4] = undefined;
    let mut arena = ast::nodeArena(&mut TEST_ARENA[..]);
    let mut graph = super::moduleGraph(&mut storage[..], &mut STRING_POOL, &mut arena);
    let mut graph = super::moduleGraph(&mut storage[..], &mut arena);

    let rootId = try super::registerFromPath(&mut graph, 0, nil, "src/main.rad") catch {
    let rootId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, nil, "src/main.rad") catch {
        throw testing::TestError::Failed;
    };
    let firstId = try super::registerFromPath(&mut graph, 0, rootId, "src/main/util.rad") catch {
    let firstId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, rootId, "src/main/util.rad") catch {
        throw testing::TestError::Failed;
    };
    let secondId = try super::registerFromPath(&mut graph, 0, rootId, "src/main/util.rad") catch {
    let secondId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, rootId, "src/main/util.rad") catch {
        throw testing::TestError::Failed;
    };
    try testing::expect(firstId == secondId);

    let parent = super::get(&graph, rootId) else {

}

@test unsafe fn testRegisterFromPathHierarchy() throws (testing::TestError) {
    static storage: [super::ModuleEntry; 8] = undefined;
    let mut arena = ast::nodeArena(&mut TEST_ARENA[..]);
    let mut graph = super::moduleGraph(&mut storage[..], &mut STRING_POOL, &mut arena);
    let mut graph = super::moduleGraph(&mut storage[..], &mut arena);

    // Register root module.
    let stdId = try super::registerFromPath(&mut graph, 0, nil, "lib/std.rad") catch {
    let stdId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, nil, "lib/std.rad") catch {
        throw testing::TestError::Failed;
    };
    let std = super::get(&graph, stdId) else {
        throw testing::TestError::Failed;
    };
    try expectSliceEq(std.filePath, "lib/std.rad");
    try expectSliceEq(super::moduleDir(std), "lib/");
    try expectPathSegments(std, &["std"]);

    // Register child of root.
    let langId = try super::registerFromPath(&mut graph, 0, stdId, "lib/std/lang.rad") catch {
    let langId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, stdId, "lib/std/lang.rad") catch {
        throw testing::TestError::Failed;
    };
    let lang = super::get(&graph, langId) else {
        throw testing::TestError::Failed;
    };

    try expectSliceEq(lang.name, "lang");
    try expectSliceEq(super::moduleDir(lang), "lib/std/");
    try expectPathSegments(lang, &["std", "lang"]);

    // Register grandchild.
    let parserId = try super::registerFromPath(&mut graph, 0, stdId, "lib/std/lang/parser.rad") catch {
    let parserId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, stdId, "lib/std/lang/parser.rad") catch {
        throw testing::TestError::Failed;
    };
    let parser = super::get(&graph, parserId) else {
        throw testing::TestError::Failed;
    };

}

@test unsafe fn testRegisterFromPathMissingParent() throws (testing::TestError) {
    static storage: [super::ModuleEntry; 8] = undefined;
    let mut arena = ast::nodeArena(&mut TEST_ARENA[..]);
    let mut graph = super::moduleGraph(&mut storage[..], &mut STRING_POOL, &mut arena);
    let mut graph = super::moduleGraph(&mut storage[..], &mut arena);

    let rootId = try super::registerFromPath(&mut graph, 0, nil, "std.rad") catch {
    let rootId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, nil, "std.rad") catch {
        throw testing::TestError::Failed;
    };
    let _ = try super::registerFromPath(&mut graph, 0, rootId, "std/lang/parser.rad") catch {
    let _ = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, rootId, "std/lang/parser.rad") catch {
        // Expected to fail due to missing intermediate parent.
        return;
    };
    throw testing::TestError::Failed;
}

@test unsafe fn testRegisterFromPathDuplicateRoot() throws (testing::TestError) {
    static storage: [super::ModuleEntry; 8] = undefined;
    let mut arena = ast::nodeArena(&mut TEST_ARENA[..]);
    let mut graph = super::moduleGraph(&mut storage[..], &mut STRING_POOL, &mut arena);
    let mut graph = super::moduleGraph(&mut storage[..], &mut arena);

    let rootId = try super::registerFromPath(&mut graph, 0, nil, "std.rad") catch {
    let rootId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, nil, "std.rad") catch {
        throw testing::TestError::Failed;
    };
    let _ = try super::registerFromPath(&mut graph, 0, rootId, "parser.rad") catch {
    let _ = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, rootId, "parser.rad") catch {
        // Expected to fail due to missing intermediate parent.
        return;
    };
    throw testing::TestError::Failed;
}

@test unsafe fn testRegisterFromPathRegistersRoot() throws (testing::TestError) {
    static storage: [super::ModuleEntry; 8] = undefined;
    let mut arena = ast::nodeArena(&mut TEST_ARENA[..]);
    let mut graph = super::moduleGraph(&mut storage[..], &mut STRING_POOL, &mut arena);
    let mut graph = super::moduleGraph(&mut storage[..], &mut arena);

    let rootId = try super::registerFromPath(&mut graph, 0, nil, "lib/std.rad") catch {
    let rootId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, nil, "lib/std.rad") catch {
        throw testing::TestError::Failed;
    };
    // Verify root module was registered with correct ID.
    try testing::expect(rootId == 0);


}

@test unsafe fn testRegisterFromPathIgnoresLeadingDirectories() throws (testing::TestError) {
    static storage: [super::ModuleEntry; 8] = undefined;
    let mut arena = ast::nodeArena(&mut TEST_ARENA[..]);
    let mut graph = super::moduleGraph(&mut storage[..], &mut STRING_POOL, &mut arena);
    let mut graph = super::moduleGraph(&mut storage[..], &mut arena);

    let rootId = try super::registerFromPath(&mut graph, 0, nil, "src/pkg/root.rad") catch {
    let rootId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, nil, "src/pkg/root.rad") catch {
        throw testing::TestError::Failed;
    };
    // Verify root module was registered with correct ID.
    try testing::expect(rootId == 0);

    let langId = try super::registerFromPath(&mut graph, 0, rootId, "src/pkg/root/lang.rad") catch {
    let langId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, rootId, "src/pkg/root/lang.rad") catch {
        throw testing::TestError::Failed;
    };
    let lang = super::get(&graph, langId) else {
        throw testing::TestError::Failed;
    };
    try expectSliceEq(lang.name, "lang");
    try expectPathSegments(lang, &["root", "lang"]);

    let parserId = try super::registerFromPath(&mut graph, 0, rootId, "src/pkg/root/lang/parser.rad") catch {
    let parserId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, rootId, "src/pkg/root/lang/parser.rad") catch {
        throw testing::TestError::Failed;
    };
    let parser = super::get(&graph, parserId) else {
        throw testing::TestError::Failed;
    };

lib/std/lang/package.rad +3 -3

/// Initialize `pkg` with the provided name and ID.
export fn init(
    pkg: &mut Package,
    id: u16,
    name: *[u8],
    pool: *mut strings::Pool
    pool: &mut strings::Pool
) {
    set pkg.id = id;
    set pkg.name = strings::intern(pool, name);
    set pkg.rootModuleId = nil;

}

/// Register a module described by the file path.
export fn registerModule(pkg: &mut Package, graph: &mut module::ModuleGraph, filePath: *[u8]) -> u16
export 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, pkg.id, pkg.rootModuleId, filePath);
    let modId = try module::registerFromPath(graph, pool, pkg.id, pkg.rootModuleId, filePath);
    // First registered module becomes the root.
    if pkg.rootModuleId == nil {
        set pkg.rootModuleId = modId;
    }
    return modId;

lib/std/lang/parser.rad +37 -41

    /// Current parsing context (normal or conditional).
    context: Context,
}

/// Create a new parser initialized with the given source kind, source and node arena.
/// The node arena must outlive the returned parser.
export unsafe fn mkParser(sourceLoc: scanner::SourceLoc, source: *[u8], arena: &mut ast::NodeArena, pool: *mut strings::Pool) -> Parser {
/// The node arena and string pool must outlive every copy of the parser.
export unsafe fn mkParser(sourceLoc: scanner::SourceLoc, source: *[u8], arena: &mut ast::NodeArena, pool: *unsafe mut strings::Pool) -> Parser {
    return Parser {
        scanner: scanner::scanner(sourceLoc, source, pool),
        current: scanner::invalid(0, ""),
        previous: scanner::invalid(0, ""),
        errors: ErrorList { list: undefined, count: 0 },
        arena: arena as *unsafe mut ast::NodeArena,
        arena: (&mut *arena) as *unsafe mut ast::NodeArena,
        allocator: alloc::arenaAllocator(&mut arena.arena),
        context: Context::Normal,
    };
}


        return node(p, ast::NodeValue::ArrayRepeatLit(
            ast::ArrayRepeatLit { item: firstExpr, count }
        ));
    }
    // Regular array literal: `[a, b, ...]`.
    let mut items = ast::nodeSlice(&mut *p.arena, 64).append(firstExpr, p.allocator);
    let mut items = ast::nodeSlice(p.arena, 64).append(firstExpr, p.allocator);

    while consume(p, scanner::TokenKind::Comma) and not check(p, scanner::TokenKind::RBracket) {
        let elem = try parseNormalExpr(p);
        items.append(elem, p.allocator);
    }

    }
    try expect(p, scanner::TokenKind::LParen, "expected `(` after builtin name");

    // Parse arguments into a list. Use capacity 4 to handle any valid argument count
    // plus some extra for error recovery.
    let mut args = ast::nodeSlice(&mut *p.arena, 4);
    let mut args = ast::nodeSlice(p.arena, 4);

    if kind == ast::Builtin::SliceOf {
        // Parse comma-separated expressions until closing paren.
        // Argument count validation is done in semantic analysis.
        while not check(p, scanner::TokenKind::RParen) {

    let expr = try parseBinary(p, left, -1);
    return try parseCondExpr(p, expr);
}

/// Try to consume a compound assignment operator and return its binary op.
fn tryCompoundAssignOp(p: &mut Parser) -> ?ast::BinaryOp {
unsafe fn tryCompoundAssignOp(p: &mut Parser) -> ?ast::BinaryOp {
    match p.current.kind {
        case scanner::TokenKind::PlusEqual =>    { advance(p); return ast::BinaryOp::Add; }
        case scanner::TokenKind::MinusEqual =>   { advance(p); return ast::BinaryOp::Sub; }
        case scanner::TokenKind::StarEqual =>    { advance(p); return ast::BinaryOp::Mul; }
        case scanner::TokenKind::SlashEqual =>   { advance(p); return ast::BinaryOp::Div; }

    throw failParsing(p, "expected assignment after `set`");
}

/// Parse leading attributes and declaration modifiers.
unsafe fn parseAttributes(p: &mut Parser) -> ?ast::Attributes {
    let mut attrs = ast::nodeSlice(&mut *p.arena, 4);
    let mut attrs = ast::nodeSlice(p.arena, 4);

    if let attr = tryParseAnnotation(p) {
        attrs.append(attr, p.allocator);
    }
    if consume(p, scanner::TokenKind::Export) {

unsafe fn tryParseAnnotation(p: &mut Parser) -> ?*ast::Node {
    if not check(p, scanner::TokenKind::AtIdent) {
        return nil;
    }
    // Token is @identifier, skip the '@' to get the name.
    let ident = &p.current.source[..];
    let ident = p.current.source;
    if ident == "@default" {
        advance(p); // Consume `@default`.
        return nodeAttribute(p, ast::Attribute::Default);
    }
    if ident == "@test" {

    }
}

/// Parse statements until the specified ending token is encountered.
///
/// Adds each parsed statement to the given block's statement list.
export unsafe fn parseStmtsUntil(p: &mut Parser, end: scanner::TokenKind, blk: &mut ast::Block)
/// Returns the completed immutable statement list.
export unsafe fn parseStmtsUntil(p: &mut Parser, end: scanner::TokenKind, capacity: u32) -> *[*ast::Node]
    throws (ParseError)
{
    let mut statements = ast::nodeSlice(p.arena, capacity);
    while not check(p, end) {
        let stmt = try parseStmt(p);
        blk.statements.append(stmt, p.allocator);
        statements.append(stmt, p.allocator);

        if check(p, end) or check(p, scanner::TokenKind::Eof) {
            break;
        }
        if not consume(p, scanner::TokenKind::Semicolon) {

            if expectsSemicolon(stmt) {
                throw failParsing(p, "expected `;` after statement");
            }
        }
    }
    return statements;
}

/// Parse a block of statements enclosed in curly braces.
export unsafe fn parseBlock(p: &mut Parser) -> *ast::Node
    throws (ParseError)

/// Parse a statement block with the specified unsafe permission.
unsafe fn parseBlockBody(p: &mut Parser, isUnsafe: bool) -> *ast::Node
    throws (ParseError)
{
    let start = p.current;
    let mut blk = mkBlock(p, 64);
    set blk.isUnsafe = isUnsafe;

    if not consume(p, scanner::TokenKind::LBrace) {
        throw failParsing(p, "expected `{`");
    }
    try parseStmtsUntil(p, scanner::TokenKind::RBrace, &mut blk);
    let statements = try parseStmtsUntil(p, scanner::TokenKind::RBrace, 64);
    let blk = ast::Block { statements, isUnsafe };
    try expect(p, scanner::TokenKind::RBrace, "expected `}`");

    return node(p, ast::NodeValue::Block(blk));
}

/// Create an empty block with no statements.
unsafe fn mkBlock(p: &mut Parser, cap: u32) -> ast::Block {
    return ast::Block { statements: ast::nodeSlice(&mut *p.arena, cap), isUnsafe: false };
}

/// Create a block containing a single statement node.
unsafe fn mkBlockWith(p: &mut Parser, node: *ast::Node) -> ast::Block {
    let stmts = ast::nodeSlice(&mut *p.arena, 1).append(node, p.allocator);
    let stmts = ast::nodeSlice(p.arena, 1).append(node, p.allocator);
    return ast::Block { statements: stmts, isUnsafe: false };
}

/// Parse the branch that follows `else` in let-else style constructs.
///

unsafe fn node(p: &mut Parser, value: ast::NodeValue) -> *mut ast::Node {
    let span = ast::Span {
        offset: p.previous.offset,
        length: p.previous.source.len,
    };
    let n = ast::allocNode(&mut *p.arena, span, value);
    let n = ast::allocNode(p.arena, span, value);
    finishSpan(p, n);

    return n;
}

/// Update the span of `node` using the most recently consumed token.
fn finishSpan(p: &mut Parser, node: *mut ast::Node) {
fn finishSpan(p: &mut Parser, node: &mut ast::Node) {
    let start: u32 = node.span.offset;
    let mut end: u32 = p.previous.offset + p.previous.source.len;

    if end >= start {
        set node.span.length = end - start;

export fn check(p: &Parser, kind: scanner::TokenKind) -> bool {
    return p.current.kind == kind;
}

/// Advance the parser by one token.
export fn advance(p: &mut Parser) {
export unsafe fn advance(p: &mut Parser) {
    set p.previous = p.current;
    set p.current = scanner::next(&mut p.scanner);
}

/// Parse an `if let` pattern matching statement.

    try expect(p, scanner::TokenKind::Try, "expected `try`");

    let shouldPanic = consume(p, scanner::TokenKind::Bang);
    let returnsOptional = consume(p, scanner::TokenKind::Question);
    let expr = try parseUnaryExpr(p);
    let mut catches = ast::nodeSlice(&mut *p.arena, 4);
    let mut catches = ast::nodeSlice(p.arena, 4);

    while consume(p, scanner::TokenKind::Catch) {
        let mut binding: ?*ast::Node = nil;
        let mut typeNode: ?*ast::Node = nil;


    try expect(p, scanner::TokenKind::Match, "expected `match`");

    let subject = try parseCond(p);
    try expect(p, scanner::TokenKind::LBrace, "expected `{` before match prongs");

    let mut prongs = ast::nodeSlice(&mut *p.arena, 128);
    let mut prongs = ast::nodeSlice(p.arena, 128);
    while not check(p, scanner::TokenKind::RBrace) and
          not check(p, scanner::TokenKind::Eof) // TODO: We shouldn't have to manually check for EOF.
    {
        let prongNode = try parseMatchProng(p);
        prongs.append(prongNode, p.allocator);

{
    let mut guard: ?*ast::Node = nil;

    // Case prong: `case <pattern>, ... if <guard> => <body>`.
    if consume(p, scanner::TokenKind::Case) {
        let mut patterns = ast::nodeSlice(&mut *p.arena, 16);
        let mut patterns = ast::nodeSlice(p.arena, 16);
        loop {
            let pattern = try parseMatchPattern(p);
            patterns.append(pattern, p.allocator);

            if not consume(p, scanner::TokenKind::Comma) {

) -> *mut [*ast::Node]
    throws (ParseError)
{
    let terminator = scanner::TokenKind::RBrace if mode == RecordFieldMode::Labeled
        else scanner::TokenKind::RParen;
    let mut fields = ast::nodeSlice(&mut *p.arena, MAX_RECORD_FIELDS);
    let mut fields = ast::nodeSlice(p.arena, MAX_RECORD_FIELDS);
    while not check(p, terminator) {
        let mut recordField: ast::NodeValue = undefined;
        match mode {
            case RecordFieldMode::Labeled => {
                // Allow optional `let` keyword before field name.

    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(&mut *p.arena, 4);
    let mut derives = ast::nodeSlice(p.arena, 4);

    if not consume(p, scanner::TokenKind::Colon) {
        return derives;
    }
    loop {

/// Eg. `{ x: 1, y: 2 }`
/// Eg. `{ x: 1, .. }`
unsafe fn parseRecordLit(p: &mut Parser, typeName: ?*ast::Node) -> *ast::Node
    throws (ParseError)
{
    let mut fields = ast::nodeSlice(&mut *p.arena, MAX_RECORD_FIELDS);
    let mut fields = ast::nodeSlice(p.arena, MAX_RECORD_FIELDS);
    let mut ignoreRest = false;
    try expect(p, scanner::TokenKind::LBrace, "expected `{` to begin record literal");

    while not check(p, scanner::TokenKind::RBrace) {
        // Check for `..` to ignore remaining fields.

    let name = try parseIdent(p, "expected union name");
    let derives = try parseDerives(p);

    try expect(p, scanner::TokenKind::LBrace, "expected `{` before union body");

    let mut variants = ast::nodeSlice(&mut *p.arena, 128);
    let mut variants = ast::nodeSlice(p.arena, 128);
    while not check(p, scanner::TokenKind::RBrace) {
        // Allow optional `case` keyword before variant name.
        consume(p, scanner::TokenKind::Case);

        let variantName = try parseIdent(p, "expected variant name");

/// Parse an optional `throws` clause and return the collected type list.
unsafe fn parseThrowList(p: &mut Parser) -> *mut [*ast::Node]
    throws (ParseError)
{
    if not consume(p, scanner::TokenKind::Throws) {
        return ast::nodeSlice(&mut *p.arena, 0);
        return ast::nodeSlice(p.arena, 0);
    }
    return try parseList(
        p,
        scanner::TokenKind::LParen,
        scanner::TokenKind::RParen,

/// Parse a function signature following the function name.
unsafe fn parseFnTypeSig(p: &mut Parser) -> ast::FnSig
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::LParen, "expected `(` after function name");
    let mut params = ast::nodeSlice(&mut *p.arena, 8);
    let mut params = ast::nodeSlice(p.arena, 8);

    while not check(p, scanner::TokenKind::RParen) {
        let param = try parseFnParam(p);
        params.append(param, p.allocator);



    if consume(p, scanner::TokenKind::Semicolon) {
        if let a = attrs; ast::attributesContains(&a, ast::Attribute::Extern) {
            // Keep existing attributes unchanged.
        } else {
            let mut list = ast::nodeSlice(&mut *p.arena, 4);
            let mut list = ast::nodeSlice(p.arena, 4);
            if let a = attrs {
                for i in 0..a.list.len {
                    list.append(a.list[i], p.allocator);
                }
            }

        ident: binding.name, type: binding.type, value, alignment: binding.alignment, mutable,
    }));
}

/// Parse a module from source text using the provided arena for node storage.
export unsafe fn parse(sourceLoc: scanner::SourceLoc, input: *[u8], arena: &mut ast::NodeArena, pool: *mut strings::Pool) -> *mut ast::Node
export unsafe fn parse(sourceLoc: scanner::SourceLoc, input: *[u8], arena: &mut ast::NodeArena, pool: *unsafe mut strings::Pool) -> *mut ast::Node
    throws (ParseError)
{
    let mut p = mkParser(sourceLoc, input, arena, pool);
    return try parseModule(&mut p) catch {
        printErrors(&p);

export unsafe fn parseModule(p: &mut Parser) -> *mut ast::Node
    throws (ParseError)
{
    advance(p); // Set the parser up with a first token.

    let mut blk = mkBlock(p, 512);
    try parseStmtsUntil(p, scanner::TokenKind::Eof, &mut blk);
    let statements = try parseStmtsUntil(p, scanner::TokenKind::Eof, 512);
    let blk = ast::Block { statements, isUnsafe: false };
    consume(p, scanner::TokenKind::Eof);

    return node(p, ast::NodeValue::Block(blk));
}

/// Consume a token of the given kind if present.
export fn consume(p: &mut Parser, kind: scanner::TokenKind) -> bool {
export unsafe fn consume(p: &mut Parser, kind: scanner::TokenKind) -> bool {
    if check(p, kind) {
        advance(p);
        return true;
    }
    return false;
}

/// Expect a token of the given kind or report an error.
export fn expect(p: &mut Parser, kind: scanner::TokenKind, message: *[u8]) -> *[u8]
export unsafe fn expect(p: &mut Parser, kind: scanner::TokenKind, message: *[u8]) -> *[u8]
    throws (ParseError)
{
    if not consume(p, kind) {
        let token = p.current;
        reportError(p, token, message);

    try expect(p, scanner::TokenKind::Trait, "expected `trait`");
    let name = try parseIdent(p, "expected trait name");
    let supertraits = try parseDerives(p);
    try expect(p, scanner::TokenKind::LBrace, "expected `{` after trait name");

    let mut methods = ast::nodeSlice(&mut *p.arena, ast::MAX_TRAIT_METHODS);
    let mut methods = ast::nodeSlice(p.arena, ast::MAX_TRAIT_METHODS);
    while not check(p, scanner::TokenKind::RBrace) and
          not check(p, scanner::TokenKind::Eof)
    {
        let method = try parseTraitMethodSig(p);
        methods.append(method, p.allocator);

    let traitName = try parseTypePath(p);
    try expect(p, scanner::TokenKind::For, "expected `for` after trait name");
    let targetType = try parseTypePath(p);
    try expect(p, scanner::TokenKind::LBrace, "expected `{` after target type");

    let mut methods = ast::nodeSlice(&mut *p.arena, ast::MAX_TRAIT_METHODS);
    let mut methods = ast::nodeSlice(p.arena, ast::MAX_TRAIT_METHODS);

    while not check(p, scanner::TokenKind::RBrace) and
          not check(p, scanner::TokenKind::Eof)
    {
        let attrs = parseAttributes(p);

    open: scanner::TokenKind,
    close: scanner::TokenKind,
    parseItem: unsafe fn (&mut Parser) -> *ast::Node throws (ParseError)
) -> *mut [*ast::Node] throws (ParseError) {
    try expect(p, open, listExpectMessage(open));
    let mut items = ast::nodeSlice(&mut *p.arena, 8);
    let mut items = ast::nodeSlice(p.arena, 8);

    while not check(p, close) {
        let item = try parseItem(p);
        items.append(item, p.allocator);


lib/std/lang/parser/tests.rad +2 -2

    try testing::expect(sign == expectedSign);
}

/// Extract a union variant and verify its name and index.
/// Returns the payload's fields slice for further checking with `expectField`.
fn expectVariant(varNode: *ast::Node, name: *[u8], index: u32) -> ?*mut [*ast::Node]
fn expectVariant(varNode: *ast::Node, name: *[u8], index: u32) -> ?*[*ast::Node]
    throws (testing::TestError)
{
    let case ast::NodeValue::UnionDeclVariant(v) = varNode.value
        else throw testing::TestError::Failed;
    try expectIdent(v.name, name);

    return fields;
}

/// Check a record field has the expected name and type signature.
fn expectFieldSig(
    fields: *mut [*ast::Node], index: u32, name: ?*[u8], sig: ast::TypeSig
    fields: *[*ast::Node], index: u32, name: ?*[u8], sig: ast::TypeSig
) throws (testing::TestError) {
    let fieldNode = fields[index];
    let case ast::NodeValue::RecordField { field, type: fieldType, .. } = fieldNode.value
        else throw testing::TestError::Failed;


lib/std/lang/resolver.rad +368 -265

/// Trait definition stored in the resolver.
export record TraitType: Copy {
    /// Trait name.
    name: *[u8],
    /// Method signatures, including from supertraits.
    methods: *mut [TraitMethod],
    methods: *unsafe mut [TraitMethod],
    /// Supertraits that must also be implemented.
    supertraits: *mut [*TraitType],
    supertraits: *unsafe mut [*unsafe TraitType],
}

/// A single method signature within a trait.
export record TraitMethod: Copy {
    /// Method name.
    name: *[u8],
    /// Function type for the method, excluding the receiver.
    fnType: *mut FnType,
    fnType: *FnType,
    /// Whether the receiver is mutable.
    mutable: bool,
    /// Pointer-like class used by the receiver.
    receiverClass: types::PointerClass,
    /// V-table slot index.

}

/// An entry in the trait instance registry.
export record InstanceEntry: Copy {
    /// Trait type descriptor.
    traitType: *TraitType,
    traitType: *unsafe TraitType,
    /// Concrete type that implements the trait.
    concreteType: Type,
    /// Name of the concrete type.
    concreteTypeName: *[u8],
    /// Module where this instance was declared.
    moduleId: u16,
    /// Method symbols for each trait method, in declaration order.
    methods: *mut [*mut Symbol],
    methods: *unsafe mut [*unsafe mut Symbol],
}

/// An entry in the method registry.
export record MethodEntry: Copy {
    /// Concrete type that owns the method.

    /// Name of the concrete type.
    concreteTypeName: *[u8],
    /// Method name.
    name: *[u8],
    /// Function type excluding the receiver.
    fnType: *mut FnType,
    fnType: *FnType,
    /// Whether the receiver is mutable.
    mutable: bool,
    /// Pointer-like class used by the receiver.
    receiverClass: types::PointerClass,
    /// Symbol for the method.
    symbol: *mut Symbol,
    symbol: *unsafe mut Symbol,
}

/// Identifier for the synthetic `len` field.
export constant LEN_FIELD: *[u8] = "len";
/// Identifier for the synthetic `ptr` field.


/// Information about a union variant.
record UnionVariant: Copy {
    name: *[u8],
    valueType: Type,
    symbol: *mut Symbol,
    symbol: *unsafe mut Symbol,
}

/// Array type payload.
export record ArrayType: Copy {
    item: *Type,
    length: u32,
}

/// Record nominal type.
export record RecordType: Copy {
    fields: *[RecordField],
    fields: *unsafe [RecordField],
    labeled: bool,
    /// Cached layout.
    layout: Layout,
    /// Whether the declaration explicitly carries the `Once` marker.
    declaredLinear: bool,

    declaredCopy: bool,
}

/// Union nominal type.
export record UnionType: Copy {
    variants: *[UnionVariant],
    variants: *unsafe [UnionVariant],
    /// Cached layout.
    layout: Layout,
    /// Cached payload offset within the union aggregate.
    valOffset: u32,
    /// If all variants have void payloads.

    /// Wrap return value in success variant of result type.
    ResultWrap,
    /// Coerce a concrete pointer to a trait object.
    TraitObject {
        /// Trait type information.
        traitInfo: *TraitType,
        traitInfo: *unsafe TraitType,
        /// Instance entry for v-table lookup.
        inst: *unsafe InstanceEntry,
    },
}

/// Result of resolving a module path.
record ResolvedModule: Copy {
    /// Module entry in the graph.
    entry: *module::ModuleEntry,
    /// Scope containing the module's declarations.
    scope: *mut Scope,
    scope: *unsafe mut Scope,
}

/// Type layout.
export record Layout: Copy {
    /// Size in bytes.

    },
}

/// Resolved function signature details.
export record FnType: Copy {
    /// Parameter types in call order.
    paramTypes: *[*Type],
    /// Return value type.
    returnType: *Type,
    /// Error types that the function can throw.
    throwList: *[*Type],
    /// Whether calling this function requires an unsafe context.
    isUnsafe: bool,
    localCount: u32,
}

/// Describes a type computed during semantic analysis.
export union Type: Copy {
    /// A type that couldn't be decided.

    /// Eg. `[i32; 32]`.
    Array(ArrayType),
    /// Eg. `?T`.
    Optional(*Type),
    /// Eg. `fn id(i32) -> i32`.
    Fn(*mut FnType),
    Fn(*FnType),
    /// Named, ie. user-defined types, includes union variants.
    Nominal(*NominalType),
    Nominal(*unsafe NominalType),
    /// Owning trait object. An erased type with v-table.
    TraitObject {
        /// Ownership and safety class.
        class: types::PointerClass,
        /// Trait definition.
        traitInfo: *TraitType,
        traitInfo: *unsafe TraitType,
        /// Whether the pointer is mutable.
        mutable: bool,
    },
}


    /// Module reference.
    Module {
        /// Module entry in the graph.
        entry: *module::ModuleEntry,
        /// Module scope.
        scope: *mut Scope,
        scope: *unsafe mut Scope,
    },
    /// Payload describing type symbols with their resolved type.
    Type(*mut NominalType),
    Type(*unsafe mut NominalType),
    /// Trait symbol.
    Trait(*mut TraitType),
    Trait(*unsafe mut TraitType),
}

/// Resolved symbol allocated during semantic analysis.
export record Symbol: Copy {
    /// Symbol name in source code.

    DuplicateBinding(*[u8]),
    /// Identifier referenced before it was declared.
    UnresolvedSymbol(*[u8]),
    /// Attempted to assign to an immutable binding.
    ImmutableBinding,
    /// Slice append requires a valid allocator record and callback.
    InvalidSliceAllocator,
    /// Expected a compile-time constant expression.
    ConstExprRequired,
    /// Symbol arena exhausted while binding identifiers.
    SymbolOverflow,
    /// Expression has the wrong type.

    Internal,
}

/// Diagnostics returned by the analyzer.
export record Diagnostics: Copy {
    errors: *mut [Error],
    /// Immutable errors captured at the end of an analysis operation.
    errors: *[Error],
}

/// Mutable diagnostic storage owned by a resolver.
record DiagnosticBuffer {
    /// Backing entries. Only the prefix below `len` is initialized.
    entries: *mut [Error],
    /// Number of recorded errors.
    len: u32,
}

/// Call context.
union CallCtx: Copy {
    /// Normal function call.

}

/// Result of resolving a record literal's type name.
record ResolvedRecordLitType: Copy {
    /// The record nominal type to use for field checking.
    recordType: *NominalType,
    recordType: *unsafe NominalType,
    /// The result type of the literal (record type or union type for variants).
    resultType: Type,
}

/// Result of checking for a `super` path prefix.
record SuperAccessResult: Copy {
    scope: *mut Scope,
    scope: *unsafe mut Scope,
    child: *ast::Node,
}

/// Node-specific resolver metadata.
export union NodeExtra: Copy {

    /// For-loop iteration metadata.
    ForLoop(ForLoopInfo),
    /// Trait method call metadata.
    TraitMethodCall {
        /// Trait definition.
        traitInfo: *TraitType,
        traitInfo: *unsafe TraitType,
        /// Method index in the v-table.
        methodIndex: u32,
    },
    /// Standalone method call metadata.
    MethodCall { method: *unsafe MethodEntry },

    SliceDelete { elemType: *Type },
}

/// Combined resolver metadata for a single AST node.
export record NodeData: Copy {
    /// Number of local bindings and internal iteration variables in this function.
    localCount: u32,
    /// Resolved type for this node.
    ty: Type,
    /// Coercion plan applied to this node.
    coercion: Coercion,
    /// Symbol associated with this node.
    sym: ?*mut Symbol,
    sym: ?*unsafe mut Symbol,
    /// Constant value for literal nodes.
    constValue: ?ConstValue,
    /// Lexical scope owned by this node.
    scope: ?*mut Scope,
    scope: ?*unsafe mut Scope,
    /// Node-specific extra data.
    extra: NodeExtra,
}

/// Table storing all resolver metadata indexed by node ID.
record NodeDataTable: Copy {
record NodeDataTable {
    /// Semantic data indexed by AST node ID.
    entries: *mut [NodeData],
}

/// Lexical scope.
export record Scope: Copy {
    /// Owning AST node, or `nil` for the root scope.
    owner: ?*ast::Node,
    /// Parent/enclosing scope.
    parent: ?*mut Scope,
    parent: ?*unsafe mut Scope,
    /// Module ID if this is a module scope.
    moduleId: ?u16,
    /// Symbols introduced inside the scope, allocated from the arena.
    symbols: *mut [*mut Symbol],
    symbols: *unsafe mut [*unsafe mut Symbol],
    /// Number of live symbols.
    symbolsLen: u32,
}

/// An object used by the enter and exit functions for module scopes.

    /// Module root node.
    root: *ast::Node,
    /// Module entry in graph.
    entry: *module::ModuleEntry,
    /// The newly entered scope.
    newScope: *mut Scope,
    newScope: *unsafe mut Scope,
    /// The previous scope.
    prevScope: *mut Scope,
    prevScope: *unsafe mut Scope,
    /// The previous module.
    prevMod: u16,
}

/// Loop context for tracking control flow within loops.


/// Per-control-flow-path ownership state.
/// Read only the initialized symbol prefix below `len`.
record LinearEnv: Copy {
    /// Symbol pointers. Entries below `len` are initialized and not optional.
    symbols: [*mut Symbol; MAX_LINEAR_BINDINGS],
    symbols: [*unsafe mut Symbol; MAX_LINEAR_BINDINGS],
    /// Bit set for each binding that remains available.
    available: u64,
    /// Number of initialized entries in `symbols`.
    len: u32,
    /// Whether this control-flow path has terminated.

/// `enterLinearLoop` initializes each slot before it increases `loopDepth`.
record LinearChecker: Copy {
    /// Resolver that owns the symbols and diagnostics.
    resolver: *unsafe mut Resolver,
    /// Source symbols protected by active pattern references.
    loans: [*mut Symbol; MAX_LINEAR_BINDINGS],
    loans: [*unsafe mut Symbol; MAX_LINEAR_BINDINGS],
    /// Number of initialized entries in `loans`.
    loanLen: u32,
    /// Binding count at entry to each active loop.
    loopMarks: [u32; MAX_LINEAR_LOOP_DEPTH],
    /// Available bindings at entry to each active loop.

    }
    return MatchSubject { effectiveTy: ty, by: MatchBy::Value };
}

/// Global resolver state.
export record Resolver: Copy {
export record Resolver {
    /// Current scope.
    scope: *mut Scope,
    scope: *unsafe mut Scope,
    /// Package scope containing package roots and top-level symbols.
    pkgScope: *mut Scope,
    pkgScope: *unsafe mut Scope,
    /// Stack of loop contexts for nested loops.
    loopStack: [LoopCtx; MAX_LOOP_DEPTH],
    /// Current loop depth, indexes into loop stack.
    loopDepth: u32,
    /// Signature of the function currently being analyzed.
    currentFn: ?*unsafe mut FnType,
    currentFn: ?FnType,
    /// Declaration that owns the active function body and its local bindings.
    currentFnNode: ?*ast::Node,
    /// Current module being analyzed.
    currentMod: u16,
    /// Whether the current lexical context permits unsafe operations.
    inUnsafeContext: bool,
    /// Configuration for semantic analysis.

    /// Combined semantic metadata table indexed by node ID.
    nodeData: NodeDataTable,
    /// Linked list of interned types.
    types: ?*TypeNode,
    /// Diagnostics recorded so far.
    errors: *mut [Error],
    errors: DiagnosticBuffer,
    /// Module graph for the current package.
    moduleGraph: *unsafe module::ModuleGraph,
    /// Cache of module scopes indexed by module ID.
    moduleScopes: [?*mut Scope; module::MAX_MODULES],
    moduleScopes: [?*unsafe mut Scope; module::MAX_MODULES],
    /// Trait instance registry.
    instances: [InstanceEntry; MAX_INSTANCES],
    /// Number of registered instances.
    instancesLen: u32,
    /// Standalone method registry.

    let node = try! alloc::alloc(
        &mut self.arena, @sizeOf(TypeNode), @alignOf(TypeNode)
    ) as *mut TypeNode;

    set *node = TypeNode { ty, next: self.types };
    set self.types = node;
    let frozen: *TypeNode = node;
    set self.types = frozen;

    return &node.ty;
    return &frozen.ty;
}

/// Allocate a nominal type descriptor and return a pointer to it.
unsafe fn allocNominalType(self: &mut Resolver, info: NominalType) -> *mut NominalType {
unsafe fn allocNominalType(self: &mut Resolver, 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::alloc(
    let entry = try! alloc::allocRaw(
        &mut self.arena, @sizeOf(NominalType), @alignOf(NominalType)
    ) as *mut NominalType;
    ) as *unsafe mut NominalType;

    set *entry = info;

    return entry;
}

/// Allocate a function type descriptor and return a pointer to it.
unsafe fn allocFnType(self: &mut Resolver, info: FnType) -> *mut FnType {
unsafe fn allocFnType(self: &mut Resolver, info: FnType) -> *FnType {
    let entry = try! alloc::alloc(
        &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(self: &Resolver, node: *ast::Node) -> ?Error {
    for i in 0..self.errors.len {
        let err = &self.errors[i];
        let err = self.errors.entries[i];
        if err.node == node {
            return err;
        }
    }
    return nil;
}

/// Storage buffers used by the analyzer.
export record ResolverStorage: Copy {
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: *mut Scope,
    pkgScope: *unsafe mut Scope,
    /// Error storage.
    errors: *mut [Error],
}

/// Input for resolving a single package.

/// Construct a resolver with module context and backing storage.
export unsafe fn resolver(
    storage: ResolverStorage,
    config: Config
) -> Resolver {
    let mut arena = storage.arena;
    let symbols = try! alloc::allocSlice(
        &mut arena, @sizeOf(*mut Symbol), @alignOf(*mut Symbol), MAX_MODULE_SYMBOLS
    ) as *mut [*mut Symbol];
    let case ResolverStorage { arena: initialArena, nodeData, pkgScope, errors } = storage else panic "expected resolver storage";
    let mut arena = initialArena;
    let symbols = try! alloc::allocRawSlice(
        &mut 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 *storage.pkgScope = Scope {
    set *pkgScope = Scope {
        owner: nil,
        parent: nil,
        moduleId: nil,
        symbols,
        symbolsLen: 0,
    };

    // Clear all node semantic metadata to sentinel values.
    // TODO: Use array repeat literal?
    for i in 0..storage.nodeData.len {
        set storage.nodeData[i] = NodeData {
    for i in 0..nodeData.len {
        set nodeData[i] = NodeData {
            localCount: 0,
            ty: Type::Unknown,
            coercion: Coercion::Identity,
            sym: nil,
            constValue: nil,
            scope: nil,
            extra: NodeExtra::None,
        };
    }

    let mut moduleScopes: [?*mut Scope; module::MAX_MODULES] = undefined;
    let mut moduleScopes: [?*unsafe mut Scope; module::MAX_MODULES] = undefined;
    // TODO: Simplify.
    for i in 0..moduleScopes.len {
        set moduleScopes[i] = nil;
    }
    return Resolver {
        scope: storage.pkgScope,
        pkgScope: storage.pkgScope,
        scope: pkgScope,
        pkgScope: pkgScope,
        loopStack: undefined,
        loopDepth: 0,
        currentFn: nil,
        currentFnNode: nil,
        currentMod: 0,
        inUnsafeContext: false,
        config,
        arena,
        nodeData: NodeDataTable { entries: storage.nodeData },
        nodeData: NodeDataTable { entries: nodeData },
        types: nil,
        errors: @sliceOf(storage.errors.ptr, 0, storage.errors.len),
        errors: DiagnosticBuffer { entries: errors, len: 0 },
        // TODO: Shouldn't be undefined.
        moduleGraph: undefined,
        moduleScopes,
        instances: undefined,
        instancesLen: 0,
        methods: undefined,
        methodsLen: 0,
    };
}

/// 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 {
    let count = self.errors.len;
    let entries = try! alloc::allocSlice(
        &mut 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 `true` if there are no errors in the diagnostics.
export fn success(diag: &Diagnostics) -> bool {
    return diag.errors.len == 0;
}

/// Retrieve an error diagnostic by index, if present.
export fn errorAt(errs: *[Error], index: u32) -> ?*Error {
export fn errorAt(errs: &[Error], index: u32) -> ?Error {
    if index >= errs.len {
        return nil;
    }
    return &errs[index];
    return errs[index];
}

/// Record an error diagnostic and return an error sentinel suitable for throwing.
unsafe fn emitError(self: &mut Resolver, node: ?*ast::Node, kind: ErrorKind) -> ResolveError {
fn emitError(self: &mut Resolver, 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.cap {
    if self.errors.len >= self.errors.entries.len {
        return ResolveError::Failure;
    }
    // Don't record more than one error per node.
    if let n = node; errorForNode(self, n) <> nil {
        return ResolveError::Failure;
    }
    let idx = self.errors.len;
    set self.errors = @sliceOf(self.errors.ptr, idx + 1, self.errors.cap);
    set self.errors[idx] = Error { kind, node, moduleId: self.currentMod };
    set self.errors.entries[idx] = Error { kind, node, moduleId: self.currentMod };
    set self.errors.len = idx + 1;

    return ResolveError::Failure;
}

/// Like [`emitError`], but for type mismatches specifically.
unsafe fn emitTypeMismatch(self: &mut Resolver, 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) -> *mut Scope {
unsafe fn allocScope(self: &mut Resolver, 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::alloc(&mut self.arena, @sizeOf(Scope), @alignOf(Scope));
    let entry = p as *mut Scope;
    let p = try! alloc::allocRaw(&mut self.arena, @sizeOf(Scope), @alignOf(Scope));
    let entry = p as *unsafe mut Scope;

    // Allocate symbols from the arena.
    let symbols = try! alloc::allocSlice(
        &mut self.arena, @sizeOf(*mut Symbol), @alignOf(*mut Symbol), capacity
    ) as *mut [*mut Symbol];
    let symbols = try! alloc::allocRawSlice(
        &mut 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;

    return 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) -> *Scope {
export unsafe fn enterScope(self: &mut Resolver, owner: *ast::Node) -> *unsafe Scope {
    let scope = allocScope(self, owner, MAX_LOCAL_SYMBOLS);
    set scope.parent = self.scope;
    set self.scope = scope;
    return 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) {
    let modEntry = module::findChild(&*self.moduleGraph, name, self.currentMod)
    let modEntry = module::findChild(self.moduleGraph, name, self.currentMod)
        else throw emitError(self, node, ErrorKind::UnresolvedSymbol(name));
    let modRoot = modEntry.ast
        else panic "enterSubModule: analyzing module that wasn't parsed";

    return enterModuleScope(self, modRoot, modEntry);

    set self.scope = entry.prevScope;
    set self.currentMod = entry.prevMod;
}

/// Exit the most recent scope.
export fn exitScope(self: &mut Resolver) {
export unsafe fn exitScope(self: &mut Resolver) {
    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 the expected return type for a new function body.
unsafe fn enterFn(self: &mut Resolver, node: *ast::Node, ty: &mut FnType) {
unsafe fn enterFn(self: &mut Resolver, node: *ast::Node, ty: &FnType) {
    assert self.currentFn == nil, "enterFn: already in a function";
    set self.currentFn = ty as *unsafe mut FnType;
    set self.currentFn = *ty;
    set self.currentFnNode = node;
    enterScope(self, node);
}

/// Clear the expected return type when leaving a function body.
fn exitFn(self: &mut Resolver) {
unsafe fn exitFn(self: &mut Resolver) {
    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.currentFn = nil;
    set self.currentFnNode = nil;
    exitScope(self);
}

/// Extract the identifier text from a node.
unsafe fn nodeName(self: &mut Resolver, node: *ast::Node) -> *[u8]

        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: *mut Symbol) {
fn setNodeSymbol(self: &mut Resolver, 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;
}

fn setVariantInfo(self: &mut Resolver, 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: *TraitType, methodIndex: u32) {
fn setTraitMethodCall(self: &mut Resolver, 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) {

    }
    return false;
}

/// Get the resolver metadata for a node.
export fn nodeData(self: &Resolver, node: *ast::Node) -> *NodeData {
    return &self.nodeData.entries[node.id];
export fn nodeData(self: &Resolver, 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 {
    let ty = self.nodeData.entries[node.id].ty;

    }
    return ty;
}

/// Get the scope associated with a node.
export fn scopeFor(self: &Resolver, node: *ast::Node) -> ?*mut Scope {
export fn scopeFor(self: &Resolver, 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) -> ?*mut Symbol {
export fn symbolFor(self: &Resolver, 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 {

    }
    return c;
}

/// Get the module ID for a symbol by walking up its scope chain.
export fn moduleIdForSymbol(self: &Resolver, sym: *Symbol) -> ?u16 {
export unsafe fn moduleIdForSymbol(self: &Resolver, 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 fn variantPatternBinding(self: &Resolver, pattern: *ast::Node) -> ?*ast::Node {
export unsafe fn variantPatternBinding(self: &Resolver, 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) -> *mut Symbol {
    let sym = try! alloc::alloc(&mut self.arena, @sizeOf(Symbol), @alignOf(Symbol)) as *mut Symbol;
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;
    set *sym = Symbol { name, data, attrs, node, moduleId: nil };

    return sym;
}


    }
    return b;
}

/// Get the layout of a type.
export fn getTypeLayout(ty: Type) -> Layout {
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 { .. } =>
            return Layout { size: PTR_SIZE * 2, alignment: PTR_SIZE },
        case Type::Void, Type::Never => return Layout { size: 0, alignment: 0 },

        }
    }
}

/// Get the layout of a type or value.
export fn getLayout(self: &Resolver, node: *ast::Node, ty: Type) -> Layout {
export unsafe fn getLayout(self: &Resolver, 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 {

    }
    return layout;
}

/// Get the layout of an array type.
export fn getArrayLayout(arr: ArrayType) -> Layout {
export unsafe fn getArrayLayout(arr: ArrayType) -> Layout {
    let itemLayout = getTypeLayout(*arr.item);
    return Layout {
        size: itemLayout.size * arr.length,
        alignment: itemLayout.alignment,
    };
}

/// Get the layout of an optional type.
export fn getOptionalLayout(inner: Type) -> Layout {
export unsafe fn getOptionalLayout(inner: Type) -> Layout {
    // Nullable types use null pointer optimization -- no tag byte needed.
    if isNullableType(inner) {
        return getTypeLayout(inner);
    }
    let innerLayout = getTypeLayout(inner);

        alignment,
    };
}

/// Get the payload offset within an optional aggregate.
export fn getOptionalValOffset(inner: Type) -> u32 {
export unsafe fn getOptionalValOffset(inner: Type) -> u32 {
    let innerLayout = getTypeLayout(inner);
    return mem::alignUp(1, innerLayout.alignment);
}

/// Check if a type is optional.

        }
    }
}

/// Get the layout of a result aggregate with a tag and the larger payload.
export fn getResultLayout(payload: Type, throwList: *[*Type]) -> Layout {
export unsafe fn getResultLayout(payload: Type, throwList: *[*Type]) -> Layout {
    let payloadLayout = getTypeLayout(payload);
    let mut maxSize = payloadLayout.size;
    let mut maxAlign = payloadLayout.alignment;

    for errType in throwList {

        alignment: max(PTR_SIZE, maxAlign),
    };
}

/// Compute the layout for a union given its resolved variants.
fn computeUnionLayout(variants: *[UnionVariant]) -> UnionLayoutInfo {
unsafe fn computeUnionLayout(variants: *unsafe [UnionVariant]) -> UnionLayoutInfo {
    let tagSize: u32 = 1;
    let mut maxVarSize: u32 = 0;
    let mut maxVarAlign: u32 = 1;
    let mut isAllVoid: bool = true;


    set *iota = tag + 1;
    return tag;
}

/// Check if a type is a union without payloads.
export fn isVoidUnion(ty: Type) -> bool {
export unsafe fn isVoidUnion(ty: Type) -> bool {
    let case Type::Nominal(NominalType::Union(unionType)) = ty
        else return false;
    return unionType.isAllVoid;
}


        else => {},
    }
}

/// Ensure a nominal type has its body resolved.
unsafe fn ensureNominalResolved(self: &mut Resolver, tyInfo: *NominalType, site: *ast::Node)
unsafe fn ensureNominalResolved(self: &mut Resolver, tyInfo: *unsafe NominalType, site: *ast::Node)
    throws (ResolveError)
{
    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.

        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: *mut [*ast::Node]) -> bool {
unsafe fn isListAssignable(self: &mut Resolver, 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.

    }
    return nil;
}

/// Check if two function type descriptors are structurally equivalent.
fn fnTypeEqual(a: &FnType, b: *FnType) -> bool {
fn fnTypeEqual(a: &FnType, b: &FnType) -> bool {
    if a.isUnsafe <> b.isUnsafe {
        return false;
    }
    return fnSignatureEqual(a, b);
}

/// Compare parameter, return, and error types of functions.
fn fnSignatureEqual(a: &FnType, b: *FnType) -> bool {
fn fnSignatureEqual(a: &FnType, b: &FnType) -> bool {
    if a.paramTypes.len <> b.paramTypes.len {
        return false;
    }
    if a.throwList.len <> b.throwList.len {
        return false;

    return true;
}

/// Check if two types are structurally equal.
export fn typesEqual(a: Type, b: Type) -> bool {
    // Nominal and trait types compare by descriptor identity.
    if a == b {
        return true;
    }
    if let case Type::Pointer { class: aClass, target: aTarget, mutable: aMutable } = a {
        let case Type::Pointer { class: bClass, target: bTarget, mutable: bMutable } = b

        let case Type::Slice { class: bClass, item: bItem, mutable: bMutable } = b
            else return false;
        return aClass == bClass and aMutable == bMutable
            and typesEqual(*aItem, *bItem);
    }
    if let case Type::TraitObject { class: aClass, traitInfo: aTraitInfo, mutable: aMutable } = a {
        let case Type::TraitObject { class: bClass, traitInfo: bTraitInfo, mutable: bMutable } = b
            else return false;
        return aClass == bClass and aMutable == bMutable
            and aTraitInfo == bTraitInfo;
    }
    match a {
        case Type::Array(aa) => {
            let case Type::Array(ab) = b else return false;
            return aa.length == ab.length and typesEqual(*aa.item, *ab.item);
        }

        else => return false,
    }
}

/// Return whether `ty` may be duplicated implicitly.
export fn isCopy(ty: Type) -> bool {
export unsafe fn isCopy(ty: Type) -> bool {
    match ty {
        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,
        else => return true,
    }
}

/// Return whether a type must be consumed exactly once.
export fn isLinear(ty: Type) -> bool {
export unsafe fn isLinear(ty: Type) -> bool {
    match ty {
        case Type::Array(array) => return isLinear(*array.item),
        case Type::Optional(inner) => return isLinear(*inner),
        case Type::Nominal(NominalType::Record(recInfo)) => {
            if recInfo.declaredLinear {

        else => return false,
    }
}

/// Return whether a by-value use moves `ty`.
fn isMoveOnly(ty: Type) -> bool {
unsafe fn isMoveOnly(ty: Type) -> bool {
    return not isCopy(ty);
}

/// Return whether `ty` is a direct unsafe pointer-like value.
fn isUnsafePointerType(ty: Type) -> bool {

        else => return false,
    }
}

/// Get the record info from a record type.
export fn getRecord(ty: Type) -> ?RecordType {
export unsafe fn getRecord(ty: Type) -> ?RecordType {
    let case Type::Nominal(NominalType::Record(recInfo)) = ty else return nil;
    return recInfo;
}

/// Auto-dereference a type: if it's a pointer, return the target type.

    }
    return ty;
}

/// Get field info for a record-like type (records, slices) by field index.
export fn getRecordField(ty: Type, index: u32) -> ?RecordField {
export unsafe fn getRecordField(ty: Type, index: u32) -> ?RecordField {
    if let case Type::Slice { class, item, mutable } = ty {
        match index {
            case 0 => return RecordField {
                name: PTR_FIELD,
                fieldType: Type::Pointer { class, target: item, mutable },

    }
    return nil;
}

/// Check if the two types can be compared for equality.
fn isComparable(left: Type, right: Type) -> bool {
unsafe fn isComparable(left: Type, right: Type) -> bool {
    if left == Type::Unknown or right == Type::Unknown {
        return false;
    }
    if left == right {
        return true;

    self: &mut Resolver,
    name: *[u8],
    owner: *ast::Node,
    data: SymbolData,
    attrs: u32,
    scope: *mut Scope
) -> *mut Symbol throws (ResolveError) {
    scope: *unsafe mut Scope
) -> *unsafe mut Symbol throws (ResolveError) {
    let sym = allocSymbol(self, data, name, owner, attrs);
    try addSymbolToScope(self, sym, scope, owner);
    setNodeSymbol(self, owner, sym);

    return sym;
}

/// Add a symbol to the given scope.
unsafe fn addSymbolToScope(self: &mut Resolver, sym: *mut Symbol, scope: *mut Scope, site: *ast::Node) throws (ResolveError) {
unsafe fn addSymbolToScope(self: &mut Resolver, 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));
        }
    }

    owner: *ast::Node,
    type: Type,
    mutable: bool,
    alignment: u32,
    attrs: u32
) -> ?*mut Symbol throws (ResolveError) {
) -> ?*unsafe mut Symbol throws (ResolveError) {
    if let case ast::NodeValue::Placeholder = ident.value {
        setNodeType(self, owner, type);
        return nil;
    }
    let name = try nodeName(self, ident);

    let sym = try bindIdent(self, name, owner, data, attrs, scope);
    setNodeType(self, owner, type);
    setNodeType(self, ident, type);

    // Track number of local bindings for lowering stage.
    if let mut fnType = self.currentFn {
        set fnType.localCount += 1;
    if let owner = self.currentFnNode {
        set self.nodeData.entries[owner.id].localCount += 1;
    }
    return sym;
}

/// Bind a constant identifier in the current scope.

    ident: *ast::Node,
    owner: *ast::Node,
    type: Type,
    val: ?ConstValue,
    attrs: u32
) -> *mut Symbol throws (ResolveError) {
) -> *unsafe mut Symbol throws (ResolveError) {
    let name = try nodeName(self, ident);
    let data = SymbolData::Constant { type, value: val };
    let scope = self.scope;
    let sym = try bindIdent(self, name, owner, data, attrs, scope);
    setNodeType(self, owner, type);

/// This is used when declaring modules with `mod` or
/// importing modules with `use`.
unsafe fn bindModuleIdent(
    self: &mut Resolver,
    entry: *module::ModuleEntry,
    scope: *mut Scope,
    scope: *unsafe mut Scope,
    owner: *ast::Node,
    attrs: u32,
    bindingScope: *mut Scope
) -> *mut Symbol throws (ResolveError) {
    bindingScope: *unsafe mut Scope
) -> *unsafe mut Symbol throws (ResolveError) {
    let data = SymbolData::Module { entry, scope };
    let name = entry.name;

    return try bindIdent(self, name, owner, data, attrs, bindingScope);
}

/// Bind a type identifier in the current scope.
unsafe fn bindTypeIdent(
    self: &mut Resolver,
    ident: *ast::Node,
    owner: *ast::Node,
    type: *mut NominalType,
    type: *unsafe mut NominalType,
    attrs: u32
) -> *mut Symbol throws (ResolveError) {
) -> *unsafe mut Symbol throws (ResolveError) {
    let name = try nodeName(self, ident);
    let data = SymbolData::Type(type);
    let scope = self.scope;
    return try bindIdent(self, name, owner, data, attrs, scope);
}

/// Predicate that matches any symbol.
fn isAnySymbol(_sym: *mut Symbol) -> bool {
fn isAnySymbol(_sym: *unsafe mut Symbol) -> bool {
    return true;
}

/// Predicate that matches value or constant symbols.
fn isValueSymbol(sym: *mut Symbol) -> bool {
unsafe fn isValueSymbol(sym: *unsafe mut Symbol) -> bool {
    if let case SymbolData::Value { .. } = sym.data {
        return true;
    }
    if let case SymbolData::Constant { .. } = sym.data {
        return true;
    }
    return false;
}

/// Predicate that matches type symbols.
fn isTypeSymbol(sym: *mut Symbol) -> bool {
unsafe fn isTypeSymbol(sym: *unsafe mut Symbol) -> bool {
    if let case SymbolData::Type(_) = sym.data {
        return true;
    }
    return false;
}

/// Find a symbol by name in a specific scope, filtered by a predicate.
fn findInScope(scope: *Scope, name: *[u8], predicate: fn(*mut Symbol) -> bool) -> ?*mut Symbol {
unsafe fn findInScope(scope: *unsafe Scope, name: *[u8], predicate: unsafe fn(*unsafe mut Symbol) -> bool) -> ?*unsafe mut Symbol {
    for i in 0..scope.symbolsLen {
        let sym = scope.symbols[i];
        if sym.name == name and predicate(sym) {
            return sym;
        }
    }
    return nil;
}

/// Find a symbol by name, traversing scopes upwards, filtered by a predicate.
fn findInScopeRecursive(scope: *Scope, name: *[u8], predicate: fn(*mut Symbol) -> bool) -> ?*mut Symbol {
unsafe fn findInScopeRecursive(scope: *unsafe Scope, name: *[u8], predicate: unsafe fn(*unsafe mut Symbol) -> bool) -> ?*unsafe mut Symbol {
    let mut curr = scope;
    loop {
        if let sym = findInScope(curr, name, predicate) {
            return sym;
        }

    }
    return nil;
}

/// Find a symbol by name in a specific scope (matches any symbol kind).
export fn findSymbolInScope(scope: *Scope, name: *[u8]) -> ?*mut Symbol {
export unsafe fn findSymbolInScope(scope: *unsafe Scope, name: *[u8]) -> ?*unsafe mut Symbol {
    return findInScope(scope, name, isAnySymbol);
}

/// Look up a value symbol by name, searching from the given scope outward.
fn findValueSymbol(scope: *Scope, name: *[u8]) -> ?*mut Symbol {
unsafe fn findValueSymbol(scope: *unsafe Scope, name: *[u8]) -> ?*unsafe mut Symbol {
    return findInScopeRecursive(scope, name, isValueSymbol);
}

/// Look up a type symbol by name, searching from the given scope outward.
fn findTypeSymbol(scope: *Scope, name: *[u8]) -> ?*mut Symbol {
unsafe fn findTypeSymbol(scope: *unsafe Scope, name: *[u8]) -> ?*unsafe mut Symbol {
    return findInScopeRecursive(scope, name, isTypeSymbol);
}

/// Like `findValueSymbol`, but finds symbols of any kinds.
fn findAnySymbol(scope: *Scope, name: *[u8]) -> ?*mut Symbol {
unsafe fn findAnySymbol(scope: *unsafe Scope, name: *[u8]) -> ?*unsafe mut Symbol {
    return findInScopeRecursive(scope, name, isAnySymbol);
}

/// Flatten an identifier or scope access chain into an array of name segments.
/// Examples: `fnord` -> `&["fnord"]`, `a::b::c` -> `&["a", "b", "c"]`.

    return out;
}

/// Find the module ID for a given scope by walking up the scope chain until
/// we hit the module's scope.
fn findModuleForScope(scope: *Scope) -> ?u16 {
unsafe fn findModuleForScope(scope: *unsafe Scope) -> ?u16 {
    let mut s = scope;
    loop {
        if let id = s.moduleId {
            return id;
        }

    }
}

/// 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) -> ?*mut Scope throws (ResolveError) {
    let currentMod = module::get(&*self.moduleGraph, self.currentMod)
unsafe fn getParentModuleScope(self: &mut Resolver, 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 symbol is accessible from the given scope.
/// A symbol is accessible if:
/// * It has the `export` attribute, OR
/// * It's being accessed from within the module where it was defined.
fn isSymbolVisible(sym: *Symbol, symScope: *Scope, fromScope: *Scope) -> bool {
unsafe fn isSymbolVisible(sym: *unsafe Symbol, symScope: *unsafe Scope, fromScope: *unsafe Scope) -> bool {
    // Public symbols are visible from anywhere.
    if ast::hasAttribute(sym.attrs, ast::Attribute::Export) {
        return true;
    }
    // In test mode, @test symbols are visible from anywhere

/// starting from the given scope.
unsafe fn resolveAccess(
    self: &mut Resolver,
    node: *ast::Node,
    access: ast::Access,
    scope: *Scope
) -> *mut Symbol throws (ResolveError) {
    scope: *unsafe Scope
) -> *unsafe mut Symbol throws (ResolveError) {
    // 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;

unsafe fn resolvePath(
    self: &mut Resolver,
    node: *ast::Node,
    access: ast::Access,
    path: &[*[u8]],
    scope: *Scope
) -> *mut Symbol throws (ResolveError) {
    scope: *unsafe Scope
) -> *unsafe mut Symbol throws (ResolveError) {
    assert path.len <> 0, "resolvePath: empty path";
    // Start by finding the root of the path.
    let root = path[0];
    let sym = findInScopeRecursive(scope, root, isAnySymbol)
        else throw emitError(self, node, ErrorKind::UnresolvedSymbol(root));

/// Recursively resolve the remaining path segments by traversing child modules.
unsafe fn resolveModulePathRecursive(
    self: &mut Resolver,
    node: *ast::Node,
    path: &[*[u8]],
    sym: *Symbol
    sym: *unsafe Symbol
) -> ResolvedModule throws (ResolveError) {
    let case SymbolData::Module { entry, scope } = sym.data
        else throw emitError(self, node, ErrorKind::Internal);

    if path.len == 0 {

        childSym
    );
}

/// Resolve a type name, which could be an identifier or scoped path.
unsafe fn resolveTypeName(self: &mut Resolver, node: *ast::Node) -> *NominalType throws (ResolveError) {
unsafe fn resolveTypeName(self: &mut Resolver, 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

    }
    return nil;
}

/// Visit every node contained in a list, returning the last resolved type.
unsafe fn visitList(self: &mut Resolver, list: *mut [*ast::Node]) -> Type
unsafe fn visitList(self: &mut Resolver, list: *[*ast::Node]) -> Type
    throws (ResolveError)
{
    let mut diverges = false;
    for item in list {
        if try infer(self, item) == Type::Never {

        else => return false,
    }
}

/// Determine whether a node represents a compile-time constant expression.
export fn isConstExpr(self: &Resolver, node: *ast::Node) -> bool {
export unsafe fn isConstExpr(self: &Resolver, node: *ast::Node) -> bool {
    match node.value {
        case ast::NodeValue::Bool(_),
             ast::NodeValue::Char(_),
             ast::NodeValue::Number(_),
             ast::NodeValue::String(_),


/// 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: *mut [*ast::Node], recInfo: RecordType)
unsafe fn checkRecordConstructorArgs(self: &mut Resolver, 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: *mut [*ast::Node], recInfo: RecordType, pattern: *ast::Node) throws (ResolveError) {
unsafe fn checkRecordArity(self: &mut Resolver, 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,
        }));

    let mut fnType = FnType {
        paramTypes: &[],
        returnType: allocType(self, retTy),
        throwList: &[],
        isUnsafe: ast::hasAttribute(attrMask, ast::Attribute::Unsafe),
        localCount: 0,
    };
    // Enter the function scope to process parameters.
    enterFn(self, node, &mut fnType);
    enterFn(self, node, &fnType);

    if decl.sig.params.len > MAX_FN_PARAMS {
        exitFn(self);
        throw emitError(self, node, ErrorKind::FnParamOverflow(CountMismatch {
            expected: MAX_FN_PARAMS,


/// Resolve a function or method body and restore the enclosing context.
unsafe fn resolveExecutableBody(
    self: &mut Resolver,
    node: *ast::Node,
    fnType: *mut FnType,
    fnType: *FnType,
    receiverName: ?*ast::Node,
    params: *mut [*ast::Node],
    params: *[*ast::Node],
    body: *ast::Node,
) throws (ResolveError) {
    let wasUnsafe = self.inUnsafeContext;
    set self.inUnsafeContext = fnType.isUnsafe;
    // Enter function scope.

/// Return whether a required return is missing.
unsafe fn checkExecutableBody(
    self: &mut Resolver,
    fnType: *FnType,
    receiverName: ?*ast::Node,
    params: *mut [*ast::Node],
    params: *[*ast::Node],
    body: *ast::Node,
) -> bool throws (ResolveError) {
    if let receiver = receiverName {
        // Bind the receiver parameter.
        let receiverTy = *fnType.paramTypes[0];

    /// The declaration permits implicit copies.
    copy: bool,
}

/// Resolve compiler-known ownership markers from a derive list.
unsafe fn resolveOwnershipMarkers(self: &mut Resolver, derives: *mut [*ast::Node]) -> OwnershipMarkers
unsafe fn resolveOwnershipMarkers(self: &mut Resolver, derives: *[*ast::Node]) -> OwnershipMarkers
    throws (ResolveError)
{
    let mut result = OwnershipMarkers { linear: false, copy: false };
    for derive in derives {
        let name = try nodeName(self, derive);

    }
    return result;
}

/// Resolve record fields from a node list.
unsafe fn resolveRecordFields(self: &mut Resolver, node: *ast::Node, fields: *mut [*ast::Node], labeled: bool) -> RecordType
unsafe fn resolveRecordFields(self: &mut Resolver, node: *ast::Node, fields: *[*ast::Node], labeled: bool) -> RecordType
    throws (ResolveError)
{
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut result: *mut [RecordField] = &mut [];
    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);


    set *nominalTy = NominalType::Record(recordType);
}

/// Bind a type name.
unsafe fn bindTypeName(self: &mut Resolver, node: *ast::Node, name: *ast::Node, attrs: ?ast::Attributes) -> *mut Symbol
unsafe fn bindTypeName(self: &mut Resolver, node: *ast::Node, name: *ast::Node, attrs: ?ast::Attributes) -> *unsafe mut Symbol
    throws (ResolveError)
{
    let attrMask = resolveAttributes(self, attrs);
    try ensureDefaultAttrNotAllowed(self, node, attrMask);



    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]) -> *mut TraitType {
    let p = try! alloc::alloc(&mut self.arena, @sizeOf(TraitType), @alignOf(TraitType));
    let entry = p as *mut TraitType;
unsafe fn allocTraitType(self: &mut Resolver, name: *[u8]) -> *unsafe mut TraitType {
    let p = try! alloc::allocRaw(&mut self.arena, @sizeOf(TraitType), @alignOf(TraitType));
    let entry = p as *unsafe mut TraitType;
    set *entry = TraitType { name, 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) -> *mut Symbol
unsafe fn bindTraitName(self: &mut Resolver, node: *ast::Node, name: *ast::Node, attrs: ?ast::Attributes) -> *unsafe mut Symbol
    throws (ResolveError)
{
    let attrMask = resolveAttributes(self, attrs);
    try ensureDefaultAttrNotAllowed(self, node, attrMask);



    return sym;
}

/// Find a trait method by name.
export fn findTraitMethod(traitType: *TraitType, name: *[u8]) -> ?*TraitMethod {
export unsafe fn findTraitMethod(traitType: *unsafe TraitType, name: *[u8]) -> ?*unsafe TraitMethod {
    for i in 0..traitType.methods.len {
        if 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: *mut [*ast::Node], methods: *mut [*ast::Node])
unsafe fn resolveTraitBody(self: &mut Resolver, 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

        let fnType = FnType {
            paramTypes: &paramTypes[..],
            returnType: retType,
            throwList: &throwList[..],
            isUnsafe: ast::hasAttribute(attrMask, ast::Attribute::Unsafe),
            localCount: 0,
        };
        traitType.methods.append(TraitMethod {
            name: methodName,
            fnType: allocFnType(self, fnType),
            mutable,

    }
}

/// 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) -> *mut Symbol
unsafe fn resolveNamePath(self: &mut Resolver, node: *ast::Node) -> *unsafe mut Symbol
    throws (ResolveError)
{
    match node.value {
        case ast::NodeValue::Ident(name) => {
            let sym = findAnySymbol(self.scope, name)

unsafe fn resolveInstanceDecl(
    self: &mut Resolver,
    node: *ast::Node,
    traitName: *ast::Node,
    targetType: *ast::Node,
    methods: *mut [*ast::Node]
    methods: *[*ast::Node]
) throws (ResolveError) {
    // Look up the trait.
    let traitSym = try resolveNamePath(self, traitName);
    let case SymbolData::Trait(traitInfo) = traitSym.data
        else throw emitError(self, traitName, ErrorKind::Internal);


    // Build the instance entry.
    if self.instancesLen >= MAX_INSTANCES {
        throw emitError(self, node, ErrorKind::Internal);
    }
    let methodSlice = try! alloc::allocSlice(
        &mut self.arena, @sizeOf(*mut Symbol), @alignOf(*mut Symbol), traitInfo.methods.len as u32
    ) as *mut [*mut Symbol];
    let methodSlice = try! alloc::allocRawSlice(
        &mut 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,

        let fnType = FnType {
            paramTypes: &paramTypes[..],
            returnType: tm.fnType.returnType,
            throwList: tm.fnType.throwList,
            isUnsafe: tm.fnType.isUnsafe,
            localCount: 0,
        };

        // 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.


    setNodeType(self, node, Type::Void);
}

/// Resolve instance method bodies.
unsafe fn resolveInstanceMethodBodies(self: &mut Resolver, methods: *mut [*ast::Node])
unsafe fn resolveInstanceMethodBodies(self: &mut Resolver, methods: *[*ast::Node])
    throws (ResolveError)
{
    for methodNode in methods {
        let case ast::NodeValue::MethodDecl {
            name, receiverName, receiverType, sig, body, ..

    let fullFnType = FnType {
        paramTypes: &paramTypes[..],
        returnType: retTypePtr,
        throwList,
        isUnsafe,
        localCount: 0,
    };
    let fnTy = Type::Fn(allocFnType(self, fullFnType));

    // Function type excluding receiver, for call arg checking.
    let checkFnType = FnType {
        paramTypes: &paramTypes[1..],
        returnType: retTypePtr,
        throwList,
        isUnsafe,
        localCount: 0,
    };

    // Create a symbol for the method without binding it into the module scope.
    let sym = allocSymbol(self, SymbolData::Value {
        mutable: false, alignment: 0, type: fnTy, addressTaken: false,

    };
    set self.methodsLen += 1;
}

/// Look up an instance entry by trait and concrete type.
unsafe fn findInstance(self: &Resolver, traitInfo: *TraitType, concreteType: Type) -> ?*unsafe InstanceEntry {
unsafe fn findInstance(self: &Resolver, 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) {
            return entry;
        }

    }
    return nil;
}

/// Look up a standalone method entry by its symbol.
export unsafe fn findMethodBySymbol(self: &Resolver, sym: *mut Symbol) -> ?*unsafe MethodEntry {
export unsafe fn findMethodBySymbol(self: &Resolver, 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;
        }

    // do it again.
    if let case NominalType::Union(_) = *nominalTy {
        return;
    }
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut variants: *mut [UnionVariant] = &mut [];
    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);

    if let pat = forStmt.index {
        try bindForLoopPattern(self, pat, Type::U32, false);
    }
    // The lowerer always creates at least one internal variable for iteration,
    // even when the binding is a placeholder or no explicit index is given.
    if let mut fnType = self.currentFn {
        set fnType.localCount += 1;
    if let owner = self.currentFnNode {
        set self.nodeData.entries[owner.id].localCount += 1;
    }
    try visitLoop(self, forStmt.body);
    exitScope(self);

    try visitOptional(self, forStmt.elseBranch, Type::Void);


/// Check whether any pattern in a case prong matches unconditionally.
/// A plain `_` or an all-binding array pattern (e.g. `[x, y]`) qualifies.
/// Note: top-level identifiers in `case` are comparisons, not bindings,
/// so they do not count as wildcards.
fn hasWildcardPattern(patterns: *mut [*ast::Node]) -> bool {
fn hasWildcardPattern(patterns: *[*ast::Node]) -> bool {
    for pattern in patterns {
        match pattern.value {
            case ast::NodeValue::Placeholder => return true,
            case ast::NodeValue::ArrayLit(items) => {
                if isIrrefutableArrayPattern(items) {

    return false;
}

/// Check whether all elements of an array pattern are irrefutable.
/// Inside array patterns, identifiers are bindings, not comparisons.
fn isIrrefutableArrayPattern(items: *mut [*ast::Node]) -> bool {
fn isIrrefutableArrayPattern(items: *[*ast::Node]) -> bool {
    for item in items {
        match item.value {
            case ast::NodeValue::Ident(_), ast::NodeValue::Placeholder => {}
            case ast::NodeValue::ArrayLit(inner) => {
                if not isIrrefutableArrayPattern(inner) {

/// Analyze builtin function calls like `@sizeOf(T)` and `@alignOf(T)`.
unsafe fn resolveBuiltinCall(
    self: &mut Resolver,
    node: *ast::Node,
    kind: ast::Builtin,
    args: *mut [*ast::Node]
    args: *[*ast::Node]
) -> Type throws (ResolveError) {
    // Handle `@sliceOf(ptr, len)` and `@sliceOf(ptr, len, cap)`.
    if kind == ast::Builtin::SliceOf {
        if args.len <> 2 and args.len <> 3 {
            throw emitError(self, node, ErrorKind::BuiltinArgCountMismatch(CountMismatch {


    // Associate return type to call.
    return setNodeType(self, node, *info.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;
    if rec.fields.len <> 2 or not rec.labeled {
        return false;
    }
    let func = rec.fields[0];
    let ctx = rec.fields[1];
    let funcName = func.name else return false;
    let ctxName = ctx.name else return false;
    if not mem::eq(funcName, "func") or not mem::eq(ctxName, "ctx") or
       func.offset <> 0 or ctx.offset <> 8
    {
        return false;
    }
    let case Type::Fn(callback) = func.fieldType else return false;
    let case Type::Pointer { target, .. } = ctx.fieldType else return false;
    if *target <> Type::Opaque or callback.paramTypes.len <> 3 or callback.throwList.len <> 0 {
        return false;
    }
    if not typesEqual(*callback.paramTypes[0], ctx.fieldType) or
       *callback.paramTypes[1] <> Type::U32 or *callback.paramTypes[2] <> Type::U32
    {
        return false;
    }
    let case Type::Pointer { class, target: result, mutable } = *callback.returnType
        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,
    node: *ast::Node,
    parent: *ast::Node,
    parentType: Type,
    args: *mut [*ast::Node],
    args: *[*ast::Node],
    elemType: *Type,
    mutable: bool
) -> Type throws (ResolveError) {
    if not mutable {
        throw emitError(self, parent, ErrorKind::ImmutableBinding);

            actual: args.len as u32,
        }));
    }
    // First argument must be assignable to the element type.
    try checkAssignable(self, args[0], *elemType);
    // Second argument: the allocator. We accept any type -- the lowerer
    // reads `.func` and `.ctx` at fixed offsets.
    try visit(self, args[1], Type::Unknown);
    // The allocator stores its callback and context at fixed offsets.
    let allocatorTy = try infer(self, args[1]);
    if let case Type::Nominal(info) = allocatorTy {
        try ensureNominalResolved(self, info, args[1]);
    }
    if not isSliceAllocator(allocatorTy) {
        throw emitError(self, args[1], ErrorKind::InvalidSliceAllocator);
    }
    set self.nodeData.entries[node.id].extra = NodeExtra::SliceAppend { elemType };

    // 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,
    node: *ast::Node,
    parent: *ast::Node,
    args: *mut [*ast::Node],
    args: *[*ast::Node],
    elemType: *Type,
    mutable: bool
) -> Type throws (ResolveError) {
    if not mutable {
        throw emitError(self, parent, ErrorKind::ImmutableBinding);

    }
    return nil;
}

/// Analyze a union constructor call with payload.
unsafe fn resolveUnionConstructorCall(self: &mut Resolver, node: *ast::Node, call: ast::Call, unionNominal: *NominalType) -> Type
unsafe fn resolveUnionConstructorCall(self: &mut Resolver, 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";

/// 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: *NominalType) -> Type
unsafe fn resolveRecordConstructorCall(self: &mut Resolver, 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, innerHint);
}

/// Analyze an array literal expression.
unsafe fn resolveArrayLit(self: &mut Resolver, node: *ast::Node, items: *mut [*ast::Node], hint: Type) -> Type
unsafe fn resolveArrayLit(self: &mut Resolver, node: *ast::Node, items: *[*ast::Node], hint: Type) -> Type
    throws (ResolveError)
{
    let length = items.len;
    let mut expectedTy: Type = Type::Unknown;


    self: &mut Resolver,
    node: *ast::Node,
    access: ast::Access,
    unionType: UnionType,
    variantName: *[u8]
) -> *mut Symbol throws (ResolveError) {
) -> *unsafe mut Symbol throws (ResolveError) {
    // Look up the variant in the union's nominal type.
    for i in 0..unionType.variants.len {
        let variant = &unionType.variants[i];
        if variant.name == variantName {
            let case SymbolData::Variant { ordinal, index, .. } = variant.symbol.data

        }
    }
}

/// Return the storage class of an addressed location.
fn addressStorageClass(self: &Resolver, node: *ast::Node) -> types::PointerClass {
unsafe fn addressStorageClass(self: &Resolver, 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(_) =>

    }
    return false;
}

/// Check if an `as` cast between two types is valid.
fn isValidCast(source: Type, target: Type) -> bool {
unsafe fn isValidCast(source: Type, target: Type) -> bool {
    // Allow identity casts.
    if source == target {
        return true;
    }
    // Allow numeric to numeric.

/// 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,
    node: *ast::Node,
    catches: *mut [*ast::Node],
    catches: *[*ast::Node],
    calleeInfo: *FnType,
    resultTy: Type,
    hint: Type
) -> Type throws (ResolveError) {
    let firstNode = catches[0];

/// 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,
    node: *ast::Node,
    catches: *mut [*ast::Node],
    catches: *[*ast::Node],
    calleeInfo: *FnType,
    resultTy: Type,
    hint: Type
) -> Type throws (ResolveError) {
    // Track which of the callee's throw types have been covered.

            let fnType = FnType {
                paramTypes: &paramTypes[..],
                returnType: retType,
                throwList: &throwList[..],
                isUnsafe,
                localCount: 0,
            };
            return Type::Fn(allocFnType(self, fnType));
        }
        // Resolve an opaque trait object signature.
        case ast::TypeSig::TraitObject { class, traitName, mutable } => {


    let case ast::NodeValue::Block(block) = module.modBody.value
        else panic "resolveExpr: expected block for module body";
    enterScope(self, module.modBody);
    try resolveModuleDecls(self, &block) catch {
        return Diagnostics { errors: self.errors };
        return diagnostics(self);
    };
    try resolveModuleDefs(self, &block) catch {
        return Diagnostics { errors: self.errors };
        return diagnostics(self);
    };
    exitScope(self);

    return Diagnostics { errors: self.errors };
    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) {
    let case ast::NodeValue::Block(block) = root.value
        else panic "resolveModuleRoot: expected block for module root";

    enterScope(self, root);
    try resolveModuleDecls(self, &block) catch {
        return Diagnostics { errors: self.errors };
        return diagnostics(self);
    };
    try resolveModuleDefs(self, &block) catch {
        return Diagnostics { errors: self.errors };
        return diagnostics(self);
    };
    exitScope(self);
    setNodeType(self, root, Type::Void);

    return Diagnostics { errors: self.errors };
    return diagnostics(self);
}

/// 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.

        try visitDecl(res, stmt);
    }
}

/// Find a tracked binding by symbol identity.
fn findLinearBinding(env: &LinearEnv, sym: *mut Symbol) -> ?u32 {
unsafe fn findLinearBinding(env: &LinearEnv, sym: *unsafe mut Symbol) -> ?u32 {
    for i in 0..env.len {
        if env.symbols[i] == sym {
            return i;
        }
    }


/// 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)
{
    let sym = symbolFor(&mut *checker.resolver, node) else return;
    let sym = symbolFor(checker.resolver, node) else return;
    let case SymbolData::Value { type: ty, .. } = sym.data else return;
    if not isMoveOnly(ty) {
        return;
    }
    if env.len >= MAX_LINEAR_BINDINGS {
        throw emitError(&mut *checker.resolver, node, ErrorKind::Internal);
        throw emitError(checker.resolver, node, ErrorKind::Internal);
    }
    set env.symbols[env.len] = sym;
    set env.available |= (1 as u64) << (env.len as u64);
    set env.len += 1;
}

/// Mark a tracked binding as uninitialized.
fn markLinearBindingUnavailable(self: &mut Resolver, env: &mut LinearEnv, node: *ast::Node) {
unsafe fn markLinearBindingUnavailable(self: &mut Resolver, 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));
}


                let sym = env.symbols[i];
                let case SymbolData::Value { type: ty, .. } = sym.data
                    else panic "finishLinearScope: expected value symbol";
                if isLinear(ty) {
                    throw emitError(
                        &mut *checker.resolver,
                        checker.resolver,
                        sym.node,
                        ErrorKind::LinearNotConsumed(sym.name),
                    );
                }
            }
        }
    }
    set env.len = start;
}

/// Move or consume a tracked identifier once.
unsafe fn consumeLinearIdent(
/// Require a tracked identifier to remain available for any access.
unsafe fn checkLinearIdent(
    checker: &mut LinearChecker,
    env: &mut LinearEnv,
    node: *ast::Node,
) throws (ResolveError) {
    let sym = symbolFor(&mut *checker.resolver, node) else return;
    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";
        let kind = ErrorKind::LinearUseAfterConsume(sym.name) if isLinear(ty)
            else ErrorKind::AffineUseAfterMove(sym.name);
        throw emitError(&mut *checker.resolver, node, kind);
        throw emitError(checker.resolver, node, kind);
    }
}

/// Move or consume a tracked identifier once.
unsafe fn consumeLinearIdent(
    checker: &mut LinearChecker,
    env: &mut LinearEnv,
    node: *ast::Node,
) throws (ResolveError) {
    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.

            let sym = left.symbols[i];
            let case SymbolData::Value { type: ty, .. } = sym.data
                else panic "joinLinearBranches: expected value symbol";
            if isLinear(ty) {
                throw emitError(
                    &mut *checker.resolver,
                    checker.resolver,
                    node,
                    ErrorKind::LinearBranchMismatch(sym.name),
                );
            }
            set available &= ~((1 as u64) << (i as u64));

            let sym = env.symbols[i];
            let case SymbolData::Value { type: ty, .. } = sym.data
                else panic "finishLinearExit: expected value symbol";
            if isLinear(ty) {
                throw emitError(
                    &mut *checker.resolver,
                    checker.resolver,
                    sym.node,
                    ErrorKind::LinearNotConsumed(sym.name),
                );
            }
        }
    }
    set env.terminated = true;
}

/// Find the local root borrowed or consumed by an argument expression.
fn linearRootSymbol(self: &mut Resolver, node: *ast::Node) -> ?*mut Symbol {
fn linearRootSymbol(self: &mut Resolver, 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),


/// Protect a pattern source until its reference bindings leave scope.
unsafe fn addPatternLoan(checker: &mut LinearChecker, subject: *ast::Node)
    throws (ResolveError)
{
    let root = linearRootSymbol(&mut *checker.resolver, subject) else return;
    let root = linearRootSymbol(checker.resolver, subject) else return;
    if checker.loanLen >= MAX_LINEAR_BINDINGS {
        throw emitError(&mut *checker.resolver, subject, ErrorKind::Internal);
        throw emitError(checker.resolver, subject, ErrorKind::Internal);
    }
    set checker.loans[checker.loanLen] = root;
    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)
{
    let root = linearRootSymbol(&mut *checker.resolver, node) else return;
    let root = linearRootSymbol(checker.resolver, node) else return;
    for i in 0..checker.loanLen {
        if checker.loans[i] == root {
            throw emitError(&mut *checker.resolver, node, ErrorKind::BorrowConflict(root.name));
            throw emitError(checker.resolver, node, ErrorKind::BorrowConflict(root.name));
        }
    }
}

/// Return whether a parameter can mutate or consume its argument's storage.
fn isExclusiveArgument(ty: Type) -> bool {
unsafe fn isExclusiveArgument(ty: Type) -> bool {
    match ty {
        case Type::Pointer { mutable, .. } => return mutable,
        case Type::Slice { mutable, .. } => return mutable,
        case Type::TraitObject { mutable, .. } => return mutable,
        else => return isMoveOnly(ty),

) -> bool throws (ResolveError) {
    let mut hasReferences = false;
    match pattern.value {
        case ast::NodeValue::Ident(_) => {
            try addLinearBinding(checker, env, pattern);
            if let ty = typeFor(&mut *checker.resolver, pattern) {
            if let ty = typeFor(checker.resolver, pattern) {
                return isRefType(ty);
            }
        }
        case ast::NodeValue::Call(call) => {
            for arg in call.args {

    for i in 0..mark {
        let bit = (1 as u64) << (i as u64);
        if (env.available & bit) <> (entryAvailable & bit) {
            let sym = env.symbols[i];
            throw emitError(
                &mut *checker.resolver,
                checker.resolver,
                node,
                ErrorKind::LinearBranchMismatch(sym.name),
            );
        }
    }

        for i in 0..mark {
            let bit = (1 as u64) << (i as u64);
            if (env.available & bit) <> (expected & bit) {
                let sym = env.symbols[i];
                throw emitError(
                    &mut *checker.resolver,
                    checker.resolver,
                    node,
                    ErrorKind::LinearBranchMismatch(sym.name),
                );
            }
        }

    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 {
    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,
    env: &mut LinearEnv,
    node: *ast::Node,
    matchExpr: ast::Match,
) throws (ResolveError) {
    try checkLinearNode(checker, env, matchExpr.subject, LinearUse::Consume);
    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 {
        let case ast::NodeValue::MatchProng(prong) = prongNode.value

            for i in bindingsStart..branch.len {
                let sym = branch.symbols[i];
                let case SymbolData::Value { type: ty, .. } = sym.data
                    else panic "checkLinearMatch: expected value symbol";
                if isLinear(ty) {
                    throw emitError(&mut *checker.resolver, prongNode, ErrorKind::LinearDiscard);
                    throw emitError(checker.resolver, prongNode, ErrorKind::LinearDiscard);
                }
            }
        }
        if let guard = prong.guard {
            try checkLinearNode(checker, &mut branch, guard, LinearUse::Consume);

    match checker.resolver.nodeData.entries[node.id].extra {
        case NodeExtra::TraitMethodCall { traitInfo, methodIndex } =>
            set fnInfo = traitInfo.methods[methodIndex].fnType,
        case NodeExtra::MethodCall { method } => set fnInfo = method.fnType,
        else => {
            if let calleeTy = typeFor(&mut *checker.resolver, call.callee) {
            if let calleeTy = typeFor(checker.resolver, call.callee) {
                if let case Type::Fn(info) = calleeTy {
                    set fnInfo = info;
                }
            }
        }

        for arg in call.args {
            try checkLinearNode(checker, env, arg, LinearUse::Consume);
        }
        return;
    };
    let mut roots: [?*mut Symbol; MAX_FN_PARAMS + 1] = undefined;
    let mut roots: [?*unsafe mut Symbol; MAX_FN_PARAMS + 1] = undefined;
    let mut exclusive: [bool; MAX_FN_PARAMS + 1] = undefined;
    let mut rootsLen: u32 = 0;

    // Method function types exclude their implicit receiver. Account for it
    // explicitly so owning receivers are consumed and reference receivers

        if haveReceiver {
            if receiverMutable or receiverClass == types::PointerClass::Owned {
                try checkPatternLoan(checker, access.parent);
            }
            if receiverClass <> types::PointerClass::Unsafe {
                let root = linearRootSymbol(&mut *checker.resolver, access.parent);
                let root = linearRootSymbol(checker.resolver, access.parent);
                if let rootSym = root {
                    set roots[rootsLen] = rootSym;
                    set exclusive[rootsLen] =
                        receiverClass == types::PointerClass::Owned or receiverMutable;
                    set rootsLen += 1;

    for arg, i in call.args {
        let expected = *info.paramTypes[i];
        if isExclusiveArgument(expected) {
            try checkPatternLoan(checker, arg);
        }
        let root = linearRootSymbol(&mut *checker.resolver, arg);
        let root = linearRootSymbol(checker.resolver, arg);
        let mut argExclusive = isMoveOnly(expected);
        if let case Type::Pointer { class: types::PointerClass::Ref, mutable, .. } = expected {
            set argExclusive = mutable;
        } else if let case Type::Slice { class: types::PointerClass::Ref, mutable, .. } = expected {
            set argExclusive = mutable;

            if let rootSym = root {
                for j in 0..rootsLen {
                    if let previous = roots[j] {
                        if previous == rootSym and (exclusive[j] or argExclusive) {
                            throw emitError(
                                &mut *checker.resolver,
                                checker.resolver,
                                arg,
                                ErrorKind::BorrowConflict(rootSym.name),
                            );
                        }
                    }

    checker: &mut LinearChecker,
    env: &mut LinearEnv,
    node: *ast::Node,
    conditional: ast::IfLet,
) throws (ResolveError) {
    if let subjectTy = typeFor(&mut *checker.resolver, conditional.pattern.scrutinee);
    if let subjectTy = typeFor(checker.resolver, conditional.pattern.scrutinee);
        isLinear(subjectTy)
    {
        throw emitError(
            &mut *checker.resolver,
            checker.resolver,
            conditional.pattern.scrutinee,
            ErrorKind::LinearPartialMove,
        );
    }
    try checkLinearNode(
        checker,
        env,
        conditional.pattern.scrutinee,
        LinearUse::Consume,
        patternSubjectUse(checker.resolver, conditional.pattern.scrutinee),
    );
    let base = *env;
    let mut thenEnv = base;
    let bindingsStart = thenEnv.len;
    let loanStart = checker.loanLen;

    if env.terminated {
        return;
    }
    match node.value {
        case ast::NodeValue::Ident(_) => {
            if usage <> LinearUse::Place {
                try checkLinearIdent(checker, env, node);
            }
            if usage == LinearUse::Consume {
                if let ty = typeFor(&mut *checker.resolver, node); isExclusiveArgument(ty) {
                if let ty = typeFor(checker.resolver, node); isExclusiveArgument(ty) {
                    try checkPatternLoan(checker, node);
                }
                try consumeLinearIdent(checker, env, node);
            }
        }
        case ast::NodeValue::ExprStmt(expr) => {
            if let exprTy = typeFor(&mut *checker.resolver, expr) {
            if let exprTy = typeFor(checker.resolver, expr) {
                if isLinear(exprTy) {
                    throw emitError(&mut *checker.resolver, expr, ErrorKind::LinearDiscard);
                    throw emitError(checker.resolver, expr, ErrorKind::LinearDiscard);
                }
            }
            try checkLinearNode(checker, env, expr, LinearUse::Consume);
        }
        case ast::NodeValue::Block(_) => try checkLinearBlock(checker, env, node),

            let mut isUndefined = false;
            if let case ast::NodeValue::Undef = binding.value.value {
                set isUndefined = true;
            }
            if isUndefined {
                if let bindingTy = typeFor(&mut *checker.resolver, binding.ident);
                if let bindingTy = typeFor(checker.resolver, binding.ident);
                    isLinear(bindingTy)
                {
                    throw emitError(
                        &mut *checker.resolver,
                        checker.resolver,
                        binding.value,
                        ErrorKind::LinearUndefined,
                    );
                }
            }
            try checkLinearNode(checker, env, binding.value, LinearUse::Consume);
            try addLinearBinding(checker, env, node);
            if isUndefined {
                markLinearBindingUnavailable(&mut *checker.resolver, env, node);
                markLinearBindingUnavailable(checker.resolver, env, node);
            }
        }
        case ast::NodeValue::Assign(assign) => {
            try checkPatternLoan(checker, assign.left);
            let mut target: ?u32 = nil;
            let mut targetLinear = false;
            if let leftTy = typeFor(&mut *checker.resolver, assign.left) {
            if let leftTy = typeFor(checker.resolver, assign.left) {
                if isMoveOnly(leftTy) {
                    set targetLinear = isLinear(leftTy);
                    if let case ast::NodeValue::Ident(_) = assign.left.value {
                        if let sym = symbolFor(&mut *checker.resolver, assign.left) {
                        if let sym = symbolFor(checker.resolver, assign.left) {
                            set target = findLinearBinding(env, sym);
                        }
                    }
                    if target == nil {
                    if targetLinear and target == nil {
                        throw emitError(
                            &mut *checker.resolver,
                            checker.resolver,
                            assign.left,
                            ErrorKind::LinearOverwrite,
                        );
                    }
                }

            try checkLinearNode(checker, env, assign.left, LinearUse::Place);
            try checkLinearNode(checker, env, assign.right, LinearUse::Consume);
            if let index = target {
                if targetLinear and linearBindingAvailable(env, index) {
                    throw emitError(
                        &mut *checker.resolver,
                        checker.resolver,
                        assign.left,
                        ErrorKind::LinearOverwrite,
                    );
                }
                set env.available |= (1 as u64) << (index as u64);

                try checkPatternLoan(checker, addr.target);
            }
            try checkLinearNode(checker, env, addr.target, LinearUse::Borrow);
        }
        case ast::NodeValue::Deref(target) => {
            if let resultTy = typeFor(&mut *checker.resolver, node) {
            if let resultTy = typeFor(checker.resolver, node) {
                if isMoveOnly(resultTy) and usage == LinearUse::Consume {
                    throw emitError(&mut *checker.resolver, node, ErrorKind::LinearPartialMove);
                    throw emitError(checker.resolver, node, ErrorKind::LinearPartialMove);
                }
            }
            try checkLinearNode(checker, env, target, LinearUse::Observe);
        }
        case ast::NodeValue::FieldAccess(access) => {
            if let resultTy = typeFor(&mut *checker.resolver, node) {
            if let resultTy = typeFor(checker.resolver, node) {
                if isMoveOnly(resultTy) and usage == LinearUse::Consume {
                    throw emitError(&mut *checker.resolver, node, ErrorKind::LinearPartialMove);
                    throw emitError(checker.resolver, node, ErrorKind::LinearPartialMove);
                }
            }
            try checkLinearNode(checker, env, access.parent, LinearUse::Observe);
        }
        case ast::NodeValue::ScopeAccess(_) => {}
        case ast::NodeValue::Subscript { container, index } => {
            if let resultTy = typeFor(&mut *checker.resolver, node) {
            if let resultTy = typeFor(checker.resolver, node) {
                if isMoveOnly(resultTy) and usage == LinearUse::Consume {
                    throw emitError(&mut *checker.resolver, node, ErrorKind::LinearPartialMove);
                    throw emitError(checker.resolver, node, ErrorKind::LinearPartialMove);
                }
            }
            try checkLinearNode(checker, env, container, LinearUse::Observe);
            try checkLinearNode(checker, env, index, LinearUse::Consume);
        }

            for item in items {
                try checkLinearNode(checker, env, item, LinearUse::Consume);
            }
        }
        case ast::NodeValue::ArrayRepeatLit(repeat) => {
            if let itemTy = typeFor(&mut *checker.resolver, repeat.item) {
            if let itemTy = typeFor(checker.resolver, repeat.item) {
                if not isCopy(itemTy) {
                    throw emitError(
                        &mut *checker.resolver,
                        checker.resolver,
                        repeat.item,
                        ErrorKind::LinearDiscard,
                    );
                }
            }
            try checkLinearNode(checker, env, repeat.item, LinearUse::Consume);
            try checkLinearNode(checker, env, repeat.count, LinearUse::Consume);
        }
        case ast::NodeValue::BinOp(op) => {
            try checkLinearNode(checker, env, op.left, LinearUse::Consume);
            try checkLinearNode(checker, env, op.right, LinearUse::Consume);
            let mut operandUse = LinearUse::Consume;
            match op.op {
                case ast::BinaryOp::Eq, ast::BinaryOp::Ne,
                     ast::BinaryOp::Lt, ast::BinaryOp::Gt,
                     ast::BinaryOp::Lte, ast::BinaryOp::Gte =>
                    set operandUse = LinearUse::Observe,
                else => {}
            }
            try checkLinearNode(checker, env, op.left, operandUse);
            try checkLinearNode(checker, env, op.right, operandUse);
        }
        case ast::NodeValue::UnOp(op) => {
            try checkLinearNode(checker, env, op.value, LinearUse::Consume);
        }
        case ast::NodeValue::As(expr) => {
            try checkLinearNode(checker, env, expr.value, LinearUse::Consume);
            let mut castUse = usage;
            if let targetTy = typeFor(checker.resolver, node); isNumericType(targetTy) {
                set castUse = LinearUse::Observe;
            }
            try checkLinearNode(checker, env, expr.value, castUse);
        }
        case ast::NodeValue::Range(range) => {
            if let start = range.start {
                try checkLinearNode(checker, env, start, LinearUse::Consume);
            }

        }
        case ast::NodeValue::IfLet(conditional) => {
            try checkLinearIfLet(checker, env, node, conditional);
        }
        case ast::NodeValue::LetElse(binding) => {
            if let subjectTy = typeFor(&mut *checker.resolver, binding.pattern.scrutinee);
            if let subjectTy = typeFor(checker.resolver, binding.pattern.scrutinee);
                isLinear(subjectTy)
            {
                throw emitError(
                    &mut *checker.resolver,
                    checker.resolver,
                    binding.pattern.scrutinee,
                    ErrorKind::LinearPartialMove,
                );
            }
            try checkLinearNode(
                checker,
                env,
                binding.pattern.scrutinee,
                LinearUse::Consume,
                patternSubjectUse(checker.resolver, binding.pattern.scrutinee),
            );
            let base = *env;
            let mut guardedEnv = base;
            if let guard = binding.pattern.guard {
                try checkLinearNode(checker, &mut guardedEnv, guard, LinearUse::Consume);

                );
                try joinLinearBranches(checker, env, &conditionExit, &elseEnv, node);
            }
        }
        case ast::NodeValue::WhileLet(whileStmt) => {
            if let subjectTy = typeFor(&mut *checker.resolver, whileStmt.pattern.scrutinee);
            if let subjectTy = typeFor(checker.resolver, whileStmt.pattern.scrutinee);
                isLinear(subjectTy)
            {
                throw emitError(
                    &mut *checker.resolver,
                    checker.resolver,
                    whileStmt.pattern.scrutinee,
                    ErrorKind::LinearPartialMove,
                );
            }
            let base = *env;

            let mut bodyEnv = base;
            try checkLinearNode(
                checker,
                &mut bodyEnv,
                whileStmt.pattern.scrutinee,
                LinearUse::Consume,
                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 joinLinearBranches(checker, env, &conditionExit, &elseEnv, node);
            }
        }
        case ast::NodeValue::For(forStmt) => {
            if let iterableTy = typeFor(&mut *checker.resolver, forStmt.iterable) {
            if let iterableTy = typeFor(checker.resolver, forStmt.iterable) {
                if isLinear(iterableTy) {
                    throw emitError(
                        &mut *checker.resolver,
                        checker.resolver,
                        forStmt.iterable,
                        ErrorKind::LinearPartialMove,
                    );
                }
            }


/// Check exact-use ownership for one resolved function.
unsafe fn checkLinearFn(
    self: &mut Resolver,
    receiver: ?*ast::Node,
    params: *mut [*ast::Node],
    params: *[*ast::Node],
    body: *ast::Node,
) throws (ResolveError) {
    let mut checker = LinearChecker {
        resolver: self as *unsafe mut Resolver,
        loans: undefined,

        let diags = try resolvePackage(self, pkg.rootEntry, pkg.rootAst);
        if not success(&diags) {
            return diags;
        }
    }
    return Diagnostics { errors: self.errors };
    return diagnostics(self);
}

/// Resolve a package.
unsafe fn resolvePackage(self: &mut Resolver, rootEntry: *module::ModuleEntry, node: *ast::Node) -> Diagnostics throws (ResolveError) {
    let rootId = rootEntry.id;

        else panic "resolvePackage: expected block for module root";

    // Module graph analysis phase: bind all module name symbols and scopes.
    try resolveModuleGraph(self, &block) catch {
        assert self.errors.len > 0, "resolvePackage: failure should have diagnostics";
        return Diagnostics { errors: self.errors };
        return diagnostics(self);
    };

    // Declaration phase: bind all names and analyze top-level declarations.
    try resolveModuleDecls(self, &block) catch {
        assert self.errors.len > 0, "resolvePackage: failure should have diagnostics";
    };
    if self.errors.len > 0 {
        return Diagnostics { errors: self.errors };
        return diagnostics(self);
    }

    // Definition phase: analyze function bodies and sub-module definitions.
    try resolveModuleDefs(self, &block) catch {
        assert self.errors.len > 0, "resolvePackage: failure should have diagnostics";
    };
    setNodeType(self, node, Type::Void);

    return Diagnostics { errors: self.errors };
    return diagnostics(self);
}

lib/std/lang/resolver/printer.rad +10 -7

        io::print("mut ");
    }
}

/// Print a resolved type in a textual form.
fn printType(ty: super::Type) {
unsafe fn printType(ty: super::Type) {
    printTypeBody(ty, false);
}

/// Print just the type name without detailed structure info.
fn printTypeName(ty: super::Type) {
unsafe fn printTypeName(ty: super::Type) {
    printTypeBody(ty, true);
}

/// Print a resolved type, optionally abbreviated for function signatures.
fn printTypeBody(ty: super::Type, brief: bool) {
unsafe fn printTypeBody(ty: super::Type, brief: bool) {
    match ty {
        case super::Type::Unknown => {
            io::print("<unknown>");
        }
        case super::Type::Undefined => {

        }
    }
}

/// Print detailed information about a nominal type (record or union).
fn printNominalType(info: *super::NominalType) {
unsafe fn printNominalType(info: *unsafe super::NominalType) {
    match *info {
        case super::NominalType::Placeholder(_) => {
            io::print("<placeholder>");
        }
        case super::NominalType::Record(recordType) => {

        }
    }
}

/// Print just the type kind for a nominal type, without detailed info.
fn printNominalTypeName(info: *super::NominalType) {
unsafe fn printNominalTypeName(info: *unsafe super::NominalType) {
    match *info {
        case super::NominalType::Placeholder(_) => {
            io::print("<placeholder>");
        }
        case super::NominalType::Record(_) => {

        }
    }
}

/// Print a single diagnostic entry.
unsafe fn printError(err: *super::Error, res: &super::Resolver) {
unsafe fn printError(err: &super::Error, res: &super::Resolver) {
    if let node = err.node {
        // Find the module containing this error.
        if let moduleEntry = module::get(&*res.moduleGraph, err.moduleId) {
        if let moduleEntry = module::get(res.moduleGraph, err.moduleId) {
            // Get the source text if available.
            if let source = moduleEntry.source {
                // Convert offset to location.
                if let loc = scanner::getLocation(scanner::SourceLoc::File(moduleEntry.filePath), source, node.span.offset) {
                    // Print: filename:line:col: error: message

            io::print("expected numeric type");
        }
        case super::ErrorKind::ExpectedPointer => {
            io::print("expected pointer type");
        }
        case super::ErrorKind::InvalidSliceAllocator => {
            io::print("expected allocator with func callback and matching opaque ctx pointer");
        }
        case super::ErrorKind::ExpectedRecord => {
            io::print("expected record type");
        }
        case super::ErrorKind::ExpectedIndexable => {
            io::print("expected array or slice");

lib/std/lang/resolver/tests.rad +138 -12

        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 STRING_POOL, &mut MODULE_ARENA);
    set MODULE_GRAPH = module::moduleGraph(&mut MODULE_ENTRIES[..], &mut MODULE_ARENA);
    let config = super::Config { buildTest: true };
    let res = super::resolver(testStorage(), config);

    return res;
}

unsafe fn resolveStatements(
    self: &mut super::Resolver, 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 { errors: self.errors }, root: module.modBody };
        return TestResult { diagnostics: super::diagnostics(self), root: module.modBody };
    };
    return TestResult { diagnostics, root: module.fnBody };
}

/// Parse and analyze an expression string for testing.


/// 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) {
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let stmt = try parser::parse(scanner::SourceLoc::String, stmt, &mut arena, &mut STRING_POOL) catch {
    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;
    };

    arena: &mut ast::NodeArena
) -> u16 throws (testing::TestError) {
    let filePath = "<test>";
    let mut modId: u16 = undefined;
    if let parent = parentId {
        set modId = try module::registerChild(graph, parent, name, filePath) catch {
        set modId = try module::registerChild(graph, &mut STRING_POOL, parent, name, filePath) catch {
            throw testing::TestError::Failed;
        };
    } else {
        set modId = try module::registerRootWithName(graph, 0, name, filePath) catch {
        set modId = try module::registerRootWithName(graph, &mut STRING_POOL, 0, name, filePath) catch {
            throw testing::TestError::Failed;
        };
    }
    let root = try parser::parse(scanner::SourceLoc::String, code, arena, &mut STRING_POOL) catch {
        panic "registerModule: parsing failed";

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) {
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
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;

        throw testing::TestError::Failed;
    }
}

/// Verify that an error represents a specific type mismatch.
fn expectTypeMismatch(err: &super::Error, expected: super::Type, actual: super::Type)
fn expectTypeMismatch(err: super::Error, expected: super::Type, actual: super::Type)
    throws (testing::TestError)
{
    let case super::ErrorKind::TypeMismatch(mismatch) = err.kind
        else throw testing::TestError::Failed;
    try testing::expect(mismatch.expected == expected);

    }
    return body.statements[index];
}

/// Retrieve a function body block by function name from the program scope.
fn getFnBody(a: &super::Resolver, root: *ast::Node, name: *[u8]) -> ast::Block
unsafe fn getFnBody(a: &super::Resolver, 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)

    return blk;
}

/// Get the payload type of a union variant, if it has one.
/// For single-field unlabeled variants like `Variant(i32)`, unwraps to return the inner type.
fn getUnionVariantPayload(nominalTy: *super::NominalType, variantName: *[u8]) -> super::Type {
unsafe fn getUnionVariantPayload(nominalTy: *unsafe super::NominalType, variantName: *[u8]) -> super::Type {
    let case super::NominalType::Union(unionType) = *nominalTy
        else panic "getUnionVariantPayload: not a union";
    for i in 0..unionType.variants.len {
        if mem::eq(unionType.variants[i].name, variantName) {
            let payloadType = unionType.variants[i].valueType;

    }
    panic "getUnionVariantPayload: variant not found";
}

/// Get a nominal type by name, in the scope of the given block node.
fn getTypeInScopeOf(a: &super::Resolver, blk: *ast::Node, name: *[u8]) -> *super::NominalType
unsafe fn getTypeInScopeOf(a: &super::Resolver, 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)

}

/// 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 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.

/// Unsafe contexts permit pattern access through raw pointers.
@test unsafe fn testRawPointerPatternsAllowed() throws (testing::TestError) {
    try expectAnalyzeOk("union U: Copy { A(u8), B } unsafe fn run(p: *unsafe U) { match p { case U::A(n) => { *n; } else => {} } if let case U::A(n) = p { *n; } while let case U::A(n) = p { *n; break; } }");
    try expectAnalyzeOk("record R: Copy { n: u8 } unsafe fn run(p: *unsafe R) { let case R { n } = p else return; }");
}

/// Slice append requires the allocator layout and callback signature.
@test unsafe fn testSliceAppendAllocatorRejected() throws (testing::TestError) {
    let programs = &[
        "fn run(s: *mut [u8]) { s.append(1, 0); }",
        "record A { ctx: *mut opaque, func: fn(*mut opaque, u32, u32) -> *mut opaque } fn run(s: *mut [u8], a: A) { s.append(1, a); }",
        "record A { func: u64, ctx: u64 } fn run(s: *mut [u8], a: A) { s.append(1, a); }",
        "record A { func: fn(*mut opaque, u64, u32) -> *mut opaque, ctx: *mut opaque } fn run(s: *mut [u8], a: A) { s.append(1, a); }",
        "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);
    }
}

/// Slice allocators can use raw context pointers.
@test unsafe fn testSliceAppendRawContextAllowed() throws (testing::TestError) {
    try expectAnalyzeOk("record A: Copy { func: unsafe fn(*unsafe mut opaque, u32, u32) -> *mut opaque, ctx: *unsafe mut opaque } fn run(s: *mut [u8], a: A) { s.append(1, a); }");
}

/// A live pattern reference protects its payload from writes through copied pointers.
@test unsafe fn testPatternPayloadPointerAliasesRejected() throws (testing::TestError) {
    let programs = &[
        "union U: Copy { A(u8), B } fn run(p: *mut U) { let q = p; match p { case U::A(n) => { set *q = U::B; *n; } else => {} } }",
        "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);
    }
}

/// Every access to a moved safe mutable pointer is rejected.
@test unsafe fn testMutablePointerMovesRejected() throws (testing::TestError) {
    let programs = &[
        "fn run(p: *mut u8) { let q = p; *p; }",
        "fn run(p: *mut u8) { let q = p; set *p = 1; }",
        "fn run(p: *mut u8) { let q = p; let r = &*p; }",
        "fn read(p: &u8) {} fn run(p: *mut u8) { let q = p; read(p); }",
        "fn run(p: &mut u8) { let q = p; *p; }",
        "fn run(p: *mut [u8]) { let q = p; p.len; }",
        "fn run(p: &mut [u8]) { let q = p; p[0]; }",
        "record R { value: u8 } fn run(p: *mut R) { let q = p; p.value; }",
        "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);
    }
}

/// Copy composites cannot contain safe mutable owners or their containers.
@test unsafe fn testCopyMutablePointerFieldsRejected() throws (testing::TestError) {
    let programs = &[
        "record R: Copy { p: *mut u8 }",
        "union U: Copy { A(*mut u8), B }",
        "record R: Copy { p: ?*mut u8 }",
        "record R: Copy { p: [*mut u8; 2] }",
        "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);
    }
}

/// Moves transfer safe mutable pointers, and calls can borrow them temporarily.
@test unsafe fn testMutablePointerMovesAllowed() throws (testing::TestError) {
    try expectAnalyzeOk("fn run(p: *mut u8) -> u8 { let q = p; set *q = 1; return *q; }");
    try expectAnalyzeOk("fn setValue(p: &mut u8) { set *p = 1; } fn run(p: *mut u8) { setValue(p); setValue(p); *p; }");
    try expectAnalyzeOk("fn run(p: *u8) { let q = p; *p; *q; }");
    try expectAnalyzeOk("fn run(p: *mut u8, q: *mut u8) { unsafe { p == q; p as u64; } 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 = 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) {
    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, throwing));
    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);
}

/// 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);
}

lib/std/lang/scanner.rad +6 -6

    source: *[u8],
    /// Offset of current token into buffer.
    token: u32,
    /// Offset of current character being scanned.
    cursor: u32,
    /// Interned string pool.
    pool: *mut strings::Pool,
    /// Interned string pool. It must remain valid while scanning.
    pool: *unsafe mut strings::Pool,
}

/// Individual token with kind, source text, and position.
///
/// Represents a single lexical element extracted from source,

    /// Column number.
    col: u16,
}

/// Create a new scanner object.
export fn scanner(sourceLoc: SourceLoc, source: *[u8], pool: *mut strings::Pool) -> Scanner {
export unsafe fn scanner(sourceLoc: SourceLoc, source: *[u8], pool: *unsafe mut strings::Pool) -> Scanner {
    // Intern built-in functions and attributes.
    strings::intern(pool, "@sizeOf");
    strings::intern(pool, "@alignOf");
    strings::intern(pool, "@sliceOf");
    strings::intern(pool, "@default");

    }
    return TokenKind::Ident;
}

/// Scan an identifier, keyword, or label.
fn scanIdentifier(s: &mut Scanner) -> Token {
unsafe fn scanIdentifier(s: &mut Scanner) -> Token {
    while let ch = current(s); char::isAlpha(ch) or ch == '_' or char::isDigit(ch) {
        advance(s);
    }
    let ident = &s.source[s.token..s.cursor];
    let kind = keywordOrIdent(ident);

        return Token { kind, source: strings::intern(s.pool, ident), offset: s.token };
    }
    return tok(s, kind);
}

/// Scan the next token.
export fn next(s: &mut Scanner) -> Token {
/// Scan the next token. The retained string pool must be valid and writable.
export unsafe fn next(s: &mut Scanner) -> Token {
    skipWhitespace(s);  // Skip any whitespace between tokens.
    set s.token = s.cursor; // Token starts at current position.

    if isEof(s) {
        return tok(s, TokenKind::Eof);

lib/std/lang/scanner/tests.rad +20 -20

    unsafe {
        return super::scanner(super::SourceLoc::File("test.r"), source, &mut TEST_STRING_POOL);
    }
}

@test fn testScanTokens() throws (testing::TestError) {
@test unsafe fn testScanTokens() throws (testing::TestError) {
    let mut s = testScanner(
        "'x' < fnord fnord: 0 => >> mod and nil"
    );
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Char);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Lt);

    try testing::expect(super::next(&mut s).kind == super::TokenKind::And);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Nil);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Eof);
}

@test fn testScanChars() throws (testing::TestError) {
@test unsafe fn testScanChars() throws (testing::TestError) {
    let mut s = testScanner(
        "'\\0'"
    );
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Char);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Eof);
}

@test fn testScanWhitespace() throws (testing::TestError) {
@test unsafe fn testScanWhitespace() throws (testing::TestError) {
    let mut s = testScanner(
        " X\n\nY //\n Z//1 \n"
    );
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Ident);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Ident);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Ident);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Eof);
}

@test fn testScanIdentsAndKeywords() throws (testing::TestError) {
@test unsafe fn testScanIdentsAndKeywords() throws (testing::TestError) {
    let mut s = testScanner(
        "m mo mod modo"
    );
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Ident);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Ident);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Mod);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Ident);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Eof);
}

@test fn testScanIdentifiers() throws (testing::TestError) {
@test unsafe fn testScanIdentifiers() throws (testing::TestError) {
    let mut s = testScanner(
        "fnord::yikes no1 4j"
    );
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Ident);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::ColonColon);

    try testing::expect(super::next(&mut s).kind == super::TokenKind::Number);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Ident);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Eof);
}

@test fn testScanAtIdentifiers() throws (testing::TestError) {
@test unsafe fn testScanAtIdentifiers() throws (testing::TestError) {
    let mut s = testScanner(
        "@default @"
    );
    try testing::expect(super::next(&mut s).kind == super::TokenKind::AtIdent);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Invalid);
}

@test fn testScanStrings() throws (testing::TestError) {
@test unsafe fn testScanStrings() throws (testing::TestError) {
    let mut s = testScanner(
        "\"Hello World!\" \"\\\"\""
    );
    let mut t: super::Token = super::next(&mut s);
    try testing::expect(t.kind == super::TokenKind::String);

    try testing::expect(t.kind == super::TokenKind::String);
    try testing::expect(t.source.len == 4);
    try testing::expect(mem::eq(t.source, "\"\\\"\""));
}

@test fn testGetLocation() throws (testing::TestError) {
@test unsafe fn testGetLocation() throws (testing::TestError) {
    let mut s = testScanner(
        "abc\n  def\n    ghi"
    );
    let mut tok: super::Token = super::next(&mut s);
    try testing::expect(tok.kind == super::TokenKind::Ident);

    } else {
        try testing::expect(false);
    }
}

@test fn testScanEmptyInput() throws (testing::TestError) {
@test unsafe fn testScanEmptyInput() throws (testing::TestError) {
    let mut s = testScanner("");
    let tok: super::Token = super::next(&mut s);

    try testing::expect(tok.kind == super::TokenKind::Eof);
    try testing::expect(tok.source.len == 0);
    try testing::expect(tok.offset == 0);
}

@test fn testScanSingleCharTokens() throws (testing::TestError) {
@test unsafe fn testScanSingleCharTokens() throws (testing::TestError) {
    let mut s = testScanner(
        "(){}[] ,;+-*~|&"
    );
    try testing::expect(super::next(&mut s).kind == super::TokenKind::LParen);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::RParen);

    try testing::expect(super::next(&mut s).kind == super::TokenKind::Pipe);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Amp);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Eof);
}

@test fn testScanDoubleCharTokens() throws (testing::TestError) {
@test unsafe fn testScanDoubleCharTokens() throws (testing::TestError) {
    let mut s = testScanner(
        "== <> <= >= < > >> << -> =>"
    );
    try testing::expect(super::next(&mut s).kind == super::TokenKind::EqualEqual);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::LtGt);

    try testing::expect(super::next(&mut s).kind == super::TokenKind::Arrow);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::FatArrow);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Eof);
}

@test fn testScanIdentifierLengths() throws (testing::TestError) {
@test unsafe fn testScanIdentifierLengths() throws (testing::TestError) {
    let mut s = testScanner(
        "sho xyz981 lal_lel"
    );
    let mut tok: super::Token = super::next(&mut s);
    try testing::expect(tok.kind == super::TokenKind::Ident);

    set tok = super::next(&mut s);
    try testing::expect(tok.kind == super::TokenKind::Ident);
    try testing::expect(tok.source.len == 7);
}

@test fn testScanNumbers() throws (testing::TestError) {
@test unsafe fn testScanNumbers() throws (testing::TestError) {
    let mut s = testScanner(
        "2 -2 +2 value-2 value+2 value--2 value+-2 value-+2 f(-2)"
    );
    let expected: [super::TokenKind; 29] = [
        super::TokenKind::Number,

    for expectedKind in expected {
        try testing::expect(super::next(&mut s).kind == expectedKind);
    }
}

@test fn testScanKeywords() throws (testing::TestError) {
@test unsafe fn testScanKeywords() throws (testing::TestError) {
    let mut s = testScanner("nil mod not static unsafe");
    let tok1: super::Token = super::next(&mut s);

    try testing::expect(tok1.kind == super::TokenKind::Nil);
    try testing::expect(tok1.source.len == 3);

    let tok5: super::Token = super::next(&mut s);
    try testing::expect(tok5.kind == super::TokenKind::Unsafe);
    try testing::expect(tok5.source.len == 6);
}

@test fn testScanVoidAsIdent() throws (testing::TestError) {
@test unsafe fn testScanVoidAsIdent() throws (testing::TestError) {
    let mut s = testScanner("void");
    let tok: super::Token = super::next(&mut s);
    try testing::expect(tok.kind == super::TokenKind::Ident);
    try testing::expect(tok.source.len == 4);
}

@test fn testScanWhitespaceAndComments() throws (testing::TestError) {
@test unsafe fn testScanWhitespaceAndComments() throws (testing::TestError) {
    let mut s = testScanner(
        "  \t\n  // This is a comment..\n  42"
    );
    let tok: super::Token = super::next(&mut s);
    try testing::expect(tok.kind == super::TokenKind::Number);
    try testing::expect(tok.source.len == 2);
    try testing::expect(super::isEof(&s));
}

@test fn testScanInvalidCharacters() throws (testing::TestError) {
@test unsafe fn testScanInvalidCharacters() throws (testing::TestError) {
    let mut s = testScanner(
        "`#$"
    );
    let mut tok: super::Token = super::next(&mut s);
    try testing::expect(tok.kind == super::TokenKind::Invalid);

    set tok = super::next(&mut s);
    try testing::expect(tok.kind == super::TokenKind::Invalid);
    try testing::expect(tok.offset == 2);
}

@test fn testScanUnterminatedString() throws (testing::TestError) {
@test unsafe fn testScanUnterminatedString() throws (testing::TestError) {
    let mut s = testScanner("\"Hello World!");
    let tok: super::Token = super::next(&mut s);

    try testing::expect(tok.kind == super::TokenKind::Invalid);
    try testing::expect(tok.source == "unterminated string");
    try testing::expect(tok.offset == 0);
}

@test fn testScanUnderminatedStringEscape() throws (testing::TestError) {
@test unsafe fn testScanUnderminatedStringEscape() throws (testing::TestError) {
    let mut s = testScanner("\"\\");
    let tok: super::Token = super::next(&mut s);

    try testing::expect(tok.kind == super::TokenKind::Invalid);
}

@test fn testScanFunctionDefinition() throws (testing::TestError) {
@test unsafe fn testScanFunctionDefinition() throws (testing::TestError) {
    let mut s = testScanner(
        "fn add(a: i32, b: i32) -> i32 { return a + b; }"
    );
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Fn);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Ident);

lib/std/lang/sexpr.rad +1 -1

/// Output target for S-expression printing.
export union Output: Copy {
    /// Print to stdout.
    Stdout,
    /// Write to a buffer, tracking position.
    Buffer { buf: *mut [u8], pos: *unsafe mut u32 },
    Buffer { buf: *unsafe mut [u8], pos: *unsafe mut u32 },
}

/// An S-expression element.
export union Expr: Copy {
    /// An empty expression.

lib/std/lang/strings.rad +3 -3

    /// Not found, contains empty slot index.
    Empty(u32),
}

/// Look up a string, returning either the found entry or the empty slot index.
fn lookup(sp: *Pool, str: *[u8]) -> Lookup {
fn lookup(sp: &Pool, str: *[u8]) -> Lookup {
    let mut idx = dict::hash(str) & (TABLE_SIZE - 1);

    loop {
        let entry = sp.table[idx];
        if entry.len > 0 {

    }
}

/// Look up a string in the pool.
/// Returns the canonical interned pointer if the string exists.
export fn find(sp: *Pool, str: *[u8]) -> ?*[u8] {
export fn find(sp: &Pool, str: *[u8]) -> ?*[u8] {
    match lookup(sp, str) {
        case Lookup::Found(entry) => return entry,
        case Lookup::Empty(_) => return nil,
    }
}

/// Intern a string, returning a canonical pointer for equality comparison.
///
/// If the string content already exists in the pool, returns the existing pointer.
/// Otherwise, adds the string pointer to the pool and returns it.
export fn intern(sp: *mut Pool, str: *[u8]) -> *[u8] {
export fn intern(sp: &mut Pool, str: *[u8]) -> *[u8] {
    match lookup(sp, str) {
        case Lookup::Found(entry) => return entry,
        case Lookup::Empty(idx) => {
            assert sp.count < TABLE_SIZE / 2, "intern: string pool is full";
            set sp.table[idx] = str;

test/runner.rad +4 -4

}

/// Write a self-contained RV64 image containing text and data sections.
unsafe fn writeImage(
    code: *[u32],
    roData: *[u8],
    roData: &[u8],
    rwData: *[u8],
    path: *[u8]
) -> bool {
    let mut header = rv64::imageHeader(code.len * rv64::INSTR_SIZE as u32, roData.len, rwData.len);
    let headerBytes: *unsafe [u8] = @sliceOf(&header[0] as *unsafe u8, header.len * rv64::WORD_SIZE as u32);
    let codeBytes = @sliceOf(code.ptr as *u8, code.len * rv64::INSTR_SIZE as u32);

    let fd = unix::openOpts(path, unix::OpenFlags(*unix::O_WRONLY | *unix::O_CREAT | *unix::O_TRUNC), 420);
    if fd < 0 { return false; }
    let written = unix::writeAll(fd, &headerBytes[..]) and unix::writeAll(fd, codeBytes)
    let written = unix::writeAll(fd, &headerBytes[..]) and unix::writeAll(fd, &codeBytes[..])
        and unix::writeAll(fd, roData) and unix::writeAll(fd, rwData);
    let closed = unix::close(fd) == 0;
    return written and closed;
}


        io::printError(sourcePath);
        io::printError("\n");
        return false;
    };

    if not writeImage(program.text, program.data, &[], outputPath) {
    if not writeImage(program.text, &program.data[..], &[], outputPath) {
        io::printError("error: could not write output: ");
        io::printError(outputPath);
        io::printError("\n");
        return false;
    }

    let expected = &EXPECTED_BUF[..expectedLen];
    let source = &SOURCE_BUF[..sourceLen];

    // Parse source.
    let mut astArena = ast::nodeArena(&mut AST_ARENA_STORAGE[..]);
    let root = try parser::parse(scanner::SourceLoc::String, source, &mut astArena, &mut STRING_POOL) catch {
    let root: *ast::Node = try parser::parse(scanner::SourceLoc::String, source, &mut astArena, &mut STRING_POOL) catch {
        io::printLn("error: parsing failed");
        return false;
    };

    // Run resolver.

test/tests/edge.cases.6.rad +2 -2

    r: u32,
    s: u32,
    t: u32,
}

record Analyzer: Copy {
record Analyzer {
    pad0: u32,
    pad1: u32,
    entries: *mut [Entry],
    len: u32,
}


@default unsafe fn main() -> i32 {
    let target = &mut STORAGE[..];
    init(target);
    add();
    return checkHeader(target);
    return checkHeader(&STORAGE[..]);
}

test/tests/edge.cases.7.addr.bug.rad +1 -1

//! returns: 42

record PtrHolder: Copy {
record PtrHolder {
    ptr: *mut i32,
}

static target: i32 = 10;
unsafe static holder: PtrHolder = undefined;

test/tests/pointer.arithmetic.unsafe.rad +1 -1

/// Backing storage for pointer offsets.
static DATA: [u8; 3] = [11, 22, 33];

/// Read and write valid offsets in an unsafe function.
@default unsafe fn main() -> i32 {
    let p = &mut DATA[0];
    let p: *unsafe mut u8 = &mut DATA[0];
    let q = p + 1;
    if *q <> 22 { return 1; }
    if *(1 + q) <> 33 { return 2; }
    if *(q - 1) <> 11 { return 3; }
    set *q = 44;

test/tests/pointer.cast.unsafe.rad +2 -2

/// Reinterpret valid storage in an unsafe function.
@default unsafe fn main() -> i32 {
    let bytes = &mut DATA[..] as *mut [u8];
    if bytes[0] <> 42 { return 1; }
    set bytes[0] = 43;
    let word = bytes.ptr as *u64;
    if *word <> 43 { return 2; }
    let words = bytes as *[u64];
    let word = words.ptr as *u64;
    if *word <> 43 { return 2; }
    if words[0] <> 43 { return 3; }
    return 0;
}

test/tests/pointer.slice.store.rad +2 -2

    c: u32,
    d: u32,
    e: u32,
}

record Table: Copy {
record Table {
    entries: *mut [Entry],
    len: u32,
}

record PtrBox: Copy {
record PtrBox {
    ptr: *mut *mut [Entry],
}

unsafe static STORAGE: [Entry; 2] = undefined;
unsafe static TABLE: Table = undefined;

test/tests/slice.append.rad +9 -9

//! returns: 0
//! Test slice .append() method with inline allocator.

/// Simple bump allocator for testing.
record Arena: Copy {
record Arena {
    data: *mut [u8],
    offset: u32,
}

fn newArena(data: *mut [u8]) -> Arena {

    return base as *mut opaque;
}

/// Allocator record matching the compiler's expected layout.
record Allocator: Copy {
    func: unsafe fn(*mut opaque, u32, u32) -> *mut opaque,
    ctx: *mut opaque,
    func: unsafe fn(*unsafe mut opaque, u32, u32) -> *mut opaque,
    ctx: *unsafe mut opaque,
}

unsafe fn arenaAllocFn(ctx: *mut opaque, size: u32, al: u32) -> *mut opaque {
    let arena = ctx as *mut Arena;
    return arenaAlloc(arena, size, al);
unsafe fn arenaAllocFn(ctx: *unsafe mut opaque, size: u32, al: u32) -> *mut opaque {
    let arena = ctx as *unsafe mut Arena;
    return arenaAlloc(&mut *arena, size, al);
}

fn arenaAllocator(arena: *mut Arena) -> Allocator {
unsafe fn arenaAllocator(arena: &mut Arena) -> Allocator {
    return Allocator {
        func: arenaAllocFn,
        ctx: arena as *mut opaque,
        ctx: (arena as *unsafe mut Arena) as *unsafe mut opaque,
    };
}

unsafe static BUF: [u8; 4096] = undefined;


    if nums[3] <> 40 {
        return 12;
    }

    // Append from empty (cap == 0 triggers growth with cap = 1).
    let mut empty = @sliceOf(ptr as *mut i32, 0, 0);
    let mut empty: *mut [i32] = &mut [];
    empty.append(99, a);

    if empty.len <> 1 {
        return 13;
    }

test/tests/slice.append.ril +293 -293

    ebreak;
    unreachable;
  @then58
    ret 12;
  @merge59
    reserve %167 16 8;
    store w64 %10 %167 0;
    store w32 0 %167 8;
    store w32 0 %167 12;
    load w32 %170 %167 8;
    load w32 %171 %167 12;
    br.ult w32 %170 %171 @append.store62 @append.grow63;
    reserve %157 16 8;
    store w64 0 %157 0;
    store w32 0 %157 8;
    store w32 0 %157 12;
    load w32 %160 %157 8;
    load w32 %161 %157 12;
    br.ult w32 %160 %161 @append.store62 @append.grow63;
  @guard#pass60
    load w64 %153 %11 0;
    mul w64 %154 3 4;
    add w64 %155 %153 %154;
    sload w32 %156 %155 0;
    br.ne w32 %156 40 @then58 @merge59;
  @guard#trap61
    ebreak;
    unreachable;
  @append.store62
    load w64 %185 %167 0;
    mul w64 %186 %170 4;
    add w64 %187 %185 %186;
    store w32 99 %187 0;
    add w32 %188 %170 1;
    store w32 %188 %167 8;
    load w32 %191 %167 8;
    br.ne w32 %191 1 @then67 @merge68;
    load w64 %175 %157 0;
    mul w64 %176 %160 4;
    add w64 %177 %175 %176;
    store w32 99 %177 0;
    add w32 %178 %160 1;
    store w32 %178 %157 8;
    load w32 %181 %157 8;
    br.ne w32 %181 1 @then67 @merge68;
  @append.grow63
    shl w32 %172 %171 1;
    or w32 %173 %172 1;
    load w64 %174 %7 0;
    load w64 %175 %7 8;
    mul w32 %176 %173 4;
    call w64 %177 %174(%175, %176, 4);
    load w64 %178 %167 0;
    mul w32 %179 %170 4;
    shl w32 %162 %161 1;
    or w32 %163 %162 1;
    load w64 %164 %7 0;
    load w64 %165 %7 8;
    mul w32 %166 %163 4;
    call w64 %167 %164(%165, %166, 4);
    load w64 %168 %157 0;
    mul w32 %169 %160 4;
    jmp @append64(0);
  @append64(w32 %180)
    br.ult w32 %180 %179 @append65 @append66;
  @append64(w32 %170)
    br.ult w32 %170 %169 @append65 @append66;
  @append65
    add w64 %181 %178 %180;
    load w8 %182 %181 0;
    add w64 %183 %177 %180;
    store w8 %182 %183 0;
    add w32 %184 %180 1;
    jmp @append64(%184);
    add w64 %171 %168 %170;
    load w8 %172 %171 0;
    add w64 %173 %167 %170;
    store w8 %172 %173 0;
    add w32 %174 %170 1;
    jmp @append64(%174);
  @append66
    store w64 %177 %167 0;
    store w32 %173 %167 12;
    store w64 %167 %157 0;
    store w32 %163 %157 12;
    jmp @append.store62;
  @then67
    ret 13;
  @merge68
    load w32 %192 %167 12;
    br.ne w32 %192 1 @then69 @merge70;
    load w32 %182 %157 12;
    br.ne w32 %182 1 @then69 @merge70;
  @then69
    ret 14;
  @merge70
    load w32 %193 %167 8;
    br.ult w32 0 %193 @guard#pass73 @guard#trap74;
    load w32 %183 %157 8;
    br.ult w32 0 %183 @guard#pass73 @guard#trap74;
  @then71
    ret 15;
  @merge72
    load w32 %198 %11 8;
    load w64 %199 %11 0;
    load w32 %188 %11 8;
    load w64 %189 %11 0;
    jmp @loop75(0, 0);
  @guard#pass73
    load w64 %194 %167 0;
    sload w32 %195 %194 0;
    br.ne w32 %195 99 @then71 @merge72;
    load w64 %184 %157 0;
    sload w32 %185 %184 0;
    br.ne w32 %185 99 @then71 @merge72;
  @guard#trap74
    ebreak;
    unreachable;
  @loop75(w32 %200, w32 %204)
    br.slt w32 %200 %198 @body76 @merge77;
  @loop75(w32 %190, w32 %194)
    br.slt w32 %190 %188 @body76 @merge77;
  @body76
    mul w64 %201 %200 4;
    add w64 %202 %199 %201;
    sload w32 %203 %202 0;
    add w32 %205 %204 %203;
    add w32 %206 %200 1;
    jmp @loop75(%206, %205);
    mul w64 %191 %190 4;
    add w64 %192 %189 %191;
    sload w32 %193 %192 0;
    add w32 %195 %194 %193;
    add w32 %196 %190 1;
    jmp @loop75(%196, %195);
  @merge77
    br.ne w32 %204 150 @then78 @merge79;
    br.ne w32 %194 150 @then78 @merge79;
  @then78
    ret 16;
  @merge79
    copy %207 $main$nominal$arena;
    call w64 %208 $arenaAlloc(%207, 2, 1);
    reserve %209 16 8;
    store w64 %208 %209 0;
    store w32 0 %209 8;
    store w32 2 %209 12;
    load w32 %213 %209 8;
    load w32 %214 %209 12;
    br.ult w32 %213 %214 @append.store80 @append.grow81;
    copy %197 $main$nominal$arena;
    call w64 %198 $arenaAlloc(%197, 2, 1);
    reserve %199 16 8;
    store w64 %198 %199 0;
    store w32 0 %199 8;
    store w32 2 %199 12;
    load w32 %203 %199 8;
    load w32 %204 %199 12;
    br.ult w32 %203 %204 @append.store80 @append.grow81;
  @append.store80
    load w64 %228 %209 0;
    add w64 %229 %228 %213;
    store w8 171 %229 0;
    add w32 %230 %213 1;
    store w32 %230 %209 8;
    load w32 %235 %209 8;
    load w32 %236 %209 12;
    br.ult w32 %235 %236 @append.store85 @append.grow86;
    load w64 %218 %199 0;
    add w64 %219 %218 %203;
    store w8 171 %219 0;
    add w32 %220 %203 1;
    store w32 %220 %199 8;
    load w32 %225 %199 8;
    load w32 %226 %199 12;
    br.ult w32 %225 %226 @append.store85 @append.grow86;
  @append.grow81
    shl w32 %215 %214 1;
    or w32 %216 %215 1;
    load w64 %217 %7 0;
    load w64 %218 %7 8;
    mul w32 %219 %216 1;
    call w64 %220 %217(%218, %219, 1);
    load w64 %221 %209 0;
    mul w32 %222 %213 1;
    shl w32 %205 %204 1;
    or w32 %206 %205 1;
    load w64 %207 %7 0;
    load w64 %208 %7 8;
    mul w32 %209 %206 1;
    call w64 %210 %207(%208, %209, 1);
    load w64 %211 %199 0;
    mul w32 %212 %203 1;
    jmp @append82(0);
  @append82(w32 %223)
    br.ult w32 %223 %222 @append83 @append84;
  @append82(w32 %213)
    br.ult w32 %213 %212 @append83 @append84;
  @append83
    add w64 %224 %221 %223;
    load w8 %225 %224 0;
    add w64 %226 %220 %223;
    store w8 %225 %226 0;
    add w32 %227 %223 1;
    jmp @append82(%227);
    add w64 %214 %211 %213;
    load w8 %215 %214 0;
    add w64 %216 %210 %213;
    store w8 %215 %216 0;
    add w32 %217 %213 1;
    jmp @append82(%217);
  @append84
    store w64 %220 %209 0;
    store w32 %216 %209 12;
    store w64 %210 %199 0;
    store w32 %206 %199 12;
    jmp @append.store80;
  @append.store85
    load w64 %250 %209 0;
    add w64 %251 %250 %235;
    store w8 205 %251 0;
    add w32 %252 %235 1;
    store w32 %252 %209 8;
    load w32 %255 %209 8;
    br.ne w32 %255 2 @then90 @merge91;
    load w64 %240 %199 0;
    add w64 %241 %240 %225;
    store w8 205 %241 0;
    add w32 %242 %225 1;
    store w32 %242 %199 8;
    load w32 %245 %199 8;
    br.ne w32 %245 2 @then90 @merge91;
  @append.grow86
    shl w32 %237 %236 1;
    or w32 %238 %237 1;
    load w64 %239 %7 0;
    load w64 %240 %7 8;
    mul w32 %241 %238 1;
    call w64 %242 %239(%240, %241, 1);
    load w64 %243 %209 0;
    mul w32 %244 %235 1;
    shl w32 %227 %226 1;
    or w32 %228 %227 1;
    load w64 %229 %7 0;
    load w64 %230 %7 8;
    mul w32 %231 %228 1;
    call w64 %232 %229(%230, %231, 1);
    load w64 %233 %199 0;
    mul w32 %234 %225 1;
    jmp @append87(0);
  @append87(w32 %245)
    br.ult w32 %245 %244 @append88 @append89;
  @append87(w32 %235)
    br.ult w32 %235 %234 @append88 @append89;
  @append88
    add w64 %246 %243 %245;
    load w8 %247 %246 0;
    add w64 %248 %242 %245;
    store w8 %247 %248 0;
    add w32 %249 %245 1;
    jmp @append87(%249);
    add w64 %236 %233 %235;
    load w8 %237 %236 0;
    add w64 %238 %232 %235;
    store w8 %237 %238 0;
    add w32 %239 %235 1;
    jmp @append87(%239);
  @append89
    store w64 %242 %209 0;
    store w32 %238 %209 12;
    store w64 %232 %199 0;
    store w32 %228 %199 12;
    jmp @append.store85;
  @then90
    ret 17;
  @merge91
    load w32 %256 %209 8;
    br.ult w32 0 %256 @guard#pass94 @guard#trap95;
    load w32 %246 %199 8;
    br.ult w32 0 %246 @guard#pass94 @guard#trap95;
  @then92
    ret 18;
  @merge93
    load w32 %259 %209 8;
    br.ult w32 1 %259 @guard#pass98 @guard#trap99;
    load w32 %249 %199 8;
    br.ult w32 1 %249 @guard#pass98 @guard#trap99;
  @guard#pass94
    load w64 %257 %209 0;
    load w8 %258 %257 0;
    br.ne w8 %258 171 @then92 @merge93;
    load w64 %247 %199 0;
    load w8 %248 %247 0;
    br.ne w8 %248 171 @then92 @merge93;
  @guard#trap95
    ebreak;
    unreachable;
  @then96
    ret 19;
  @merge97
    load w32 %265 %209 8;
    load w32 %266 %209 12;
    br.ult w32 %265 %266 @append.store100 @append.grow101;
    load w32 %255 %199 8;
    load w32 %256 %199 12;
    br.ult w32 %255 %256 @append.store100 @append.grow101;
  @guard#pass98
    load w64 %260 %209 0;
    add w64 %261 %260 1;
    load w8 %262 %261 0;
    br.ne w8 %262 205 @then96 @merge97;
    load w64 %250 %199 0;
    add w64 %251 %250 1;
    load w8 %252 %251 0;
    br.ne w8 %252 205 @then96 @merge97;
  @guard#trap99
    ebreak;
    unreachable;
  @append.store100
    load w64 %280 %209 0;
    add w64 %281 %280 %265;
    store w8 239 %281 0;
    add w32 %282 %265 1;
    store w32 %282 %209 8;
    load w32 %285 %209 8;
    br.ne w32 %285 3 @then105 @merge106;
    load w64 %270 %199 0;
    add w64 %271 %270 %255;
    store w8 239 %271 0;
    add w32 %272 %255 1;
    store w32 %272 %199 8;
    load w32 %275 %199 8;
    br.ne w32 %275 3 @then105 @merge106;
  @append.grow101
    shl w32 %267 %266 1;
    or w32 %268 %267 1;
    load w64 %269 %7 0;
    load w64 %270 %7 8;
    mul w32 %271 %268 1;
    call w64 %272 %269(%270, %271, 1);
    load w64 %273 %209 0;
    mul w32 %274 %265 1;
    shl w32 %257 %256 1;
    or w32 %258 %257 1;
    load w64 %259 %7 0;
    load w64 %260 %7 8;
    mul w32 %261 %258 1;
    call w64 %262 %259(%260, %261, 1);
    load w64 %263 %199 0;
    mul w32 %264 %255 1;
    jmp @append102(0);
  @append102(w32 %275)
    br.ult w32 %275 %274 @append103 @append104;
  @append102(w32 %265)
    br.ult w32 %265 %264 @append103 @append104;
  @append103
    add w64 %276 %273 %275;
    load w8 %277 %276 0;
    add w64 %278 %272 %275;
    store w8 %277 %278 0;
    add w32 %279 %275 1;
    jmp @append102(%279);
    add w64 %266 %263 %265;
    load w8 %267 %266 0;
    add w64 %268 %262 %265;
    store w8 %267 %268 0;
    add w32 %269 %265 1;
    jmp @append102(%269);
  @append104
    store w64 %272 %209 0;
    store w32 %268 %209 12;
    store w64 %262 %199 0;
    store w32 %258 %199 12;
    jmp @append.store100;
  @then105
    ret 20;
  @merge106
    load w32 %286 %209 12;
    br.ne w32 %286 5 @then107 @merge108;
    load w32 %276 %199 12;
    br.ne w32 %276 5 @then107 @merge108;
  @then107
    ret 21;
  @merge108
    load w32 %287 %209 8;
    br.ult w32 2 %287 @guard#pass111 @guard#trap112;
    load w32 %277 %199 8;
    br.ult w32 2 %277 @guard#pass111 @guard#trap112;
  @then109
    ret 22;
  @merge110
    load w32 %291 %209 8;
    br.ult w32 0 %291 @guard#pass115 @guard#trap116;
    load w32 %281 %199 8;
    br.ult w32 0 %281 @guard#pass115 @guard#trap116;
  @guard#pass111
    load w64 %288 %209 0;
    add w64 %289 %288 2;
    load w8 %290 %289 0;
    br.ne w8 %290 239 @then109 @merge110;
    load w64 %278 %199 0;
    add w64 %279 %278 2;
    load w8 %280 %279 0;
    br.ne w8 %280 239 @then109 @merge110;
  @guard#trap112
    ebreak;
    unreachable;
  @then113
    ret 23;
  @merge114
    copy %294 $main$nominal$arena;
    mul w32 %295 4 2;
    call w64 %296 $arenaAlloc(%294, %295, 4);
    reserve %297 16 8;
    store w64 %296 %297 0;
    store w32 0 %297 8;
    store w32 2 %297 12;
    load w32 %300 %297 8;
    load w32 %301 %297 12;
    br.ult w32 %300 %301 @append.store117 @append.grow118;
    copy %284 $main$nominal$arena;
    mul w32 %285 4 2;
    call w64 %286 $arenaAlloc(%284, %285, 4);
    reserve %287 16 8;
    store w64 %286 %287 0;
    store w32 0 %287 8;
    store w32 2 %287 12;
    load w32 %290 %287 8;
    load w32 %291 %287 12;
    br.ult w32 %290 %291 @append.store117 @append.grow118;
  @guard#pass115
    load w64 %292 %209 0;
    load w8 %293 %292 0;
    br.ne w8 %293 171 @then113 @merge114;
    load w64 %282 %199 0;
    load w8 %283 %282 0;
    br.ne w8 %283 171 @then113 @merge114;
  @guard#trap116
    ebreak;
    unreachable;
  @append.store117
    load w64 %315 %297 0;
    mul w64 %316 %300 4;
    add w64 %317 %315 %316;
    store w32 42 %317 0;
    add w32 %318 %300 1;
    store w32 %318 %297 8;
    blit %297 %297 16;
    load w32 %321 %297 8;
    br.eq w32 %321 1 @assert.ok123 @assert.fail122;
    load w64 %305 %287 0;
    mul w64 %306 %290 4;
    add w64 %307 %305 %306;
    store w32 42 %307 0;
    add w32 %308 %290 1;
    store w32 %308 %287 8;
    blit %287 %287 16;
    load w32 %311 %287 8;
    br.eq w32 %311 1 @assert.ok123 @assert.fail122;
  @append.grow118
    shl w32 %302 %301 1;
    or w32 %303 %302 1;
    load w64 %304 %7 0;
    load w64 %305 %7 8;
    mul w32 %306 %303 4;
    call w64 %307 %304(%305, %306, 4);
    load w64 %308 %297 0;
    mul w32 %309 %300 4;
    shl w32 %292 %291 1;
    or w32 %293 %292 1;
    load w64 %294 %7 0;
    load w64 %295 %7 8;
    mul w32 %296 %293 4;
    call w64 %297 %294(%295, %296, 4);
    load w64 %298 %287 0;
    mul w32 %299 %290 4;
    jmp @append119(0);
  @append119(w32 %310)
    br.ult w32 %310 %309 @append120 @append121;
  @append119(w32 %300)
    br.ult w32 %300 %299 @append120 @append121;
  @append120
    add w64 %311 %308 %310;
    load w8 %312 %311 0;
    add w64 %313 %307 %310;
    store w8 %312 %313 0;
    add w32 %314 %310 1;
    jmp @append119(%314);
    add w64 %301 %298 %300;
    load w8 %302 %301 0;
    add w64 %303 %297 %300;
    store w8 %302 %303 0;
    add w32 %304 %300 1;
    jmp @append119(%304);
  @append121
    store w64 %307 %297 0;
    store w32 %303 %297 12;
    store w64 %297 %287 0;
    store w32 %293 %287 12;
    jmp @append.store117;
  @assert.fail122
    unreachable;
  @assert.ok123
    load w32 %322 %297 8;
    br.ult w32 0 %322 @guard#pass126 @guard#trap127;
    load w32 %312 %287 8;
    br.ult w32 0 %312 @guard#pass126 @guard#trap127;
  @assert.fail124
    unreachable;
  @assert.ok125
    load w32 %327 %297 8;
    load w32 %328 %297 12;
    br.ult w32 %327 %328 @append.store128 @append.grow129;
    load w32 %317 %287 8;
    load w32 %318 %287 12;
    br.ult w32 %317 %318 @append.store128 @append.grow129;
  @guard#pass126
    load w64 %323 %297 0;
    sload w32 %324 %323 0;
    br.eq w32 %324 42 @assert.ok125 @assert.fail124;
    load w64 %313 %287 0;
    sload w32 %314 %313 0;
    br.eq w32 %314 42 @assert.ok125 @assert.fail124;
  @guard#trap127
    ebreak;
    unreachable;
  @append.store128
    load w64 %342 %297 0;
    mul w64 %343 %327 4;
    add w64 %344 %342 %343;
    store w32 43 %344 0;
    add w32 %345 %327 1;
    store w32 %345 %297 8;
    blit %297 %297 16;
    load w32 %348 %297 8;
    br.eq w32 %348 2 @assert.ok134 @assert.fail133;
    load w64 %332 %287 0;
    mul w64 %333 %317 4;
    add w64 %334 %332 %333;
    store w32 43 %334 0;
    add w32 %335 %317 1;
    store w32 %335 %287 8;
    blit %287 %287 16;
    load w32 %338 %287 8;
    br.eq w32 %338 2 @assert.ok134 @assert.fail133;
  @append.grow129
    shl w32 %329 %328 1;
    or w32 %330 %329 1;
    load w64 %331 %7 0;
    load w64 %332 %7 8;
    mul w32 %333 %330 4;
    call w64 %334 %331(%332, %333, 4);
    load w64 %335 %297 0;
    mul w32 %336 %327 4;
    shl w32 %319 %318 1;
    or w32 %320 %319 1;
    load w64 %321 %7 0;
    load w64 %322 %7 8;
    mul w32 %323 %320 4;
    call w64 %324 %321(%322, %323, 4);
    load w64 %325 %287 0;
    mul w32 %326 %317 4;
    jmp @append130(0);
  @append130(w32 %337)
    br.ult w32 %337 %336 @append131 @append132;
  @append130(w32 %327)
    br.ult w32 %327 %326 @append131 @append132;
  @append131
    add w64 %338 %335 %337;
    load w8 %339 %338 0;
    add w64 %340 %334 %337;
    store w8 %339 %340 0;
    add w32 %341 %337 1;
    jmp @append130(%341);
    add w64 %328 %325 %327;
    load w8 %329 %328 0;
    add w64 %330 %324 %327;
    store w8 %329 %330 0;
    add w32 %331 %327 1;
    jmp @append130(%331);
  @append132
    store w64 %334 %297 0;
    store w32 %330 %297 12;
    store w64 %324 %287 0;
    store w32 %320 %287 12;
    jmp @append.store128;
  @assert.fail133
    unreachable;
  @assert.ok134
    load w32 %349 %297 8;
    br.ult w32 0 %349 @guard#pass135 @guard#trap136;
    load w32 %339 %287 8;
    br.ult w32 0 %339 @guard#pass135 @guard#trap136;
  @guard#pass135
    load w64 %350 %297 0;
    load w32 %353 %297 8;
    load w32 %354 %297 12;
    br.ult w32 %353 %354 @append.store137 @append.grow138;
    load w64 %340 %287 0;
    load w32 %343 %287 8;
    load w32 %344 %287 12;
    br.ult w32 %343 %344 @append.store137 @append.grow138;
  @guard#trap136
    ebreak;
    unreachable;
  @append.store137
    load w64 %368 %297 0;
    mul w64 %369 %353 4;
    add w64 %370 %368 %369;
    store w32 44 %370 0;
    add w32 %371 %353 1;
    store w32 %371 %297 8;
    blit %297 %297 16;
    load w32 %374 %297 8;
    br.eq w32 %374 3 @assert.ok143 @assert.fail142;
    load w64 %358 %287 0;
    mul w64 %359 %343 4;
    add w64 %360 %358 %359;
    store w32 44 %360 0;
    add w32 %361 %343 1;
    store w32 %361 %287 8;
    blit %287 %287 16;
    load w32 %364 %287 8;
    br.eq w32 %364 3 @assert.ok143 @assert.fail142;
  @append.grow138
    shl w32 %355 %354 1;
    or w32 %356 %355 1;
    load w64 %357 %7 0;
    load w64 %358 %7 8;
    mul w32 %359 %356 4;
    call w64 %360 %357(%358, %359, 4);
    load w64 %361 %297 0;
    mul w32 %362 %353 4;
    shl w32 %345 %344 1;
    or w32 %346 %345 1;
    load w64 %347 %7 0;
    load w64 %348 %7 8;
    mul w32 %349 %346 4;
    call w64 %350 %347(%348, %349, 4);
    load w64 %351 %287 0;
    mul w32 %352 %343 4;
    jmp @append139(0);
  @append139(w32 %363)
    br.ult w32 %363 %362 @append140 @append141;
  @append139(w32 %353)
    br.ult w32 %353 %352 @append140 @append141;
  @append140
    add w64 %364 %361 %363;
    load w8 %365 %364 0;
    add w64 %366 %360 %363;
    store w8 %365 %366 0;
    add w32 %367 %363 1;
    jmp @append139(%367);
    add w64 %354 %351 %353;
    load w8 %355 %354 0;
    add w64 %356 %350 %353;
    store w8 %355 %356 0;
    add w32 %357 %353 1;
    jmp @append139(%357);
  @append141
    store w64 %360 %297 0;
    store w32 %356 %297 12;
    store w64 %350 %287 0;
    store w32 %346 %287 12;
    jmp @append.store137;
  @assert.fail142
    unreachable;
  @assert.ok143
    load w32 %375 %297 12;
    br.eq w32 %375 5 @assert.ok145 @assert.fail144;
    load w32 %365 %287 12;
    br.eq w32 %365 5 @assert.ok145 @assert.fail144;
  @assert.fail144
    unreachable;
  @assert.ok145
    load w32 %376 %297 8;
    br.ult w32 0 %376 @guard#pass146 @guard#trap147;
    load w32 %366 %287 8;
    br.ult w32 0 %366 @guard#pass146 @guard#trap147;
  @guard#pass146
    load w64 %377 %297 0;
    br.ne w64 %350 %377 @assert.ok149 @assert.fail148;
    load w64 %367 %287 0;
    br.ne w64 %340 %367 @assert.ok149 @assert.fail148;
  @guard#trap147
    ebreak;
    unreachable;
  @assert.fail148
    unreachable;
  @assert.ok149
    load w32 %380 %297 8;
    br.ult w32 0 %380 @guard#pass152 @guard#trap153;
    load w32 %370 %287 8;
    br.ult w32 0 %370 @guard#pass152 @guard#trap153;
  @assert.fail150
    unreachable;
  @assert.ok151
    load w32 %383 %297 8;
    br.ult w32 1 %383 @guard#pass156 @guard#trap157;
    load w32 %373 %287 8;
    br.ult w32 1 %373 @guard#pass156 @guard#trap157;
  @guard#pass152
    load w64 %381 %297 0;
    sload w32 %382 %381 0;
    br.eq w32 %382 42 @assert.ok151 @assert.fail150;
    load w64 %371 %287 0;
    sload w32 %372 %371 0;
    br.eq w32 %372 42 @assert.ok151 @assert.fail150;
  @guard#trap153
    ebreak;
    unreachable;
  @assert.fail154
    unreachable;
  @assert.ok155
    load w32 %388 %297 8;
    br.ult w32 2 %388 @guard#pass160 @guard#trap161;
    load w32 %378 %287 8;
    br.ult w32 2 %378 @guard#pass160 @guard#trap161;
  @guard#pass156
    load w64 %384 %297 0;
    mul w64 %385 1 4;
    add w64 %386 %384 %385;
    sload w32 %387 %386 0;
    br.eq w32 %387 43 @assert.ok155 @assert.fail154;
    load w64 %374 %287 0;
    mul w64 %375 1 4;
    add w64 %376 %374 %375;
    sload w32 %377 %376 0;
    br.eq w32 %377 43 @assert.ok155 @assert.fail154;
  @guard#trap157
    ebreak;
    unreachable;
  @assert.fail158
    unreachable;
  @assert.ok159
    ret 0;
  @guard#pass160
    load w64 %389 %297 0;
    mul w64 %390 2 4;
    add w64 %391 %389 %390;
    sload w32 %392 %391 0;
    br.eq w32 %392 44 @assert.ok159 @assert.fail158;
    load w64 %379 %287 0;
    mul w64 %380 2 4;
    add w64 %381 %379 %380;
    sload w32 %382 %381 0;
    br.eq w32 %382 44 @assert.ok159 @assert.fail158;
  @guard#trap161
    ebreak;
    unreachable;
}

test/tests/static.slice.offset.rad +1 -1

record Entry: Copy {
    a: i32,
    b: i32,
}

record Table: Copy {
record Table {
    scratch: *mut [Entry],
    entries: *mut [Entry],
    len: u32,
}


test/tests/trait.dispatch.rad +4 -4

record Acc: Copy {
    n: i32,
}

trait Ops {
    fn (*Ops) get() -> i32;
    fn (*mut Ops) put(n: i32);
    fn (&Ops) get() -> i32;
    fn (&mut Ops) put(n: i32);
}

instance Ops for Acc {
    fn (a: *Acc) get() -> i32 {
    fn (a: &Acc) get() -> i32 {
        return a.n;
    }

    fn (a: *mut Acc) put(n: i32) {
    fn (a: &mut Acc) put(n: i32) {
        set a.n = n;
    }
}

fn dispatch(o: *mut opaque Ops) -> i32 {

415	415		for i in 0..pkgCount {
416	416		if i <> entryIdx and inputs[i].startupPath <> nil {
417	417		throw error(&["`-start` is only supported on the entry package"]);
418	418		}
419	419		}
420		-	let graph = module::moduleGraph(&mut MODULE_ENTRIES[..], &mut STRING_POOL, arena);
	420	+	let graph = module::moduleGraph(&mut MODULE_ENTRIES[..], arena);
421	421		let mut ctx = CompileContext {
422	422		packages: undefined,
423	423		inputs,
424	424		packageCount: pkgCount,
425	425		entryPkgIdx,

442	442		}
443	443		return ctx;
444	444		}
445	445
446	446		/// Get the entry package from the context.
447		-	unsafe fn getEntryPackage(ctx: unsafe CompileContext) -> unsafe package::Package throws (Error) {
	447	+	fn getEntryPackage(ctx: &CompileContext) -> package::Package throws (Error) {
448	448		let entryIdx = ctx.entryPkgIdx else {
449	449		throw error(&["no entry package specified"]);
450	450		};
451		-	return &ctx.packages[entryIdx];
	451	+	return ctx.packages[entryIdx];
452	452		}
453	453
454	454		/// Return the startup assembly path for the entry package, if one was supplied.
455	455		fn getEntryStartupPath(ctx: &CompileContext) -> ?*[u8] {
456	456		let entryIdx = ctx.entryPkgIdx else {

478	478		let mut arena = alloc::new(&mut MAIN_ARENA[..]);
479	479		module::printer::printGraph(&ctx.graph, &mut arena);
480	480		}
481	481
482	482		/// Dump the parsed AST.
483		-	unsafe fn dumpAst(ctx: *unsafe CompileContext) throws (Error) {
	483	+	unsafe fn dumpAst(ctx: &CompileContext) throws (Error) {
484	484		let pkg = try getEntryPackage(ctx);
485		-	let root = try getRootModule(&*pkg, &ctx.graph);
	485	+	let root = try getRootModule(&pkg, &ctx.graph);
486	486		let mut arena = alloc::new(&mut MAIN_ARENA[..]);
487	487
488	488		ast::printer::printTree(root.ast, &mut arena);
489	489		}
490	490

505	505		res, &ctx.graph, entryPkg.name, &mut res.arena, &mut res.arena, options
506	506		);
507	507		try lowerAllPackagesInto(ctx, res, &mut low);
508	508
509	509		// Finalize and return the unified program.
510		-	return lower::finalize(&low);
	510	+	return lower::finalize(low);
511	511		}
512	512
513	513		/// Lower all packages into an existing lowerer.
514	514		unsafe fn lowerAllPackagesInto(
515	515		ctx: *unsafe mut CompileContext,

520	520		panic "lowerAllPackagesInto: no entry package";
521	521		};
522	522		// Lower all packages except entry.
523	523		for i in 0..ctx.packageCount {
524	524		if i <> entryIdx {
525		-	try lowerPackage(ctx, res, &mut *low, &mut ctx.packages[i], false);
	525	+	try lowerPackage(ctx, res, low, &ctx.packages[i], false);
526	526		}
527	527		}
528	528		// Lower entry package.
529		-	try lowerPackage(ctx, res, &mut *low, &mut ctx.packages[entryIdx], true);
	529	+	try lowerPackage(ctx, res, low, &ctx.packages[entryIdx], true);
530	530		}
531	531
532	532		/// Lower all modules in a package into the lowerer accumulator.
533	533		unsafe fn lowerPackage(
534		-	ctx: *unsafe CompileContext,
	534	+	ctx: &CompileContext,
535	535		res: *unsafe mut resolver::Resolver,
536	536		low: &mut lower::Lowerer,
537		-	pkg: &mut package::Package,
	537	+	pkg: &package::Package,
538	538		isEntry: bool
539	539		) throws (Error) {
540	540		let rootId = pkg.rootModuleId else {
541	541		throw error(&["no root module found"]);
542	542		};
543	543		// Set lowerer's package context for qualified name generation.
544	544		// TODO: We shouldn't have to call this manually.
545		-	lower::setPackage(&mut *low, &ctx.graph, pkg.name);
	545	+	lower::setPackage(low, &ctx.graph, pkg.name);
546	546
547		-	try lowerModuleTreeInto(ctx, &mut *low, &ctx.graph, rootId, isEntry, pkg);
	547	+	try lowerModuleTreeInto(ctx, low, &ctx.graph, rootId, isEntry, pkg);
548	548		}
549	549
550	550		/// Recursively lower a module and all its children into the accumulator.
551	551		unsafe fn lowerModuleTreeInto(
552		-	ctx: *unsafe CompileContext,
	552	+	ctx: &CompileContext,
553	553		low: &mut lower::Lowerer,
554	554		graph: &module::ModuleGraph,
555	555		modId: u16,
556	556		isRoot: bool,
557	557		pkg: &package::Package

142	142		/// Number of assembly source paths.
143	143		asmPathCount: u32,
144	144		}
145	145
146	146		/// Compilation context.
147		-	record CompileContext: Copy {
	147	+	record CompileContext {
148	148		/// Array of packages to compile.
149	149		packages: [package::Package; MAX_PACKAGES],
150	150		/// Driver inputs for each package slot.
151	151		inputs: [PackageInput; MAX_PACKAGES],
152	152		/// Number of packages.

166	166		}
167	167
168	168		/// Root module info for a package.
169	169		record RootModule: Copy {
170	170		entry: *module::ModuleEntry,
171		-	ast: *mut ast::Node,
	171	+	ast: *ast::Node,
172	172		}
173	173
174	174		/// Entry handling for streamed code generation.
175	175		union CodegenEntryMode: Copy {
176	176		/// Do not reserve an entry jump.

245	245		graph: &mut module::ModuleGraph,
246	246		path: *[u8],
247	247		nodeArena: &mut ast::NodeArena,
248	248		sourceArena: &mut alloc::Arena
249	249		) throws (Error) {
250		-	pkgLog(&*pkg, &["parsing", "(", path, ")", ".."]);
	250	+	pkgLog(pkg, &["parsing", "(", path, ")", ".."]);
251	251
252		-	let moduleId = try package::registerModule(&mut *pkg, graph, path) catch {
	252	+	let moduleId = try package::registerModule(pkg, graph, &mut STRING_POOL, path) catch {
253	253		throw error(&["error registering module"]);
254	254		};
255	255		// Read file into remaining arena space.
256	256		let buffer = alloc::remainingBuf(sourceArena);
257	257		if buffer.len == 0 {

560	560		throw error(&["module entry not found"]);
561	561		};
562	562		let modAst = entry.ast else {
563	563		throw error(&["module has no AST"]);
564	564		};
565		-	pkgLog(&*pkg, &["lowering", "(", entry.filePath, ")", ".."]);
	565	+	pkgLog(pkg, &["lowering", "(", entry.filePath, ")", ".."]);
566	566
567		-	try lower::lowerModule(&mut *low, modId, modAst, isRoot) catch err {
	567	+	try lower::lowerModule(low, modId, modAst, isRoot) catch err {
568	568		io::printError("radiance: ");
569	569		io::printError("internal error during lowering: ");
570	570		lower::printError(err);
571	571		io::printError("\n");
572	572
573	573		throw Error::Other;
574	574		};
575	575		// Recurse into children.
576	576		for i in 0..entry.childrenLen {
577	577		let childId = module::childAt(entry, i);
578		-	try lowerModuleTreeInto(ctx, &mut *low, graph, childId, false, pkg);
	578	+	try lowerModuleTreeInto(ctx, low, graph, childId, false, pkg);
579	579		}
580	580		}
581	581
582	582		/// Build a scope access chain: a::b::c from a slice of identifiers.
583	583		unsafe fn synthScopeAccess(arena: &mut ast::NodeArena, path: &[[u8]]) -> ast::Node {

683	683		unsafe fn generateTestRunner(
684	684		ctx: *unsafe mut CompileContext,
685	685		arena: &mut ast::NodeArena
686	686		) throws (Error) {
687	687		let entryPkg = try getEntryPackage(ctx);
688		-	let root = try getRootModule(&*entryPkg, &ctx.graph);
	688	+	let root = try getRootModule(&entryPkg, &ctx.graph);
689	689
690	690		// Collect all test functions across all modules.
691	691		let mut tests: [TestDesc; MAX_TESTS] = undefined;
692	692		let mut testCount: u32 = 0;
693	693

708	708		io::printError(" test(s)\n");
709	709
710	710		// Synthesize the `@default` function and append to the root module.
711	711		let fnDecl = synthTestMainFn(arena, &tests[..testCount]);
712	712
713		-	injectIntoBlock(root.ast, arena, fnDecl);
	713	+	let updatedRoot = injectIntoBlock(root.ast, arena, fnDecl);
	714	+	try module::setAst(&mut ctx.graph, root.entry.id, updatedRoot) catch {
	715	+	throw error(&["failed to set test runner AST"]);
	716	+	};
714	717		}
715	718
716	719		/// Synthesize the test entry point.
717	720		unsafe fn synthTestMainFn(arena: &mut ast::NodeArena, tests: &[TestDesc]) -> *ast::Node {
718	721		// Build array literal: `[testing::test(...), ...]`.

760	763		return ast::synthNode(arena, ast::NodeValue::FnDecl(ast::FnDecl {
761	764		name: fnName, sig: fnSig, body: fnBody, attrs: fnAttrs,
762	765		}));
763	766		}
764	767
765		-	/// Append a declaration to a block node's statement list.
	768	+	/// Build a block node with a declaration appended to its statement list.
766	769		unsafe fn injectIntoBlock(
767		-	blockNode: *mut ast::Node,
	770	+	blockNode: *ast::Node,
768	771		arena: &mut ast::NodeArena,
769	772		decl: *ast::Node
770		-	) {
	773	+	) -> *ast::Node {
771	774		let case ast::NodeValue::Block(block) = blockNode.value else {
772	775		panic "injectIntoBlock: expected Block node";
773	776		};
774		-	let stmts = block.statements.append(decl, alloc::arenaAllocator(&mut arena.arena));
775		-	set blockNode.value = ast::NodeValue::Block(ast::Block { statements: stmts, isUnsafe: block.isUnsafe });
	777	+	let allocator = alloc::arenaAllocator(&mut arena.arena);
	778	+	let mut stmts = ast::nodeSlice(arena, block.statements.len + 1);
	779	+	for stmt in block.statements {
	780	+	stmts.append(stmt, allocator);
	781	+	}
	782	+	stmts.append(decl, allocator);
	783	+	return ast::allocNode(arena, blockNode.span, ast::NodeValue::Block(
	784	+	ast::Block { statements: stmts, isUnsafe: block.isUnsafe }
	785	+	));
776	786		}
777	787
778	788		/// Write a self-contained RV64 image containing text and data sections.
779	789		unsafe fn writeImage(
780	790		code: *[u32],

786	796		let headerBytes: unsafe [u8] = @sliceOf(&header[0] as unsafe u8, header.len * rv64::WORD_SIZE as u32);
787	797		let codeBytes = @sliceOf(code.ptr as u8, code.len rv64::INSTR_SIZE as u32);
788	798
789	799		let fd = unix::openOpts(path, unix::OpenFlags(unix::O_WRONLY \| unix::O_CREAT \| *unix::O_TRUNC), 420);
790	800		if fd < 0 { return false; }
791		-	let written = unix::writeAll(fd, &headerBytes[..]) and unix::writeAll(fd, codeBytes)
	801	+	let written = unix::writeAll(fd, headerBytes) and unix::writeAll(fd, codeBytes)
792	802		and unix::writeAll(fd, roData) and unix::writeAll(fd, rwData);
793	803		let closed = unix::close(fd) == 0;
794	804		return written and closed;
795	805		}
796	806

847	857		/// Run the resolver on the parsed modules.
848	858		unsafe fn runResolver(ctx: *unsafe mut CompileContext, nodeCount: u32) -> resolver::Resolver throws (Error) {
849	859		let mut mainArena = alloc::new(&mut MAIN_ARENA[..]);
850	860		let entryPkg = try getEntryPackage(ctx);
851	861
852		-	pkgLog(&*entryPkg, &["resolving", ".."]);
	862	+	pkgLog(&entryPkg, &["resolving", ".."]);
853	863
854	864		let nodeDataSize = nodeCount * @sizeOf(resolver::NodeData);
855	865		let nodeDataPtr = try! alloc::alloc(&mut mainArena, nodeDataSize, @alignOf(resolver::NodeData));
856	866		let nodeData = @sliceOf(nodeDataPtr as *mut resolver::NodeData, nodeCount);
857	867		let storage = resolver::ResolverStorage {

865	875		// Build the semantic package list consumed by the resolver.
866	876		let mut resolverPkgs: [resolver::Pkg; MAX_PACKAGES] = undefined;
867	877		let mut resolverPackageCount: u32 = 0;
868	878		for i in 0..ctx.packageCount {
869	879		let pkg = &ctx.packages[i];
870		-	let root = try getRootModule(&*pkg, &ctx.graph);
	880	+	let root = try getRootModule(pkg, &ctx.graph);
871	881
872	882		set resolverPkgs[resolverPackageCount] = resolver::Pkg {
873	883		rootEntry: root.entry,
874	884		rootAst: root.ast,
875	885		};

347	349		let rwDataSize = data::emitSection(
348	350		globalData, &dataSymMap, &generator.e.labels, codeBase, rwDataBuf, false
349	351		);
350	352		return Program {
351	353		code: emit::getCode(&generator.e),
352		-	funcs: generator.e.funcs,
	354	+	funcs: &generator.e.funcs[..],
353	355		roDataSize,
354	356		rwDataSize,
355	357		debugEntries: emit::getDebugEntries(&generator.e),
356	358		};
357	359		}

877	887		}
878	888
879	889		// Resolve all packages.
880	890		// TODO: Fix this error printing dance.
881	891		let diags = try resolver::resolve(&mut res, &ctx.graph, &resolverPkgs[..resolverPackageCount]) catch {
882		-	let diags = resolver::Diagnostics { errors: res.errors };
	892	+	let diags = resolver::diagnostics(&mut res);
883	893		resolver::printer::printDiagnostics(&diags, &res);
884	894		throw Error::Other;
885	895		};
886	896		if not resolver::success(&diags) {
887	897		resolver::printer::printDiagnostics(&diags, &res);

905	915		pkg: &package::Package,
906	916		path: *[u8],
907	917		asmDataLen: &mut u32,
908	918		arena: &mut alloc::Arena
909	919		) throws (Error) {
910		-	pkgLog(&*pkg, &["asm:", "parsing", "(", path, ")", ".."]);
	920	+	pkgLog(pkg, &["asm:", "parsing", "(", path, ")", ".."]);
911	921
912	922		let sourceLen = unix::readFile(path, &mut ASM_SOURCE_BUF[..]) else {
913	923		throw error(&["error reading assembly file"]);
914	924		};
915	925		let source = &ASM_SOURCE_BUF[..sourceLen];

966	976		) -> rv64::Program throws (Error) {
967	977		let entryIdx = ctx.entryPkgIdx else {
968	978		panic "lowerAndGenerateAllPackages: no entry package";
969	979		};
970	980		let entryPkg = &ctx.packages[entryIdx];
971		-	let startupPath = getEntryStartupPath(&*ctx);
	981	+	let startupPath = getEntryStartupPath(ctx);
972	982		let options = lower::LowerOptions { debug: ctx.debug, buildTest: ctx.config.buildTest };
973	983		let storage = rv64::Storage {
974	984		dataSyms: &mut CODEGEN_DATA_SYMS[..],
975	985		dataSymEntries: &mut CODEGEN_DATA_SYM_ENTRIES[..],
976	986		};

985	995		rv64::ProgramOptions { entryPatch, debug: codegenOptions.debug },
986	996		&mut res.arena
987	997		);
988	998		let mut codegenCtx = codegen::Context {
989	999		generator: &mut generator,
990		-	fnArena: fnArena as *unsafe mut alloc::Arena,
	1000	+	fnArena: (&mut fnArena) as unsafe mut alloc::Arena,
991	1001		};
992	1002		let mut low = lower::lowerer(
993	1003		res, &ctx.graph, entryPkg.name, &mut res.arena, fnArena as *unsafe mut alloc::Arena, options
994	1004		);
995	1005		set low.output = lower::FnOutput::Stream(lower::FnSink {
996	1006		ctx: &mut codegenCtx as *unsafe mut opaque,
997	1007		emitFn: codegen::emit,
998	1008		});
999	1009		let mut asmDataLen: u32 = 0;
1000	1010		if let path = startupPath {
1001		-	try assembleAsmModule(&mut generator, &*entryPkg, path, &mut asmDataLen, &mut res.arena);
	1011	+	try assembleAsmModule(&mut generator, entryPkg, path, &mut asmDataLen, &mut res.arena);
1002	1012		}
1003	1013		try lowerAllPackagesInto(ctx, res, &mut low);
1004		-	let asmData = try assembleAsmInputs(&*ctx, &mut generator, &mut asmDataLen, &mut res.arena);
	1014	+	let asmData = try assembleAsmInputs(ctx, &mut generator, &mut asmDataLen, &mut res.arena);
1005	1015
1006	1016		match generator.entryPatch {
1007	1017		case rv64::EntryPatch::Reserved(targetName) => {
1008	1018		if targetName == nil {
1009	1019		throw error(&["fatal:", "no default function found"]);
1010	1020		}
1011	1021		}
1012	1022		else => {}
1013	1023		}
1014	1024		if let path = codegenOptions.logPath {
1015		-	pkgLog(&*entryPkg, &["generating code", "(", path, ")", ".."]);
	1025	+	pkgLog(entryPkg, &["generating code", "(", path, ")", ".."]);
1016	1026		}
1017		-	return rv64::finishProgram(&mut generator, &low.data[..], storage, asmData, &mut RO_DATA_BUF[..], &mut RW_DATA_BUF[..]);
	1027	+	return rv64::finishProgram(&mut generator, low.data, storage, asmData, &mut RO_DATA_BUF[..], &mut RW_DATA_BUF[..]);
1018	1028		}
1019	1029
1020	1030		/// Lower, optionally dump, and optionally generate binary output.
1021	1031		unsafe fn compile(
1022	1032		ctx: *unsafe mut CompileContext,

1047	1057		// Generate binary output if path specified.
1048	1058		let outPath = ctx.outputPath else {
1049	1059		try lowerAllPackages(ctx, res);
1050	1060		return;
1051	1061		};
1052		-	let startupPath = getEntryStartupPath(&*ctx);
	1062	+	let startupPath = getEntryStartupPath(ctx);
1053	1063		let result = try lowerAndGenerateAllPackages(ctx, res, fnArena, CodegenOptions {
1054	1064		logPath: outPath,
1055	1065		debug: ctx.debug,
1056	1066		entryMode: CodegenEntryMode::None
1057	1067		if startupPath <> nil

1069	1079
1070	1080		// Write debug info file if enabled.
1071	1081		if ctx.debug {
1072	1082		try writeDebugInfo(result.debugEntries, &ctx.graph, outPath, &mut res.arena);
1073	1083		}
1074		-	pkgLog(&*entryPkg, &["ok", "(", outPath, ")"]);
	1084	+	pkgLog(&entryPkg, &["ok", "(", outPath, ")"]);
1075	1085		}
1076	1086
1077	1087		@default unsafe fn main(env: *sys::Env) -> i32 {
1078	1088		let mut arena = ast::nodeArena(&mut TEMP_ARENA[..]);
1079	1089		let mut ctx = try processCommand(env.args, &mut arena) catch {

13	13		fnArena: *unsafe mut alloc::Arena,
14	14		}
15	15
16	16		/// Emit one lowered function to machine code and reclaim its IL arena.
17	17		/// The context must point to a valid `Context` with live generator and arena storage.
18		-	export unsafe fn emit(ctxPtr: unsafe mut opaque, func: il::Fn, role: lower::FnRole) {
	18	+	export unsafe fn emit(ctxPtr: unsafe mut opaque, func: unsafe il::Fn, role: lower::FnRole) {
19	19		let ctx = ctxPtr as *unsafe mut Context;
20	20
21	21		match role {
22	22		case lower::FnRole::Default => {
23		-	rv64::recordFunctionAlias(&mut *ctx.generator, super::DEFAULT_ENTRY_SYMBOL);
	23	+	rv64::recordFunctionAlias(ctx.generator, super::DEFAULT_ENTRY_SYMBOL);
24	24		match ctx.generator.entryPatch {
25	25		case rv64::EntryPatch::Reserved(_) => {
26	26		set ctx.generator.entryPatch = rv64::EntryPatch::Reserved(func.name);
27	27		}
28	28		// Startup assembly calls the default function through its

32	32		}
33	33		else => {}
34	34		}
35	35		let generator = ctx.generator;
36	36		let arena = ctx.fnArena;
37		-	rv64::generateFunction(&mut generator, func, &mut arena);
38		-	alloc::reset(&mut *ctx.fnArena);
	37	+	rv64::generateFunction(generator, func, arena);
	38	+	alloc::reset(ctx.fnArena);
39	39		}

159	159		export fn imageHeader(codeBytes: u32, roDataBytes: u32, rwDataBytes: u32) -> [u32; 5] {
160	160		return [IMAGE_MAGIC, IMAGE_VERSION, codeBytes, roDataBytes, rwDataBytes];
161	161		}
162	162
163	163		/// Storage buffers passed from driver for code generation.
164		-	export record Storage: Copy {
	164	+	export record Storage {
165	165		/// Buffer for data symbols.
166	166		dataSyms: *mut [data::DataSym],
167	167		/// Hash table entries for data symbol lookup.
168	168		dataSymEntries: *mut [dict::Entry],
169	169		}

201	201		/// State for incremental RV64 program generation.
202	202		///
203	203		/// The generator owns global codegen state that must survive across function
204	204		/// emission. Function-local scratch stays outside this record so callers can
205	205		/// reclaim it after each function.
206		-	export record Generator: Copy {
	206	+	export record Generator {
207	207		/// Binary emitter and relocation state.
208	208		e: emit::Emitter,
209	209		/// Entry jump patching state.
210	210		entryPatch: EntryPatch,
211	211		}

234	234		}
235	235
236	236		/// Generate code for one IL function.
237	237		export unsafe fn generateFunction(
238	238		generator: &mut Generator,
239		-	func: *il::Fn,
	239	+	func: *unsafe il::Fn,
240	240		arena: &mut alloc::Arena
241	241		) {
242	242		if func.isExtern {
243	243		return;
244	244		}

299	299		}
300	300
301	301		/// Finish RV64 code generation and return the emitted program.
302	302		export unsafe fn finishProgram(
303	303		generator: &mut Generator,
304		-	globalData: *[il::Data],
	304	+	globalData: &[il::Data],
305	305		storage: Storage,
306	306		roDataPrefix: *[u8],
307		-	roDataBuf: *mut [u8],
308		-	rwDataBuf: *mut [u8]
	307	+	roDataBuf: &mut [u8],
	308	+	rwDataBuf: &mut [u8]
309	309		) -> Program {
310	310		// Build data map after function lowering. Function-local literals can add
311	311		// global data while functions are lowered, so final layout belongs here.
	312	+	let case Storage { dataSyms: symbolBuf, dataSymEntries } = storage
	313	+	else panic "expected code generation storage";
312	314		let mut dataSymCount: u32 = 0;
313	315		let roLayoutSize = data::layoutSectionAtOffset(
314		-	globalData, storage.dataSyms, &mut dataSymCount, RO_DATA_BASE, roDataPrefix.len, true
	316	+	globalData, symbolBuf, &mut dataSymCount, RO_DATA_BASE, roDataPrefix.len, true
315	317		);
316		-	data::layoutSection(globalData, storage.dataSyms, &mut dataSymCount, RW_DATA_BASE, false);
	318	+	data::layoutSection(globalData, symbolBuf, &mut dataSymCount, RW_DATA_BASE, false);
317	319
318		-	let dataSyms = &storage.dataSyms[..dataSymCount];
319		-	let dataSymMap = data::buildMap(dataSyms, storage.dataSymEntries);
	320	+	let dataSyms = &symbolBuf[..dataSymCount];
	321	+	let dataSymMap = data::buildMap(dataSyms, dataSymEntries);
320	322		let codeBase = mem::alignUp(RO_DATA_BASE + roLayoutSize, DWORD_SIZE as u32);
321	323
322	324		match generator.entryPatch {
323	325		case EntryPatch::Reserved(targetName) => {
324	326		let target = targetName else {

450	450		/// Fixup payload.
451	451		info: FixupInfo,
452	452		}
453	453
454	454		/// Parser and emission state.
455		-	export record Assembler: Copy {
	455	+	export record Assembler {
456	456		/// Allocation arena for temporary assembler state.
457	457		arena: *unsafe mut alloc::Arena,
458	458		/// Assembler lexical scanner.
459	459		scan: scanner::Scanner,
460	460		/// Output text buffer.

484	484		sourceKind: scanner::SourceKind,
485	485		source: *[u8],
486	486		textBuf: *mut [u32],
487	487		dataBuf: *mut [u8],
488	488		arena: &mut alloc::Arena,
489		-	pool: *mut strings::Pool,
	489	+	pool: *unsafe mut strings::Pool,
490	490		dataBase: u32
491	491		) -> Program throws (Error) {
492	492		let slotCap = source.len + SOURCE_CAP_PADDING;
493	493		let tableCap = nextPowerOfTwo(slotCap * TABLE_CAPACITY_SCALE);
494	494

497	497		let externalFixups = try! alloc::allocSlice(arena, @sizeOf(Fixup), @alignOf(Fixup), slotCap);
498	498		let entries = try! alloc::allocSlice(arena, @sizeOf(dict::Entry), @alignOf(dict::Entry), tableCap);
499	499		let constEntries = try! alloc::allocSlice(arena, @sizeOf(dict::Entry), @alignOf(dict::Entry), tableCap);
500	500		let exportEntries = try! alloc::allocSlice(arena, @sizeOf(dict::Entry), @alignOf(dict::Entry), tableCap);
501	501
	502	+	let symbolBuf = symbols as *mut [Symbol];
	503	+	let fixupBuf = fixups as *mut [Fixup];
	504	+	let externalBuf = externalFixups as *mut [Fixup];
502	505		let mut a = Assembler {
503	506		arena: arena as *unsafe mut alloc::Arena,
504	507		scan: scanner::scanner(sourceKind, source, pool),
505		-	text: @sliceOf(textBuf.ptr, 0, textBuf.len),
506		-	data: @sliceOf(dataBuf.ptr, 0, dataBuf.len),
	508	+	text: &mut textBuf[..0],
	509	+	data: &mut dataBuf[..0],
507	510		section: Section::Text,
508		-	symbols: @sliceOf((symbols as mut [Symbol]).ptr, 0, (symbols as mut [Symbol]).len),
	511	+	symbols: &mut symbolBuf[..0],
509	512		symbolMap: dict::init(entries as *mut [dict::Entry]),
510	513		constMap: dict::init(constEntries as *mut [dict::Entry]),
511	514		exportMap: dict::init(exportEntries as *mut [dict::Entry]),
512		-	fixups: @sliceOf((fixups as mut [Fixup]).ptr, 0, (fixups as mut [Fixup]).len),
513		-	externalFixups: @sliceOf((externalFixups as mut [Fixup]).ptr, 0, (externalFixups as mut [Fixup]).len),
	515	+	fixups: &mut fixupBuf[..0],
	516	+	externalFixups: &mut externalBuf[..0],
514	517		dataBase,
515	518		};
516	519		// Parse assembly source and emit instructions.
517	520		try parser::parseProgram(&mut a);
518	521		// Resolve fixups and finalize program.
519	522		try emit::finishProgram(&mut a);
520	523
521		-	return Program {
522		-	text: a.text,
523		-	data: a.data,
524		-	symbols: a.symbols,
525		-	externalFixups: a.externalFixups,
526		-	};
	524	+	let case Assembler { text, data, symbols: definedSymbols, externalFixups: pendingFixups, .. } = a
	525	+	else panic "expected assembler state";
	526	+	return Program { text, data, symbols: definedSymbols, externalFixups: pendingFixups };
527	527		}
528	528
529	529		/// Return the next power of two at least as large as `value`.
530	530		fn nextPowerOfTwo(value: u32) -> u32 {
531	531		let mut n: u32 = MIN_TABLE_CAPACITY;

18	18		a.symbols.append(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(&mut *a.arena));
	23	+	}, alloc::arenaAllocator(a.arena));
24	24		dict::insert(&mut a.symbolMap, name, idx as i32);
25	25		}
26	26
27	27		/// Append one encoded instruction word to the text section.
28	28		export unsafe fn emitText(a: &mut super::Assembler, word: u32) throws (super::Error) {
29		-	a.text.append(word, alloc::arenaAllocator(&mut *a.arena));
	29	+	a.text.append(word, alloc::arenaAllocator(a.arena));
30	30		}
31	31
32	32		/// Append `words` no-op instructions to the text section.
33	33		export unsafe fn emitTextPadding(a: &mut super::Assembler, words: u32) throws (super::Error) {
34	34		for _ in 0..words {

36	36		}
37	37		}
38	38
39	39		/// Append one byte to the data section.
40	40		export unsafe fn emitByte(a: &mut super::Assembler, byte: u8) throws (super::Error) {
41		-	a.data.append(byte, alloc::arenaAllocator(&mut *a.arena));
	41	+	a.data.append(byte, alloc::arenaAllocator(a.arena));
42	42		}
43	43
44	44		/// Emit a little-endian integer with `bytes` bytes.
45	45		unsafe fn emitDataInt(a: &mut super::Assembler, bits: u64, bytes: u32) throws (super::Error) {
46	46		for i in 0..bytes {

78	78		}
79	79		}
80	80
81	81		/// Record a pending symbol fixup.
82	82		unsafe fn recordFixup(a: &mut super::Assembler, symbol: *[u8], info: super::FixupInfo) {
83		-	a.fixups.append(super::Fixup { symbol, info }, alloc::arenaAllocator(&mut *a.arena));
	83	+	a.fixups.append(super::Fixup { symbol, info }, alloc::arenaAllocator(a.arena));
84	84		}
85	85
86	86		/// Record a text fixup that must be resolved after all program text is known.
87	87		unsafe fn recordExternalFixup(a: &mut super::Assembler, fixup: super::Fixup) {
88		-	a.externalFixups.append(fixup, alloc::arenaAllocator(&mut *a.arena));
	88	+	a.externalFixups.append(fixup, alloc::arenaAllocator(a.arena));
89	89		}
90	90
91	91		/// Record a text-section symbol fixup and reserve its instruction words.
92	92		export unsafe fn recordTextFixup(a: &mut super::Assembler, symbol: *[u8], info: super::FixupInfo, words: u32) throws (super::Error) {
93	93		recordFixup(a, symbol, info);

37	37		}
38	38		return mem::alignUp(value, alignment);
39	39		}
40	40
41	41		/// Advance the parser by one token, preserving the previous token.
42		-	fn advance(a: &mut super::Assembler) {
	42	+	unsafe fn advance(a: &mut super::Assembler) {
43	43		set a.scan.previous = a.scan.current;
44	44		set a.scan.current = scanner::next(&mut a.scan);
45	45		}
46	46
47	47		/// Consume the current token when it has `kind`.
48		-	fn consume(a: &mut super::Assembler, kind: scanner::TokenKind) -> bool {
	48	+	unsafe fn consume(a: &mut super::Assembler, kind: scanner::TokenKind) -> bool {
49	49		if a.scan.current.kind == kind {
50	50		advance(a);
51	51		return true;
52	52		}
53	53		return false;

69	69		throw failOnToken(tok, "data directive is only valid in the data section");
70	70		}
71	71		}
72	72
73	73		/// Consume `kind` or throw `message` at the current token.
74		-	fn expect(a: &mut super::Assembler, kind: scanner::TokenKind, message: *[u8]) throws (super::Error) {
	74	+	unsafe fn expect(a: &mut super::Assembler, kind: scanner::TokenKind, message: *[u8]) throws (super::Error) {
75	75		if not consume(a, kind) {
76	76		throw fail(a, message);
77	77		}
78	78		}
79	79
80	80		/// Consume `kind` and return the consumed token.
81		-	fn expectToken(a: &mut super::Assembler, kind: scanner::TokenKind, message: *[u8]) -> scanner::Token throws (super::Error) {
	81	+	unsafe fn expectToken(a: &mut super::Assembler, kind: scanner::TokenKind, message: *[u8]) -> scanner::Token throws (super::Error) {
82	82		try expect(a, kind, message);
83	83		return a.scan.previous;
84	84		}
85	85
86	86		/// Require that the current item has reached its semicolon terminator.