radiance · commit

Makefile +3 -2

endif

# Compiler build

SEED      := seed/radiance.rv64
SEED_OPTS := $(STD) -pkg radiance -mod compiler/radiance.rad -entry radiance
COMPILER_SRC := compiler/radiance.rad compiler/radiance/codegen.rad
SEED_OPTS := $(STD) -pkg radiance $(patsubst %,-mod %,$(COMPILER_SRC)) -entry radiance

$(RAD_BIN): $(STD_LIB) compiler/radiance.rad | $(BIN_DIR)
$(RAD_BIN): $(STD_LIB) $(COMPILER_SRC) | $(BIN_DIR)
	@echo "radiance $(SEED) => $@"
	@$(EMU) $(EMU_FLAGS) -run $(SEED) $(SEED_OPTS) -o $@

$(BIN_DIR):
	@mkdir -p $@

compiler/radiance.rad +126 -140

//! Radiance compiler front-end.
mod codegen;

use std::mem;
use std::fmt;
use std::io;
use std::lang::alloc;
use std::lang::ast;

static ASM_RO_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = undefined;

/// Assembly source file extension.
constant ASM_SOURCE_EXT: *[u8] = ".ras";
/// Symbol name exported for startup code to call the semantic entry function.
constant DEFAULT_ENTRY_SYMBOL: *[u8] = "::default";
export constant DEFAULT_ENTRY_SYMBOL: *[u8] = "::default";

/// Usage string.
constant USAGE: *[u8] =
    "usage: radiance -pkg <name> [-start <input.ras>] -mod <input>.. [-pkg <name> -mod <input>..] -entry <pkg> -o <output>\n";


record RootModule: Copy {
    entry: *module::ModuleEntry,
    ast: *mut ast::Node,
}

/// State carried by the streaming lowerer/codegen callback.
record CodegenSinkContext: Copy {
    /// RV64 generator receiving lowered functions.
    generator: *mut rv64::Generator,
    /// Arena holding the current function's lowered IL.
    fnArena: *mut alloc::Arena,
}

/// Entry handling for streamed code generation.
union CodegenEntryMode: Copy {
    /// Do not reserve an entry jump.
    None,
    /// Reserve and patch an entry jump to the `@default` function.

    /// How the generated program should handle entry.
    entryMode: CodegenEntryMode,
}

/// Print a driver error line.
fn error(msg: *[*[u8]]) -> Error {
fn error(msg: &[*[u8]]) -> Error {
    io::printError("radiance: ");

    for part, i in msg {
        io::printError(part);
        if i < msg.len - 1 {

    io::printError("\n");
    return Error::Other;
}

/// Print a log line for the given package.
fn pkgLog(pkg: *package::Package, msg: *[*[u8]]) {
fn pkgLog(pkg: &package::Package, msg: &[*[u8]]) {
    io::printError("radiance: ");
    io::printError(pkg.name);
    io::printError(": ");

    for part, i in msg {

        asmPathCount: 0,
    };
}

/// Register, load, and parse `path` within `pkg`.
fn processModule(
    pkg: *mut package::Package,
    graph: *mut module::ModuleGraph,
unsafe fn processModule(
    pkg: *unsafe mut package::Package,
    graph: &mut module::ModuleGraph,
    path: *[u8],
    nodeArena: *mut ast::NodeArena,
    sourceArena: *mut alloc::Arena
    nodeArena: &mut ast::NodeArena,
    sourceArena: &mut alloc::Arena
) throws (Error) {
    pkgLog(pkg, &["parsing", "(", path, ")", ".."]);
    pkgLog(&*pkg, &["parsing", "(", path, ")", ".."]);

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

        throw error(&["error setting source"]);
    };
}

/// Consume the next argument, or print an error and throw.
fn nextArg(args: *[*[u8]], idx: *mut u32, msg: *[*[u8]]) -> *[u8] throws (Error) {
fn nextArg(args: *[*[u8]], idx: &mut u32, msg: &[*[u8]]) -> *[u8] throws (Error) {
    set *idx += 1;
    if *idx >= args.len {
        throw error(msg);
    }
    return args[*idx];
}

/// Parse CLI arguments and return compilation context.
fn processCommand(
unsafe fn processCommand(
    args: *[*[u8]],
    arena: *mut ast::NodeArena
    arena: &mut ast::NodeArena
) -> CompileContext throws (Error) {
    let mut buildTest = false;
    let mut debugEnabled = false;
    let mut outputPath: ?*[u8] = nil;
    let mut dump = Dump::None;

        } else if mem::eq(arg, "-mod") {
            try nextArg(args, &mut idx, &["`-mod` requires a module path"]);
            let pkgIdx = currentPkgIdx else {
                throw error(&["`-mod` must follow a `-pkg` argument"]);
            };
            let input = &mut inputs[pkgIdx];
            let input: *unsafe mut PackageInput = &mut inputs[pkgIdx];
            if hasExtension(args[idx], ASM_SOURCE_EXT) {
                if input.asmPathCount >= MAX_ASM_MODULES {
                    throw error(&["too many assembly modules specified"]);
                }
                set input.asmPaths[input.asmPathCount] = args[idx];

        } else if mem::eq(arg, "-start") {
            try nextArg(args, &mut idx, &["`-start` requires an assembly path"]);
            let pkgIdx = currentPkgIdx else {
                throw error(&["`-start` must follow a `-pkg` argument"]);
            };
            let input = &mut inputs[pkgIdx];
            let input: *unsafe mut PackageInput = &mut inputs[pkgIdx];
            if input.startupPath <> nil {
                throw error(&["package", input.name, "has more than one startup file"]);
            }
            if not hasExtension(args[idx], ASM_SOURCE_EXT) {
                throw error(&["`-start` requires a `.ras` assembly file"]);

        debug: debugEnabled,
    };
    // Initialize and parse all packages.
    let mut sourceArena = alloc::new(&mut MODULE_SOURCES[..]);
    for i in 0..pkgCount {
        package::init(&mut ctx.packages[i], i as u16, ctx.inputs[i].name, &mut STRING_POOL);
        let name = ctx.inputs[i].name;
        package::init(&mut ctx.packages[i], i as u16, name, &mut STRING_POOL);

        for j in 0..ctx.inputs[i].radPathCount {
            let path = ctx.inputs[i].radPaths[j];
            try processModule(&mut ctx.packages[i], &mut ctx.graph, path, arena, &mut sourceArena);
        }
    }
    return ctx;
}

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

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

/// Get root module info from a package.
fn getRootModule(pkg: *package::Package, graph: *module::ModuleGraph) -> RootModule throws (Error) {
fn getRootModule(pkg: &package::Package, graph: &module::ModuleGraph) -> RootModule throws (Error) {
    let rootId = pkg.rootModuleId else {
        throw error(&["no root module found"]);
    };
    let rootEntry = module::get(graph, rootId) else {
        throw error(&["root module entry not found"]);

    };
    return RootModule { entry: rootEntry, ast: rootAst };
}

/// Dump the module graph.
fn dumpGraph(ctx: *CompileContext) {
unsafe fn dumpGraph(ctx: &CompileContext) {
    let mut arena = alloc::new(&mut MAIN_ARENA[..]);
    module::printer::printGraph(&ctx.graph, &mut arena);
}

/// Dump the parsed AST.
fn dumpAst(ctx: *CompileContext) throws (Error) {
unsafe fn dumpAst(ctx: *unsafe 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);
}

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

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

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

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

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

/// Recursively lower a module and all its children into the accumulator.
fn lowerModuleTreeInto(
    ctx: *CompileContext,
    low: *mut lower::Lowerer,
    graph: *module::ModuleGraph,
unsafe fn lowerModuleTreeInto(
    ctx: *unsafe CompileContext,
    low: &mut lower::Lowerer,
    graph: &module::ModuleGraph,
    modId: u16,
    isRoot: bool,
    pkg: *package::Package
    pkg: &package::Package
) throws (Error) {
    let entry = module::get(graph, modId) else {
        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(low, modId, modAst, isRoot) catch err {
    try lower::lowerModule(&mut *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, low, graph, childId, false, pkg);
        try lowerModuleTreeInto(ctx, &mut *low, graph, childId, false, pkg);
    }
}

/// Build a scope access chain: a::b::c from a slice of identifiers.
fn synthScopeAccess(arena: *mut ast::NodeArena, path: *[*[u8]]) -> *ast::Node {
fn synthScopeAccess(arena: &mut ast::NodeArena, path: &[*[u8]]) -> *ast::Node {
    let mut result = ast::synthNode(
        arena,
        ast::NodeValue::Ident(strings::intern(&mut STRING_POOL, path[0]))
    );
    for i in 1..path.len {

    }
    return result;
}

/// Check if a function declaration has the `@test` attribute and return its name if so.
fn getTestFnName(decl: *ast::FnDecl) -> ?*[u8] {
fn getTestFnName(decl: &ast::FnDecl) -> ?*[u8] {
    let attrs = decl.attrs else { return nil; };
    if not ast::attributesContains(&attrs, ast::Attribute::Test) {
        return nil;
    }
    let case ast::NodeValue::Ident(name) = decl.name.value

}

/// Scan a single module's AST for `@test` functions and append them to `tests`.
fn collectModuleTests(
    entry: *module::ModuleEntry,
    tests: *mut [TestDesc],
    testCount: *mut u32
    tests: &mut [TestDesc],
    testCount: &mut u32
) {
    let modAst = entry.ast else {
        return;
    };
    let case ast::NodeValue::Block(block) = modAst.value else {

        }
    }
}

/// Synthesize a `testing::test("mod", "name", mod::fn)` call for one test.
fn synthTestCall(arena: *mut ast::NodeArena, desc: *TestDesc) -> *ast::Node {
unsafe fn synthTestCall(arena: &mut ast::NodeArena, desc: &TestDesc) -> *ast::Node {
    let callee = synthScopeAccess(arena, &["testing", "test"]);
    let modStr = il::formatQualifiedName(
        &mut arena.arena,
        &desc.modPath[..desc.modPath.len - 1],
        desc.modPath[desc.modPath.len - 1]

///     ]);
/// }
/// ```
///
/// Uses `#`-prefixed names to avoid conflicts with user code.
fn generateTestRunner(
    ctx: *mut CompileContext,
    arena: *mut ast::NodeArena
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;


    }
    if testCount == 0 {
        throw error(&["fatal:", "no test functions found"]);
    }
    let mut countBuf: [u8; 10] = undefined;
    let countStr = fmt::formatU32(testCount, &mut countBuf[..]);
    pkgLog(entryPkg, &["found", countStr, "test(s)"]);
    let start = fmt::formatU32(testCount, &mut countBuf[..]);
    io::printError("radiance: ");
    io::printError(entryPkg.name);
    io::printError(": found ");
    io::printError(&countBuf[start..]);
    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);
}

/// Synthesize the test entry point.
fn synthTestMainFn(arena: *mut ast::NodeArena, tests: *[TestDesc]) -> *ast::Node {
unsafe fn synthTestMainFn(arena: &mut ast::NodeArena, tests: &[TestDesc]) -> *ast::Node {
    // Build array literal: `[testing::test(...), ...]`.
    let a = alloc::arenaAllocator(&mut arena.arena);
    let mut elements = ast::nodeSlice(arena, tests.len as u32);
    for i in 0..tests.len {
        elements.append(synthTestCall(arena, &tests[i]), a);

    // Build: `return testing::runAllTests(&[...]);`
    let retStmt = ast::synthNode(arena, ast::NodeValue::Return { value: callExpr });
    let bodyStmts = ast::nodeSlice(arena, 1).append(retStmt, a);
    let fnBody = ast::synthNode(arena, ast::NodeValue::Block(ast::Block { statements: bodyStmts }));

    // Build: `fn #testMain() -> i32`
    // Build: `unsafe fn #testMain() -> i32`
    let fnName = ast::synthNode(arena, ast::NodeValue::Ident(strings::intern(&mut STRING_POOL, "#testMain")));
    let returnType = ast::synthNode(arena, ast::NodeValue::TypeSig(ast::TypeSig::Integer {
        width: 4, sign: ast::Signedness::Signed,
    }));
    let fnSig = ast::FnSig {
        params: ast::nodeSlice(arena, 0),
        returnType,
        throwList: ast::nodeSlice(arena, 0),
    };

    // `@default` attribute.
    // Entry and function safety attributes.
    let attrNode = ast::synthNode(arena, ast::NodeValue::Attribute(ast::Attribute::Default));
    let attrList = ast::nodeSlice(arena, 1).append(attrNode, a);
    let unsafeAttr = ast::synthNode(arena, ast::NodeValue::Attribute(ast::Attribute::Unsafe));
    let attrList = ast::nodeSlice(arena, 2).append(attrNode, a).append(unsafeAttr, a);
    let fnAttrs = ast::Attributes { list: attrList };

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

/// Append a declaration to a block node's statement list.
fn injectIntoBlock(
unsafe fn injectIntoBlock(
    blockNode: *mut ast::Node,
    arena: *mut ast::NodeArena,
    arena: &mut ast::NodeArena,
    decl: *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 });
}

/// Write a self-contained RV64 image containing text and data sections.
fn writeImage(
unsafe fn writeImage(
    code: *[u32],
    roData: *[u8],
    rwData: *[u8],
    path: *[u8]
) -> bool {
    let mut header = rv64::imageHeader(code.len * rv64::INSTR_SIZE as u32, roData.len, rwData.len);
    let headerWords = &header[..];
    let headerBytes = @sliceOf(headerWords.ptr as *u8, headerWords.len * rv64::WORD_SIZE as 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);

    return unix::writeFileParts(path, &[headerBytes, codeBytes, roData, rwData]);
    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)
        and unix::writeAll(fd, roData) and unix::writeAll(fd, rwData);
    let closed = unix::close(fd) == 0;
    return written and closed;
}

/// Write a data section to a file at `basePath` + `ext`.
/// Empty data truncates any stale sidecar left by an earlier build.
fn writeDataWithExt(

/// Serialize debug entries and write the `.debug` file.
/// Resolves module IDs to file paths via the module graph.
/// Format per entry is `{pc: u32,  offset: u32, filePath: [u8], NULL}`.
fn writeDebugInfo(
    entries: *[types::DebugEntry],
    graph: *module::ModuleGraph,
    graph: &module::ModuleGraph,
    basePath: *[u8],
    arena: *mut alloc::Arena
    arena: &mut alloc::Arena
) throws (Error) {
    if entries.len == 0 {
        return;
    }
    // Use remaining arena space as serialization buffer.

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

/// Run the resolver on the parsed modules.
fn runResolver(ctx: *mut CompileContext, nodeCount: u32) -> resolver::Resolver throws (Error) {
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,
        };

        throw Error::Other;
    };
    if not resolver::success(&diags) {
        resolver::printer::printDiagnostics(&diags, &res);
        let mut countBuf: [u8; 10] = undefined;
        let countStr = fmt::formatU32(diags.errors.len, &mut countBuf[..]);
        throw error(&["failed:", countStr, "errors"]);
        let start = fmt::formatU32(diags.errors.len, &mut countBuf[..]);
        io::printError("radiance: failed: ");
        io::printError(&countBuf[start..]);
        io::printError(" errors\n");
        throw Error::Other;
    }
    return res;
}

/// Emit one lowered function to machine code and reclaim its IL arena.
fn generateLoweredFn(ctxPtr: *mut opaque, func: *il::Fn, role: lower::FnRole) {
    let ctx = ctxPtr as *mut CodegenSinkContext;

    match role {
        case lower::FnRole::Default => {
            rv64::recordFunctionAlias(ctx.generator, DEFAULT_ENTRY_SYMBOL);
            match ctx.generator.entryPatch {
                case rv64::EntryPatch::Reserved(_) => {
                    set ctx.generator.entryPatch = rv64::EntryPatch::Reserved(func.name);
                }
                // No entry jump was reserved: startup assembly calls the
                // default function through `DEFAULT_ENTRY_SYMBOL` instead.
                case rv64::EntryPatch::None => {}
            }
        }
        else => {}
    }
    rv64::generateFunction(ctx.generator, func, ctx.fnArena);
    alloc::reset(ctx.fnArena);
}

/// Assemble one `.ras` input and merge it into the active code generator.
///
/// Text symbols are appended to `generator`. Data emitted by the assembler is
/// copied into `ASM_RO_DATA_BUF` at `*asmDataLen`, and `*asmDataLen` is advanced
/// so the next assembly module receives the correct rodata base address.
fn assembleAsmModule(
    generator: *mut rv64::Generator,
    pkg: *package::Package,
unsafe fn assembleAsmModule(
    generator: &mut rv64::Generator,
    pkg: &package::Package,
    path: *[u8],
    asmDataLen: *mut u32,
    arena: *mut alloc::Arena
    asmDataLen: &mut u32,
    arena: &mut alloc::Arena
) throws (Error) {
    pkgLog(pkg, &["asm:", "parsing", "(", path, ")", ".."]);
    pkgLog(&*pkg, &["asm:", "parsing", "(", path, ")", ".."]);

    let source = unix::readFile(path, &mut ASM_SOURCE_BUF[..]) else {
    let sourceLen = unix::readFile(path, &mut ASM_SOURCE_BUF[..]) else {
        throw error(&["error reading assembly file"]);
    };
    let source = &ASM_SOURCE_BUF[..sourceLen];
    if source.len == ASM_SOURCE_BUF.len {
        throw error(&["fatal:", "assembly source too large:", path]);
    }
    let program = try asm::assemble(
        asm::scanner::SourceKind::File { path },


    rv64::addAssembly(generator, program);
}

/// Assemble all inputs collected in the package inputs.
fn assembleAsmInputs(
    ctx: *CompileContext,
    generator: *mut rv64::Generator,
    asmDataLen: *mut u32,
    arena: *mut alloc::Arena
unsafe fn assembleAsmInputs(
    ctx: &CompileContext,
    generator: &mut rv64::Generator,
    asmDataLen: &mut u32,
    arena: &mut alloc::Arena
) -> *[u8] throws (Error) {
    for i in 0..ctx.packageCount {
        let input = &ctx.inputs[i];
        for j in 0..input.asmPathCount {
        for j in 0..ctx.inputs[i].asmPathCount {
            try assembleAsmModule(
                generator,
                &ctx.packages[i],
                input.asmPaths[j],
                ctx.inputs[i].asmPaths[j],
                asmDataLen,
                arena
            );
        }
    }
    return &ASM_RO_DATA_BUF[..*asmDataLen];
}

/// Lower all packages while streaming each lowered function into RV64 codegen.
fn lowerAndGenerateAllPackages(
    ctx: *mut CompileContext,
    res: *mut resolver::Resolver,
    fnArena: *mut alloc::Arena,
unsafe fn lowerAndGenerateAllPackages(
    ctx: *unsafe mut CompileContext,
    res: *unsafe mut resolver::Resolver,
    fnArena: &mut alloc::Arena,
    codegenOptions: CodegenOptions
) -> 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[..],
    };

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

/// Lower, optionally dump, and optionally generate binary output.
fn compile(
    ctx: *mut CompileContext,
    res: *mut resolver::Resolver,
    fnArena: *mut alloc::Arena
unsafe fn compile(
    ctx: *unsafe mut CompileContext,
    res: *unsafe mut resolver::Resolver,
    fnArena: &mut alloc::Arena
) throws (Error) {
    let entryPkg = try getEntryPackage(ctx);
    let mut out = sexpr::Output::Stdout;

    if ctx.dump == Dump::Il {

    // 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 fn main(env: *sys::Env) -> i32 {
@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 {
        return 1;
    };
    match ctx.dump {

compiler/radiance/codegen.rad added +39 -0

1	+	//! Streaming code generation with caller-managed context storage.
2	+
3	+	use std::arch::rv64;
4	+	use std::lang::alloc;
5	+	use std::lang::il;
6	+	use std::lang::lower;
7	+
8	+	/// State carried by the streaming lowerer/codegen callback.
9	+	export record Context: Copy {
10	+	/// Generator receiving functions. It must remain valid for every callback.
11	+	generator: *unsafe mut rv64::Generator,
12	+	/// Arena for function IL. It must remain valid for every callback.
13	+	fnArena: *unsafe mut alloc::Arena,
14	+	}
15	+
16	+	/// Emit one lowered function to machine code and reclaim its IL arena.
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) {
19	+	let ctx = ctxPtr as *unsafe mut Context;
20	+
21	+	match role {
22	+	case lower::FnRole::Default => {
23	+	rv64::recordFunctionAlias(&mut *ctx.generator, super::DEFAULT_ENTRY_SYMBOL);
24	+	match ctx.generator.entryPatch {
25	+	case rv64::EntryPatch::Reserved(_) => {
26	+	set ctx.generator.entryPatch = rv64::EntryPatch::Reserved(func.name);
27	+	}
28	+	// Startup assembly calls the default function through its
29	+	// default entry symbol when no entry jump is reserved.
30	+	case rv64::EntryPatch::None => {}
31	+	}
32	+	}
33	+	else => {}
34	+	}
35	+	let generator = ctx.generator;
36	+	let arena = ctx.fnArena;
37	+	rv64::generateFunction(&mut generator, func, &mut arena);
38	+	alloc::reset(&mut *ctx.fnArena);
39	+	}

lib/std/arch/rv64.rad +10 -9

    /// Entry jump patching state.
    entryPatch: EntryPatch,
}

/// Begin RV64 code generation for a program's global state.
export fn beginProgram(
export unsafe fn beginProgram(
    options: ProgramOptions,
    arena: *mut alloc::Arena
    arena: &mut alloc::Arena
) -> Generator {
    let mut e = try! emit::emitter(arena, options.debug);

    // Emit placeholder entry jump when requested.
    // We'll patch this at the end once we know where the function is.

        entryPatch: options.entryPatch,
    };
}

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

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

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

/// Add the text section of an assembled program to the generator.
///
/// This function snapshots the generator's current code length as the base

/// separate assembly inputs may reuse the same local names.
///
/// Non-text symbols are ignored here because assembled data is not appended to
/// the generator's text stream. The driver merges assembled data into the RO data
/// prefix separately and passes that data to [`finishProgram`].
export fn addAssembly(generator: *mut Generator, program: asm::Program) {
export fn addAssembly(generator: &mut Generator, program: asm::Program) {
    let baseIndex = generator.e.codeLen;

    for symbol in program.symbols {
        if symbol.section == asm::Section::Text {
            let index = baseIndex + ((symbol.offset as u32) / INSTR_SIZE as u32);

    }
}

/// Finish RV64 code generation and return the emitted program.
export fn finishProgram(
    generator: *mut Generator,
    generator: &mut Generator,
    globalData: *[il::Data],
    storage: Storage,
    roDataPrefix: *[u8],
    roDataBuf: *mut [u8],
    rwDataBuf: *mut [u8]

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

}

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

    /// Absolute runtime address of data-section offset zero.
    dataBase: u32,
}

/// Assemble source using `dataBase` as the runtime address of the data-section.
export fn assemble(
export unsafe fn assemble(
    sourceKind: scanner::SourceKind,
    source: *[u8],
    textBuf: *mut [u32],
    dataBuf: *mut [u8],
    arena: *mut alloc::Arena,
    arena: &mut alloc::Arena,
    pool: *mut strings::Pool,
    dataBase: u32
) -> Program throws (Error) {
    let slotCap = source.len + SOURCE_CAP_PADDING;
    let tableCap = nextPowerOfTwo(slotCap * TABLE_CAPACITY_SCALE);

    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 mut a = Assembler {
        arena,
        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),
        section: Section::Text,
        symbols: @sliceOf((symbols as *mut [Symbol]).ptr, 0, (symbols as *mut [Symbol]).len),

lib/std/arch/rv64/asm/emit.rad +20 -20

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

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

    a.symbols.append(super::Symbol {
        name,
        section: a.section,
        offset,
        isExported: dict::get(&a.exportMap, name) <> nil,
    }, alloc::arenaAllocator(a.arena));
    }, alloc::arenaAllocator(&mut *a.arena));
    dict::insert(&mut a.symbolMap, name, idx as i32);
}

/// Append one encoded instruction word to the text section.
export fn emitText(a: *mut super::Assembler, word: u32) throws (super::Error) {
    a.text.append(word, alloc::arenaAllocator(a.arena));
export unsafe fn emitText(a: &mut super::Assembler, word: u32) throws (super::Error) {
    a.text.append(word, alloc::arenaAllocator(&mut *a.arena));
}

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

/// Append one byte to the data section.
export fn emitByte(a: *mut super::Assembler, byte: u8) throws (super::Error) {
    a.data.append(byte, alloc::arenaAllocator(a.arena));
export unsafe fn emitByte(a: &mut super::Assembler, byte: u8) throws (super::Error) {
    a.data.append(byte, alloc::arenaAllocator(&mut *a.arena));
}

/// Emit a little-endian integer with `bytes` bytes.
fn emitDataInt(a: *mut super::Assembler, bits: u64, bytes: u32) throws (super::Error) {
unsafe fn emitDataInt(a: &mut super::Assembler, bits: u64, bytes: u32) throws (super::Error) {
    for i in 0..bytes {
        try emitByte(a, ((bits >> ((i as u64) * super::BITS_PER_BYTE)) & super::BYTE_MASK) as u8);
    }
}

/// Patch a little-endian integer with `bytes` bytes.
fn patchDataInt(a: *mut super::Assembler, offset: u32, bits: u64, bytes: u32) {
fn patchDataInt(a: &mut super::Assembler, offset: u32, bits: u64, bytes: u32) {
    for i in 0..bytes {
        set a.data[offset + i] = ((bits >> ((i as u64) * super::BITS_PER_BYTE)) & super::BYTE_MASK) as u8;
    }
}

/// Emit an integer data directive value.
export fn emitDataValue(a: *mut super::Assembler, value: i64, width: super::DataWidth) throws (super::Error) {
export unsafe fn emitDataValue(a: &mut super::Assembler, value: i64, width: super::DataWidth) throws (super::Error) {
    match width {
        case super::DataWidth::Word => try emitDataInt(a, value as u64, rv64::WORD_SIZE as u32),
        case super::DataWidth::Dword => try emitDataInt(a, value as u64, rv64::DWORD_SIZE as u32),
    }
}

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

        }
    }
}

/// Record a pending symbol fixup.
fn recordFixup(a: *mut super::Assembler, symbol: *[u8], info: super::FixupInfo) {
    a.fixups.append(super::Fixup { symbol, info }, alloc::arenaAllocator(a.arena));
unsafe fn recordFixup(a: &mut super::Assembler, symbol: *[u8], info: super::FixupInfo) {
    a.fixups.append(super::Fixup { symbol, info }, alloc::arenaAllocator(&mut *a.arena));
}

/// Record a text fixup that must be resolved after all program text is known.
fn recordExternalFixup(a: *mut super::Assembler, fixup: super::Fixup) {
    a.externalFixups.append(fixup, alloc::arenaAllocator(a.arena));
unsafe fn recordExternalFixup(a: &mut super::Assembler, fixup: super::Fixup) {
    a.externalFixups.append(fixup, alloc::arenaAllocator(&mut *a.arena));
}

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

/// Find a previously defined symbol by name.
fn findSymbol(a: *super::Assembler, name: *[u8]) -> ?super::Symbol {
fn findSymbol(a: &super::Assembler, name: *[u8]) -> ?super::Symbol {
    let idx = dict::get(&a.symbolMap, name)
        else return nil;
    return a.symbols[idx as u32];
}

/// Return the final address for a data symbol.
fn dataSymbolAddr(a: *super::Assembler, symbol: super::Symbol) -> i32 throws (super::Error) {
fn dataSymbolAddr(a: &super::Assembler, symbol: super::Symbol) -> i32 throws (super::Error) {
    if symbol.section <> super::Section::Data {
        throw super::Error::Invalid { offset: 0, message: "data address target must be in data section" };
    }
    return symbol.offset + (a.dataBase as i32);
}

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

        case super::BranchOp::Bgt  => return encode::bgt(rs1, rs2, imm),
    }
}

/// Decode string literal escapes and emit the resulting data bytes.
export fn emitDecodedString(a: *mut super::Assembler, literal: *[u8]) throws (super::Error) {
export unsafe fn emitDecodedString(a: &mut super::Assembler, literal: *[u8]) throws (super::Error) {
    let raw = &literal[super::QUOTE_DELIM_LEN..literal.len - super::QUOTE_DELIM_LEN];
    let mut i: u32 = 0;

    while i < raw.len {
        if raw[i] == '\\' and i + 1 < raw.len {

lib/std/arch/rv64/asm/parser.rad +62 -62

    /// Signed byte offset preceding the base register.
    offset: i32,
}

/// Parse assembler source into the supplied assembler state.
export fn parseProgram(a: *mut super::Assembler) throws (super::Error) {
export unsafe fn parseProgram(a: &mut super::Assembler) throws (super::Error) {
    advance(a);

    while a.scan.current.kind <> scanner::TokenKind::Eof {
        try parseItem(a);
    }

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

/// Advance the parser by one token, preserving the previous token.
fn advance(a: *mut super::Assembler) {
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 {
fn consume(a: &mut super::Assembler, kind: scanner::TokenKind) -> bool {
    if a.scan.current.kind == kind {
        advance(a);
        return true;
    }
    return false;
}

/// Create an error at the current token.
fn fail(a: *super::Assembler, message: *[u8]) -> super::Error {
fn fail(a: &super::Assembler, message: *[u8]) -> super::Error {
    return super::Error::Invalid { offset: a.scan.current.offset, message };
}

/// Create an error at `tok`.
fn failOnToken(tok: scanner::Token, message: *[u8]) -> super::Error {
    return super::Error::Invalid { offset: tok.offset, message };
}

/// Require that a data directive appears while assembling the data section.
fn expectDataSection(a: *super::Assembler, tok: scanner::Token) throws (super::Error) {
fn expectDataSection(a: &super::Assembler, tok: scanner::Token) throws (super::Error) {
    if a.section <> super::Section::Data {
        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) {
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) {
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.
fn expectTerminator(a: *super::Assembler, message: *[u8]) throws (super::Error) {
fn expectTerminator(a: &super::Assembler, message: *[u8]) throws (super::Error) {
    if a.scan.current.kind <> scanner::TokenKind::Semicolon {
        throw fail(a, message);
    }
}

/// Require that `value` fits in i32.
fn expectI32Value(a: *super::Assembler, value: i64, message: *[u8]) -> i32 throws (super::Error) {
fn expectI32Value(a: &super::Assembler, value: i64, message: *[u8]) -> i32 throws (super::Error) {
    if value < -super::I32_MIN_MAGNITUDE or value > super::I32_MAX_VALUE {
        throw fail(a, message);
    }
    return value as i32;
}

/// Require that `value` fits in a signed 12-bit immediate field.
fn expectSmallImmValue(a: *super::Assembler, value: i64) -> i32 throws (super::Error) {
fn expectSmallImmValue(a: &super::Assembler, value: i64) -> i32 throws (super::Error) {
    if not encode::isSmallImm64(value) {
        throw fail(a, "immediate out of range");
    }
    return value as i32;
}

/// Define a label at the current text or data offset.
fn defineSymbol(a: *mut super::Assembler, name: *[u8], tok: scanner::Token) throws (super::Error) {
unsafe fn defineSymbol(a: &mut super::Assembler, name: *[u8], tok: scanner::Token) throws (super::Error) {
    if dict::get(&a.symbolMap, name) <> nil {
        throw failOnToken(tok, "duplicate label");
    }
    emit::defineSymbol(a, name);
}

/// Emit a parsed integer data value after applying source-level range checks.
fn emitDataValue(a: *mut super::Assembler, value: i64, width: super::DataWidth) throws (super::Error) {
unsafe fn emitDataValue(a: &mut super::Assembler, value: i64, width: super::DataWidth) throws (super::Error) {
    match width {
        case super::DataWidth::Word =>
            try emit::emitDataValue(a, (try expectI32Value(a, value, "word literal out of range")) as i64, width),
        case super::DataWidth::Dword =>
            try emit::emitDataValue(a, value, width),
    }
}

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

    }
    return strings::intern(a.scan.pool, &a.scan.source[start..end]);
}

/// Parse a bare symbol name.
fn parseSymbolName(a: *mut super::Assembler) -> *[u8] throws (super::Error) {
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 {
    return tok == scanner::TokenKind::Label or tok == scanner::TokenKind::QuotedLabel;
}

/// Parse the contents of a quoted label token, decoding escapes as needed.
fn parseQuotedLabelName(a: *mut super::Assembler) -> *[u8] throws (super::Error) {
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(a.arena, 1, 1, raw.len) catch {
    let storage = try alloc::allocSlice(&mut *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]);
}

/// Parse a label reference or definition name.
fn parseLabelName(a: *mut super::Assembler) -> *[u8] throws (super::Error) {
unsafe fn parseLabelName(a: &mut super::Assembler) -> *[u8] throws (super::Error) {
    if a.scan.current.kind == scanner::TokenKind::QuotedLabel {
        return try parseQuotedLabelName(a);
    }
    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) {
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.
fn parseItem(a: *mut super::Assembler) throws (super::Error) {
unsafe fn parseItem(a: &mut super::Assembler) throws (super::Error) {
    match a.scan.current.kind {
        case scanner::TokenKind::Ident => {
            let tok = a.scan.current;
            let name = try parseSymbolName(a);
            try parseInstruction(a, name, tok);

    };
    return super::CSRS[index].csr;
}

/// Parse an instruction after its mnemonic has already been consumed.
fn parseInstruction(a: *mut super::Assembler, name: *[u8], tok: scanner::Token) throws (super::Error) {
unsafe fn parseInstruction(a: &mut super::Assembler, name: *[u8], tok: scanner::Token) throws (super::Error) {
    if a.section <> super::Section::Text {
        throw failOnToken(tok, "instructions are only valid in the text section");
    }
    let form = lookupInstruction(name) else {
        throw failOnToken(tok, "unknown instruction");

        case super::InstructionEncoder::Upper { enc } => return try parseUpper(a, enc),
    }
}

/// Parse the `li` pseudo-instruction.
fn parseLi(a: *mut super::Assembler) throws (super::Error) {
unsafe fn parseLi(a: &mut super::Assembler) throws (super::Error) {
    let rd = try parseRegister(a);
    let value = try parseValue(a);
    if encode::isSmallImm64(value) {
        try emit::emitText(a, encode::addi(rd, rv64::ZERO, value as i32));
        return;

    try emit::emitText(a, encode::lui(rd, split.hi));
    try emit::emitText(a, encode::addi(rd, rd, split.lo));
}

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

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

/// Parse a CSR read-like instruction with destination register then CSR.
fn parseRdCsr(a: *mut super::Assembler, enc: fn(gen::Reg, u32) -> u32) throws (super::Error) {
unsafe fn parseRdCsr(a: &mut super::Assembler, enc: fn(gen::Reg, u32) -> u32) throws (super::Error) {
    let rd = try parseRegister(a);
    let csr = try parseCsr(a);

    try emit::emitText(a, enc(rd, csr));
}

/// Parse a CSR write-like instruction with CSR then source register.
fn parseCsrRs1(a: *mut super::Assembler, enc: fn(u32, gen::Reg) -> u32) throws (super::Error) {
unsafe fn parseCsrRs1(a: &mut super::Assembler, enc: fn(u32, gen::Reg) -> u32) throws (super::Error) {
    let csr = try parseCsr(a);
    let rs1 = try parseRegister(a);

    try emit::emitText(a, enc(csr, rs1));
}

/// Parse `csrrw`.
fn parseCsrrw(a: *mut super::Assembler) throws (super::Error) {
unsafe fn parseCsrrw(a: &mut super::Assembler) throws (super::Error) {
    let rd = try parseRegister(a);
    let csr = try parseCsr(a);
    let rs1 = try parseRegister(a);

    try emit::emitText(a, encode::csrrw(rd, csr, rs1));
}

/// Parse a CSR immediate instruction.
fn parseCsrsi(a: *mut super::Assembler) throws (super::Error) {
unsafe fn parseCsrsi(a: &mut super::Assembler) throws (super::Error) {
    let csr = try parseCsr(a);
    let imm = try parseValue(a);
    if imm < 0 or imm >= super::CSR_IMM_LIMIT {
        throw fail(a, "CSR immediate out of range");
    }
    try emit::emitText(a, encode::csrsi(csr, imm as u32));
}

/// Parse a two-register instruction.
fn parseRR(a: *mut super::Assembler, enc: fn(gen::Reg, gen::Reg) -> u32) throws (super::Error) {
unsafe fn parseRR(a: &mut super::Assembler, enc: fn(gen::Reg, gen::Reg) -> u32) throws (super::Error) {
    let rd = try parseRegister(a);
    let rs = try parseRegister(a);

    try emit::emitText(a, enc(rd, rs));
}

/// Parse a three-register instruction.
fn parseRRR(a: *mut super::Assembler, enc: fn(gen::Reg, gen::Reg, gen::Reg) -> u32) throws (super::Error) {
unsafe fn parseRRR(a: &mut super::Assembler, enc: fn(gen::Reg, gen::Reg, gen::Reg) -> u32) throws (super::Error) {
    let rd = try parseRegister(a);
    let rs1 = try parseRegister(a);
    let rs2 = try parseRegister(a);

    try emit::emitText(a, enc(rd, rs1, rs2));
}

/// Parse a register-register-immediate instruction.
fn parseRRI(a: *mut super::Assembler, enc: fn(gen::Reg, gen::Reg, i32) -> u32) throws (super::Error) {
unsafe fn parseRRI(a: &mut super::Assembler, enc: fn(gen::Reg, gen::Reg, i32) -> u32) throws (super::Error) {
    let rd = try parseRegister(a);
    let rs1 = try parseRegister(a);
    let imm = try parseSmallImm(a);

    try emit::emitText(a, enc(rd, rs1, imm));
}

/// Parse a shift-immediate instruction and enforce its RV64 shift bound.
fn parseShift(
    a: *mut super::Assembler,
unsafe fn parseShift(
    a: &mut super::Assembler,
    enc: fn(gen::Reg, gen::Reg, i32) -> u32,
    limit: i32,
    message: *[u8]
) throws (super::Error) {
    let rd = try parseRegister(a);


    try emit::emitText(a, enc(rd, rs1, shamt));
}

/// Parse a load instruction with a memory operand.
fn parseLoad(a: *mut super::Assembler, enc: fn(gen::Reg, gen::Reg, i32) -> u32) throws (super::Error) {
unsafe fn parseLoad(a: &mut super::Assembler, enc: fn(gen::Reg, gen::Reg, i32) -> u32) throws (super::Error) {
    let rd = try parseRegister(a);
    let memop = try parseMemory(a);

    try emit::emitText(a, enc(rd, memop.base, memop.offset));
}

/// Parse a store instruction with a memory operand.
fn parseStore(a: *mut super::Assembler, enc: fn(gen::Reg, gen::Reg, i32) -> u32) throws (super::Error) {
unsafe fn parseStore(a: &mut super::Assembler, enc: fn(gen::Reg, gen::Reg, i32) -> u32) throws (super::Error) {
    let rs2 = try parseRegister(a);
    let memop = try parseMemory(a);

    try emit::emitText(a, enc(rs2, memop.base, memop.offset));
}

/// Parse a two-register branch instruction.
fn parseBranch(a: *mut super::Assembler, op: super::BranchOp) throws (super::Error) {
unsafe fn parseBranch(a: &mut super::Assembler, op: super::BranchOp) throws (super::Error) {
    let rs1 = try parseRegister(a);
    let rs2 = try parseRegister(a);

    try parseBranchLabel(a, op, rs1, rs2);
}

/// Parse an optional label operand.
fn parseOptionalLabel(a: *mut super::Assembler) -> ?*[u8] throws (super::Error) {
unsafe fn parseOptionalLabel(a: &mut super::Assembler) -> ?*[u8] throws (super::Error) {
    if not isLabel(a.scan.current.kind) {
        return nil;
    }
    return try parseLabelName(a);
}

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

/// Parse a branch-to-zero pseudo-instruction.
fn parseBranchZero(a: *mut super::Assembler, op: super::BranchOp) throws (super::Error) {
unsafe fn parseBranchZero(a: &mut super::Assembler, op: super::BranchOp) throws (super::Error) {
    let rs = try parseRegister(a);
    try parseBranchLabel(a, op, rs, rv64::ZERO);
}

/// Parse `jal` with an explicit destination register.
fn parseJal(a: *mut super::Assembler) throws (super::Error) {
unsafe fn parseJal(a: &mut super::Assembler) throws (super::Error) {
    let rd = try parseRegister(a);
    try parseJ(a, rd);
}

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

/// Parse an upper-immediate instruction.
fn parseUpper(a: *mut super::Assembler, enc: fn(gen::Reg, i32) -> u32) throws (super::Error) {
unsafe fn parseUpper(a: &mut super::Assembler, enc: fn(gen::Reg, i32) -> u32) throws (super::Error) {
    let rd = try parseRegister(a);
    let imm64 = try parseValue(a);
    if imm64 < 0 or imm64 > super::UPPER_IMM_MAX_VALUE {
        throw fail(a, "upper immediate out of range");
    }
    try emit::emitText(a, enc(rd, imm64 as i32));
}

/// Parse a directive after its name has already been consumed.
fn parseDirective(a: *mut super::Assembler, name: *[u8], tok: scanner::Token) throws (super::Error) {
unsafe fn parseDirective(a: &mut super::Assembler, name: *[u8], tok: scanner::Token) throws (super::Error) {
    let directive = classifyDirective(name) else {
        throw failOnToken(tok, "unknown directive");
    };
    match directive {
        case super::DirectiveKind::Text => {

        }
    }
}

/// Parse a `.constant` directive.
fn parseConstantDirective(a: *mut super::Assembler) throws (super::Error) {
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 a `.export` directive.
fn parseExportDirective(a: *mut super::Assembler) throws (super::Error) {
unsafe fn parseExportDirective(a: &mut super::Assembler) throws (super::Error) {
    let name = try parseLabelName(a);
    dict::insert(&mut a.exportMap, name, 1);
    if let idx = dict::get(&a.symbolMap, name) {
        set a.symbols[idx as u32].isExported = true;
    }
}

/// Parse a `.space` directive.
fn parseSpaceDirective(a: *mut super::Assembler) throws (super::Error) {
unsafe fn parseSpaceDirective(a: &mut super::Assembler) throws (super::Error) {
    let count = try parseValue(a);
    if count < 0 {
        throw fail(a, "space size must be non-negative");
    }
    // The data section grows on demand; only reject sizes that cannot be

        try emit::emitByte(a, 0);
    }
}

/// Parse an `.align` directive for the current section.
fn parseAlignDirective(a: *mut super::Assembler) throws (super::Error) {
unsafe fn parseAlignDirective(a: &mut super::Assembler) throws (super::Error) {
    let amount64 = try parseValue(a);
    if amount64 <= 0 {
        throw fail(a, "alignment must be positive");
    }
    if amount64 > super::U32_MAX_VALUE {

        }
    }
}

/// Parse a `.byte` directive.
fn parseByteDirective(a: *mut super::Assembler) throws (super::Error) {
unsafe fn parseByteDirective(a: &mut super::Assembler) throws (super::Error) {
    loop {
        if a.scan.current.kind == scanner::TokenKind::Char {
            let ch = parseCharLiteral(a.scan.current) else {
                throw fail(a, "invalid char literal");
            };

        }
    }
}

/// Parse a fixed-width integer data directive.
fn parseIntDirective(a: *mut super::Assembler, width: super::DataWidth) throws (super::Error) {
unsafe fn parseIntDirective(a: &mut super::Assembler, width: super::DataWidth) throws (super::Error) {
    loop {
        if isLabel(a.scan.current.kind) {
            let target = try parseLabelName(a);
            try emit::recordDataFixup(a, target, width);
        } else if a.scan.current.kind == scanner::TokenKind::Char {

        }
    }
}

/// Parse a `.ascii` string literal list.
fn parseStringDirective(a: *mut super::Assembler) throws (super::Error) {
unsafe fn parseStringDirective(a: &mut super::Assembler) throws (super::Error) {
    loop {
        let literal = try expectToken(a, scanner::TokenKind::String, "expected string literal");
        try emit::emitDecodedString(a, literal.source);
        if not consume(a, scanner::TokenKind::Comma) {
            return;
        }
    }
}

/// Parse and resolve a register operand.
fn parseRegister(a: *mut super::Assembler) -> gen::Reg throws (super::Error) {
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) {
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) {
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) {
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) {
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) {
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) {
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) {
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) {
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) {
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) {
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) {
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) {
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) {
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 +17 -17

export fn invalid(offset: u32, message: *[u8]) -> Token {
    return Token { kind: TokenKind::Invalid, source: message, offset };
}

/// Return `true` when the scanner has consumed all input.
export fn isEof(s: *Scanner) -> bool {
export fn isEof(s: &Scanner) -> bool {
    return s.cursor >= s.source.len;
}

/// Return the current character without advancing.
fn current(s: *Scanner) -> ?u8 {
fn current(s: &Scanner) -> ?u8 {
    if isEof(s) {
        return nil;
    }
    return s.source[s.cursor];
}

/// Return the next character without advancing.
fn peek(s: *Scanner) -> ?u8 {
fn peek(s: &Scanner) -> ?u8 {
    if s.cursor + 1 >= s.source.len {
        return nil;
    }
    return s.source[s.cursor + 1];
}

/// Advance the scanner cursor and return the consumed character.
fn advance(s: *mut Scanner) -> u8 {
fn advance(s: &mut Scanner) -> u8 {
    set s.cursor += 1;
    return s.source[s.cursor - 1];
}

/// Consume `expected` when it is present at the current cursor.
fn consume(s: *mut Scanner, expected: u8) -> bool {
fn consume(s: &mut Scanner, expected: u8) -> bool {
    if let ch = current(s); ch == expected {
        advance(s);
        return true;
    }
    return false;
}

/// Skip spaces, newlines, tabs, and `//` line comments.
fn skipWhitespace(s: *mut Scanner) {
fn skipWhitespace(s: &mut Scanner) {
    while let ch = current(s) {
        match ch {
            case ' ', '\n', '\r', '\t' => advance(s),
            case '/' => {
                if let nextCh = peek(s); nextCh == '/' {

        }
    }
}

/// Return the next assembler token.
export fn next(s: *mut Scanner) -> Token {
export fn next(s: &mut Scanner) -> Token {
    skipWhitespace(s);
    set s.token = s.cursor;

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

        else => return invalid(s.token, "unexpected character"),
    }
}

/// Create a token spanning the current scanner range.
fn tok(s: *Scanner, kind: TokenKind) -> Token {
fn tok(s: &Scanner, kind: TokenKind) -> Token {
    return Token { kind, source: &s.source[s.token..s.cursor], offset: s.token };
}

/// Scan the identifier continuation characters that follow the current token start.
fn scanIdentifierBody(s: *mut Scanner) {
fn scanIdentifierBody(s: &mut Scanner) {
    while let ch = current(s); char::isAlpha(ch) or char::isDigit(ch) or ch == '_' {
        advance(s);
    }
}

/// Scan a signed number when `+` or `-` is followed by a digit, otherwise return the punctuation token.
fn scanSignedNumberOrToken(s: *mut Scanner, kind: TokenKind) -> Token {
fn scanSignedNumberOrToken(s: &mut Scanner, kind: TokenKind) -> Token {
    if let nextCh = current(s); char::isDigit(nextCh) {
        return scanNumber(s);
    }
    return tok(s, kind);
}

/// Scan a numeric literal.
fn scanNumber(s: *mut Scanner) -> Token {
fn scanNumber(s: &mut Scanner) -> Token {
    let first = s.source[s.cursor - 1];
    if first == '-' or first == '+' {
        advance(s);
    }
    if s.source[s.cursor - 1] == '0' {

    }
    return tok(s, TokenKind::Number);
}

/// Scan a printable token terminated by `delim`.
fn scanCharsUntil(s: *mut Scanner, delim: u8, kind: TokenKind) -> ?Token {
fn scanCharsUntil(s: &mut Scanner, delim: u8, kind: TokenKind) -> ?Token {
    while let ch = current(s); ch <> delim {
        if not char::isPrint(ch) {
            return invalid(s.token, "invalid character");
        }
        if consume(s, '\\') {

    }
    return tok(s, kind);
}

/// Scan a string literal.
fn scanString(s: *mut Scanner) -> Token {
fn scanString(s: &mut Scanner) -> Token {
    if let token = scanCharsUntil(s, '"', TokenKind::String) {
        return token;
    }
    return invalid(s.token, "unterminated string");
}

/// Scan a character literal.
fn scanChar(s: *mut Scanner) -> Token {
fn scanChar(s: &mut Scanner) -> Token {
    if let token = scanCharsUntil(s, '\'', TokenKind::Char) {
        return token;
    }
    return invalid(s.token, "unterminated character");
}

/// Scan an identifier-shaped token of the given kind.
fn scanIdentToken(s: *mut Scanner, kind: TokenKind) -> Token {
fn scanIdentToken(s: &mut Scanner, kind: TokenKind) -> Token {
    scanIdentifierBody(s);

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

/// Scan a sigil-prefixed identifier-shaped token.
fn scanPrefixedToken(s: *mut Scanner, kind: TokenKind, message: *[u8]) -> Token {
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);

        offset: s.token,
    };
}

/// Scan an assembler label token, accepting either `@name` or `@"quoted"` syntax.
fn scanLabelToken(s: *mut Scanner) -> Token {
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/tests.rad +15 -15

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

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

    ) catch {
        throw testing::TestError::Failed;
    };
}

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

        return;
    };
    throw testing::TestError::Failed;
}

fn printInstrText(instr: u32) -> *[u8] {
unsafe fn printInstrText(instr: u32) -> *[u8] {
    let mut arena = alloc::new(&mut PRINT_ARENA_STORAGE[..]);
    let mut pos: u32 = 0;
    let mut out = sexpr::Output::Buffer { buf: &mut PRINT_BUFFER[..], pos: &mut pos };
    printer::printInstr(&mut out, &mut arena, instr);
    return &PRINT_BUFFER[..pos];
}

@test fn testAssemblePercentPrefixedRegisters() throws (testing::TestError) {
@test unsafe fn testAssemblePercentPrefixedRegisters() throws (testing::TestError) {
    let program = try assembleSource(
        ".text;\naddi %a0 %zero 42;\nsd %a0 8(%sp);\n"
    );
    try testing::expect(program.text.len == 2);
    try testing::expect(program.text[0] == encode::addi(rv64::A0, rv64::ZERO, 42));
    try testing::expect(program.text[1] == encode::sd(rv64::A0, rv64::SP, 8));
}

@test fn testAssembleDataAddressUsesRoDataBase() throws (testing::TestError) {
@test unsafe fn testAssembleDataAddressUsesRoDataBase() throws (testing::TestError) {
    let program = try assembleSource(
        ".text;\nla %t0 @value;\n.data;\n.byte 0;\n@value\n.byte 1;\n"
    );
    try testing::expect(program.text.len == 2);
    try testing::expect(program.text[0] == encode::lui(rv64::T0, 0x10));
    try testing::expect(program.text[1] == encode::addi(rv64::T0, rv64::T0, 1));
}

@test fn testAssembleTextAddressUsesPcRelative() throws (testing::TestError) {
@test unsafe fn testAssembleTextAddressUsesPcRelative() throws (testing::TestError) {
    let program = try assembleSource(
        ".text;\nla %t0 @target;\n@target\nret;\n"
    );
    try testing::expect(program.text.len == 3);
    try testing::expect(program.text[0] == encode::auipc(rv64::T0, 0));
    try testing::expect(program.text[1] == encode::addi(rv64::T0, rv64::T0, 8));
}

@test fn testAssembleQuotedLabelNames() throws (testing::TestError) {
@test unsafe fn testAssembleQuotedLabelNames() throws (testing::TestError) {
    let program = try assembleSource(
        ".text;\nj @\"foo.bar.baz\";\n@\"foo.bar.baz\"\nret;\n"
    );
    try testing::expect(program.text.len == 2);
    try testing::expect(program.text[0] == encode::jal(rv64::ZERO, 4));
    try testing::expect(program.text[1] == encode::jalr(rv64::ZERO, rv64::RA, 0));
}

@test fn testAssembleGlobalMarksOnlyDeclaredSymbols() throws (testing::TestError) {
@test unsafe fn testAssembleGlobalMarksOnlyDeclaredSymbols() throws (testing::TestError) {
    let program = try assembleSource(
        ".text;\n.export @exported;\n@local\nret;\n@exported\nret;\n@late\n.export @late;\nret;\n"
    );
    try testing::expect(program.symbols.len == 3);
    try testing::expect(not program.symbols[0].isExported);
    try testing::expect(program.symbols[1].isExported);
    try testing::expect(program.symbols[2].isExported);
}

@test fn testAssembleExternalTextFixups() throws (testing::TestError) {
@test unsafe fn testAssembleExternalTextFixups() throws (testing::TestError) {
    let program = try assembleSource(
        ".text;\ntail @\"::default\";\nla %t0 @\"::default\";\n"
    );
    try testing::expect(program.externalFixups.len == 2);


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

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

    try expectAssembleFail(
        ".data;\n.dword @missing;\n"
    );
}

@test fn testAssembleInvalidSyntaxFails() throws (testing::TestError) {
@test unsafe fn testAssembleInvalidSyntaxFails() throws (testing::TestError) {
    try expectAssembleFail(
        ".text;\n@dup\n@dup\nret;\n"
    );
    try expectAssembleFail(
        ".text;\naddi %a0, %zero, 1\n"

    try expectAssembleFail(
        ".export @kernel::main, @data::sym;\n"
    );
}

@test fn testAssembleInvalidSectionsFail() throws (testing::TestError) {
@test unsafe fn testAssembleInvalidSectionsFail() throws (testing::TestError) {
    try expectAssembleFail(
        ".data;\n.dword @target;\n.text;\n@target\nret;\n"
    );
    try expectAssembleFail(
        ".data;\naddi %a0 %zero 1;\n"

    try expectAssembleFail(
        ".data;\n@value\n.byte 1;\n.text;\nj @value;\n"
    );
}

@test fn testAssembleInvalidDirectivesFail() throws (testing::TestError) {
@test unsafe fn testAssembleInvalidDirectivesFail() throws (testing::TestError) {
    try expectAssembleFail(
        ".data;\n.ascii 'x';\n"
    );
    try expectAssembleFail(
        ".data;\n.byte 1 + 2;\n"

    try expectAssembleFail(
        ".data;\n.align 4294967296;\n"
    );
}

@test fn testAssembleInvalidImmediateRangesFail() throws (testing::TestError) {
@test unsafe fn testAssembleInvalidImmediateRangesFail() throws (testing::TestError) {
    try expectAssembleFail(
        ".text;\nslli %a0 %a1 64;\n"
    );
    try expectAssembleFail(
        ".text;\nslli %a0 %a1 4294967296;\n"

    try expectAssembleFail(
        ".text;\ncsrsi mstatus 32;\n"
    );
}

@test fn testPrintInstrUsesPercentPrefixedRegisters() throws (testing::TestError) {
@test unsafe fn testPrintInstrUsesPercentPrefixedRegisters() throws (testing::TestError) {
    let text = printInstrText(encode::addi(rv64::A0, rv64::SP, 42));
    try testing::expect(mem::eq(text, "addi    %a0, %sp, 42"));
}

lib/std/arch/rv64/emit.rad +43 -40

    }
    return frame;
}

/// Create a new emitter.
export fn emitter(arena: *mut alloc::Arena, debug: bool) -> Emitter throws (alloc::AllocError) {
export unsafe fn emitter(arena: &mut alloc::Arena, debug: bool) -> Emitter throws (alloc::AllocError) {
    let code = try alloc::allocSlice(arena, @sizeOf(u32), @alignOf(u32), MAX_INSTRS);
    let pendingBranches = try alloc::allocSlice(arena, @sizeOf(PendingBranch), @alignOf(PendingBranch), MAX_PENDING);
    let pendingCalls = try alloc::allocSlice(arena, @sizeOf(PendingCall), @alignOf(PendingCall), MAX_PENDING);
    let pendingJumps = try alloc::allocSlice(arena, @sizeOf(PendingJump), @alignOf(PendingJump), MAX_PENDING);
    let pendingAddrLoads = try alloc::allocSlice(arena, @sizeOf(PendingAddrLoad), @alignOf(PendingAddrLoad), MAX_PENDING);

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

/// Emit a single instruction.
export fn emit(e: *mut Emitter, instr: u32) {
export fn emit(e: &mut Emitter, instr: u32) {
    assert e.codeLen < e.code.len, "emit: code buffer full";
    set e.code[e.codeLen] = instr;
    set e.codeLen += 1;
}

/// Compute branch offset to a function by name.
export fn branchOffsetToFunc(e: *Emitter, srcIndex: u32, name: *[u8]) -> i32 {
export fn branchOffsetToFunc(e: &Emitter, srcIndex: u32, name: *[u8]) -> i32 {
    return labels::branchToFunc(&e.labels, srcIndex, name, super::INSTR_SIZE);
}

/// Patch an instruction at a given index.
export fn patch(e: *mut Emitter, index: u32, instr: u32) {
export fn patch(e: &mut Emitter, index: u32, instr: u32) {
    set e.code[index] = instr;
}

/// Record a block's address for branch resolution.
export fn recordBlock(e: *mut Emitter, blockIdx: u32) {
export fn recordBlock(e: &mut Emitter, blockIdx: u32) {
    assert e.codeLen <= MAX_CODE_LEN;
    labels::recordBlock(&mut e.labels, blockIdx, e.codeLen as i32 * super::INSTR_SIZE);
}

/// Record a function's code offset for call resolution.
export fn recordFuncOffset(e: *mut Emitter, name: *[u8]) {
    recordFuncOffsetAt(e, name, e.codeLen);
export fn recordFuncOffset(e: &mut Emitter, name: *[u8]) {
    let codeLen = e.codeLen;
    recordFuncOffsetAt(e, name, codeLen);
}

/// Record a function's code offset at `index` for call resolution.
export fn recordFuncOffsetAt(e: *mut Emitter, name: *[u8], index: u32) {
export fn recordFuncOffsetAt(e: &mut Emitter, name: *[u8], index: u32) {
    assert index <= MAX_CODE_LEN;
    dict::insert(&mut e.labels.funcs, name, index as i32 * super::INSTR_SIZE);
}

/// Record a function's start position for printing.
export fn recordFunc(e: *mut Emitter, name: *[u8]) {
    recordFuncAt(e, name, e.codeLen);
export fn recordFunc(e: &mut Emitter, name: *[u8]) {
    let codeLen = e.codeLen;
    recordFuncAt(e, name, codeLen);
}

/// Record a function's start position at `index` for printing.
export fn recordFuncAt(e: *mut Emitter, name: *[u8], index: u32) {
export fn recordFuncAt(e: &mut Emitter, name: *[u8], index: u32) {
    e.funcs.append(types::FuncAddr { name, index }, e.allocator);
}

/// Record a local branch needing later patching.
/// Unconditional jumps use a single slot (J-type, +-1MB range).
/// Conditional branches use two slots (B-type has only +-4KB range,
/// so large functions may need the inverted-branch + JAL fallback).
export fn recordBranch(e: *mut Emitter, targetBlock: u32, kind: BranchKind) {
export fn recordBranch(e: &mut Emitter, targetBlock: u32, kind: BranchKind) {
    e.pendingBranches.append(PendingBranch {
        index: e.codeLen,
        target: targetBlock,
        kind: kind,
    }, e.allocator);

}

/// Record a function call needing later patching.
/// Emits placeholder instructions that will be patched later.
/// Uses two slots to support long-distance calls.
export fn recordCall(e: *mut Emitter, target: *[u8]) {
export fn recordCall(e: &mut Emitter, target: *[u8]) {
    e.pendingCalls.append(PendingCall {
        index: e.codeLen,
        target,
    }, e.allocator);

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

/// Record a jump emitted by assembly that needs whole-program patching.
export fn recordJumpAt(e: *mut Emitter, target: *[u8], rd: gen::Reg, index: u32) {
export fn recordJumpAt(e: &mut Emitter, target: *[u8], rd: gen::Reg, index: u32) {
    e.pendingJumps.append(PendingJump {
        index,
        target,
        rd,
    }, e.allocator);
}

/// Record a function address load needing later patching.
/// Emits placeholder instructions that will be patched to load the function's address.
/// Uses two slots to compute long-distance addresses.
export fn recordAddrLoad(e: *mut Emitter, target: *[u8], rd: gen::Reg) {
    recordAddrLoadAt(e, target, rd, e.codeLen);
export fn recordAddrLoad(e: &mut Emitter, target: *[u8], rd: gen::Reg) {
    let codeLen = e.codeLen;
    recordAddrLoadAt(e, target, rd, codeLen);

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

/// Record a function address load already reserved by assembly.
export fn recordAddrLoadAt(e: *mut Emitter, target: *[u8], rd: gen::Reg, index: u32) {
export fn recordAddrLoadAt(e: &mut Emitter, target: *[u8], rd: gen::Reg, index: u32) {
    e.pendingAddrLoads.append(PendingAddrLoad {
        index,
        target,
        rd: rd,
        isData: false,
    }, e.allocator);
}

/// Record a data address load needing later patching.
/// Uses an absolute 32-bit load sequence matching the current data memory map.
export fn recordDataAddrLoad(e: *mut Emitter, target: *[u8], rd: gen::Reg) {
export fn recordDataAddrLoad(e: &mut Emitter, target: *[u8], rd: gen::Reg) {
    e.pendingAddrLoads.append(PendingAddrLoad {
        index: e.codeLen,
        target,
        rd: rd,
        isData: true,

///
/// Called after each function.
///
/// Uses two-instruction sequences: short branches use `branch` and `nop`,
/// long branches use inverted branch  and `jal` or `auipc` and `jalr`.
export fn patchLocalBranches(e: *mut Emitter) {
export fn patchLocalBranches(e: &mut Emitter) {
    for i in 0..e.pendingBranches.len {
        let p = e.pendingBranches[i];
        let offset = labels::branchToBlock(&e.labels, p.index, p.target, super::INSTR_SIZE);
        match p.kind {
            case BranchKind::Cond { op, rs1, rs2 } => {

    }
}

/// Patch all pending function calls.
/// Called after all functions have been generated.
export fn patchCalls(e: *mut Emitter) {
export fn patchCalls(e: &mut Emitter) {
    for i in 0..e.pendingCalls.len {
        let p = e.pendingCalls[i];
        let offset = branchOffsetToFunc(e, p.index, p.target);
        let s = splitImm(offset);


        patch(e, p.index + 1, encode::jalr(super::RA, super::SCRATCH1, s.lo));
    }
}

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

        assert encode::isJumpImm(offset), "patchJumps: jump offset too large";

    }
}

/// Patch all pending function and data address loads.
/// Called after all functions have been generated and data layout is known.
export fn patchAddrLoads(e: *mut Emitter, dataSymMap: *data::DataSymMap) {
export fn patchAddrLoads(e: &mut Emitter, dataSymMap: &data::DataSymMap) {
    for i in 0..e.pendingAddrLoads.len {
        let p = e.pendingAddrLoads[i];
        if p.isData {
            let addr = data::lookupAddr(dataSymMap, p.target) else {
                panic "patchAddrLoads: data symbol not found";

/// Adjust a large offset by loading *hi* bits into [`super::ADDR_SCRATCH`].
/// Returns adjusted base register and remaining offset.
///
/// When the offset fits a 12-bit signed immediate, returns it unchanged.
/// Otherwise uses [`super::ADDR_SCRATCH`] for the LUI+ADD decomposition.
fn adjustOffset(e: *mut Emitter, base: gen::Reg, offset: i32) -> AdjustedOffset {
fn adjustOffset(e: &mut Emitter, base: gen::Reg, offset: i32) -> AdjustedOffset {
    if offset >= super::MIN_IMM and offset <= super::MAX_IMM {
        return AdjustedOffset { base, offset };
    }
    let s = splitImm(offset);
    emit(e, encode::lui(super::ADDR_SCRATCH, s.hi));

/// Load an immediate value into a register.
/// Handles the full range of 64-bit immediates.
/// For values fitting in 12 bits, uses a single `ADDI`.
/// For values fitting in 32 bits, uses `LUI` + `ADDIW`.
/// For wider values, loads upper and lower halves then combines with shift and add.
export fn loadImm(e: *mut Emitter, rd: gen::Reg, imm: i64) {
export fn loadImm(e: &mut Emitter, rd: gen::Reg, imm: i64) {
    let immMin = super::MIN_IMM as i64;
    let immMax = super::MAX_IMM as i64;

    if imm >= immMin and imm <= immMax {
        emit(e, encode::addi(rd, super::ZERO, imm as i32));

        emit(e, encode::addi(rd, rd, chunkLo));
    }
}

/// Emit add-immediate, handling large immediates.
export fn emitAddImm(e: *mut Emitter, rd: gen::Reg, rs: gen::Reg, imm: i32) {
export fn emitAddImm(e: &mut Emitter, rd: gen::Reg, rs: gen::Reg, imm: i32) {
    if imm >= super::MIN_IMM and imm <= super::MAX_IMM {
        emit(e, encode::addi(rd, rs, imm));
    } else {
        loadImm(e, super::SCRATCH1, imm as i64);
        emit(e, encode::add(rd, rs, super::SCRATCH1));

////////////////////////
// Load/Store Helpers //
////////////////////////

/// Emit unsigned load with automatic offset adjustment.
export fn emitLoad(e: *mut Emitter, rd: gen::Reg, base: gen::Reg, offset: i32, typ: il::Type) {
export fn emitLoad(e: &mut Emitter, rd: gen::Reg, base: gen::Reg, offset: i32, typ: il::Type) {
    let adj = adjustOffset(e, base, offset);
    match typ {
        case il::Type::W8 => emit(e, encode::lbu(rd, adj.base, adj.offset)),
        case il::Type::W16 => emit(e, encode::lhu(rd, adj.base, adj.offset)),
        case il::Type::W32 => emit(e, encode::lwu(rd, adj.base, adj.offset)),
        case il::Type::W64 => emit(e, encode::ld(rd, adj.base, adj.offset)),
    }
}

/// Emit signed load with automatic offset adjustment.
export fn emitSload(e: *mut Emitter, rd: gen::Reg, base: gen::Reg, offset: i32, typ: il::Type) {
export fn emitSload(e: &mut Emitter, rd: gen::Reg, base: gen::Reg, offset: i32, typ: il::Type) {
    let adj = adjustOffset(e, base, offset);
    match typ {
        case il::Type::W8 => emit(e, encode::lb(rd, adj.base, adj.offset)),
        case il::Type::W16 => emit(e, encode::lh(rd, adj.base, adj.offset)),
        case il::Type::W32 => emit(e, encode::lw(rd, adj.base, adj.offset)),
        case il::Type::W64 => emit(e, encode::ld(rd, adj.base, adj.offset)),
    }
}

/// Emit store with automatic offset adjustment.
export fn emitStore(e: *mut Emitter, rs: gen::Reg, base: gen::Reg, offset: i32, typ: il::Type) {
export fn emitStore(e: &mut Emitter, rs: gen::Reg, base: gen::Reg, offset: i32, typ: il::Type) {
    let adj = adjustOffset(e, base, offset);
    match typ {
        case il::Type::W8 => emit(e, encode::sb(rs, adj.base, adj.offset)),
        case il::Type::W16 => emit(e, encode::sh(rs, adj.base, adj.offset)),
        case il::Type::W32 => emit(e, encode::sw(rs, adj.base, adj.offset)),
        case il::Type::W64 => emit(e, encode::sd(rs, adj.base, adj.offset)),
    }
}

/// Emit 64-bit load with automatic offset adjustment.
export fn emitLd(e: *mut Emitter, rd: gen::Reg, base: gen::Reg, offset: i32) {
export fn emitLd(e: &mut Emitter, rd: gen::Reg, base: gen::Reg, offset: i32) {
    let adj = adjustOffset(e, base, offset);
    emit(e, encode::ld(rd, adj.base, adj.offset));
}

/// Emit 64-bit store with automatic offset adjustment.
export fn emitSd(e: *mut Emitter, rs: gen::Reg, base: gen::Reg, offset: i32) {
export fn emitSd(e: &mut Emitter, rs: gen::Reg, base: gen::Reg, offset: i32) {
    let adj = adjustOffset(e, base, offset);
    emit(e, encode::sd(rs, adj.base, adj.offset));
}

/// Emit 32-bit load with automatic offset adjustment.
export fn emitLw(e: *mut Emitter, rd: gen::Reg, base: gen::Reg, offset: i32) {
export fn emitLw(e: &mut Emitter, rd: gen::Reg, base: gen::Reg, offset: i32) {
    let adj = adjustOffset(e, base, offset);
    emit(e, encode::lw(rd, adj.base, adj.offset));
}

/// Emit 32-bit store with automatic offset adjustment.
export fn emitSw(e: *mut Emitter, rs: gen::Reg, base: gen::Reg, offset: i32) {
export fn emitSw(e: &mut Emitter, rs: gen::Reg, base: gen::Reg, offset: i32) {
    let adj = adjustOffset(e, base, offset);
    emit(e, encode::sw(rs, adj.base, adj.offset));
}

/// Emit 8-bit load with automatic offset adjustment.
export fn emitLb(e: *mut Emitter, rd: gen::Reg, base: gen::Reg, offset: i32) {
export fn emitLb(e: &mut Emitter, rd: gen::Reg, base: gen::Reg, offset: i32) {
    let adj = adjustOffset(e, base, offset);
    emit(e, encode::lb(rd, adj.base, adj.offset));
}

/// Emit 8-bit store with automatic offset adjustment.
export fn emitSb(e: *mut Emitter, rs: gen::Reg, base: gen::Reg, offset: i32) {
export fn emitSb(e: &mut Emitter, rs: gen::Reg, base: gen::Reg, offset: i32) {
    let adj = adjustOffset(e, base, offset);
    emit(e, encode::sb(rs, adj.base, adj.offset));
}

//////////////////////////
// Prologue / Epilogue  //
//////////////////////////

/// Emit function prologue.
/// Allocate the frame and save registers. Save FP only for dynamic frames.
export fn emitPrologue(e: *mut Emitter, frame: *Frame) {
export fn emitPrologue(e: &mut Emitter, frame: &Frame) {
    // Fast path: leaf function with no locals.
    if frame.totalSize == 0 {
        return;
    }
    let totalSize = frame.totalSize;

        emitSd(e, sr.reg, super::SP, sr.offset);
    }
}

/// Emit a return: jump to epilogue, or emit `ret` directly for leaf functions.
export fn emitReturn(e: *mut Emitter, frame: *Frame) {
export fn emitReturn(e: &mut Emitter, frame: &Frame) {
    if frame.totalSize == 0 {
        // Leaf function: no frame to tear down, emit ret directly.
        emit(e, encode::ret());
        return;
    }
    recordBranch(e, frame.epilogueBlock, BranchKind::Jump);
}

/// Emit function epilogue.
/// Restore saved registers and release the frame. Restore FP only for dynamic frames.
export fn emitEpilogue(e: *mut Emitter, frame: *Frame) {
export fn emitEpilogue(e: &mut Emitter, frame: &Frame) {
    // Record epilogue block address for return jumps.
    recordBlock(e, frame.epilogueBlock);

    // Fast path: leaf function with no locals.
    if frame.totalSize == 0 {

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

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

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

    // Skip if this is the same location as the previous entry.
    if e.debugEntriesLen > 0 {
        let prev = &e.debugEntries[e.debugEntriesLen - 1];

    };
    set e.debugEntriesLen += 1;
}

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

lib/std/arch/rv64/isel.rad +155 -153

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

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

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

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

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

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

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

/// Get the source register for an SSA register.
/// If the register is spilled, loads the value from the spill slot into the
/// scratch register and returns it. Otherwise returns the physical register.
fn getSrcReg(s: *mut Selector, ssa: il::Reg, scratch: gen::Reg) -> gen::Reg {
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(s.e, scratch, spillBase(s), spillOffset(s, slot));
        emit::emitLd(&mut *s.e, scratch, spillBase(s), spillOffset(s, slot));
        return scratch;
    }
    return getReg(s, ssa);
}

/// Resolve an IL value to the physical register holding it.
/// For non-spilled register values, returns the physical register directly.
/// For immediates, symbols, and spilled registers, materializes into `scratch`.
fn resolveVal(s: *mut Selector, scratch: gen::Reg, val: il::Val) -> gen::Reg {
unsafe fn resolveVal(s: &mut Selector, scratch: gen::Reg, val: il::Val) -> gen::Reg {
    match val {
        case il::Val::Reg(r) => {
            return getSrcReg(s, r, scratch);
        },
        case il::Val::Imm(imm) => {
            if imm == 0 {
                return super::ZERO;
            }
            emit::loadImm(s.e, scratch, imm);
            emit::loadImm(&mut *s.e, scratch, imm);
            return scratch;
        },
        case il::Val::DataSym(name) => {
            emit::recordDataAddrLoad(s.e, name, scratch);
            emit::recordDataAddrLoad(&mut *s.e, name, scratch);
            return scratch;
        },
        case il::Val::FnAddr(name) => {
            emit::recordAddrLoad(s.e, name, scratch);
            emit::recordAddrLoad(&mut *s.e, name, scratch);
            return scratch;
        },
        case il::Val::Undef => {
            return scratch;
        }
    }
}

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

/// Emit a move instruction if source and destination differ.
fn emitMv(s: *mut Selector, rd: gen::Reg, rs: gen::Reg) {
unsafe fn emitMv(s: &mut Selector, rd: gen::Reg, rs: gen::Reg) {
    if *rd <> *rs {
        emit::emit(s.e, encode::mv(rd, rs));
        emit::emit(&mut *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) {
fn emitZext(e: &mut emit::Emitter, rd: gen::Reg, rs: gen::Reg, typ: il::Type) {
    match typ {
        case il::Type::W8 => emit::emit(e, encode::andi(rd, rs, MASK_W8)),
        case il::Type::W16 => {
            emit::emit(e, encode::slli(rd, rs, SHIFT_W16));
            emit::emit(e, encode::srli(rd, rd, SHIFT_W16));

        case il::Type::W64 => {}
    }
}

/// Emit sign-extension from a sub-word type to the full register width.
fn emitSext(e: *mut emit::Emitter, rd: gen::Reg, rs: gen::Reg, typ: il::Type) {
fn emitSext(e: &mut emit::Emitter, rd: gen::Reg, rs: gen::Reg, typ: il::Type) {
    match typ {
        case il::Type::W8 => {
            emit::emit(e, encode::slli(rd, rs, SHIFT_W8));
            emit::emit(e, encode::srai(rd, rd, SHIFT_W8));
        },

    }
}

/// Resolve a divisor in its declared width, trap if it becomes zero, and
/// return the canonicalized register.
fn resolveAndTrapIfZero(
    s: *mut Selector,
unsafe fn resolveAndTrapIfZero(
    s: &mut Selector,
    b: il::Val,
    typ: il::Type,
    signed: bool
) -> gen::Reg {
    let mut divisor = b;
    if let case il::Val::Imm(imm) = b {
        set divisor = il::Val::Imm(canonicalCmpImm(imm, typ, signed));
    }
    let rs2 = resolveVal(s, super::SCRATCH2, divisor);
    if not isExtendedImm(divisor, typ, signed) {
        emitCmpExt(s.e, rs2, rs2, typ, signed);
        emitCmpExt(&mut *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(s.e, encode::bne(rs2, super::ZERO, super::INSTR_SIZE * 2));
        emit::emit(s.e, encode::ebreak());
        emit::emit(&mut *s.e, encode::bne(rs2, super::ZERO, super::INSTR_SIZE * 2));
        emit::emit(&mut *s.e, encode::ebreak());
    }
    return rs2;
}

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

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

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

        isLeaf,
        reserveInfo.isDynamic
    );
    // Synthetic block indices start after real blocks and the epilogue block.
    let mut s = Selector {
        e, ralloc, frameSize: frame.totalSize,
        e: e as *unsafe mut emit::Emitter,
        ralloc: ralloc as *unsafe regalloc::AllocResult,
        frameSize: frame.totalSize,
        reserveOffset: 0, pendingSpill: nil,
        nextSynthBlock: func.blocks.len + 1,
        isDynamic: frame.isDynamic,
    };
    // Record function name for printing.
    emit::recordFunc(s.e, func.name);
    emit::recordFunc(&mut *s.e, func.name);
    // Record function code offset for call patching.
    emit::recordFuncOffset(s.e, func.name);
    emit::recordFuncOffset(&mut *s.e, func.name);
    // Emit prologue.
    emit::emitPrologue(s.e, &frame);
    emit::emitPrologue(&mut *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(s.e, argReg, spillBase(&s), spillOffset(&s, slot));
                emit::emitSd(&mut *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(s.e, &frame);
    emit::emitEpilogue(&mut *s.e, &frame);
    // Patch local branches now that all blocks are emitted.
    emit::patchLocalBranches(s.e);
    emit::patchLocalBranches(&mut *s.e);
}

/// Select instructions for a block.
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: *il::Block, frame: &emit::Frame, func: *il::Fn) {
    // Record block address for branch patching.
    emit::recordBlock(s.e, blockIdx);
    emit::recordBlock(&mut *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(s.e, block.locs[i]);
            emit::recordSrcLoc(&mut *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(s.e, p.rd, spillBase(s), spillOffset(s, slot));
                emit::emitSd(&mut *s.e, p.rd, spillBase(s), spillOffset(s, slot));
            }
            set s.pendingSpill = nil;
        }
    }
}

/// Select instructions for a single IL instruction.
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: *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(s.e, rd, base, offset, typ);
            emit::emitLoad(&mut *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(s.e, rd, base, offset, typ);
            emit::emitSload(&mut *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(s.e, rs, base, offset, typ);
            emit::emitStore(&mut *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(s.e, rd, base, offset);
                    emit::emitAddImm(&mut *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(s.e, encode::sub(super::SP, super::SP, rs));
                    emit::emit(&mut *s.e, encode::sub(super::SP, super::SP, rs));

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

                        emit::emit(s.e, encode::andi(super::SP, super::SP, mask));
                        emit::emit(&mut *s.e, encode::andi(super::SP, super::SP, mask));
                    }
                    emit::emit(s.e, encode::mv(rd, super::SP));
                    emit::emit(&mut *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(s.e, super::SCRATCH2, spillBase(s), spillOffset(s, dstSlot));
                emit::emitLd(&mut *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(s.e, super::SCRATCH1, rsrc, dwordBytes);
                emit::emitAddImm(&mut *s.e, super::SCRATCH1, rsrc, dwordBytes);

                let loopStart = s.e.codeLen;

                emit::emitLd(s.e, super::SCRATCH2, rsrc, 0);
                emit::emitSd(s.e, super::SCRATCH2, rdst, 0);
                emit::emit(s.e, encode::addi(rsrc, rsrc, super::DWORD_SIZE));
                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));

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

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

            // Copy remaining: 8 bytes, then 4 bytes, then 1 byte at a time.
            // Before each load/store pair, check whether the offset is
            // about to exceed the 12-bit signed immediate range. When
            // it does, advance the base registers by the accumulated
            // offset and reset to zero.
            while remaining >= super::DWORD_SIZE {
                if offset > super::MAX_IMM - super::DWORD_SIZE {
                    emit::emitAddImm(s.e, rsrc, rsrc, offset);
                    emit::emitAddImm(&mut *s.e, rsrc, rsrc, offset);
                    if *rdst <> *rsrc {
                        emit::emitAddImm(s.e, rdst, rdst, offset);
                        emit::emitAddImm(&mut *s.e, rdst, rdst, offset);
                    }
                    set offset = 0;
                }
                if let off = srcReload {
                    emit::emitLd(s.e, super::SCRATCH1, spillBase(s), off);
                    emit::emitLd(s.e, super::SCRATCH1, super::SCRATCH1, offset);
                    emit::emitLd(&mut *s.e, super::SCRATCH1, spillBase(s), off);
                    emit::emitLd(&mut *s.e, super::SCRATCH1, super::SCRATCH1, offset);
                } else {
                    emit::emitLd(s.e, super::SCRATCH1, rsrc, offset);
                    emit::emitLd(&mut *s.e, super::SCRATCH1, rsrc, offset);
                }
                emit::emitSd(s.e, super::SCRATCH1, rdst, offset);
                emit::emitSd(&mut *s.e, super::SCRATCH1, rdst, offset);
                set offset += super::DWORD_SIZE;
                set remaining -= super::DWORD_SIZE;
            }
            if remaining >= super::WORD_SIZE {
                if offset > super::MAX_IMM - super::WORD_SIZE {
                    emit::emitAddImm(s.e, rsrc, rsrc, offset);
                    emit::emitAddImm(&mut *s.e, rsrc, rsrc, offset);
                    if *rdst <> *rsrc {
                        emit::emitAddImm(s.e, rdst, rdst, offset);
                        emit::emitAddImm(&mut *s.e, rdst, rdst, offset);
                    }
                    set offset = 0;
                }
                if let off = srcReload {
                    emit::emitLd(s.e, super::SCRATCH1, spillBase(s), off);
                    emit::emitLw(s.e, super::SCRATCH1, super::SCRATCH1, offset);
                    emit::emitLd(&mut *s.e, super::SCRATCH1, spillBase(s), off);
                    emit::emitLw(&mut *s.e, super::SCRATCH1, super::SCRATCH1, offset);
                } else {
                    emit::emitLw(s.e, super::SCRATCH1, rsrc, offset);
                    emit::emitLw(&mut *s.e, super::SCRATCH1, rsrc, offset);
                }
                emit::emitSw(s.e, super::SCRATCH1, rdst, offset);
                emit::emitSw(&mut *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(s.e, rsrc, rsrc, offset);
                    emit::emitAddImm(&mut *s.e, rsrc, rsrc, offset);
                    if *rdst <> *rsrc {
                        emit::emitAddImm(s.e, rdst, rdst, offset);
                        emit::emitAddImm(&mut *s.e, rdst, rdst, offset);
                    }
                    set offset = 0;
                }
                if let off = srcReload {
                    emit::emitLd(s.e, super::SCRATCH1, spillBase(s), off);
                    emit::emitLb(s.e, super::SCRATCH1, super::SCRATCH1, offset);
                    emit::emitLd(&mut *s.e, super::SCRATCH1, spillBase(s), off);
                    emit::emitLb(&mut *s.e, super::SCRATCH1, super::SCRATCH1, offset);
                } else {
                    emit::emitLb(s.e, super::SCRATCH1, rsrc, offset);
                    emit::emitLb(&mut *s.e, super::SCRATCH1, rsrc, offset);
                }
                emit::emitSb(s.e, super::SCRATCH1, rdst, offset);
                emit::emitSb(&mut *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(s.e, rsrc, rsrc, 0 - advanced);
                    emit::emitAddImm(&mut *s.e, rsrc, rsrc, 0 - advanced);
                    if *rdst <> *rsrc {
                        emit::emitAddImm(s.e, rdst, rdst, 0 - advanced);
                        emit::emitAddImm(&mut *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(s.e, rd, rs, typ);
            emitZext(&mut *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(s.e, rd, rs, typ);
            emitSext(&mut *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(s.e, frame);
                emit::emitReturn(&mut *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(s.e, target, emit::BranchKind::Jump);
                emit::recordBranch(&mut *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(s.e, rs1, rs1, typ, useSext);
                emitCmpExt(&mut *s.e, rs1, rs1, typ, useSext);
            }
            if not bIsZero and not isExtendedImm(b, typ, useSext) {
                emitCmpExt(s.e, rs2, rs2, typ, useSext);
                emitCmpExt(&mut *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(s.e, elseTarget, emit::BranchKind::InvertedCond { op, rs1, rs2 });
                emit::recordBranch(&mut *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(s.e, thenTarget, emit::BranchKind::Jump);
                    emit::recordBranch(&mut *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(s.e, elseTarget, emit::BranchKind::InvertedCond { op, rs1, rs2 });
                emit::recordBranch(&mut *s.e, elseTarget, emit::BranchKind::InvertedCond { op, rs1, rs2 });
            } else {
                emit::recordBranch(s.e, thenTarget, emit::BranchKind::Cond { op, rs1, rs2 });
                emit::recordBranch(&mut *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(s.e, elseTarget, emit::BranchKind::Jump);
                    emit::recordBranch(&mut *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(s.e, super::SCRATCH2, c.value);
                emit::loadImm(&mut *s.e, super::SCRATCH2, c.value);

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

                    emit::recordBranch(s.e, skip, emit::BranchKind::InvertedCond {
                    emit::recordBranch(&mut *s.e, skip, emit::BranchKind::InvertedCond {
                        op: il::CmpOp::Eq, rs1, rs2: super::SCRATCH2,
                    });
                    emitBlockArgs(s, func, c.target, c.args);
                    emit::recordBranch(s.e, c.target, emit::BranchKind::Jump);
                    emit::recordBlock(s.e, skip);
                    emit::recordBranch(&mut *s.e, c.target, emit::BranchKind::Jump);
                    emit::recordBlock(&mut *s.e, skip);
                } else {
                    emit::recordBranch(s.e, c.target, emit::BranchKind::Cond {
                    emit::recordBranch(&mut *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(s.e, defaultTarget, emit::BranchKind::Jump);
            emit::recordBranch(&mut *s.e, defaultTarget, emit::BranchKind::Jump);
        },
        case il::Instr::Unreachable => {
            emit::emit(s.e, encode::ebreak());
            emit::emit(&mut *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(s.e, name);
                    emit::recordCall(&mut *s.e, name);
                },
                case il::Val::Reg(_) => {
                    emit::emit(s.e, encode::jalr(super::RA, super::SCRATCH2, 0));
                    emit::emit(&mut *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(s.e, encode::ecall());
            emit::emit(&mut *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(s.e, encode::ebreak());
            emit::emit(&mut *s.e, encode::ebreak());
        },
        case il::Instr::MemoryFence => {
            emit::emit(s.e, encode::fence());
            emit::emit(&mut *s.e, encode::fence());
        },
    }
}

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

    return signed or typ == il::Type::W32;
}

/// Extend a comparison operand to its selected canonical representation.
fn emitCmpExt(
    e: *mut emit::Emitter,
    e: &mut emit::Emitter,
    rd: gen::Reg,
    rs: gen::Reg,
    typ: il::Type,
    useSext: bool
) {

    return false;
}

/// Select a binary ALU operation, dispatching to the appropriate
/// instruction pattern based on the operation kind and type.
fn selectAluBinOp(s: *mut Selector, op: il::BinOp, typ: il::Type, rd: gen::Reg, rs1: gen::Reg, b: il::Val) {
unsafe fn selectAluBinOp(s: &mut Selector, op: il::BinOp, typ: il::Type, rd: gen::Reg, rs1: gen::Reg, b: il::Val) {
    match op {
        case il::BinOp::Add => {
            if typ == il::Type::W32 {
                // Inline W32 ADD with immediate optimization.
                if let case il::Val::Imm(imm) = b {
                    if encode::isSmallImm64(imm) {
                        emit::emit(s.e, encode::addiw(rd, rs1, imm as i32));
                        emit::emit(&mut *s.e, encode::addiw(rd, rs1, imm as i32));
                        return;
                    }
                }
                let rs2 = resolveVal(s, super::SCRATCH2, b);
                emit::emit(s.e, encode::addw(rd, rs1, rs2));
                emit::emit(&mut *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(s.e,
                    emit::emit(&mut *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(s.e,
            emit::emit(&mut *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(s.e, encode::mv(rd, super::ZERO));
                    emit::emit(&mut *s.e, encode::mv(rd, super::ZERO));
                    return;
                } else if imm == 1 {
                    emitMv(s, rd, rs1);
                    return;
                } else if imm == 2 {
                    emit::emit(s.e, encode::slli(rd, rs1, 1));
                    emit::emit(&mut *s.e, encode::slli(rd, rs1, 1));
                    return;
                } else if imm == 4 {
                    emit::emit(s.e, encode::slli(rd, rs1, 2));
                    emit::emit(&mut *s.e, encode::slli(rd, rs1, 2));
                    return;
                } else if imm == 8 {
                    emit::emit(s.e, encode::slli(rd, rs1, 3));
                    emit::emit(&mut *s.e, encode::slli(rd, rs1, 3));
                    return;
                }
            }
            let rs2 = resolveVal(s, super::SCRATCH2, b);
            emit::emit(s.e,
            emit::emit(&mut *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(s.e,
            emit::emit(&mut *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(s.e,
            emit::emit(&mut *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(s.e,
            emit::emit(&mut *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(s.e,
            emit::emit(&mut *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(s.e, rs1, rs1, typ, useSext);
            emitCmpExt(&mut *s.e, rs1, rs1, typ, useSext);
            if not isExtendedImm(b, typ, useSext) {
                emitCmpExt(s.e, rs2, rs2, typ, useSext);
                emitCmpExt(&mut *s.e, rs2, rs2, typ, useSext);
            }
            emit::emit(s.e, encode::xor(rd, rs1, rs2));
            emit::emit(&mut *s.e, encode::xor(rd, rs1, rs2));
            if let case il::BinOp::Eq = op {
                emit::emit(s.e, encode::sltiu(rd, rd, 1));
                emit::emit(&mut *s.e, encode::sltiu(rd, rd, 1));
            } else {
                emit::emit(s.e, encode::sltu(rd, super::ZERO, rd));
                emit::emit(&mut *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 =>

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

/// Select a unary ALU operation.
fn selectAluUnOp(s: *mut Selector, op: il::UnOp, typ: il::Type, rd: gen::Reg, rs: gen::Reg) {
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(s.e, encode::subw(rd, super::ZERO, rs));
                emit::emit(&mut *s.e, encode::subw(rd, super::ZERO, rs));
            } else {
                emit::emit(s.e, encode::neg(rd, rs));
                emit::emit(&mut *s.e, encode::neg(rd, rs));
            }
        }
        case il::UnOp::Not =>
            emit::emit(s.e, encode::not_(rd, rs)),
            emit::emit(&mut *s.e, encode::not_(rd, rs)),
    }
}

/// Select binary operation with immediate optimization.
fn selectBinOp(s: *mut Selector, rd: gen::Reg, rs1: gen::Reg, b: il::Val, op: BinOp, scratch: gen::Reg) {
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(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)),
                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)),
            }
            return;
        }
    }
    // Fallback: load into register.
    let rs2 = resolveVal(s, scratch, b);
    match op {
        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)),
        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)),
    }
}

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

    // Try immediate optimization first.
    if let case il::Val::Imm(shamt) = b {
        // Keep immediate forms only for encodable shift amounts.
        // 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(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)),
                    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)),
                }
            } else {
                match op {
                    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)),
                    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)),
                }
            }
            return;
        }
    }
    // Fallback: load into register.
    let rs2 = resolveVal(s, scratch, b);
    if isW32 {
        match op {
            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)),
            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)),
        }
    } else {
        match op {
            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)),
            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)),
        }
    }
}

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

/// 1. Identifies "ready" moves.
/// 2. Executes ready moves.
/// 3. Breaks cycles using scratch register.
///
/// Entries with `ZERO` destination are skipped, as they are handled by caller.
fn emitParallelMoves(s: *mut Selector, dsts: *[gen::Reg], args: *[il::Val]) {
unsafe fn emitParallelMoves(s: &mut Selector, dsts: &[gen::Reg], args: &[il::Val]) {
    let n: u32 = args.len;
    if n == 0 {
        return;
    }
    assert n <= MAX_BLOCK_ARGS, "emitParallelMoves: too many arguments";

/// 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.
fn emitBlockArgs(s: *mut Selector, func: *il::Fn, target: u32, args: *mut [il::Val]) {
unsafe fn emitBlockArgs(s: &mut Selector, func: *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(s.e, rs, spillBase(s), spillOffset(s, slot));
                emit::emitSd(&mut *s.e, rs, spillBase(s), spillOffset(s, slot));
            }
        } else {
            set dsts[i] = getReg(s, param);
        }
    }
    emitParallelMoves(s, &dsts[..], args);
}

/// Select a comparison with immediate optimization.
fn selectCmp(
    s: *mut Selector,
unsafe fn selectCmp(
    s: &mut Selector,
    typ: il::Type,
    rd: gen::Reg,
    rs1: gen::Reg,
    b: il::Val,
    op: CmpOp,

    let mut signed = false;
    if let case CmpOp::Slt = op {
        set signed = true;
    }
    let useSext = cmpUsesSext(typ, signed);
    emitCmpExt(s.e, rs1, rs1, typ, useSext);
    emitCmpExt(&mut *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(s.e, encode::slti(rd, rs1, simm)),
                case CmpOp::Ult => emit::emit(s.e, encode::sltiu(rd, rs1, simm)),
                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)),
            }
            if invert {
                emit::emit(s.e, encode::xori(rd, rd, 1));
                emit::emit(&mut *s.e, encode::xori(rd, rd, 1));
            }
            return;
        }
    }

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

lib/std/arch/rv64/printer.rad +24 -24

///////////////////////
// Output Helpers    //
///////////////////////

/// Write a string to output.
fn write(out: *mut sexpr::Output, s: *[u8]) {
unsafe fn write(out: &mut sexpr::Output, s: &[u8]) {
    sexpr::write(out, s);
}

/// Format `i32` into arena.
fn formatI32(a: *mut alloc::Arena, val: i32) -> *[u8] {
fn formatI32(a: &mut alloc::Arena, val: i32) -> *[u8] {
    let mut digits: [u8; 12] = undefined;
    let text = fmt::formatI32(val, &mut digits[..]);
    let slice = try! alloc::allocSlice(a, 1, 1, text.len) as *mut [u8];
    try! mem::copy(slice, text);
    let start = fmt::formatI32(val, &mut digits[..]);
    let slice = try! alloc::allocSlice(a, 1, 1, digits.len - start) as *mut [u8];
    try! mem::copy(slice, &digits[start..]);

    return slice;
}

/// Format `u32` into arena.
fn formatU32(a: *mut alloc::Arena, val: u32) -> *[u8] {
fn formatU32(a: &mut alloc::Arena, val: u32) -> *[u8] {
    let mut digits: [u8; 10] = undefined;
    let text = fmt::formatU32(val, &mut digits[..]);
    let slice = try! alloc::allocSlice(a, 1, 1, text.len) as *mut [u8];
    try! mem::copy(slice, text);
    let start = fmt::formatU32(val, &mut digits[..]);
    let slice = try! alloc::allocSlice(a, 1, 1, digits.len - start) as *mut [u8];
    try! mem::copy(slice, &digits[start..]);

    return slice;
}

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


/// Mnemonic column width for alignment.
constant MNEMONIC_WIDTH: u32 = 8;

/// Write text wrapped in parentheses.
fn writeParens(out: *mut sexpr::Output, s: *[u8]) {
unsafe fn writeParens(out: &mut sexpr::Output, s: &[u8]) {
    write(out, "(");
    write(out, s);
    write(out, ")");
}

/// Write strings separated by ", ".
fn writeDelim(out: *mut sexpr::Output, parts: *[*[u8]]) {
unsafe fn writeDelim(out: &mut sexpr::Output, parts: &[*[u8]]) {
    for part, i in parts {
        if i > 0 {
            write(out, ", ");
        }
        write(out, part);
    }
}

/// Write mnemonic with padding for alignment.
fn writeMnem(out: *mut sexpr::Output, m: *[u8]) {
unsafe fn writeMnem(out: &mut sexpr::Output, m: *[u8]) {
    write(out, m);
    let mut i = m.len;
    while i < MNEMONIC_WIDTH {
        write(out, " ");
        set i += 1;

////////////////////////////////
// Instruction Format Helpers //
////////////////////////////////

/// R-type: `op rd, rs1, rs2`.
fn fmtR(out: *mut sexpr::Output, m: *[u8], rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) {
unsafe fn fmtR(out: &mut sexpr::Output, m: *[u8], rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) {
    writeMnem(out, m);
    writeDelim(out, &[regNameR(rd), regNameR(rs1), regNameR(rs2)]);
}

/// I-type: `op rd, rs1, imm`.
fn fmtI(out: *mut sexpr::Output, a: *mut alloc::Arena, m: *[u8], rd: gen::Reg, rs1: gen::Reg, imm: i32) {
unsafe fn fmtI(out: &mut sexpr::Output, a: &mut alloc::Arena, m: *[u8], rd: gen::Reg, rs1: gen::Reg, imm: i32) {
    writeMnem(out, m);
    writeDelim(out, &[regNameR(rd), regNameR(rs1), formatI32(a, imm)]);
}

/// 2-reg: `op rd, rs`.
fn fmt2R(out: *mut sexpr::Output, m: *[u8], rd: gen::Reg, rs: gen::Reg) {
unsafe fn fmt2R(out: &mut sexpr::Output, m: *[u8], rd: gen::Reg, rs: gen::Reg) {
    writeMnem(out, m);
    writeDelim(out, &[regNameR(rd), regNameR(rs)]);
}

/// reg + imm: `op rd, imm`.
fn fmtRI(out: *mut sexpr::Output, a: *mut alloc::Arena, m: *[u8], rd: gen::Reg, imm: i32) {
unsafe fn fmtRI(out: &mut sexpr::Output, a: &mut alloc::Arena, m: *[u8], rd: gen::Reg, imm: i32) {
    writeMnem(out, m);
    writeDelim(out, &[regNameR(rd), formatI32(a, imm)]);
}

/// imm only: `op imm`.
fn fmtImm(out: *mut sexpr::Output, a: *mut alloc::Arena, m: *[u8], imm: i32) {
unsafe fn fmtImm(out: &mut sexpr::Output, a: &mut alloc::Arena, m: *[u8], imm: i32) {
    writeMnem(out, m);
    write(out, formatI32(a, imm));
}

/// 1-reg: `op rs`.
fn fmt1R(out: *mut sexpr::Output, m: *[u8], rs: gen::Reg) {
unsafe fn fmt1R(out: &mut sexpr::Output, m: *[u8], rs: gen::Reg) {
    writeMnem(out, m);
    write(out, regNameR(rs));
}

/// Load: `op rd, imm(rs1)`.
fn fmtLoad(out: *mut sexpr::Output, a: *mut alloc::Arena, m: *[u8], rd: gen::Reg, rs1: gen::Reg, imm: i32) {
unsafe fn fmtLoad(out: &mut sexpr::Output, a: &mut alloc::Arena, m: *[u8], rd: gen::Reg, rs1: gen::Reg, imm: i32) {
    writeMnem(out, m);
    writeDelim(out, &[regNameR(rd), formatI32(a, imm)]);
    writeParens(out, regNameR(rs1));
}

/// Store: `op rs2, imm(rs1)`.
fn fmtStore(out: *mut sexpr::Output, a: *mut alloc::Arena, m: *[u8], rs2: gen::Reg, rs1: gen::Reg, imm: i32) {
unsafe fn fmtStore(out: &mut sexpr::Output, a: &mut alloc::Arena, m: *[u8], rs2: gen::Reg, rs1: gen::Reg, imm: i32) {
    writeMnem(out, m);
    writeDelim(out, &[regNameR(rs2), formatI32(a, imm)]);
    writeParens(out, regNameR(rs1));
}

/// Branch: `op rs1, rs2, imm`.
fn fmtB(out: *mut sexpr::Output, a: *mut alloc::Arena, m: *[u8], rs1: gen::Reg, rs2: gen::Reg, imm: i32) {
unsafe fn fmtB(out: &mut sexpr::Output, a: &mut alloc::Arena, m: *[u8], rs1: gen::Reg, rs2: gen::Reg, imm: i32) {
    writeMnem(out, m);
    writeDelim(out, &[regNameR(rs1), regNameR(rs2), formatI32(a, imm)]);
}

/// Branch zero: `op rs1, imm`.
fn fmtBz(out: *mut sexpr::Output, a: *mut alloc::Arena, m: *[u8], rs1: gen::Reg, imm: i32) {
unsafe fn fmtBz(out: &mut sexpr::Output, a: &mut alloc::Arena, m: *[u8], rs1: gen::Reg, imm: i32) {
    writeMnem(out, m);
    writeDelim(out, &[regNameR(rs1), formatI32(a, imm)]);
}

/// Print a single instruction to output buffer.
export fn printInstr(out: *mut sexpr::Output, a: *mut alloc::Arena, instr: u32) {
export unsafe fn printInstr(out: &mut sexpr::Output, a: &mut alloc::Arena, instr: u32) {
    let decoded = decode::decode(instr);

    match decoded {
        case decode::Instr::Lui { rd, imm } => fmtRI(out, a, "lui", rd, imm),
        case decode::Instr::Auipc { rd, imm } => fmtRI(out, a, "auipc", rd, imm),

        },
    }
}

/// Print code with labels to the given output.
export fn printCodeTo(out: *mut sexpr::Output, pkgName: *[u8], code: *[u32], funcs: *[types::FuncAddr], arena: *mut alloc::Arena) {
export unsafe fn printCodeTo(out: &mut sexpr::Output, pkgName: *[u8], code: *[u32], funcs: *[types::FuncAddr], arena: &mut alloc::Arena) {
    // Package header.
    write(out, "# package `");
    write(out, pkgName);
    write(out, "`\n\n");


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

/// Helper to check encoding equals expected value.
fn expectEncoding(actual: u32, expected: u32) throws (testing::TestError) {
    try testing::expect(actual == expected);
}

@test fn testAddAssemblyExportsOnlyGlobalTextSymbols() throws (testing::TestError) {
@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);

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

    }
    return Dict { entries, count: 0 };
}

/// Insert or update a key-value pair. Panics if the table exceeds 50% load.
export fn insert(m: *mut Dict, key: *[u8], value: i32) {
export fn insert(m: &mut Dict, key: *[u8], value: i32) {
    let mask = m.entries.len - 1;
    let mut idx = hash(key) & mask;

    loop {
        let entry = &m.entries[idx];

        set idx = (idx + 1) & mask;
    }
}

/// Look up a value by key. Returns `nil` if not found.
export fn get(m: *Dict, key: *[u8]) -> ?i32 {
export fn get(m: &Dict, key: *[u8]) -> ?i32 {
    let mask = m.entries.len - 1;
    let mut idx = hash(key) & mask;

    loop {
        let entry = &m.entries[idx];

lib/std/fmt.rad +31 -29

    magnitude: u64,
    /// Radix used by the literal.
    radix: Radix,
}

/// Format a u32 by writing it to the provided buffer.
export fn formatU32(val: u32, buffer: *mut [u8]) -> *[u8] {
/// Write a u32 at the end of the buffer and return its start offset.
export fn formatU32(val: u32, buffer: &mut [u8]) -> u32 {
    assert buffer.len >= U32_STR_LEN;

    let mut x: u32 = val;
    let mut i: u32 = buffer.len;


            set i -= 1;
            set buffer[i] = ('0' + (x % 10) as u8);
            set x /= 10;
        }
    }
    // Return the slice from the start of the written number to
    // the end of the buffer.
    return &buffer[i..];
    // Return the offset of the first written byte.
    return i;
}

/// Format a i32 by writing it to the provided buffer.
export fn formatI32(val: i32, buffer: *mut [u8]) -> *[u8] {
/// Write a i32 at the end of the buffer and return its start offset.
export fn formatI32(val: i32, buffer: &mut [u8]) -> u32 {
    assert buffer.len >= I32_STR_LEN;

    let neg: bool = val < 0;
    let mut x: u32 = -val as u32 if neg else val as u32;
    let mut i: u32 = buffer.len;

        if neg {
            set i -= 1;
            set buffer[i] = '-';
        }
    }
    return &buffer[i..];
    return i;
}

/// Format a u64 by writing it to the provided buffer.
export fn formatU64(val: u64, buffer: *mut [u8]) -> *[u8] {
/// Write a u64 at the end of the buffer and return its start offset.
export fn formatU64(val: u64, buffer: &mut [u8]) -> u32 {
    assert buffer.len >= U64_STR_LEN;

    let mut x: u64 = val;
    let mut i: u32 = buffer.len;


            set i -= 1;
            set buffer[i] = ('0' + (x % 10) as u8);
            set x /= 10;
        }
    }
    return &buffer[i..];
    return i;
}

/// Format a i64 by writing it to the provided buffer.
export fn formatI64(val: i64, buffer: *mut [u8]) -> *[u8] {
/// Write a i64 at the end of the buffer and return its start offset.
export fn formatI64(val: i64, buffer: &mut [u8]) -> u32 {
    assert buffer.len >= I64_STR_LEN;

    let neg: bool = val < 0;
    let mut x: u64 = -val as u64 if neg else val as u64;
    let mut i: u32 = buffer.len;

        if neg {
            set i -= 1;
            set buffer[i] = '-';
        }
    }
    return &buffer[i..];
    return i;
}

/// Format a i8 by writing it to the provided buffer.
export fn formatI8(val: i8, buffer: *mut [u8]) -> *[u8] {
/// Write a i8 at the end of the buffer and return its start offset.
export fn formatI8(val: i8, buffer: &mut [u8]) -> u32 {
    return formatI32(val as i32, buffer);
}

/// Format a i16 by writing it to the provided buffer.
export fn formatI16(val: i16, buffer: *mut [u8]) -> *[u8] {
/// Write a i16 at the end of the buffer and return its start offset.
export fn formatI16(val: i16, buffer: &mut [u8]) -> u32 {
    return formatI32(val as i32, buffer);
}

/// Format a u8 by writing it to the provided buffer.
export fn formatU8(val: u8, buffer: *mut [u8]) -> *[u8] {
/// Write a u8 at the end of the buffer and return its start offset.
export fn formatU8(val: u8, buffer: &mut [u8]) -> u32 {
    return formatU32(val as u32, buffer);
}

/// Format a u16 by writing it to the provided buffer.
export fn formatU16(val: u16, buffer: *mut [u8]) -> *[u8] {
/// Write a u16 at the end of the buffer and return its start offset.
export fn formatU16(val: u16, buffer: &mut [u8]) -> u32 {
    return formatU32(val as u32, buffer);
}

/// Format a bool by writing it to the provided buffer.
export fn formatBool(val: bool, buffer: *mut [u8]) -> *[u8] {
/// Write a bool at the end of the buffer and return its start offset.
export fn formatBool(val: bool, buffer: &mut [u8]) -> u32 {
    assert buffer.len >= BOOL_STR_LEN;
    if val {
        try! mem::copy(buffer, "true");
        return &buffer[..4];
        let start = buffer.len - 4;
        try! mem::copy(&mut buffer[start..], "true");
        return start;
    } else {
        try! mem::copy(buffer, "false");
        return &buffer[..5];
        let start = buffer.len - 5;
        try! mem::copy(&mut buffer[start..], "false");
        return start;
    }
}

/// Convert a single ASCII digit into its numeric value for the given radix.
export fn digitFromAscii(ch: u8, radix: u32) -> ?u32 {

    return IntLiteral { text, magnitude: value, radix: radixType };
}

/// Process escape sequences in a raw string, writing the result into `dst`.
/// Returns the number of bytes written.
export fn unescapeString(raw: *[u8], dst: *mut [u8]) -> u32 {
export fn unescapeString(raw: *[u8], dst: &mut [u8]) -> u32 {
    let mut i: u32 = 0;
    let mut j: u32 = 0;

    while i < raw.len {
        if raw[i] == '\\' and i + 1 < raw.len {

lib/std/io.rad +17 -10

//! Input/output utilities.
use std::fmt;
use std::intrinsics;

export fn print(str: *[u8]) {
/// Write the bytes to standard output.
export fn print(str: &[u8]) {
    intrinsics::ecall(64, 1, str.ptr as i64, str.len as i64, 0);
}

export fn printError(str: *[u8]) {
/// Write the bytes to standard error.
export fn printError(str: &[u8]) {
    intrinsics::ecall(64, 2, str.ptr as i64, str.len as i64, 0);
}

export fn printLn(str: *[u8]) {
/// Write the bytes and a newline to standard output.
export fn printLn(str: &[u8]) {
    print(str);
    print("\n");
}

/// Write a signed decimal integer to standard output.
export fn printI32(val: i32) {
    let mut buffer: [u8; 11] = [0; 11];
    let result: *[u8] = fmt::formatI32(val, &mut buffer[..]);
    print(result);
    let start = fmt::formatI32(val, &mut buffer[..]);
    print(&buffer[start..]);
}

/// Write an unsigned decimal integer to standard output.
export fn printU32(val: u32) {
    let mut buffer: [u8; 10] = [0; 10];
    let result: *[u8] = fmt::formatU32(val, &mut buffer[..]);
    print(result);
    let start = fmt::formatU32(val, &mut buffer[..]);
    print(&buffer[start..]);
}

/// Write a Boolean value to standard output.
export fn printBool(val: bool) {
    let mut buffer: [u8; 5] = [0; 5];
    let result: *[u8] = fmt::formatBool(val, &mut buffer[..]);
    print(result);
    let start = fmt::formatBool(val, &mut buffer[..]);
    print(&buffer[start..]);
}

export fn read(buf: *mut [u8]) -> u32 {
/// Read standard input into the buffer and return the system call result.
export fn read(buf: &mut [u8]) -> u32 {
    return intrinsics::ecall(63, 0, buf.ptr as i64, buf.len as i64, 0) as u32;
}

export fn readToEnd(buf: *mut [u8]) -> *[u8] {
    let mut total: u32 = 0;

lib/std/lang/alloc.rad +17 -17

/// Allocate `size` bytes with the given alignment.
///
/// Returns an opaque pointer to the allocated memory. Throws `AllocError` if
/// the arena is exhausted. The caller is responsible for casting to the
/// appropriate type and initializing the memory.
export fn alloc(arena: *mut Arena, size: u32, alignment: u32) -> *mut opaque throws (AllocError) {
export fn alloc(arena: &mut Arena, size: u32, alignment: u32) -> *mut opaque throws (AllocError) {
    assert alignment > 0;
    assert size > 0;

    let aligned = mem::alignUp(arena.offset, alignment);
    let newOffset = aligned + size;

}

/// Reset the arena, allowing all memory to be reused.
///
/// Does not zero the memory.
export fn reset(arena: *mut Arena) {
export fn reset(arena: &mut Arena) {
    set arena.offset = 0;
}

/// Save the current arena state for later restoration.
export fn save(arena: *Arena) -> u32 {
export fn save(arena: &Arena) -> u32 {
    return arena.offset;
}

/// Restore the arena to a previously saved state, reclaiming all
/// allocations made since that point.
export fn restore(arena: *mut Arena, savedOffset: u32) {
export fn restore(arena: &mut Arena, savedOffset: u32) {
    set arena.offset = savedOffset;
}

/// Returns the number of bytes currently allocated.
export fn used(arena: *Arena) -> u32 {
export fn used(arena: &Arena) -> u32 {
    return arena.offset;
}

/// Returns the number of bytes remaining in the arena.
export fn remaining(arena: *Arena) -> u32 {
export fn remaining(arena: &Arena) -> u32 {
    return arena.data.len as u32 - arena.offset;
}

/// Returns the remaining buffer as a mutable slice.
export fn remainingBuf(arena: *mut Arena) -> *mut [u8] {
export fn remainingBuf(arena: &mut Arena) -> *mut [u8] {
    return &mut arena.data[arena.offset..];
}

/// Commits `size` bytes of allocation, advancing the offset.
/// Use after writing to the buffer returned by [`remainingBuf`].
export fn commit(arena: *mut Arena, size: u32) {
export fn commit(arena: &mut Arena, size: u32) {
    set arena.offset += size;
}

/// Allocate a slice of `count` elements, each of `size` bytes with given alignment.
///
/// Returns a type-erased slice that should be cast to the appropriate `*[T]`.
/// The slice length is set to `count` (element count, not bytes).
/// Throws `AllocError` if the arena is exhausted.
export fn allocSlice(arena: *mut Arena, size: u32, alignment: u32, count: u32) -> *mut [opaque] throws (AllocError) {
export fn allocSlice(arena: &mut Arena, size: u32, alignment: u32, count: u32) -> *mut [opaque] throws (AllocError) {
    if count == 0 {
        return &mut [];
    }
    let ptr = try alloc(arena, size * count, alignment);


/// pointer, a byte size and an alignment, and must return a pointer to
/// the allocated memory or panic on failure.
export record Allocator: Copy {
    /// Allocation function. Returns a pointer to `size` bytes
    /// aligned to `alignment`, or panics on failure.
    func: fn(*mut opaque, u32, u32) -> *mut opaque,
    func: unsafe fn(*unsafe mut opaque, u32, u32) -> *mut opaque,
    /// Opaque context pointer passed to `func`.
    ctx: *mut opaque,
    ctx: *unsafe mut opaque,
}

/// Create an `Allocator` backed by an `Arena`.
export fn arenaAllocator(arena: *mut Arena) -> Allocator {
/// Create an allocator whose arena must outlive all uses of the allocator.
export 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,
    };
}

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

lib/std/lang/alloc/tests.rad +1 -1

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

/// Test the Allocator interface backed by an arena.
@test fn testAllocator() throws (testing::TestError) {
@test unsafe fn testAllocator() throws (testing::TestError) {
    static STORAGE: [u8; 256] = undefined;
    let mut arena = super::new(&mut STORAGE[..]);
    let a = super::arenaAllocator(&mut arena);

    // Allocate through the Allocator indirection.

lib/std/lang/ast.rad +12 -7

        nextId: 0,
    };
}

/// Create an empty `*mut [*Node]` slice with the given capacity.
export fn nodeSlice(arena: *mut NodeArena, capacity: u32) -> *mut [*Node] {
export fn nodeSlice(arena: &mut NodeArena, capacity: u32) -> *mut [*Node] {
    if capacity == 0 {
        return &mut [];
    }
    let ptr = try! alloc::allocSlice(&mut arena.arena, @sizeOf(*Node), @alignOf(*Node), capacity);


export record Attributes: Copy {
    list: *mut [*Node],
}

/// Check if an attributes list contains an attribute.
export fn attributesContains(self: *Attributes, attr: Attribute) -> bool {
export fn attributesContains(self: &Attributes, attr: Attribute) -> bool {
    for node in self.list {
        if let case NodeValue::Attribute(a) = node.value; a == attr {
            return true;
        }
    }

        fields: *mut [*Node],
        /// Whether this record has labeled fields.
        labeled: bool,
    },
    /// Anonymous function type.
    Fn(FnSig),
    Fn {
        /// Parameter, return, and error types.
        sig: FnSig,
        /// Whether a call requires an unsafe function body.
        isUnsafe: bool,
    },
    /// Trait object type, eg. `*opaque Allocator`, `&opaque Allocator`, or
    /// `*unsafe opaque Allocator`.
    TraitObject {
        /// Ownership and safety class.
        class: types::PointerClass,

        else => return false,
    }
}

/// Allocate a new AST node from the arena with the given span and value.
export fn allocNode(arena: *mut NodeArena, span: Span, value: NodeValue) -> *mut Node {
export fn allocNode(arena: &mut NodeArena, span: Span, value: NodeValue) -> *mut Node {
    let p = try! alloc::alloc(&mut arena.arena, @sizeOf(Node), @alignOf(Node));
    let node = p as *mut Node;
    let nodeId = arena.nextId;
    set arena.nextId = nodeId + 1;



    return node;
}

/// Allocate a synthetic AST node with a zero-length span.
export fn synthNode(arena: *mut NodeArena, value: NodeValue) -> *mut Node {
export fn synthNode(arena: &mut NodeArena, value: NodeValue) -> *mut Node {
    return allocNode(arena, Span { offset: 0, length: 0 }, value);
}

/// Synthetic module with a single function in it.
record SynthFnMod: Copy {

    /// The function block.
    fnBody: *Node
}

/// Synthesize a module with a function in it with the given name and statements.
export fn synthFnModule(
    arena: *mut NodeArena, name: *[u8], bodyStmts: *mut [*Node]
export unsafe fn synthFnModule(
    arena: &mut NodeArena, name: *[u8], bodyStmts: *mut [*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 [];

lib/std/lang/ast/printer.rad +17 -16

        case types::PointerClass::Unsafe => return unsafeHead,
    }
}

/// Convert a type signature to an S-expression.
fn typeSigToExpr(a: *mut alloc::Arena, sig: super::TypeSig) -> sexpr::Expr {
fn typeSigToExpr(a: &mut alloc::Arena, sig: super::TypeSig) -> sexpr::Expr {
    match sig {
        case super::TypeSig::Void => return sexpr::sym("void"),
        case super::TypeSig::Opaque => return sexpr::sym("opaque"),
        case super::TypeSig::Bool => return sexpr::sym("bool"),
        case super::TypeSig::Integer { width, sign } => return sexpr::sym(intTypeName(width, sign)),

        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[..])),
        case super::TypeSig::Fn(sig) => {
        case super::TypeSig::Fn { sig, isUnsafe } => {
            let mut ret = sexpr::sym("void");
            if let rt = sig.returnType {
                set ret = toExpr(a, rt);
            }
            return sexpr::list(a, "fn", &[sexpr::list(a, "params", nodeListToExprs(a, &sig.params[..])), ret]);
            let head = "unsafe-fn" if isUnsafe else "fn";
            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.
fn nodeListToExprs(a: *mut alloc::Arena, nodes: *[*super::Node]) -> *[sexpr::Expr] {
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 {

    }
    return buf;
}

/// Convert optional attributes to an attribute list expression.
fn attributesToExpr(a: *mut alloc::Arena, attrs: ?super::Attributes) -> sexpr::Expr {
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[..]);
    }
    return sexpr::list(a, "attrs", exprs);
}

/// Convert an optional node to an expression, or return placeholder.
fn toExprOpt(a: *mut alloc::Arena, opt: ?*super::Node) -> sexpr::Expr {
fn toExprOpt(a: &mut alloc::Arena, opt: ?*super::Node) -> sexpr::Expr {
    if let n = opt {
        return toExpr(a, n);
    }
    return sexpr::sym("_");
}

/// Convert an optional node to an expression, or return `Null`.
fn toExprOrNull(a: *mut alloc::Arena, opt: ?*super::Node) -> sexpr::Expr {
fn toExprOrNull(a: &mut alloc::Arena, opt: ?*super::Node) -> sexpr::Expr {
    if let n = opt {
        return toExpr(a, n);
    }
    return sexpr::Expr::Null;
}

/// Convert an optional guard.
fn guardExpr(a: *mut alloc::Arena, guard: ?*super::Node) -> sexpr::Expr {
fn guardExpr(a: &mut alloc::Arena, guard: ?*super::Node) -> sexpr::Expr {
    if let g = guard {
        return sexpr::list(a, "guard", &[toExpr(a, g)]);
    }
    return sexpr::Expr::Null;
}

/// Convert a list of match prongs to expressions.
fn prongListToExprs(a: *mut alloc::Arena, nodes: *[*super::Node]) -> *[sexpr::Expr] {
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 {

    }
    return buf;
}

/// Convert a match prong to an S-expression.
fn prongToExpr(a: *mut alloc::Arena, p: super::MatchProng) -> sexpr::Expr {
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[..])),
                guardExpr(a, p.guard)

    }
}

/// Convert a record field declaration to an S-expression.
fn fieldToExpr(
    a: *mut alloc::Arena,
    a: &mut alloc::Arena,
    field: ?*super::Node,
    type: *super::Node,
    value: ?*super::Node
) -> sexpr::Expr {
    return sexpr::list(a, ":", &[toExprOpt(a, field), toExpr(a, type), toExprOrNull(a, value)]);
}

/// Convert a list of record fields to expressions.
fn fieldListToExprs(a: *mut alloc::Arena, nodes: *[*super::Node]) -> *[sexpr::Expr] {
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 {

    }
    return buf;
}

/// Convert a union variant to an S-expression.
fn variantToExpr(a: *mut alloc::Arena, name: *super::Node, type: ?*super::Node) -> sexpr::Expr {
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.
fn variantListToExprs(a: *mut alloc::Arena, nodes: *[*super::Node]) -> *[sexpr::Expr] {
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 {

    }
    return buf;
}

/// Convert an AST node to an S-expression.
export fn toExpr(a: *mut alloc::Arena, node: *super::Node) -> sexpr::Expr {
export fn toExpr(a: &mut alloc::Arena, node: *super::Node) -> sexpr::Expr {
    match node.value {
        case super::NodeValue::Placeholder => return sexpr::sym("_"),
        case super::NodeValue::Nil => return sexpr::sym("nil"),
        case super::NodeValue::Undef => return sexpr::sym("undefined"),
        case super::NodeValue::Bool(v) => {

        else => return sexpr::sym("?"),
    }
}

/// Dump the tree rooted at `root`, using the provided arena for allocation.
export fn printTree(root: *super::Node, arena: *mut alloc::Arena) {
export unsafe fn printTree(root: *super::Node, arena: &mut alloc::Arena) {
    match root.value {
        case super::NodeValue::Block(blk) => {
            for stmt, i in blk.statements {
                sexpr::print(toExpr(arena, stmt), 0);
                if i < blk.statements.len - 1 { io::print("\n\n"); }

lib/std/lang/gen/bitset.rad +23 -20

    return (n + 31) / 32;
}

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

/// Create a new bitset backed by the given zero-initialized storage.
export fn new(bits: *mut [u32]) -> Bitset {
    return Bitset { bits, len: bits.len * 32 };
/// 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 };
}

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

/// Create a bitset from arena allocation.
export fn allocate(arena: *mut alloc::Arena, len: u32) -> Bitset throws (alloc::AllocError) {
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];

    return init(bits);
}

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

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

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

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

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

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

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


    return n & 0x3F;
}

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

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

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

    for i in 0..minWords {

    }
    return true;
}

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

    for i in 0..minWords {

        set dst.bits[i] = 0;
    }
}

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

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

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

/// Get the next set bit, or nil if none remain.
export fn iterNext(it: *mut BitIter) -> ?u32 {
export unsafe fn iterNext(it: &mut BitIter) -> ?u32 {
    let numWords = it.bs.bits.len;
    // Skip to next non-zero word.
    while it.remaining == 0 {
        set it.wordIdx += 1;
        if it.wordIdx >= numWords {

lib/std/lang/gen/bitset/tests.rad +11 -11

//! Tests for the bitset module.

use std::testing;

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

    // `init` should zero-initialize, so all bits start unset.
    try testing::expect(not super::contains(&bs, 0));

    try testing::expect(not super::contains(&bs, 33));
    try testing::expect(not super::contains(&bs, 126));
}

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

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

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

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

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


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

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


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

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


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

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


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

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


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

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

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

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

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

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

    try testing::expect(count == 4);
    try testing::expect(sum == 3 + 31 + 32 + 50);
}

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


    try testing::expect(super::wordsFor(64) == 2);
    try testing::expect(super::wordsFor(65) == 3);
}

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

    // Setting beyond length should be ignored.
    super::put(&mut bs, 100);

lib/std/lang/gen/data.rad +10 -15

/// 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],
    count: *mut u32,
    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],
    count: *mut u32,
    count: &mut u32,
    base: u32,
    startOffset: u32,
    readOnly: bool
) -> u32 {
    let mut offset: u32 = startOffset;

/// 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 fn emitSection(
    items: *[il::Data],
    dataSymMap: *DataSymMap,
    fnLabels: *labels::Labels,
    dataSymMap: &DataSymMap,
    fnLabels: &labels::Labels,
    codeBase: u32,
    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 fn emitSectionAtOffset(
    items: *[il::Data],
    dataSymMap: *DataSymMap,
    fnLabels: *labels::Labels,
    dataSymMap: &DataSymMap,
    fnLabels: &labels::Labels,
    codeBase: u32,
    buf: *mut [u8],
    readOnly: bool,
    startOffset: u32
) -> u32 {

                let v = &data.values[j];
                for _ in 0..v.count {
                    match v.item {
                        case il::DataItem::Val { typ, val } => {
                            let size = il::typeSize(typ);
                            let valPtr = &val as *u8;
                            try! mem::copy(&mut buf[offset..], @sliceOf(valPtr, size));
                            try! mem::copy(&mut buf[offset..], @sliceOf(&val as &u8, size));

                            set offset += size;
                        },
                        case il::DataItem::Sym(name) => {
                            let addr = lookupAddr(dataSymMap, name) else {
                                panic "emitSectionAtOffset: data symbol not found";
                            };
                            let addr64: u64 = addr as u64;
                            let addrPtr = &addr64 as *u8;

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

                            set offset += @sizeOf(u64);
                        },
                        case il::DataItem::Fn(name) => {
                            let addr = codeBase + labels::funcOffset(fnLabels, name) as u32;
                            let addr64: u64 = addr as u64;
                            let addrPtr = &addr64 as *u8;

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

                            set offset += @sizeOf(*u8);
                        },
                        case il::DataItem::Str(s) => {
                            try! mem::copy(&mut buf[offset..], s);

    }
    return DataSymMap { dict: d, syms };
}

/// Resolve a data symbol to its final absolute address using the hash map.
export fn lookupAddr(m: *DataSymMap, name: *[u8]) -> ?u32 {
export fn lookupAddr(m: &DataSymMap, name: *[u8]) -> ?u32 {
    if let v = dict::get(&m.dict, name) {
        return v as u32;
    }
    return nil;
}

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

        funcs: dict::init(funcEntries),
    };
}

/// Reset block count for a new function.
export fn resetBlocks(l: *mut Labels) {
export fn resetBlocks(l: &mut Labels) {
    set l.blockCount = 0;
}

/// Record a block's code offset by its index. O(1).
export fn recordBlock(l: *mut Labels, blockIdx: u32, offset: i32) {
export fn recordBlock(l: &mut Labels, blockIdx: u32, offset: i32) {
    assert blockIdx < l.blockOffsets.len, "recordBlock: block index out of range";
    set l.blockOffsets[blockIdx] = offset;
    set l.blockCount += 1;
}

/// Look up a block's byte offset by index. O(1).
export fn blockOffset(l: *Labels, blockIdx: u32) -> i32 {
export fn blockOffset(l: &Labels, blockIdx: u32) -> i32 {
    assert blockIdx < l.blockCount, "blockOffset: block not recorded";
    return l.blockOffsets[blockIdx];
}

/// Look up a function's byte offset by name.
export fn funcOffset(l: *Labels, name: *[u8]) -> i32 {
export fn funcOffset(l: &Labels, name: *[u8]) -> i32 {
    if let offset = dict::get(&l.funcs, name) {
        return offset;
    }
    panic "funcOffset: unknown function";
}

/// Compute branch offset to a block given source instruction index.
export fn branchToBlock(l: *Labels, srcIndex: u32, blockIdx: u32, instrSize: i32) -> i32 {
export fn branchToBlock(l: &Labels, srcIndex: u32, blockIdx: u32, instrSize: i32) -> i32 {
    let targetOffset = blockOffset(l, blockIdx);
    let srcOffset = srcIndex as i32 * instrSize;

    return targetOffset - srcOffset;
}

/// Compute branch offset to a function given source instruction index.
export fn branchToFunc(l: *Labels, srcIndex: u32, name: *[u8], instrSize: i32) -> i32 {
export fn branchToFunc(l: &Labels, srcIndex: u32, name: *[u8], instrSize: i32) -> i32 {
    let targetOffset = funcOffset(l, name);
    let srcOffset = srcIndex as i32 * instrSize;

    return targetOffset - srcOffset;
}

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


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

lib/std/lang/gen/regalloc/assign.rad +41 -31

    usedCalleeSaved: u32,
}

/// Per-instruction context for freeing and allocating register uses.
record InstrCtx: Copy {
    current: *mut RegMap,
    usedRegs: *mut bitset::Bitset,
    current: *unsafe mut RegMap,
    usedRegs: *unsafe mut bitset::Bitset,
    /// Last operand-use index for each register used in the current block.
    lastUse: *[u32],
    live: *liveness::LiveInfo,
    live: *unsafe liveness::LiveInfo,
    blockIdx: u32,
    instrIdx: u32,
    allocatable: *[gen::Reg],
    calleeSaved: *[gen::Reg],
    assignments: *mut [?gen::Reg],
    spillInfo: *spill::SpillInfo,
    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.

    /// Index of the instruction whose operands are being recorded.
    index: u32,
}

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


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

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

        for instr, i in block.instrs {
            let mut ctx = InstrCtx {
                current: &mut current,
                usedRegs: &mut usedRegs,
                lastUse,
                live,
                live: live as *unsafe liveness::LiveInfo,
                blockIdx: b,
                instrIdx: i,
                allocatable,
                calleeSaved: config.calleeSaved,
                assignments,
                spillInfo,
                spillInfo: spillInfo as *unsafe spill::SpillInfo,
            };
            il::forEachReg(instr, processInstrRegCb, &mut ctx as *mut opaque);
            il::forEachReg(instr, processInstrRegCb, &mut ctx as &mut opaque);

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

        usedCalleeSaved,
    };
}

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

    return RegMap { virtRegs, physRegs, n: 0 };
}

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

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

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

    }
    return nil;
}

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

    return nil;
}

/// Allocate a physical register for an SSA register.
/// Cross-call values are steered to callee-saved registers.
fn rallocReg(
    current: *mut RegMap,
    usedRegs: *mut bitset::Bitset,
unsafe fn rallocReg(
    current: &mut RegMap,
    usedRegs: &mut bitset::Bitset,
    ssaReg: u32,
    allocatable: *[gen::Reg],
    calleeSaved: *[gen::Reg],
    spillInfo: *spill::SpillInfo
    spillInfo: &spill::SpillInfo
) -> gen::Reg {
    // Check if already assigned.
    if let phys = rmapFind(current, ssaReg) {
        return phys;
    }

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

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

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

/// Free operands with no later block use or live-out use, then allocate missing uses.
fn processInstrRegCb(reg: il::Reg, ctxPtr: *mut opaque) {
    let ctx = ctxPtr as *mut InstrCtx;
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(ctx.current, reg.n) {
            bitset::clear(ctx.usedRegs, *phys as u32);
        if let phys = rmapRemove(&mut *ctx.current, reg.n) {
            bitset::clear(&mut *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(
            ctx.current, ctx.usedRegs, reg.n, ctx.allocatable,
            ctx.calleeSaved, ctx.spillInfo
            &mut *current, &mut *usedRegs, reg.n, ctx.allocatable,
            ctx.calleeSaved, &*ctx.spillInfo
        );
    }
}

lib/std/lang/gen/regalloc/liveness.rad +28 -16

    target: u32,
    found: bool,
}

/// Compute liveness by growing live sets until no live-in set changes.
export fn analyze(func: *il::Fn, arena: *mut alloc::Arena) -> LiveInfo throws (alloc::AllocError) {
export unsafe fn analyze(func: *il::Fn, arena: &mut alloc::Arena) -> LiveInfo throws (alloc::AllocError) {
    let blockCount = func.blocks.len;
    if blockCount == 0 {
        return LiveInfo {
            liveIn: &mut [],
            liveOut: &mut [],

        let block = &func.blocks[b];
        for p in block.params {
            set maxReg = maxRegNum(p.value.n, maxReg);
        }
        for i in 0..block.instrs.len {
            il::forEachReg(block.instrs[i], maxRegCallback, &mut maxReg as *mut opaque);
            il::forEachReg(block.instrs[i], maxRegCallback, &mut maxReg as &mut opaque);
            if let dst = il::instrDst(block.instrs[i]) {
                set maxReg = maxRegNum(dst.n, maxReg);
            }
        }
    }

    return LiveInfo { liveIn, liveOut, defs, uses, blockCount, maxReg };
}

/// Compute `liveIn = uses | (liveOut - defs)` and update `dst`.
/// Returns `true` if `dst` changed. Combined loop avoids multiple passes.
fn computeAndUpdateLiveIn(
unsafe fn computeAndUpdateLiveIn(
    dst: *mut bitset::Bitset,
    liveOut: *bitset::Bitset,
    defs: *bitset::Bitset,
    uses: *bitset::Bitset
) -> bool {

    }
    return changed;
}

/// Compute local defs and uses for a single block.
fn computeLocalDefsUses(block: *il::Block, defs: *mut bitset::Bitset, uses: *mut bitset::Bitset) {
unsafe fn computeLocalDefsUses(block: *il::Block, defs: *mut bitset::Bitset, uses: *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];
        let mut ctx = DefsUses { defs, uses };
        il::forEachReg(instr, addUseCallback, &mut ctx as *mut opaque);
        il::forEachReg(instr, addUseCallback, &mut ctx as &mut opaque);

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

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

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

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

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

/// Return the larger of n+1 and current.
fn maxRegNum(n: u32, current: u32) -> u32 {

    }
    return current;
}

/// Add successor live-in sets to the block's live-out set.
fn addSuccessorLiveIn(func: *il::Fn, block: *il::Block, liveIn: *[bitset::Bitset], liveOut: *mut bitset::Bitset) {
unsafe fn addSuccessorLiveIn(func: *il::Fn, block: *il::Block, liveIn: *[bitset::Bitset], liveOut: *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.
fn unionBlockLiveIn(target: u32, liveIn: *[bitset::Bitset], liveOut: *mut bitset::Bitset) {
unsafe fn unionBlockLiveIn(target: u32, liveIn: *[bitset::Bitset], liveOut: *mut bitset::Bitset) {
    bitset::union_(liveOut, &liveIn[target]);
}

/// Check if a register has any use after this instruction.
export fn hasLaterUse(info: *LiveInfo, func: *il::Fn, blockIdx: u32, instrIdx: u32, reg: il::Reg) -> bool {
export unsafe fn hasLaterUse(info: *LiveInfo, func: *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;
    }

    }
    return false;
}

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

/// Callback for [`il::forEachReg`]: sets found if register matches target.
fn findRegCallback(reg: il::Reg, ctx: *mut opaque) {
    let c = ctx as *mut FindCtx;
fn findRegCallback(reg: il::Reg, ctx: &mut opaque) {
    findReg(reg, ctx as &mut FindCtx);
}

/// Set the match flag when the register equals the target.
fn findReg(reg: il::Reg, c: &mut FindCtx) {
    if reg.n == c.target {
        set c.found = true;
    }
}

lib/std/lang/gen/regalloc/spill.rad +28 -24

    costs: *mut [SpillCost],
    weight: u32,
}

/// Analyze a function and determine which values need spill slots.
export fn analyze(
export unsafe fn analyze(
    func: *il::Fn,
    live: *liveness::LiveInfo,
    live: &liveness::LiveInfo,
    numRegs: u32,
    numCalleeSaved: u32,
    slotSize: u32,
    arena: *mut alloc::Arena
    arena: &mut alloc::Arena
) -> SpillInfo throws (alloc::AllocError) {
    let maxReg = live.maxReg;
    if maxReg == 0 {
        let calleeClass = try bitset::allocate(arena, 0);
        return SpillInfo {

            // Remove definition from live set.
            if let dst = il::instrDst(instr) {
                bitset::clear(&mut scratch, dst.n);
            }
            // Add uses to live set.
            il::forEachReg(instr, addRegToSetCallback, &mut scratch as *mut opaque);
            il::forEachReg(instr, addRegToSetCallback, &mut scratch as &mut opaque);
        }
        // Also limit pressure at block entry.
        limitPressure(&mut scratch, &mut spilled, costs, numRegs);
    }


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

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

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

                    set costs[dst.n].defs = costs[dst.n].defs + weight;
                }
            }
            // Count uses.
            let mut ctx = CountCtx { costs, weight };
            il::forEachReg(instr, countRegUseCallback, &mut ctx as *mut opaque);
            il::forEachReg(instr, countRegUseCallback, &mut ctx as &mut opaque);
        }
    }
}

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

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

/// Collect all values from a bitset into a candidates buffer with their costs.
fn collectCandidates(bs: *bitset::Bitset, costs: *[SpillCost]) -> Candidates {
unsafe fn collectCandidates(bs: &bitset::Bitset, costs: *[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 {

    }
    return c;
}

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

/// Limit cross-call pressure by spilling values that exceed callee-saved capacity.
///
/// At a call site, every live value must survive the call in a callee-saved
/// register. If the count exceeds `numCalleeSaved`, spill the cheapest
/// crossing values.
fn limitCrossCallPressure(
    live: *mut bitset::Bitset,
    spilled: *mut bitset::Bitset,
unsafe fn limitCrossCallPressure(
    live: &mut bitset::Bitset,
    spilled: &mut bitset::Bitset,
    costs: *[SpillCost],
    calleeClass: *mut bitset::Bitset,
    calleeClass: &mut bitset::Bitset,
    numCalleeSaved: u32,
    callDst: ?il::Reg
) {
    // Collect crossing candidates: live values excluding the call destination.
    let mut candidates: [CostEntry; 256] = undefined;

        }
    }
}

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

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

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

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

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

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


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

/// Format a qualified symbol name: `pkg::mod::path::name`.
export fn formatQualifiedName(arena: *mut alloc::Arena, path: *[*[u8]], name: *[u8]) -> *[u8] {
export 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];

    }
}

/// Call a function for each register used by an instruction.
/// This is called by the register allocator to analyze register usage.
export fn forEachReg(instr: Instr, f: fn(Reg, *mut opaque), ctx: *mut opaque) {
export unsafe fn forEachReg(instr: Instr, f: unsafe fn(Reg, &mut opaque), ctx: &mut opaque) {
    match instr {
        case Instr::Reserve { size, .. } =>
            withReg(size, f, ctx),
        case Instr::Load { src, .. } => f(src, ctx),
        case Instr::Sload { src, .. } => f(src, ctx),

             Instr::MemoryFence => {},
    }
}

/// Call callback if value is a register.
fn withReg(val: Val, callback: fn(Reg, *mut opaque), ctx: *mut opaque) {
unsafe fn withReg(val: Val, callback: unsafe fn(Reg, &mut opaque), ctx: &mut opaque) {
    if let case Val::Reg(r) = val {
        callback(r, ctx);
    }
}

lib/std/lang/il/printer.rad +32 -30

///////////////////////
// String formatting //
///////////////////////

/// Write a `u32` before its stack buffer leaves scope.
fn writeU32(out: *mut sexpr::Output, val: u32) {
unsafe fn writeU32(out: &mut sexpr::Output, val: u32) {
    let mut digits: [u8; 10] = undefined;
    write(out, fmt::formatU32(val, &mut digits[..]));
    let start = fmt::formatU32(val, &mut digits[..]);
    write(out, &digits[start..]);
}

/// Write an `i32` before its stack buffer leaves scope.
fn writeI32(out: *mut sexpr::Output, val: i32) {
unsafe fn writeI32(out: &mut sexpr::Output, val: i32) {
    let mut digits: [u8; 12] = undefined;
    write(out, fmt::formatI32(val, &mut digits[..]));
    let start = fmt::formatI32(val, &mut digits[..]);
    write(out, &digits[start..]);
}

/// Write an `i64` before its stack buffer leaves scope.
fn writeI64(out: *mut sexpr::Output, val: i64) {
unsafe fn writeI64(out: &mut sexpr::Output, val: i64) {
    let mut digits: [u8; 20] = undefined;
    write(out, fmt::formatI64(val, &mut digits[..]));
    let start = fmt::formatI64(val, &mut digits[..]);
    write(out, &digits[start..]);
}

/////////////////////
// Output helpers  //
/////////////////////

/// Write a string to the output.
fn write(out: *mut sexpr::Output, s: *[u8]) {
unsafe fn write(out: &mut sexpr::Output, s: &[u8]) {
    sexpr::write(out, s);
}

/// Emit indentation.
fn indent(out: *mut sexpr::Output, depth: u32) {
unsafe fn indent(out: &mut sexpr::Output, depth: u32) {
    for _ in 0..depth {
        write(out, "    ");
    }
}


    }
    return false;
}

/// Write a symbol name. Simple names use `$name`, qualified names use `$"name"`.
fn writeSymbol(out: *mut sexpr::Output, name: *[u8]) {
unsafe fn writeSymbol(out: &mut sexpr::Output, name: *[u8]) {
    write(out, "$");
    if needsQuoting(name) {
        write(out, "\"");
        write(out, name);
        write(out, "\"");

        case super::Type::W64 => return "w64",
    }
}

/// Write a type.
fn writeType(out: *mut sexpr::Output, typ: super::Type) {
unsafe fn writeType(out: &mut sexpr::Output, typ: super::Type) {
    write(out, typeStr(typ));
}

////////////////////////
// Operation printing //

////////////////////
// Value printing //
////////////////////

/// Write a value (register, immediate, symbol, or undefined).
fn writeVal(out: *mut sexpr::Output, val: super::Val) {
unsafe fn writeVal(out: &mut sexpr::Output, val: super::Val) {
    match val {
        case super::Val::Reg(reg) => writeReg(out, reg),
        case super::Val::Imm(v) => writeI64(out, v),
        case super::Val::DataSym(name) => writeSymbol(out, name),
        case super::Val::FnAddr(name) => writeSymbol(out, name),
        case super::Val::Undef => write(out, "undefined"),
    }
}

/// Write a register in one operation before its stack buffer leaves scope.
fn writeReg(out: *mut sexpr::Output, reg: super::Reg) {
unsafe fn writeReg(out: &mut sexpr::Output, reg: super::Reg) {
    let mut buffer: [u8; 11] = undefined;
    let digits = fmt::formatU32(reg.n, &mut buffer[1..]);
    let start = buffer.len - digits.len - 1;
    let start = fmt::formatU32(reg.n, &mut buffer[1..]);
    set buffer[start] = '%';
    write(out, &buffer[start..]);
}

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

    }
    write(out, ")");
}

/// Write a typed parameter (e.g., `w32 %0`).
fn writeParam(out: *mut sexpr::Output, param: super::Param) {
unsafe fn writeParam(out: &mut sexpr::Output, param: super::Param) {
    writeType(out, param.type);
    write(out, " ");
    writeReg(out, param.value);
}

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

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

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

        }
    }
}

/// Write a typed binary operation: `op type %dst %a %b`.
fn writeTypedBinOp(
    out: *mut sexpr::Output,
unsafe fn writeTypedBinOp(
    out: &mut sexpr::Output,
    name: *[u8],
    typ: super::Type,
    dst: super::Reg,
    va: super::Val,
    vb: super::Val

    write(out, " ");
    writeVal(out, vb);
}

/// Write a typed unary operation: `op type %dst %val`.
fn writeTypedUnaryOp(
    out: *mut sexpr::Output,
unsafe fn writeTypedUnaryOp(
    out: &mut sexpr::Output,
    name: *[u8],
    typ: super::Type,
    dst: super::Reg,
    val: super::Val
) {

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

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

    // Block parameters.

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

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

///////////////////
// Data printing //
///////////////////

/// Write a data item.
fn writeDataItem(out: *mut sexpr::Output, item: super::DataItem) {
unsafe fn writeDataItem(out: &mut sexpr::Output, item: super::DataItem) {
    match item {
        case super::DataItem::Val { typ, val } => {
            writeType(out, typ);
            write(out, " ");
            writeI64(out, val);

        }
    }
}

/// Write a data value (item with optional repeat count).
fn writeDataValue(out: *mut sexpr::Output, value: super::DataValue) {
unsafe fn writeDataValue(out: &mut sexpr::Output, value: super::DataValue) {
    writeDataItem(out, value.item);
    if value.count > 1 {
        write(out, " * ");
        writeU32(out, value.count);
    }
}

/// Write global data.
fn writeData(out: *mut sexpr::Output, d: super::Data) {
unsafe fn writeData(out: &mut sexpr::Output, d: super::Data) {
    write(out, "data ");
    if not d.readOnly {
        write(out, "mut ");
    }
    writeSymbol(out, d.name);

//////////////////////
// Program printing //
//////////////////////

/// Print a program.
export fn printProgram(out: *mut sexpr::Output, program: *super::Program) {
export unsafe fn printProgram(out: &mut sexpr::Output, program: &super::Program) {
    // Data declarations.
    for data, i in program.data {
        writeData(out, data);
        if i < program.data.len - 1 or program.fns.len > 0 {
            write(out, "\n");

        }
    }
}

/// Print a program to a buffer, returning the written slice.
export fn printProgramToBuffer(
    program: *super::Program,
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 };
    printProgram(&mut out, program);

lib/std/lang/lower.rad +489 -481

    /// Invalid variable use.
    InvalidUse,
    /// Unexpected node value.
    UnexpectedNodeValue(*ast::Node),
    /// Unexpected type.
    UnexpectedType(*resolver::Type),
    UnexpectedType(resolver::Type),

    /// Missing control flow target.
    MissingTarget,
    /// Missing metadata that should have been set by resolver.
    MissingMetadata,

    Default,
}

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

/// Destination for functions produced by the lowerer.
export union FnOutput: Copy {
    /// Store lowered functions in the provided slice.

/// 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 {
    /// Arena for persistent lowering state, including data and symbol names.
    arena: *mut alloc::Arena,
    arena: *unsafe mut alloc::Arena,
    /// Arena for allocations owned by the function currently being lowered.
    fnArena: *mut alloc::Arena,
    fnArena: *unsafe mut alloc::Arena,
    /// Allocator backed by the arena.
    allocator: alloc::Allocator,
    /// Resolver for type information. Used to query types, symbols, and
    /// compile-time constant values during lowering.
    resolver: *resolver::Resolver,
    resolver: *unsafe resolver::Resolver,
    /// Module graph for cross-module symbol resolution.
    moduleGraph: ?*module::ModuleGraph,
    moduleGraph: ?*unsafe module::ModuleGraph,
    /// Package name for qualified symbol names.
    pkgName: *[u8],
    /// Current module being lowered.
    currentMod: ?u16,
    /// Global data items (string literals, constants, static arrays).

    return maxSize;
}

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


    return tag;
}

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

/// Append a data value to the builder.
fn dataBuilderPush(b: *mut DataValueBuilder, value: il::DataValue) {
fn dataBuilderPush(b: &mut DataValueBuilder, value: il::DataValue) {
    b.values.append(value, b.allocator);

    if value.count > 0 and not dataIsZero(value.item) {
        set b.zeroInit = false;
    }
}

/// Return the accumulated values.
fn dataBuilderFinish(b: *DataValueBuilder) -> ConstDataResult {
fn dataBuilderFinish(b: &DataValueBuilder) -> ConstDataResult {
    return ConstDataResult {
        values: &b.values[..],
        zeroInit: b.zeroInit,
    };
}


/// Per-function lowering state. Created fresh for each function and contains
/// all the mutable state needed during function body lowering.
record FnLowerer: Copy {
    /// Reference to the module-level lowerer.
    low: *mut Lowerer,
    low: *unsafe mut Lowerer,
    /// Allocator for IL allocations.
    allocator: alloc::Allocator,
    /// Type signature of the function being lowered.
    fnType: *resolver::FnType,
    /// Function name, used as prefix for generated data symbols.

/// 2. Iterates over top-level declarations, lowering each.
/// 3. Returns the complete IL program with functions and data section.
///
/// The resolver must have already processed the AST -- we rely on its type
/// annotations, symbol table, and constant evaluations.
export fn lower(
    res: *resolver::Resolver,
export unsafe fn lower(
    res: &resolver::Resolver,
    root: *ast::Node,
    pkgName: *[u8],
    arena: *mut alloc::Arena
    arena: &mut alloc::Arena
) -> il::Program throws (LowerError) {
    let mut low = Lowerer {
        arena: arena,
        fnArena: arena,
        arena: arena as *unsafe mut alloc::Arena,
        fnArena: arena as *unsafe mut alloc::Arena,
        allocator: alloc::arenaAllocator(arena),
        resolver: res,
        resolver: res as *unsafe resolver::Resolver,
        moduleGraph: nil,
        pkgName,
        currentMod: nil,
        data: &mut [],
        output: FnOutput::Accumulate(&mut []),

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

/// Create a lowerer for multi-module compilation.
export fn lowerer(
    res: *resolver::Resolver,
    graph: *module::ModuleGraph,
/// The resolver, graph, and both arenas must outlive the returned lowerer.
export unsafe fn lowerer(
    res: *unsafe resolver::Resolver,
    graph: &module::ModuleGraph,
    pkgName: *[u8],
    arena: *mut alloc::Arena,
    fnArena: *mut alloc::Arena,
    arena: *unsafe mut alloc::Arena,
    fnArena: *unsafe mut alloc::Arena,
    options: LowerOptions
) -> Lowerer {
    return Lowerer {
        arena,
        fnArena,
        allocator: alloc::arenaAllocator(arena),
        resolver: res,
        moduleGraph: graph,
        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,
        moduleGraph: graph as *unsafe module::ModuleGraph,
        pkgName,
        currentMod: nil,
        data: &mut [],
        output: FnOutput::Accumulate(&mut []),
        fnSyms: &mut [],

    };
}

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

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


        }
    }
}

/// Finalize lowering and return the unified IL program.
export fn finalize(low: *Lowerer) -> il::Program {
export fn finalize(low: &Lowerer) -> il::Program {
    let mut fns: *mut [*il::Fn] = undefined;
    match low.output {
        case FnOutput::Accumulate(accumulated) => {
            set fns = accumulated;
        }

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

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

/// Build a qualified name string for a symbol.
/// If `modId` is nil, uses current module.
fn qualifyName(self: *mut Lowerer, modId: ?u16, name: *[u8]) -> *[u8] {
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(self.arena, path, name);
    return il::formatQualifiedName(&mut *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: *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] {
fn lookupFnSym(self: &Lowerer, sym: *resolver::Symbol) -> ?*[u8] {
    for entry in self.fnSyms {
        if entry.sym == sym {
            return entry.qualName;
        }
    }
    return nil;
}

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

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

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

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

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


    return func;
}

/// Build a qualified name of the form "Type::method".
fn instanceMethodName(self: *mut Lowerer, modId: ?u16, typeName: *[u8], methodName: *[u8]) -> *[u8] {
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(self.arena, 1, 1, totalLen) as *mut [u8];
    let buf = try! alloc::allocSlice(&mut *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);


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

/// Build a v-table data name of the form "vtable::Type::Trait".
fn vtableName(self: *mut Lowerer, modId: ?u16, typeName: *[u8], traitName: *[u8]) -> *[u8] {
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(self.arena, 1, 1, totalLen) as *mut [u8];
    let buf = try! alloc::allocSlice(&mut *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..], "::");

/// Each method in the instance block is lowered as a standalone function
/// with a qualified name of the form `Type::method`. A read-only v-table
/// data record is emitted containing pointers to these functions, ordered
/// by the trait's method indices. The v-table is later referenced when
/// constructing trait objects for dynamic dispatch.
fn lowerInstanceDecl(
    self: *mut Lowerer,
unsafe fn lowerInstanceDecl(
    self: &mut Lowerer,
    node: *ast::Node,
    traitNameNode: *ast::Node,
    targetTypeNode: *ast::Node,
    methods: *mut [*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(
        self.arena, @sizeOf(il::DataValue), @alignOf(il::DataValue), traitInfo.methods.len as u32
        &mut *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]),

    }, self.allocator);
}

/// Lower a method node into an IL function with the given qualified name.
/// Shared by both instance methods and standalone methods.
fn lowerMethod(
    self: *mut Lowerer,
unsafe fn lowerMethod(
    self: &mut Lowerer,
    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);
    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(self.fnArena, @sizeOf(il::Fn), @alignOf(il::Fn)) as *mut il::Fn;
    let func = try! alloc::alloc(&mut *self.fnArena, @sizeOf(il::Fn), @alignOf(il::Fn)) as *mut il::Fn;

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

    return func;
}

/// Lower a standalone method declaration.
/// Produces a function with qualified name `Type::method`.
fn lowerMethodDecl(
    self: *mut Lowerer,
unsafe fn lowerMethodDecl(
    self: &mut Lowerer,
    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
    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);
}

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

    return false;
}

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

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

    return &buf[..totalLen];
}

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

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

        else => panic,
    }
}

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

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

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

/// Lower scalar-like constant nodes into data values, including fallback handling
/// for void-variant tags and slice string initializers.
fn lowerConstScalarDataInto(
    self: *mut Lowerer,
unsafe fn lowerConstScalarDataInto(
    self: &mut Lowerer,
    node: *ast::Node,
    ty: resolver::Type,
    dataPrefix: *[u8],
    b: *mut DataValueBuilder
    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;

        count: 1
    });
}

/// Lower a constant or static declaration to the data section.
fn lowerDataDecl(
    self: *mut Lowerer,
unsafe fn lowerDataDecl(
    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);

        values: result.values,
    }, self.allocator);
}

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

        count: 1
    });
}

/// Lower a compile-time `&[...]` expression to a concrete slice header.
fn lowerConstAddressSliceInto(
    self: *mut Lowerer,
unsafe fn lowerConstAddressSliceInto(
    self: &mut Lowerer,
    addr: ast::AddressOf,
    ty: resolver::Type,
    dataPrefix: *[u8],
    b: *mut DataValueBuilder
    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);

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

/// Lower a constant expression payload into a builder without slot padding.
/// Compute the type layout only when undefined data needs a byte count.
fn lowerConstDataPayloadInto(
    self: *mut Lowerer,
unsafe fn lowerConstDataPayloadInto(
    self: &mut Lowerer,
    node: *ast::Node,
    ty: resolver::Type,
    dataPrefix: *[u8],
    b: *mut DataValueBuilder
    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);

        }
    }
}

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

    }
}

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


}

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

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

    }
}

/// Build data values for a constant record literal.
/// Each field is lowered with a slot size that includes trailing padding.
fn lowerConstRecordLitInto(
    self: *mut Lowerer,
unsafe fn lowerConstRecordLitInto(
    self: &mut Lowerer,
    node: *ast::Node,
    recLit: ast::RecordLit,
    ty: resolver::Type,
    dataPrefix: *[u8],
    b: *mut DataValueBuilder
    b: &mut DataValueBuilder
) throws (LowerError) {
    match ty {
        case resolver::Type::Nominal(resolver::NominalType::Record(recInfo)) => {
            try lowerConstRecordCtorInto(self, recLit.fields, recInfo, dataPrefix, b);
        }
        case resolver::Type::Nominal(resolver::NominalType::Union(_)) => {
            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.
fn lowerConstRecordCtorInto(
    self: *mut Lowerer,
unsafe fn lowerConstRecordCtorInto(
    self: &mut Lowerer,
    args: *mut [*ast::Node],
    recInfo: resolver::RecordType,
    dataPrefix: *[u8],
    b: *mut DataValueBuilder
    b: &mut DataValueBuilder
) throws (LowerError) {
    let layout = recInfo.layout;
    for argNode, i in args {
        let mut valueNode = argNode;
        if let case ast::NodeValue::RecordLitField(fieldLit) = argNode.value {

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

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

    let unionInfo = unionInfoFromType(ty) else {

    }
}

/// Find an existing string data entry with matching content.
// TODO: Optimize with hash table or remove?
fn findStringData(self: *Lowerer, s: *[u8]) -> ?*[u8] {
fn findStringData(self: &Lowerer, s: *[u8]) -> ?*[u8] {
    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;

    return nil;
}

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

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


    return &buf[..totalLen];
}

/// Generate a unique name for declaration-local backing data entries.
fn nextDeclDataName(
    self: *mut Lowerer,
unsafe fn nextDeclDataName(
    self: &mut Lowerer,
    prefix: *[u8],
    count: u32,
    namespace: *[u8]
) -> *[u8] throws (LowerError) {
    let mut digits: [u8; fmt::U32_STR_LEN] = undefined;
    let suffix = fmt::formatU32(count, &mut digits[..]);
    let segments: *mut [*[u8]] = &mut [prefix, namespace, suffix];
    let start = fmt::formatU32(count, &mut digits[..]);
    let suffix = try! alloc::allocSlice(&mut *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);
    return try buildSegmentedName(self, &segments[..]);
}

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


    return name;
}

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

            },
    }
}

/// Compare two data value slices for structural equality.
fn dataValuesEq(a: *[il::DataValue], b: *[il::DataValue]) -> bool {
fn dataValuesEq(a: &[il::DataValue], b: &[il::DataValue]) -> bool {
    if a.len <> b.len {
        return false;
    }
    for i in 0..a.len {
        if a[i].count <> b[i].count {

    return true;
}

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

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

    return findSliceData(self, values, alignment);
}

/// Lower constant data to a slice value.
/// Creates or reuses a data section entry, then builds a slice header on the stack.
fn lowerConstDataAsSlice(
    self: *mut FnLowerer,
    result: *ConstDataResult,
unsafe fn lowerConstDataAsSlice(
    self: &mut FnLowerer,
    result: &ConstDataResult,
    alignment: u32,
    readOnly: bool,
    elemTy: *resolver::Type,
    mutable: bool,
    length: u32

    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(self.low, values, alignment);
        set found = findConstData(&mut *self.low, values, alignment);
    }
    if let name = found {
        set dataName = name;
    } else {
        set dataName = try nextDataName(self);

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

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

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

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

    set sym.name = name;
}

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

/// Look up the resolved type of an AST node, or throw `MissingType`.
fn typeOf(self: *mut FnLowerer, node: *ast::Node) -> resolver::Type throws (LowerError) {
    let ty = resolver::typeFor(self.low.resolver, node)
unsafe fn typeOf(self: &mut FnLowerer, node: *ast::Node) -> resolver::Type throws (LowerError) {
    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`.
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) -> *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.
/// Used when detecting a trivial phi that can be eliminated.
fn removeLastBlockParam(self: *mut FnLowerer, block: BlockId) {
fn removeLastBlockParam(self: &mut FnLowerer, block: BlockId) {
    let blk = getBlockMut(self, block);
    if blk.params.len > 0 {
        // TODO: Use `pop`?
        set blk.params = @sliceOf(blk.params.ptr, blk.params.len - 1, blk.params.cap);
    }

/// Rewrite cached SSA values for a variable across all blocks, and also
/// rewrite any terminator arguments that reference the provisional register.
/// The latter is necessary because recursive SSA resolution may have already
/// patched terminator arguments with the provisional value before it was
/// found to be trivial.
fn rewriteCachedVarValue(self: *mut FnLowerer, v: Var, from: il::Val, to: il::Val) {
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;
        }

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

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


    return id;
}

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

    return block;
}

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

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

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

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

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

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

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

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

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

    // Track whether this function is a leaf.
    if self.isLeaf {

    }
    block.instrs.append(instr, self.allocator);
}

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

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

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

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

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

/// Emit a compare-and-branch instruction with the given comparison op.
fn emitBrCmp(
    self: *mut FnLowerer,
unsafe fn emitBrCmp(
    self: &mut FnLowerer,
    op: il::CmpOp,
    typ: il::Type,
    a: il::Val,
    b: il::Val,
    thenBlock: BlockId,

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

/// Emit a guard that traps with `ebreak` when a comparison is false.
fn emitTrapUnlessCmp(
    self: *mut FnLowerer,
unsafe fn emitTrapUnlessCmp(
    self: &mut FnLowerer,
    op: il::CmpOp,
    typ: il::Type,
    a: il::Val,
    b: il::Val
) throws (LowerError) {

    }
    return aa <= bb;
}

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

    try switchToAndSeal(self, passBlock);
}

/// Emit a conditional branch. Uses fused compare-and-branch for simple scalar
/// comparisons, falls back to separate comparison plus branch otherwise.
fn emitCondBranch(
    self: *mut FnLowerer,
unsafe fn emitCondBranch(
    self: &mut FnLowerer,
    cond: *ast::Node,
    thenBlock: BlockId,
    elseBlock: BlockId
) throws (LowerError) {
    // Try fused compare-and-branch for simple scalar comparisons.

            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(self.low, operandTy);
                let typ = ilType(&mut *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),


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return dst;
}

/// Emit pattern tests for a single pattern.
fn emitPatternMatch(
    self: *mut FnLowerer,
    subject: *MatchSubject,
unsafe fn emitPatternMatch(
    self: &mut FnLowerer,
    subject: &MatchSubject,
    pattern: *ast::Node,
    matchBlock: BlockId,
    fallthrough: BlockId
) throws (LowerError) {
    // Wildcards always match; array patterns are tested element-by-element

        }
        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).

}

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



/// Emit a match binding pattern.
/// Binding patterns always match for regular values, but for optionals they
/// check for the presence of a value. Jumps to `valuePresent` on success,
/// `valueAbsent` on failure.
fn emitBindingTest(
    self: *mut FnLowerer,
    subject: *MatchSubject,
unsafe fn emitBindingTest(
    self: &mut FnLowerer,
    subject: &MatchSubject,
    valuePresent: BlockId,
    valueAbsent: BlockId
) throws (LowerError) {
    match subject.kind {
        case MatchSubjectKind::OptionalPtr, MatchSubjectKind::OptionalAggregate => {

        }
    }
}

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

/// Check if the current block already has a terminator instruction.
fn blockHasTerminator(self: *FnLowerer) -> bool {
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] {

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

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

/// Add a predecessor edge from `pred` to `target`.
/// Must be called before the target block is sealed. Duplicates are ignored.
fn addPredecessor(self: *mut FnLowerer, target: BlockId, pred: BlockId) {
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.
fn finalizeBlocks(self: *mut FnLowerer) -> *[il::Block] throws (LowerError) {
unsafe fn finalizeBlocks(self: &mut FnLowerer) -> *[il::Block] throws (LowerError) {
    let blockCount = self.blockData.len;
    let blocks = try! alloc::allocSlice(
        self.low.fnArena, @sizeOf(il::Block), @alignOf(il::Block), self.blockData.len
        &mut *self.low.fnArena, @sizeOf(il::Block), @alignOf(il::Block), blockCount
    ) as *mut [il::Block];

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


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

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

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

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

/// Get or lazily create the continue target block for the current loop.
fn getOrCreateContinueBlock(self: *mut FnLowerer) -> BlockId throws (LowerError) {
unsafe fn getOrCreateContinueBlock(self: &mut FnLowerer) -> BlockId throws (LowerError) {
    let ctx = currentLoop(self) else {
        throw LowerError::OutsideOfLoop;
    };
    if let block = ctx.continueTarget {
        return block;

    set ctx.continueTarget = block;
    return block;
}

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

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


// 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(
    self: *mut FnLowerer,
    self: &mut FnLowerer,
    name: ?*[u8],
    type: il::Type,
    mutable: bool,
    val: il::Val
) -> Var {


/// 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) {
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.
/// May insert block parameters if the value must come from predecessors.
fn useVar(self: *mut FnLowerer, v: Var) -> il::Val throws (LowerError) {
unsafe fn useVar(self: &mut FnLowerer, v: Var) -> il::Val throws (LowerError) {
    return try useVarInBlock(self, currentBlock(self), v);
}

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

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

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

/// Look up a variable by name in the current scope.
/// Searches from most recently declared to first, enabling shadowing.
fn lookupVarByName(self: *FnLowerer, name: *[u8]) -> ?Var {
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 {
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 {
fn enterVarScope(self: &FnLowerer) -> u32 {
    return self.vars.len;
}

/// Restore lexical variable scope depth.
fn exitVarScope(self: *mut FnLowerer, savedVarsLen: u32) {
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 {
fn getVar(self: &FnLowerer, v: Var) -> *VarData {
    assert *v < self.vars.len;
    return &self.vars[*v];
}

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

///     @end(w32 %1)              // x = %1, merged from predecessors
///       ret %1;
///
/// Create a register `%1` as a block parameter. In a sealed block, patch each
/// predecessor's jump to pass its value of `x`. Otherwise, defer until sealing.
fn createBlockParam(self: *mut FnLowerer, block: BlockId, v: Var) -> il::Val throws (LowerError) {
unsafe fn createBlockParam(self: &mut FnLowerer, block: BlockId, v: Var) -> il::Val throws (LowerError) {
    // Entry block must not have block parameters.
    assert block <> self.entryBlock, "createBlockParam: entry block must not have block parameters";
    // Allocate a register to hold the merged value.
    let reg = nextReg(self);
    let type = getVar(self, v).type;

///     x3 = phi(x1, x2)
///
/// This representation avoids the need for phi nodes to reference their
/// predecessor blocks explicitly, since the control flow edges already encode
/// that information.
fn resolveBlockArgs(self: *mut FnLowerer, block: BlockId, v: Var, paramIdx: u32) throws (LowerError) {
unsafe fn resolveBlockArgs(self: &mut FnLowerer, block: BlockId, v: Var, paramIdx: u32) throws (LowerError) {
    let blk = getBlock(self, block);

    // For each predecessor, recursively look up the variable's reaching definition
    // in that block, then patch the predecessor's terminator to pass that value
    // as an argument to this block's parameter.

    }
}

/// Check if a block parameter is trivial, i.e. all predecessors provide
/// the same value. Returns the trivial value if so.
fn getTrivialPhiVal(self: *mut FnLowerer, block: BlockId, v: Var) -> ?il::Val throws (LowerError) {
unsafe fn getTrivialPhiVal(self: &mut FnLowerer, block: BlockId, v: Var) -> ?il::Val throws (LowerError) {
    let blk = getBlock(self, block);
    // Get the block parameter register.
    let paramReg = blk.vars[*v];
    // Check if all predecessors provide the same value.
    let mut sameVal: ?il::Val = nil;

    return sameVal;
}

/// Patch a single terminator argument for a specific edge. This is used during
/// SSA construction to pass variable values along control flow edges.
fn patchTerminatorArg(
    self: *mut FnLowerer,
unsafe fn patchTerminatorArg(
    self: &mut FnLowerer,
    from: BlockId,         // The predecessor block containing the terminator to patch.
    target: u32,           // The index of the target block we're passing the value to.
    paramIdx: u32,         // The index of the block parameter to set.
    val: il::Val           // The value to pass as the argument.
) {

        }
    }
}

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

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

    return name;
}

/// Lower function parameters. Declares variables for each parameter.
/// When a receiver name is passed, we're handling a trait method.
fn lowerParams(
    self: *mut FnLowerer,
unsafe fn lowerParams(
    self: &mut FnLowerer,
    fnType: resolver::FnType,
    astParams: *mut [*ast::Node],
    receiverName: ?*ast::Node
) -> *[il::Param] throws (LowerError) {
    let offset: u32 = 1 if self.returnReg <> nil else 0;

        return &[];
    }
    assert fnType.paramTypes.len as u32 <= resolver::MAX_FN_PARAMS;

    let params = try! alloc::allocSlice(
        self.low.fnArena, @sizeOf(il::Param), @alignOf(il::Param), totalLen
        &mut *self.low.fnArena, @sizeOf(il::Param), @alignOf(il::Param), totalLen
    ) as *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(self.low, *fnType.paramTypes[i]);
        let type = ilType(&mut *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

    }
    return params;
}

/// Resolve match subject.
fn lowerMatchSubject(self: *mut FnLowerer, subject: *ast::Node) -> MatchSubject throws (LowerError) {
unsafe fn lowerMatchSubject(self: &mut FnLowerer, subject: *ast::Node) -> MatchSubject throws (LowerError) {
    let mut val = try lowerExpr(self, subject);
    let subjectType = try typeOf(self, subject);
    let unwrapped = resolver::unwrapMatchSubject(subjectType);

    // When matching an aggregate by value, copy it to a fresh stack slot so


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

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


        else => return false,
    }
}

/// Load the tag byte from a tagged value aggregate (optionals and unions).
fn tvalTagReg(self: *mut FnLowerer, base: il::Reg) -> il::Reg {
unsafe fn tvalTagReg(self: &mut FnLowerer, base: il::Reg) -> il::Reg {
    let tagReg = nextReg(self);
    emitLoadW8At(self, tagReg, base, TVAL_TAG_OFFSET);
    return tagReg;
}

/// Load the tag word from a result aggregate.
fn resultTagReg(self: *mut FnLowerer, base: il::Reg) -> il::Reg {
unsafe fn resultTagReg(self: &mut FnLowerer, base: il::Reg) -> il::Reg {
    let tagReg = nextReg(self);
    emitLoadW64At(self, tagReg, base, TVAL_TAG_OFFSET);
    return tagReg;
}

/// Get the register to compare against `0` for optional `nil` checking.
/// For null-ptr-optimized types, loads the data pointer, or returns it
/// directly for scalar pointers. For aggregates, returns the tag register.
fn optionalNilReg(self: *mut FnLowerer, val: il::Val, typ: resolver::Type) -> il::Reg throws (LowerError) {
unsafe fn optionalNilReg(self: &mut FnLowerer, val: il::Val, typ: resolver::Type) -> il::Reg throws (LowerError) {
    let reg = emitValToReg(self, val);

    match typ {
        case resolver::Type::Optional(resolver::Type::Slice { .. }) => {
            let ptrReg = nextReg(self);

        else => return reg,
    }
}

/// Lower an optional nil check (`opt == nil` or `opt <> nil`).
fn lowerNilCheck(self: *mut FnLowerer, opt: *ast::Node, isEq: bool) -> il::Val throws (LowerError) {
unsafe fn lowerNilCheck(self: &mut FnLowerer, opt: *ast::Node, isEq: bool) -> il::Val throws (LowerError) {
    let optTy = try typeOf(self, opt);
    // Handle `nil == nil` or `nil <> nil`.
    if optTy == resolver::Type::Nil {
        return il::Val::Imm(1) if isEq else il::Val::Imm(0);
    }

    let op = il::BinOp::Eq if isEq else il::BinOp::Ne;
    return emitTypedBinOp(self, op, cmpType, il::Val::Reg(cmpReg), il::Val::Imm(0));
}

/// Load the payload value from a tagged value aggregate at the given offset.
fn tvalPayloadVal(self: *mut FnLowerer, base: il::Reg, payload: resolver::Type, valOffset: i32) -> il::Val {
unsafe fn tvalPayloadVal(self: &mut FnLowerer, base: il::Reg, payload: resolver::Type, valOffset: i32) -> il::Val {
    if payload == resolver::Type::Void {
        return il::Val::Undef;
    }
    return emitRead(self, base, valOffset, payload);
}

/// Compute the address of the payload in a tagged value aggregate.
fn tvalPayloadAddr(self: *mut FnLowerer, base: il::Reg, valOffset: i32) -> il::Val {
unsafe fn tvalPayloadAddr(self: &mut FnLowerer, base: il::Reg, valOffset: i32) -> il::Val {
    return il::Val::Reg(emitPtrOffset(self, base, valOffset));
}

/// Bind a variable to a tagged value's payload.
fn bindPayloadVariable(
    self: *mut FnLowerer,
unsafe fn bindPayloadVariable(
    self: &mut FnLowerer,
    name: *[u8],
    subjectVal: il::Val,
    bindType: resolver::Type,
    matchBy: resolver::MatchBy,
    valOffset: i32,

        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(self.low, bindType), mutable, payload);
    return newVar(self, name, ilType(&mut *self.low, bindType), mutable, payload);
}

/// Bind an identifier from a matched subject.
fn bindMatchVariable(
    self: *mut FnLowerer,
    subject: *MatchSubject,
unsafe fn bindMatchVariable(
    self: &mut FnLowerer,
    subject: &MatchSubject,
    binding: *ast::Node,
    mutable: bool
) -> ?Var throws (LowerError) {
    // Only bind if the pattern is an identifier.
    let case ast::NodeValue::Ident(name) = binding.value else {

    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(self.low, subject.bindType), mutable, subject.val);
    return newVar(self, name, ilType(&mut *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).
fn bindPatternVariables(self: *mut FnLowerer, subject: *MatchSubject, patterns: *mut [*ast::Node], failBlock: BlockId) throws (LowerError) {
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";

}

/// Bind variables from an array literal pattern (e.g., `[a, 1, c]`).
/// Each element is either bound as a variable, skipped (placeholder), or
/// tested against the subject element, branching to `failBlock` on mismatch.
fn bindArrayPatternElements(
    self: *mut FnLowerer,
    subject: *MatchSubject,
unsafe fn bindArrayPatternElements(
    self: &mut FnLowerer,
    subject: &MatchSubject,
    items: *mut [*ast::Node],
    failBlock: BlockId
) throws (LowerError) {
    let case resolver::Type::Array(arrInfo) = subject.type
        else throw LowerError::ExpectedSliceOrArray;

        try bindFieldVariable(self, elem, base, fieldInfo, subject.by, failBlock);
    }
}

/// Bind fields from a record pattern.
fn bindRecordPatternFields(self: *mut FnLowerer, subject: *MatchSubject, pattern: *ast::Node, lit: ast::RecordLit, failBlock: BlockId) throws (LowerError) {
unsafe fn bindRecordPatternFields(self: &mut FnLowerer, subject: &MatchSubject, pattern: *ast::Node, lit: ast::RecordLit, failBlock: BlockId) throws (LowerError) {
    // No fields to bind (e.g., `{ .. }`).
    if lit.fields.len == 0 {
        return;
    }
    // Optional value patterns were already compared structurally by

    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)

    try bindNestedRecordFields(self, payloadBase, lit, recInfo, subject.by, failBlock);
}

/// Bind a single record field to a pattern variable, with support for nested
/// pattern tests that branch to `failBlock` on mismatch.
fn bindFieldVariable(
    self: *mut FnLowerer,
unsafe fn bindFieldVariable(
    self: &mut FnLowerer,
    binding: *ast::Node,
    base: il::Reg,
    fieldInfo: resolver::RecordField,
    matchBy: resolver::MatchBy,
    failBlock: BlockId

    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(self.low, fieldInfo.fieldType), false, val);
            newVar(self, name, ilType(&mut *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.

}

/// Emit a nested pattern test for a record field value, branching to
/// `failBlock` if the pattern does not match. On success, continues in
/// a fresh block and binds any nested variables.
fn emitNestedFieldTest(
    self: *mut FnLowerer,
unsafe fn emitNestedFieldTest(
    self: &mut FnLowerer,
    pattern: *ast::Node,
    base: il::Reg,
    fieldInfo: resolver::RecordField,
    matchBy: resolver::MatchBy,
    failBlock: BlockId

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

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

    let continueBlock = try createBlock(self, "nest");
    try emitPatternMatch(self, &nestedSubject, pattern, continueBlock, failBlock);
    try switchToAndSeal(self, continueBlock);

    // After the test succeeds, bind any nested variables.
    let patterns: *mut [*ast::Node] = &mut [pattern];
    try bindPatternVariables(self, &nestedSubject, patterns, failBlock);
    let patterns = [pattern];
    try bindPatternVariables(self, &nestedSubject, &patterns[..], failBlock);
}

/// Bind variables from a nested record literal pattern.
fn bindNestedRecordFields(
    self: *mut FnLowerer,
unsafe fn bindNestedRecordFields(
    self: &mut FnLowerer,
    base: il::Reg,
    lit: ast::RecordLit,
    recInfo: resolver::RecordType,
    matchBy: resolver::MatchBy,
    failBlock: BlockId
) 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.
fn lowerFnBody(self: *mut FnLowerer, body: *ast::Node) -> *[il::Block] throws (LowerError) {
unsafe fn lowerFnBody(self: &mut FnLowerer, body: *ast::Node) -> *[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.
fn lowerMatchSwitch(self: *mut FnLowerer, prongs: *mut [*ast::Node], subject: *MatchSubject, mergeBlock: *mut ?BlockId) throws (LowerError) {
unsafe fn lowerMatchSwitch(self: &mut FnLowerer, prongs: *mut [*ast::Node], subject: &MatchSubject, mergeBlock: &mut ?BlockId) throws (LowerError) {
    let mut blocks: [BlockId; 32] = undefined;
    let mut cases: *mut [il::SwitchCase] = &mut [];
    let mut defaultIdx: u32 = 0;
    let entry = currentBlock(self);


                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],

///   arm#1:
///       jmp else#0;                     // guard failed, fallthrough to `else`
///   else#0:
///       ret 0;                          // `else` body
///
fn lowerMatch(self: *mut FnLowerer, node: *ast::Node, m: ast::Match) throws (LowerError) {
unsafe fn lowerMatch(self: &mut FnLowerer, node: *ast::Node, m: ast::Match) throws (LowerError) {
    assert m.prongs.len > 0;

    let prongs = m.prongs;
    // Lower the subject expression once; reused across all arms.
    let subject = try lowerMatchSubject(self, m.subject);
    // 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 switchToAndSeal(self, blk);
    }
}

/// Lower an `if let` statement.
fn lowerIfLet(self: *mut FnLowerer, cond: ast::IfLet) throws (LowerError) {
unsafe fn lowerIfLet(self: &mut FnLowerer, cond: ast::IfLet) throws (LowerError) {
    let savedVarsLen = enterVarScope(self);
    let subject = try lowerMatchSubject(self, cond.pattern.scrutinee);
    let mut thenBlock: BlockId = undefined;
    if cond.pattern.guard == nil {
        set thenBlock = try createBlock(self, "then");

/// Emit pattern match branch with optional guard, and bind variables.
/// Used by `if-let`, `let-else`, and `while-let` lowering.
///
/// When a guard is present, the guard block is created before `successBlock`
/// to ensure block indices are in RPO.
fn lowerPatternMatch(
    self: *mut FnLowerer,
    subject: *MatchSubject,
    pat: *ast::PatternMatch,
    successBlock: *mut BlockId,
unsafe fn lowerPatternMatch(
    self: &mut FnLowerer,
    subject: &MatchSubject,
    pat: &ast::PatternMatch,
    successBlock: &mut BlockId,
    successLabel: *[u8],
    failBlock: BlockId
) throws (LowerError) {
    // If guard present, pattern match jumps to @guard, then guard evaluation
    // jumps to `successBlock` or `failBlock`. Otherwise, jump directly to

    } else {
        set targetBlock = *successBlock;
    }
    match pat.kind {
        case ast::PatternKind::Case => {
            let patterns: *mut [*ast::Node] = &mut [pat.pattern];
            let patterns = [pat.pattern];
            // Jump to `targetBlock` if the pattern matches, `failBlock` otherwise.
            try emitPatternMatches(self, subject, patterns, targetBlock, failBlock);
            try emitPatternMatches(self, subject, &patterns[..], targetBlock, failBlock);
            try switchToAndSeal(self, targetBlock);
            // Bind any variables inside the pattern. Nested patterns may
            // emit additional tests that branch to `failBlock`, switching
            // the current block.
            try bindPatternVariables(self, subject, patterns, failBlock);
            try bindPatternVariables(self, subject, &patterns[..], failBlock);
        }
        case ast::PatternKind::Binding => {
            // Jump to `targetBlock` if there is a value present, `failBlock` otherwise.
            try emitBindingTest(self, subject, targetBlock, failBlock);
            try switchToAndSeal(self, targetBlock);

        try switchToAndSeal(self, *successBlock);
    }
}

/// Lower a `let-else` statement.
fn lowerLetElse(self: *mut FnLowerer, letElse: ast::LetElse) throws (LowerError) {
unsafe fn lowerLetElse(self: &mut FnLowerer, letElse: ast::LetElse) throws (LowerError) {
    let subject = try lowerMatchSubject(self, letElse.pattern.scrutinee);
    let mut successBlock: BlockId = undefined;
    if letElse.pattern.guard == nil {
        set successBlock = try createBlock(self, "success");
    }

    // Continue at @merge after a successful match or value-producing fallback.
    try switchToAndSeal(self, mergeBlock);
}

/// Lower a `while let` loop as a match-driven loop.
fn lowerWhileLet(self: *mut FnLowerer, w: ast::WhileLet) throws (LowerError) {
unsafe fn lowerWhileLet(self: &mut FnLowerer, w: ast::WhileLet) throws (LowerError) {
    let savedVarsLen = enterVarScope(self);
    // Create control flow blocks: loop header, body (created lazily when
    // there's a guard), and exit.
    let whileBlock = try createBlock(self, "while");
    let mut bodyBlock: BlockId = undefined;

///////////////////
// Node Lowering //
///////////////////

/// Lower an AST node.
fn lowerNode(self: *mut FnLowerer, node: *ast::Node) throws (LowerError) {
unsafe fn lowerNode(self: &mut FnLowerer, node: *ast::Node) throws (LowerError) {
    if self.low.options.debug {
        set self.srcLoc.offset = node.span.offset;
    }
    match node.value {
        case ast::NodeValue::Block(_) => {

            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(self.low, node, decl.value, true);
            try lowerDataDecl(&mut *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(self.low, node, decl.value, false);
            try lowerDataDecl(&mut *self.low, node, decl.value, false);
        }
        case ast::NodeValue::If(i) => {
            try lowerIf(self, i);
        }
        case ast::NodeValue::IfLet(i) => {

        }
    }
}

/// Lower a code block.
fn lowerBlock(self: *mut FnLowerer, node: *ast::Node) throws (LowerError) {
unsafe fn lowerBlock(self: &mut FnLowerer, node: *ast::Node) throws (LowerError) {
    let case ast::NodeValue::Block(blk) = node.value else {
        throw LowerError::ExpectedBlock(node);
    };
    let savedVarsLen = enterVarScope(self);
    for stmt in blk.statements {


/// Return the effective type of a node after any coercion applied by
/// the resolver. `lowerExpr` already materializes the coercion in the
/// IL value, so the lowerer must use the post-coercion type when
/// choosing how to compare or store that value.
fn effectiveType(self: *mut FnLowerer, node: *ast::Node) -> resolver::Type throws (LowerError) {
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 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 {
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 {

    }
    return index as i64;
}

/// Reserve stack storage for a value of the given type.
fn emitReserve(self: *mut FnLowerer, typ: resolver::Type) -> il::Reg throws (LowerError) {
unsafe fn emitReserve(self: &mut FnLowerer, typ: resolver::Type) -> il::Reg throws (LowerError) {
    let layout = resolver::getTypeLayout(typ);
    return emitReserveLayout(self, layout);
}

/// Reserve stack storage with an explicit layout.
fn emitReserveLayout(self: *mut FnLowerer, layout: resolver::Layout) -> il::Reg {
unsafe fn emitReserveLayout(self: &mut FnLowerer, layout: resolver::Layout) -> il::Reg {
    let dst = nextReg(self);

    emit(self, il::Instr::Reserve {
        dst,
        size: il::Val::Imm(layout.size as i64),

    });
    return dst;
}

/// Store a value into an address.
fn emitStore(self: *mut FnLowerer, base: il::Reg, offset: i32, typ: resolver::Type, src: il::Val) throws (LowerError) {
unsafe fn emitStore(self: &mut FnLowerer, base: il::Reg, offset: i32, typ: resolver::Type, src: il::Val) throws (LowerError) {
    // `undefined` values need no store.
    if let case il::Val::Undef = src {
        return;
    }
    if isAggregateType(typ) {

        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(self.low, typ),
            typ: ilType(&mut *self.low, typ),
            src,
            dst: base,
            offset,
        });
    }
}

/// Allocate stack space for a value and store it. Returns a pointer to the value.
fn emitStackVal(self: *mut FnLowerer, typ: resolver::Type, val: il::Val) -> il::Val throws (LowerError) {
unsafe fn emitStackVal(self: &mut FnLowerer, typ: resolver::Type, val: il::Val) -> il::Val throws (LowerError) {
    let ptr = try emitReserve(self, typ);
    try emitStore(self, ptr, 0, typ, val);
    return il::Val::Reg(ptr);
}

/// Generic helper to build any tagged aggregate.
/// Reserves space based on the provided layout, stores the tag, and optionally
/// stores the payload value at `valOffset`.
fn buildTagged(
    self: *mut FnLowerer,
unsafe fn buildTagged(
    self: &mut FnLowerer,
    layout: resolver::Layout,
    tag: i64,
    payload: ?il::Val,
    payloadType: resolver::Type,
    tagSize: u32,

/// Wrap a value in an optional type.
///
/// For optional pointers (`?*T`), the value is returned as-is since pointers
/// use zero to represent `nil`. For other optionals, builds a tagged aggregate.
/// with the tag set to `1`, and the value as payload.
fn wrapInOptional(self: *mut FnLowerer, val: il::Val, optType: resolver::Type) -> il::Val throws (LowerError) {
unsafe fn wrapInOptional(self: &mut FnLowerer, val: il::Val, optType: resolver::Type) -> il::Val throws (LowerError) {
    let case resolver::Type::Optional(inner) = optType else {
        throw LowerError::ExpectedOptional;
    };
    // Null-pointer-optimized (NPO) types are used as-is -- valid values are never null.
    if resolver::isNullableType(*inner) {


/// Build a `nil` value for an optional type.
///
/// For optional pointers (`?*T`), returns an immediate `0` (null pointer).
/// For other optionals, builds a tagged aggregate with tag set to `0` (absent).
fn buildNilOptional(self: *mut FnLowerer, optType: resolver::Type) -> il::Val throws (LowerError) {
unsafe fn buildNilOptional(self: &mut FnLowerer, optType: resolver::Type) -> il::Val throws (LowerError) {
    let case resolver::Type::Optional(inner) = optType
        else throw LowerError::ExpectedOptional;
    if let case resolver::Type::Pointer { .. } = *inner {
        return il::Val::Imm(0);
    }

    let valOffset = resolver::getOptionalValOffset(*inner) as i32;
    return try buildTagged(self, resolver::getTypeLayout(optType), 0, nil, *inner, 1, valOffset);
}

/// Build a result value for throwing functions.
fn buildResult(
    self: *mut FnLowerer,
unsafe fn buildResult(
    self: &mut FnLowerer,
    tag: i64,
    payload: ?il::Val,
    payloadType: resolver::Type
) -> il::Val throws (LowerError) {
    let successType = *self.fnType.returnType;

    );
    return try buildTagged(self, layout, tag, payload, payloadType, resolver::PTR_SIZE as i32, RESULT_VAL_OFFSET);
}

/// Build a slice aggregate from a data pointer, length and capacity.
fn buildSliceValue(
    self: *mut FnLowerer,
unsafe fn buildSliceValue(
    self: &mut FnLowerer,
    elemTy: *resolver::Type,
    mutable: bool,
    ptrVal: il::Val,
    lenVal: il::Val,
    capVal: il::Val


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

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

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

/// Compute a field pointer by adding a byte offset to a base address.
fn emitPtrOffset(self: *mut FnLowerer, base: il::Reg, offset: i32) -> il::Reg {
unsafe fn emitPtrOffset(self: &mut FnLowerer, base: il::Reg, offset: i32) -> il::Reg {
    if offset == 0 {
        return base;
    }
    let dst = nextReg(self);


    return dst;
}

/// Emit an element address computation for array/slice indexing.
/// Computes: `base + idx * stride`.
fn emitElem(self: *mut FnLowerer, stride: u32, base: il::Reg, idx: il::Val) -> il::Reg {
unsafe fn emitElem(self: &mut FnLowerer, stride: u32, base: il::Reg, idx: il::Val) -> il::Reg {
    // If index is zero, return base directly.
    if idx == il::Val::Imm(0) {
        return base;
    }
    // If stride is `1`, skip the multiply.

    });
    return dst;
}

/// Emit a typed binary operation, returning the result as a value.
fn emitTypedBinOp(self: *mut FnLowerer, op: il::BinOp, typ: il::Type, a: il::Val, b: il::Val) -> il::Val {
unsafe fn emitTypedBinOp(self: &mut FnLowerer, op: il::BinOp, typ: il::Type, a: il::Val, b: il::Val) -> il::Val {
    let dst = nextReg(self);
    emit(self, il::Instr::BinOp { op, typ, dst, a, b });
    return il::Val::Reg(dst);
}

/// Emit a tag comparison for void variant equality/inequality.
fn emitTagCmp(self: *mut FnLowerer, op: ast::BinaryOp, val: il::Val, tagIdx: i64, valType: resolver::Type) -> il::Val
unsafe fn emitTagCmp(self: &mut FnLowerer, op: ast::BinaryOp, val: il::Val, tagIdx: i64, valType: resolver::Type) -> il::Val
    throws (LowerError)
{
    let reg = emitValToReg(self, val);

    // For all-void unions, the value *is* the tag, not a pointer.

    let binOp = il::BinOp::Eq if op == ast::BinaryOp::Eq else il::BinOp::Ne;
    return emitTypedBinOp(self, binOp, il::Type::W8, tag, il::Val::Imm(tagIdx));
}

/// Logical "and" between two values. Returns the result in a register.
fn emitLogicalAnd(self: *mut FnLowerer, left: ?il::Val, right: il::Val) -> il::Val {
unsafe fn emitLogicalAnd(self: &mut FnLowerer, left: ?il::Val, right: il::Val) -> il::Val {
    let prev = left else {
        return right;
    };
    return emitTypedBinOp(self, il::BinOp::And, il::Type::W32, prev, right);
}

//////////////////////////
// Aggregate Comparison //
//////////////////////////

/// Emit an equality test for values at an offset of the given base registers.
fn emitEqAtOffset(
    self: *mut FnLowerer,
unsafe fn emitEqAtOffset(
    self: &mut FnLowerer,
    left: il::Reg,
    right: il::Reg,
    offset: i32,
    fieldType: resolver::Type
) -> il::Val throws (LowerError) {

    }
    // 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(self.low, fieldType), dst, a, b });
    emit(self, il::Instr::BinOp { op: il::BinOp::Eq, typ: ilType(&mut *self.low, fieldType), dst, a, b });

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

/// Compare two record values for equality.
fn lowerRecordEq(
    self: *mut FnLowerer,
unsafe fn lowerRecordEq(
    self: &mut FnLowerer,
    recInfo: resolver::RecordType,
    a: il::Reg,
    b: il::Reg,
    offset: i32
) -> il::Val throws (LowerError) {

    }
    return il::Val::Imm(1);
}

/// Compare two slice values for equality.
fn lowerSliceEq(
    self: *mut FnLowerer,
unsafe fn lowerSliceEq(
    self: &mut FnLowerer,
    elemTy: *resolver::Type,
    mutable: bool,
    a: il::Reg,
    b: il::Reg,
    offset: i32

/// branchless formulation: `tagEq AND (tagNil OR payloadEq)`
///
/// For inner types that may contain uninitialized data when `nil` (unions,
/// nested optionals), the payload comparison is guarded behind a branch
/// so that `nil` payloads are never inspected.
fn lowerOptionalEq(
    self: *mut FnLowerer,
unsafe fn lowerOptionalEq(
    self: &mut FnLowerer,
    inner: resolver::Type,
    a: il::Reg,
    b: il::Reg,
    offset: i32
) -> il::Val throws (LowerError) {

/// For all-void unions, we skip the control flow entirely and just compare
/// the tags directly.
///
/// TODO: Could be optimized to branchless when all non-void variants share
/// the same payload type: `tagEq AND (isVoidVariant OR payloadEq)`.
fn lowerUnionEq(
    self: *mut FnLowerer,
unsafe fn lowerUnionEq(
    self: &mut FnLowerer,
    unionInfo: resolver::UnionType,
    a: il::Reg,
    b: il::Reg,
    offset: i32
) -> il::Val throws (LowerError) {


    // 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(
        self.low.fnArena, @sizeOf(il::SwitchCase), @alignOf(il::SwitchCase), unionInfo.variants.len as u32
        &mut *self.low.fnArena, @sizeOf(il::SwitchCase), @alignOf(il::SwitchCase), unionInfo.variants.len as u32
    ) as *mut [il::SwitchCase];

    let mut caseBlocks: [?BlockId; resolver::MAX_UNION_VARIANTS] = undefined;
    for variant, i in unionInfo.variants {
        if variant.valueType == resolver::Type::Void {

    try switchToAndSeal(self, mergeBlock);
    return il::Val::Reg(resultReg);
}

/// Compare two array values for equality, element by element.
fn lowerArrayEq(
    self: *mut FnLowerer,
unsafe fn lowerArrayEq(
    self: &mut FnLowerer,
    arr: resolver::ArrayType,
    a: il::Reg,
    b: il::Reg,
    offset: i32
) -> il::Val throws (LowerError) {

    // Empty arrays are always equal.
    return il::Val::Imm(1);
}

/// Compare two aggregate values for equality.
fn lowerAggregateEq(
    self: *mut FnLowerer,
unsafe fn lowerAggregateEq(
    self: &mut FnLowerer,
    typ: resolver::Type,
    a: il::Reg,
    b: il::Reg,
    offset: i32
) -> il::Val throws (LowerError) {

    }
}

/// Lower a record literal expression. Handles both plain records and union variant
/// record literals like `Union::Variant { field: value }`.
fn lowerRecordLit(self: *mut FnLowerer, node: *ast::Node, lit: ast::RecordLit) -> il::Val throws (LowerError) {
unsafe fn lowerRecordLit(self: &mut FnLowerer, node: *ast::Node, lit: ast::RecordLit) -> il::Val throws (LowerError) {
    let typ = try typeOf(self, node);
    match typ {
        case resolver::Type::Nominal(resolver::NominalType::Record(recInfo)) => {
            let dst = try emitReserve(self, typ);
            try lowerRecordFields(self, dst, &recInfo, lit.fields, 0);

            emitStoreW8At(self, il::Val::Imm(index as i64), dst, TVAL_TAG_OFFSET);
            try lowerRecordFields(self, dst, &recInfo, lit.fields, valOffset);

            return il::Val::Reg(dst);
        }
        else => throw LowerError::UnexpectedType(&typ),
        else => throw LowerError::UnexpectedType(typ),
    }
}

/// Lower fields of a record literal into a destination register.
/// The `offset` is added to each field's offset when storing.
fn lowerRecordFields(
    self: *mut FnLowerer,
unsafe fn lowerRecordFields(
    self: &mut FnLowerer,
    dst: il::Reg,
    recInfo: *resolver::RecordType,
    recInfo: &resolver::RecordType,
    fields: *mut [*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.
fn lowerRecordCtor(self: *mut FnLowerer, nominal: *resolver::NominalType, args: *mut [*ast::Node]) -> il::Val throws (LowerError) {
unsafe fn lowerRecordCtor(self: &mut FnLowerer, nominal: *resolver::NominalType, args: *mut [*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]`.
fn lowerArrayLit(self: *mut FnLowerer, node: *ast::Node, elements: *mut [*ast::Node]) -> il::Val
unsafe fn lowerArrayLit(self: &mut FnLowerer, node: *ast::Node, elements: *mut [*ast::Node]) -> il::Val
    throws (LowerError)
{
    let typ = try typeOf(self, node);
    let case resolver::Type::Array(arrInfo) = typ else {
        throw LowerError::ExpectedArray;

}

/// Lower an array repeat literal expression like `[42; 3]`.
/// Unrolls the initialization at compile time.
// TODO: Beyond a certain length, lower this to a loop.
fn lowerArrayRepeatLit(self: *mut FnLowerer, node: *ast::Node, repeat: ast::ArrayRepeatLit) -> il::Val
unsafe fn lowerArrayRepeatLit(self: &mut FnLowerer, node: *ast::Node, repeat: ast::ArrayRepeatLit) -> 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(...)`.
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: *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;

    }
    return try buildTagged(self, resolver::getTypeLayout(unionTy), index as i64, payloadVal, payloadType, 1, valOffset);
}

/// Lower a field access into a pointer to the field.
fn lowerFieldRef(self: *mut FnLowerer, access: ast::Access) -> FieldRef throws (LowerError) {
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;
    };

        fieldType: fieldInfo.fieldType,
    };
}

/// Lower a field access expression.
fn lowerFieldAccess(self: *mut FnLowerer, access: ast::Access) -> il::Val throws (LowerError) {
unsafe fn lowerFieldAccess(self: &mut FnLowerer, access: ast::Access) -> il::Val throws (LowerError) {
    let fieldRef = try lowerFieldRef(self, access);
    return emitRead(self, fieldRef.base, fieldRef.offset, fieldRef.fieldType);
}

/// Compute data pointer and element count for a range into a container.
/// Used by both slice range expressions (`&a[start..end]`) and slice
/// assignments (`a[start..end] = value`).
fn resolveSliceRangePtr(
    self: *mut FnLowerer,
unsafe fn resolveSliceRangePtr(
    self: &mut FnLowerer,
    container: *ast::Node,
    range: ast::Range,
    info: resolver::SliceRangeInfo
) -> SliceRangeResult throws (LowerError) {
    let baseVal = try lowerExpr(self, container);

    }
    return SliceRangeResult { dataReg, count };
}

/// Lower a slice range expression into a slice header value.
fn lowerSliceRange(
    self: *mut FnLowerer,
unsafe fn lowerSliceRange(
    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
    );
}

/// Lower an address-of (`&x`) expression.
fn lowerAddressOf(self: *mut FnLowerer, node: *ast::Node, addr: ast::AddressOf) -> il::Val throws (LowerError) {
unsafe fn lowerAddressOf(self: &mut FnLowerer, node: *ast::Node, addr: ast::AddressOf) -> il::Val throws (LowerError) {
    // Handle subscript: `&ary[i]` or `&ary[start..end]`.
    if let case ast::NodeValue::Subscript { container, index } = addr.target.value {
        if let case ast::NodeValue::Range(range) = index.value {
            return try lowerSliceRange(self, container, range, node);
        }

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

    }
    throw LowerError::UnexpectedNodeValue(addr.target);
}

/// Lower an addressed array literal as a slice.
fn lowerArrayLiteralSlice(
    self: *mut FnLowerer,
unsafe fn lowerArrayLiteralSlice(
    self: &mut FnLowerer,
    sliceNode: *ast::Node,
    arrayNode: *ast::Node
) -> il::Val throws (LowerError) {
    let sliceTy = try typeOf(self, sliceNode);
    let case resolver::Type::Slice { item, mutable, .. } = sliceTy else {
        throw LowerError::UnexpectedType(&sliceTy);
        throw LowerError::UnexpectedType(sliceTy);
    };
    let arrayTy = try typeOf(self, arrayNode);
    let case resolver::Type::Array(arrayInfo) = arrayTy else {
        throw LowerError::ExpectedArray;
    };

    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(self.low, elements, arrayTy, self.fnName, &mut b),
                try lowerConstArrayLitInto(&mut *self.low, elements, arrayTy, fnName, &mut b),
            case ast::NodeValue::ArrayRepeatLit(repeat) =>
                try lowerConstArrayRepeatInto(self.low, repeat, arrayTy, self.fnName, &mut b),
                try lowerConstArrayRepeatInto(&mut *self.low, repeat, arrayTy, fnName, &mut b),
            else => throw LowerError::UnexpectedNodeValue(arrayNode),
        }
        let result = dataBuilderFinish(&b);
        let alignment = resolver::getTypeLayout(*item).alignment;
        return try lowerConstDataAsSlice(


/// Lower the common element pointer computation for subscript operations.
/// Handles both arrays and slices by resolving the container type, extracting
/// the data pointer (for slices), and emitting an [`il::Instr::Elem`] to compute
/// the element address.
fn lowerElemPtr(
    self: *mut FnLowerer, container: *ast::Node, index: *ast::Node
unsafe fn lowerElemPtr(
    self: &mut FnLowerer, container: *ast::Node, index: *ast::Node
) -> ElemPtrResult throws (LowerError) {
    let containerTy = try typeOf(self, container);
    let subjectTy = resolver::autoDeref(containerTy);
    let baseVal = try lowerExpr(self, container);
    let indexVal = try lowerExpr(self, index);

        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,

}

/// Lower a dereference expression.
/// Handles both pointer deref (`*ptr`) and record deref (`*r` on single-field
/// unlabeled record). Both read at offset 0 using the resolver-assigned type.
fn lowerDeref(self: *mut FnLowerer, node: *ast::Node, target: *ast::Node) -> il::Val throws (LowerError) {
unsafe fn lowerDeref(self: &mut FnLowerer, node: *ast::Node, target: *ast::Node) -> il::Val throws (LowerError) {
    let type = try typeOf(self, node);
    let ptrVal = try lowerExpr(self, target);
    let ptrReg = emitValToReg(self, ptrVal);

    return emitRead(self, ptrReg, 0, type);
}

/// Lower a subscript expression.
fn lowerSubscript(self: *mut FnLowerer, node: *ast::Node, container: *ast::Node, index: *ast::Node) -> il::Val
unsafe fn lowerSubscript(self: &mut FnLowerer, node: *ast::Node, container: *ast::Node, index: *ast::Node) -> il::Val
    throws (LowerError)
{
    if let case ast::NodeValue::Range(_) = index.value {
        panic "lowerSubscript: range subscript must use address-of (&)";
    }


    return emitRead(self, result.elemReg, 0, result.elemType);
}

/// Lower a let binding.
fn lowerLet(self: *mut FnLowerer, node: *ast::Node, l: ast::Let) throws (LowerError) {
unsafe fn lowerLet(self: &mut FnLowerer, node: *ast::Node, l: ast::Let) throws (LowerError) {
    // Evaluate value.
    let val = try lowerExpr(self, l.value);
    // Handle placeholder pattern: `let _ = expr;`
    if let case ast::NodeValue::Placeholder = l.ident.value {
        return;
    }
    let case ast::NodeValue::Ident(name) = l.ident.value else {
        throw LowerError::ExpectedIdentifier;
    };
    let typ = try typeOf(self, l.value);
    let ilType = ilType(self.low, typ);
    let ilType = ilType(&mut *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;

///
///     @entry -> (true)  @then ---> @end <--.
///         |                                 )
///         `---- (false) -------------------'
///
fn lowerIf(self: *mut FnLowerer, i: ast::If) throws (LowerError) {
unsafe fn lowerIf(self: &mut FnLowerer, i: ast::If) throws (LowerError) {
    let thenBlock = try createBlock(self, "then");

    if let elseNode = i.elseBranch { // If-else case.
        let elseBlock = try createBlock(self, "else");
        try emitCondBranch(self, i.condition, thenBlock, elseBlock);

}

/// Lower an assignment target that designates a memory location, and return
/// the address to store through. Returns `nil` without emitting anything for
/// targets that aren't memory-backed, such as locals tracked in SSA.
fn lowerPlace(self: *mut FnLowerer, target: *ast::Node) -> ?FieldRef throws (LowerError) {
unsafe fn lowerPlace(self: &mut FnLowerer, target: *ast::Node) -> ?FieldRef throws (LowerError) {
    match target.value {
        case ast::NodeValue::FieldAccess(access) => {
            return try lowerFieldRef(self, access);
        }
        case ast::NodeValue::Deref(pointer) => {

/// whether it was handled. Nothing is emitted when it isn't.
///
/// Compound assignments share their target node with the left operand of the
/// desugared binary expression. Resolve that place once so side effects in a
/// dereference, field parent, or subscript index are not repeated for the store.
fn lowerCompoundAssign(
    self: *mut FnLowerer, expr: *ast::Node, binop: ast::BinOp
unsafe fn lowerCompoundAssign(
    self: &mut FnLowerer, expr: *ast::Node, binop: ast::BinOp
) -> bool throws (LowerError) {
    let place = try lowerPlace(self, binop.left) else return false;
    let current = emitRead(self, place.base, place.offset, place.fieldType);
    let left = try applyCoercion(self, binop.left, current);
    let right = try lowerExpr(self, binop.right);
    let exprType = try typeOf(self, expr);
    let result = emitScalarBinOp(
        self, binop.op, ilType(self.low, exprType), left, right, isUnsignedType(exprType)
        self, binop.op, ilType(&mut *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.
fn lowerAssign(self: *mut FnLowerer, node: *ast::Node, a: ast::Assign) throws (LowerError) {
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 `slice[range] = value`.
fn lowerSliceAssign(
    self: *mut FnLowerer,
unsafe fn lowerSliceAssign(
    self: &mut FnLowerer,
    rhs: *ast::Node,
    container: *ast::Node,
    range: ast::Range,
    info: resolver::SliceRangeInfo
) throws (LowerError) {

        try emitFillLoop(self, r.dataReg, fillVal, r.count, *info.itemType, elemSize);
    }
}

/// Emit a typed fill loop: `for i in 0..count { dst[i * stride] = value; }`.
fn emitFillLoop(
    self: *mut FnLowerer,
unsafe fn emitFillLoop(
    self: &mut FnLowerer,
    dst: il::Reg,
    value: il::Val,
    count: il::Val,
    elemType: resolver::Type,
    elemSize: u32

///
///   @entry -> @loop -> @loop
///               |
///               `----> @end
///
fn lowerLoop(self: *mut FnLowerer, body: *ast::Node) throws (LowerError) {
unsafe fn lowerLoop(self: &mut FnLowerer, body: *ast::Node) throws (LowerError) {
    let loopBlock = try createBlock(self, "loop");
    let endBlock = try createBlock(self, "merge");

    // Enter the loop with the given break and continue targets.
    // `break` jumps to `endBlock`,

///
///   @entry -> @loop -> (true)  @body -> @loop
///               |
///               `----> (false) @end
///
fn lowerWhile(self: *mut FnLowerer, w: ast::While) throws (LowerError) {
unsafe fn lowerWhile(self: &mut FnLowerer, w: ast::While) throws (LowerError) {
    let whileBlock = try createBlock(self, "while");
    let bodyBlock = try createBlock(self, "body");
    let endBlock = try createBlock(self, "merge");

    enterLoop(self, endBlock, whileBlock);

    try switchToAndSeal(self, endBlock);
    exitLoop(self);
}

/// Emit an increment of a variable by `1`.
fn emitIncrement(self: *mut FnLowerer, v: Var, typ: il::Type) throws (LowerError) {
unsafe fn emitIncrement(self: &mut FnLowerer, v: Var, typ: il::Type) throws (LowerError) {
    let cur = try useVar(self, v);
    let next = nextReg(self);

    emit(self, il::Instr::BinOp { op: il::BinOp::Add, typ, dst: next, a: cur, b: il::Val::Imm(1) });
    defVar(self, v, il::Val::Reg(next));

/// The step block is created lazily (after the loop body) so that it gets
/// a block index higher than all body blocks. This ensures the register
/// allocator processes definitions before uses in forward block order,
/// avoiding stale assignments when a value defined deep in the body flows
/// through the step block as a block argument.
fn lowerForLoop(self: *mut FnLowerer, iter: *ForIter, body: *ast::Node) throws (LowerError) {
unsafe fn lowerForLoop(self: &mut FnLowerer, iter: &ForIter, body: *ast::Node) throws (LowerError) {
    let loopBlock = try createBlock(self, "loop");
    let bodyBlock = try createBlock(self, "body");
    let endBlock = try createBlock(self, "merge");

    enterLoop(self, endBlock, nil);


    switchToBlock(self, endBlock);
}

/// Lower a `for` loop over a range, array, or slice.
fn lowerFor(self: *mut FnLowerer, node: *ast::Node, f: ast::For) throws (LowerError) {
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(self.low, *valType);
            let iterType = ilType(&mut *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(self.low, *elemType),
                    ilType(&mut *self.low, *elemType),
                    false,
                    il::Val::Undef
                );
            }
            let iter = ForIter::Collection { valVar, idxVar, dataReg, lengthVal, elemType };

    }
    exitVarScope(self, savedVarsLen);
}

/// Lower a break statement.
fn lowerBreak(self: *mut FnLowerer) throws (LowerError) {
unsafe fn lowerBreak(self: &mut FnLowerer) throws (LowerError) {
    let ctx = currentLoop(self) else {
        throw LowerError::OutsideOfLoop;
    };
    try emitJmp(self, ctx.breakTarget);
}

/// Lower a continue statement.
fn lowerContinue(self: *mut FnLowerer) throws (LowerError) {
unsafe fn lowerContinue(self: &mut FnLowerer) throws (LowerError) {
    let block = try getOrCreateContinueBlock(self);
    try emitJmp(self, block);
}

/// Emit a return, blitting into the caller's return buffer if needed.
///
/// When the function has a return buffer parameter, the value is blitted
/// into the buffer and the buffer pointer is returned. Otherwise, the value is
/// returned directly.
fn emitRetVal(self: *mut FnLowerer, val: il::Val) throws (LowerError) {
unsafe fn emitRetVal(self: &mut FnLowerer, val: il::Val) throws (LowerError) {
    if let retReg = self.returnReg {
        let src = emitValToReg(self, val);
        let size = resolver::getResultLayout(*self.fnType.returnType, self.fnType.throwList).size
            if self.fnType.throwList.len > 0
            else resolver::getTypeLayout(*self.fnType.returnType).size;

        emit(self, il::Instr::Ret { val });
    }
}

/// Lower a return statement.
fn lowerReturnStmt(self: *mut FnLowerer, node: *ast::Node, value: ?*ast::Node) throws (LowerError) {
unsafe fn lowerReturnStmt(self: &mut FnLowerer, node: *ast::Node, value: ?*ast::Node) throws (LowerError) {
    let mut val = il::Val::Undef;
    if let expr = value {
        set val = try lowerExpr(self, expr);
    }
    set val = try applyCoercion(self, node, val);
    try emitRetVal(self, val);
}

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

    try emitRetVal(self, resultVal);
}

/// Ensure a value is in a register (eg. for branch conditions).
fn emitValToReg(self: *mut FnLowerer, val: il::Val) -> il::Reg {
unsafe fn emitValToReg(self: &mut FnLowerer, val: il::Val) -> il::Reg {
    match val {
        case il::Val::Reg(r) => return r,
        case il::Val::Imm(_), il::Val::DataSym(_), il::Val::FnAddr(_) => {
            let dst = nextReg(self);
            emit(self, il::Instr::Copy { dst, val });

///       // ...
///       jmp @end(%b);
///     @end(w8 %result)
///       ret %result;
///
fn lowerLogicalOp(
    self: *mut FnLowerer,
unsafe fn lowerLogicalOp(
    self: &mut FnLowerer,
    binop: ast::BinOp,
    thenLabel: *[u8],
    elseLabel: *[u8],
    mergeLabel: *[u8],
    op: LogicalOp

    try switchToAndSeal(self, mergeBlock);
    return il::Val::Reg(resultReg);
}

/// Lower a conditional expression (`thenExpr if condition else elseExpr`).
fn lowerCondExpr(self: *mut FnLowerer, node: *ast::Node, cond: ast::CondExpr) -> il::Val
unsafe fn lowerCondExpr(self: &mut FnLowerer, node: *ast::Node, cond: ast::CondExpr) -> il::Val
    throws (LowerError)
{
    let typ = try typeOf(self, node);
    let thenBlock = try createBlock(self, "cond#then");
    let elseBlock = try createBlock(self, "cond#else");


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

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

        else => return nil,
    }
}

/// Lower a binary operation.
fn lowerBinOp(self: *mut FnLowerer, node: *ast::Node, binop: ast::BinOp) -> il::Val throws (LowerError) {
unsafe fn lowerBinOp(self: &mut FnLowerer, node: *ast::Node, binop: ast::BinOp) -> il::Val throws (LowerError) {
    // Short-circuit logical operators don't evaluate both operands eagerly.
    if binop.op == ast::BinaryOp::And {
        return try lowerLogicalOp(self, binop, "and#then", "and#else", "and#end", LogicalOp::And);
    } else if binop.op == ast::BinaryOp::Or {
        return try lowerLogicalOp(self, binop, "or#then", "or#else", "or#end", LogicalOp::Or);


    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(self.low, resultTy), a, b, isUnsignedType(resultTy));
    return emitScalarBinOp(self, binop.op, ilType(&mut *self.low, resultTy), a, b, isUnsignedType(resultTy));
}

/// Emit an aggregate equality or inequality comparison.
fn emitAggregateEqOp(
    self: *mut FnLowerer,
unsafe fn emitAggregateEqOp(
    self: &mut FnLowerer,
    op: ast::BinaryOp,
    typ: resolver::Type,
    a: il::Val,
    b: il::Val
) -> il::Val throws (LowerError) {

    }
    return result;
}

/// Emit a scalar binary operation instruction.
fn emitScalarBinOp(
    self: *mut FnLowerer,
unsafe fn emitScalarBinOp(
    self: &mut FnLowerer,
    op: ast::BinaryOp,
    typ: il::Type,
    a: il::Val,
    b: il::Val,
    unsigned: bool

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

/// Normalize sub-word values to well-defined high bits.
fn normalizeSubword(self: *mut FnLowerer, typ: il::Type, unsigned: bool, val: il::Val) -> il::Val {
unsafe fn normalizeSubword(self: &mut FnLowerer, typ: il::Type, unsigned: bool, val: il::Val) -> il::Val {
    if typ == il::Type::W8 or typ == il::Type::W16 {
        let extDst: il::Reg = nextReg(self);
        if unsigned {
            emit(self, il::Instr::Zext { typ, dst: extDst, val });
        } else {

    }
    return val;
}

/// Lower a unary operation.
fn lowerUnOp(self: *mut FnLowerer, node: *ast::Node, unop: ast::UnOp) -> il::Val throws (LowerError) {
unsafe fn lowerUnOp(self: &mut FnLowerer, node: *ast::Node, unop: ast::UnOp) -> il::Val throws (LowerError) {
    if unop.op == ast::UnaryOp::Neg {
        if let case ast::NodeValue::Number(lit) = unop.value.value {
            return il::Val::Imm((0 - lit.magnitude) as i64);
        }
    }
    let val = try lowerExpr(self, unop.value);
    let t = try typeOf(self, node);
    let typ = ilType(self.low, t);
    let typ = ilType(&mut *self.low, t);
    let dst = nextReg(self);
    let mut needsExt: bool = false;

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

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

/// Lower a cast expression (`x as T`).
fn lowerCast(self: *mut FnLowerer, node: *ast::Node, cast: ast::As) -> il::Val throws (LowerError) {
unsafe fn lowerCast(self: &mut FnLowerer, node: *ast::Node, cast: ast::As) -> il::Val throws (LowerError) {
    let val = try lowerExpr(self, cast.value);

    let srcType = try typeOf(self, cast.value);
    let dstType = try typeOf(self, node);
    if resolver::typesEqual(srcType, dstType) {


/// Lower a string literal to a slice value.
///
/// String literals are stored as global data and the result is a slice
/// pointing to the data with the appropriate length.
fn lowerStringLit(self: *mut FnLowerer, node: *ast::Node, s: *[u8]) -> il::Val throws (LowerError) {
unsafe fn lowerStringLit(self: &mut FnLowerer, node: *ast::Node, s: *[u8]) -> il::Val throws (LowerError) {
    // Get the slice type from the node.
    let sliceTy = try typeOf(self, node);
    let case resolver::Type::Slice { item, mutable, .. } = sliceTy
        else throw LowerError::ExpectedSliceOrArray;
    // Build the string data value.
    let ptr = try! alloc::alloc(
        self.low.arena, @sizeOf(il::DataValue), @alignOf(il::DataValue)
        &mut *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.
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: *mut [*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.
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: *mut [*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

    }
    return try buildSliceValue(self, item, mutable, ptrVal, lenVal, capVal);
}

/// Lower a `try` expression.
fn lowerTry(self: *mut FnLowerer, node: *ast::Node, t: ast::Try) -> il::Val throws (LowerError) {
unsafe fn lowerTry(self: &mut FnLowerer, node: *ast::Node, t: ast::Try) -> il::Val throws (LowerError) {
    let case ast::NodeValue::Call(callExpr) = t.expr.value else {
        throw LowerError::ExpectedCall;
    };
    let calleeTy = try typeOf(self, callExpr.callee);
    let case resolver::Type::Fn(calleeInfo) = calleeTy else {

    // Type of the try expression, which is either the return type of the function
    // if successful, or an optional of it, if using `try?`.
    let tryExprTy = try typeOf(self, node);
    // Check for trait method dispatch or standalone method call.
    let mut resVal: il::Val = undefined;
    let 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(self.low, errTy), false, errVal);
                let _ = newVar(self, name, ilType(&mut *self.low, errTy), false, errVal);
            }
            try lowerBlock(self, first.body);
            try emitMergeIfUnterminated(self, &mut mergeBlock);
            exitVarScope(self, savedVarsLen);
        }

/// Lower typed multi-catch clauses.
///
/// Emits a switch on the global error tag to dispatch to the correct catch
/// clause. Each typed clause extracts the error payload for its specific type
/// and binds it to the clause's identifier.
fn lowerMultiCatch(
    self: *mut FnLowerer,
unsafe fn lowerMultiCatch(
    self: &mut FnLowerer,
    catches: *mut [*ast::Node],
    calleeInfo: *resolver::FnType,
    base: il::Reg,
    tagReg: il::Reg,
    mergeBlock: *mut ?BlockId
    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;

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

            cases.append(il::SwitchCase {
                value: getOrAssignErrorTag(self.low, errTy) as i64,
                value: getOrAssignErrorTag(&mut *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(self.low, errTy), false, errVal);
            newVar(self, name, ilType(&mut *self.low, errTy), false, errVal);
        }
        try lowerBlock(self, clause.body);
        try emitMergeIfUnterminated(self, mergeBlock);

        exitVarScope(self, savedVarsLen);

/// Emit a byte-copy loop: `for i in 0..size { dst[i] = src[i]; }`.
///
/// Used when `blit` cannot be used because the copy size is dynamic.
/// Terminates the current block and leaves the builder positioned
/// after the loop.
fn emitByteCopyLoop(
    self: *mut FnLowerer,
unsafe fn emitByteCopyLoop(
    self: &mut FnLowerer,
    dst: il::Reg,
    src: il::Reg,
    size: il::Val,
    label: *[u8]
) throws (LowerError) {

///
///     @store:
///       store element at ptr + len * stride
///       increment len
///
fn lowerSliceAppend(self: *mut FnLowerer, call: ast::Call, elemType: *resolver::Type) -> il::Val throws (LowerError) {
unsafe fn lowerSliceAppend(self: &mut FnLowerer, call: ast::Call, elemType: *resolver::Type) -> il::Val throws (LowerError) {
    let case ast::NodeValue::FieldAccess(access) = call.callee.value
        else throw LowerError::MissingMetadata;

    // Get the address of the slice header.
    let sliceVal = try lowerExpr(self, access.parent);


/// Lower `slice.delete(index)`.
///
/// Bounds-check the index, shift elements after it by one stride
/// via a byte-copy loop, and decrement `len`.
fn lowerSliceDelete(self: *mut FnLowerer, call: ast::Call, elemType: *resolver::Type) throws (LowerError) {
unsafe fn lowerSliceDelete(self: &mut FnLowerer, call: ast::Call, elemType: *resolver::Type) throws (LowerError) {
    let case ast::NodeValue::FieldAccess(access) = call.callee.value
        else throw LowerError::MissingMetadata;

    let elemLayout = resolver::getTypeLayout(*elemType);
    let stride = elemLayout.size;


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

/// Lower a call expression, which may be a function call or type constructor.
fn lowerCallOrCtor(self: *mut FnLowerer, node: *ast::Node, call: ast::Call) -> il::Val throws (LowerError) {
    let nodeData = resolver::nodeData(self.low.resolver, node).extra;
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;

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

///     load w64 %data %obj 0          // data pointer
///     load w64 %vtable %obj 8        // v-table pointer
///     load w64 %fn %vtable <slot>    // function pointer
///     call <retTy> %ret %fn(%data, args...)
///
fn lowerTraitMethodCall(
    self: *mut FnLowerer,
unsafe fn lowerTraitMethodCall(
    self: &mut FnLowerer,
    node: *ast::Node,
    call: ast::Call,
    traitInfo: *resolver::TraitType,
    methodIndex: u32
) -> il::Val throws (LowerError) {


/// Lower a call argument, snapshotting aggregate place expressions before
/// evaluating later arguments. Aggregates are represented by addresses in the
/// IL, so retaining the original address would let a later argument mutation
/// change the value already supplied for this argument.
fn lowerCallArg(self: *mut FnLowerer, arg: *ast::Node, hasLater: bool) -> il::Val
unsafe fn lowerCallArg(self: &mut FnLowerer, arg: *ast::Node, hasLater: bool) -> il::Val
    throws (LowerError)
{
    let val = try lowerExpr(self, arg);

    if hasLater and ast::isPlaceExpr(arg) {

///
/// All call lowering paths (regular, trait method, standalone method) converge
/// here after preparing the callee value, function type, and argument array.
/// The `args` slice must already include a slot at index zero for the hidden
/// return parameter; that slot is filled by this function.
fn emitCallValue(
    self: *mut FnLowerer,
unsafe fn emitCallValue(
    self: &mut FnLowerer,
    callee: il::Val,
    fnInfo: *resolver::FnType,
    args: *mut [il::Val],
) -> il::Val throws (LowerError) {
    let retTy = *fnInfo.returnType;

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



/// Lower a method receiver expression to a pointer value.
///
/// If the parent is already a pointer type, the value is used directly.
/// If the parent is a value type (eg. a local record), its address is taken.
fn lowerReceiver(self: *mut FnLowerer, parent: *ast::Node, parentTy: resolver::Type) -> il::Val
unsafe fn lowerReceiver(self: &mut FnLowerer, parent: *ast::Node, parentTy: resolver::Type) -> il::Val
    throws (LowerError)
{
    if let case resolver::Type::Pointer { .. } = parentTy {
        // Already a pointer: lower and use directly.
        return try lowerExpr(self, parent);

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

/// Given `obj.method(args)` where `method` is a standalone method on a concrete type,
/// emits a direct call with the receiver address as the first argument:
///
///     call <retTy> %ret @Type::method(&obj, args...)
///
fn lowerMethodCall(
    self: *mut FnLowerer,
unsafe fn lowerMethodCall(
    self: &mut FnLowerer,
    node: *ast::Node,
    call: ast::Call,
    method: *resolver::MethodEntry,
    method: &resolver::MethodEntry,
) -> il::Val throws (LowerError) {
    let case ast::NodeValue::FieldAccess(access) = call.callee.value
        else throw LowerError::MissingMetadata;

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

    let qualName = instanceMethodName(self.low, nil, method.concreteTypeName, method.name);
    let qualName = instanceMethodName(&mut *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;

    }
    return try emitCallValue(self, il::Val::FnAddr(qualName), fnInfo, args);
}

/// Check if a call is to a compiler intrinsic and lower it directly.
fn lowerIntrinsicCall(self: *mut FnLowerer, call: ast::Call) -> ?il::Val throws (LowerError) {
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;

        throw LowerError::UnknownIntrinsic;
    }
}

/// Lower an ecall intrinsic: `ecall(num, a0, a1, a2, a3) -> i32`.
fn lowerEcall(self: *mut FnLowerer, call: ast::Call) -> il::Val throws (LowerError) {
unsafe fn lowerEcall(self: &mut FnLowerer, call: ast::Call) -> il::Val throws (LowerError) {
    if call.args.len <> 5 {
        throw LowerError::InvalidArgCount;
    }
    let num = try lowerExpr(self, call.args[0]);
    let a0 = try lowerExpr(self, call.args[1]);


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

/// Lower an ebreak intrinsic: `ebreak()`.
fn lowerEbreak(self: *mut FnLowerer, call: ast::Call) -> il::Val throws (LowerError) {
unsafe fn lowerEbreak(self: &mut FnLowerer, call: ast::Call) -> il::Val throws (LowerError) {
    if call.args.len <> 0 {
        throw LowerError::InvalidArgCount;
    }
    emit(self, il::Instr::Ebreak);

    return il::Val::Undef;
}

/// Lower `memoryFence()`.
fn lowerMemoryFence(self: *mut FnLowerer, call: ast::Call) -> il::Val throws (LowerError) {
unsafe fn lowerMemoryFence(self: &mut FnLowerer, call: ast::Call) -> il::Val throws (LowerError) {
    if call.args.len <> 0 {
        throw LowerError::InvalidArgCount;
    }
    emit(self, il::Instr::MemoryFence);
    return il::Val::Undef;
}

/// Resolve callee to an IL value. For direct function calls, use the symbol name.
/// For variables holding function pointers or complex expressions (eg. `array[i]()`),
/// lower the callee expression.
fn lowerCallee(self: *mut FnLowerer, callee: *ast::Node) -> il::Val throws (LowerError) {
    if let sym = resolver::nodeData(self.low.resolver, callee).sym {
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 case ast::NodeValue::FnDecl(_) = sym.node.value {
            // First try to look up the symbol in our registered functions.
            // This handles cross-package calls correctly, since packages are
            // lowered in dependency order.
            if let qualName = lookupFnSym(self.low, sym) {
            if let qualName = lookupFnSym(&mut *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(self.low, modId, sym.name));
            return il::Val::FnAddr(qualifyName(&mut *self.low, modId, sym.name));
        }
    }
    return try lowerExpr(self, callee);
}

/// Lower a function call expression.
fn lowerCall(self: *mut FnLowerer, node: *ast::Node, call: ast::Call) -> il::Val throws (LowerError) {
unsafe fn lowerCall(self: &mut FnLowerer, node: *ast::Node, call: ast::Call) -> il::Val throws (LowerError) {
    // Check for intrinsic calls before normal call lowering.
    if let intrinsicVal = try lowerIntrinsicCall(self, call) {
        return intrinsicVal;
    }
    let calleeTy = try typeOf(self, call.callee);


    return try emitCallValue(self, callee, fnInfo, args);
}

/// Apply coercions requested by the resolver.
fn applyCoercion(self: *mut FnLowerer, node: *ast::Node, val: il::Val) -> il::Val throws (LowerError) {
    let coerce = resolver::coercionFor(self.low.resolver, node) else {
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 {
        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,
    }
}

/// Lower an implicit numeric cast coercion.
///
/// Handles widening conversions between integer types. Uses sign-extension
/// for signed source types and zero-extension for unsigned source types.
fn lowerNumericCast(self: *mut FnLowerer, val: il::Val, srcType: resolver::Type, dstType: resolver::Type) -> il::Val {
unsafe fn lowerNumericCast(self: &mut FnLowerer, val: il::Val, srcType: resolver::Type, dstType: resolver::Type) -> il::Val {
    let srcLayout = resolver::getTypeLayout(srcType);
    let dstLayout = resolver::getTypeLayout(dstType);

    if srcLayout.size == dstLayout.size {
        // Same size: bit pattern is unchanged, value is returned as-is.
        return val;
    }
    // Widening: extend based on source signedness.
    // Narrowing: truncate and normalize to destination width.
    let widening = srcLayout.size < dstLayout.size;
    let extType = ilType(self.low, srcType) if widening else ilType(self.low, dstType);
    let extType = ilType(&mut *self.low, srcType) if widening else ilType(&mut *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.
fn lowerGlobalValue(self: *mut FnLowerer, sym: *resolver::Symbol, ty: resolver::Type) -> il::Val {
unsafe fn lowerGlobalValue(self: &mut FnLowerer, sym: *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));
    }


    return emitRead(self, src, 0, ty);
}

/// Lower an identifier that refers to a global symbol.
fn lowerGlobalSymbol(self: *mut FnLowerer, node: *ast::Node) -> il::Val throws (LowerError) {
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);


        else => throw LowerError::UnexpectedNodeValue(node),
    }
}

/// Lower an assignment to a static variable.
fn lowerStaticAssign(self: *mut FnLowerer, target: *ast::Node, val: il::Val) throws (LowerError) {
unsafe fn lowerStaticAssign(self: &mut FnLowerer, target: *ast::Node, val: il::Val) throws (LowerError) {
    let sym = try symOf(self, target);
    let case resolver::SymbolData::Value { type, .. } = sym.data else {
        throw LowerError::ImmutableAssignment;
    };
    let dst = emitDataAddr(self, sym);

    try emitStore(self, dst, 0, type, val);
}

/// Lower a scope access expression like `Module::Const` or `Union::Variant`.
/// This doesn't handle record literal variants.
fn lowerScopeAccess(self: *mut FnLowerer, node: *ast::Node) -> il::Val throws (LowerError) {
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);

    }
}

/// Lower an expression AST node to an IL value.
/// This is the main expression dispatch, all expression nodes go through here.
fn lowerExpr(self: *mut FnLowerer, node: *ast::Node) -> il::Val throws (LowerError) {
unsafe fn lowerExpr(self: &mut FnLowerer, node: *ast::Node) -> il::Val throws (LowerError) {
    if self.low.options.debug {
        set self.srcLoc.offset = node.span.offset;
    }
    let mut val: il::Val = undefined;


        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(self.low, node, decl.value, true);
            try lowerDataDecl(&mut *self.low, node, decl.value, true);
            set val = il::Val::Undef;
        }
        case ast::NodeValue::StaticDecl(decl) => {
            try registerLocalDataDeclName(self, node);
            try lowerDataDecl(self.low, node, decl.value, false);
            try lowerDataDecl(&mut *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 {
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 +30 -26

    source: ?*[u8],
}

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

/// Initialize an empty module graph backed by the provided storage.
export fn moduleGraph(
/// The AST arena must outlive the returned graph.
export unsafe fn moduleGraph(
    storage: *mut [ModuleEntry],
    pool: *mut strings::Pool,
    arena: *mut ast::NodeArena
    arena: &mut ast::NodeArena
) -> ModuleGraph {
    return ModuleGraph {
        entries: storage,
        entriesLen: 0,
        pool,
        arena,
        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, packageId: u16, filePath: *[u8]) -> u16 throws (ModuleError) {
    let name = try basenameSlice(filePath);
    return try registerRootWithName(graph, 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,
    packageId: u16,
    name: *[u8],
    filePath: *[u8]
) -> u16 throws (ModuleError) {
    let m = try allocModule(graph, packageId, name, filePath);

}

/// Register a child module.
/// Returns the module identifier.
export fn registerChild(
    graph: *mut ModuleGraph,
    graph: &mut ModuleGraph,
    parentId: u16,
    name: *[u8],
    filePath: *[u8]
) -> u16 throws (ModuleError) {
    assert name.len > 0, "registerChild: name must not be empty";


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

/// Fetch a read-only view of the module identified by `id`.
export fn get(graph: *ModuleGraph, id: u16) -> ?*ModuleEntry {
export fn get(graph: &ModuleGraph, id: u16) -> ?*ModuleEntry {
    if not isValidId(graph, id) {
        return nil;
    }
    return &graph.entries[id as u32];
}

/// Access a mutable entry by identifier.
fn getMut(graph: *mut ModuleGraph, id: u16) -> ?*mut ModuleEntry {
fn getMut(graph: &mut ModuleGraph, id: u16) -> ?*mut ModuleEntry {
    if not isValidId(graph, id) {
        return nil;
    }
    return &mut graph.entries[id as u32];
}

    assert m.pathDepth > 0, "moduleQualifiedPath: path must not be empty";
    return &m.path[..m.pathDepth];
}

/// Retrieve the lifecycle state for `id`.
export fn state(graph: *ModuleGraph, id: u16) -> ModuleState throws (ModuleError) {
export fn state(graph: &ModuleGraph, id: u16) -> ModuleState throws (ModuleError) {
    let m = get(graph, id) else {
        throw ModuleError::NotFound(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: *mut ast::Node) throws (ModuleError) {
    let m = getMut(graph, id) else throw ModuleError::NotFound(id);
    set m.ast = root;
    set m.state = ModuleState::Parsed;
}

/// Set the source text for a module.
export fn setSource(graph: *mut ModuleGraph, id: u16, source: *[u8]) throws (ModuleError) {
export fn setSource(graph: &mut ModuleGraph, id: u16, source: *[u8]) throws (ModuleError) {
    let m = getMut(graph, id) else throw ModuleError::NotFound(id);
    set m.source = source;
}

/// Look up a child module by name under the given parent.
export fn findChild(graph: *ModuleGraph, name: *[u8], parentId: u16) -> ?*ModuleEntry {
export fn findChild(graph: &ModuleGraph, name: *[u8], parentId: u16) -> ?*ModuleEntry {
    assert isValidId(graph, parentId), "findChild: parent identifier is valid";

    let parent = &graph.entries[parentId as u32];
    for i in 0..parent.childrenLen {
        let childId = parent.children[i];

}

/// Parse a file path into components by splitting on '/'.
/// Expects and removes the '.rad' extension from the last component.
/// Returns the number of components extracted, or `nil` if the path is invalid.
export fn parsePath(filePath: *[u8], components: *mut [*[u8]]) -> ?u32 {
export fn parsePath(filePath: *[u8], components: &mut [*[u8]]) -> ?u32 {
    let mut count: u32 = 0;
    let mut last: u32 = 0;

    // Split on '/' to extract all but the last component.
    for i in 0..filePath.len {


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

        throw ModuleError::InvalidPath;
    }

    // Strip the root's qualified path from the parsed components.
    let rootPath = moduleQualifiedPath(rootEntry);
    let childPath = stripPathPrefix(rootPath, &parts[..partsLen]) else {
    let prefixLen = stripPathPrefix(rootPath, &parts[..partsLen]) else {
        throw ModuleError::InvalidPath;
    };
    if childPath.len == 0 {
    if prefixLen == partsLen {
        throw ModuleError::InvalidPath;
    }
    let childName = childPath[childPath.len - 1];
    let childName = parts[partsLen - 1];

    // Navigate through all but the last segment to find the parent.
    let mut parentId = root;
    for part in &childPath[..childPath.len - 1] {
    for part in &parts[prefixLen..partsLen - 1] {
        let child = findChild(graph, part, parentId) else {
            throw ModuleError::MissingParent;
        };
        set parentId = child.id;
    }
    return try registerChild(graph, 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, 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;


    return childId;
}

/// Check if `id` points at an allocated entry.
fn isValidId(graph: *ModuleGraph, id: u16) -> bool {
fn isValidId(graph: &ModuleGraph, id: u16) -> bool {
    return (id as u32) < graph.entriesLen;
}

/// Return the length of the directory prefix for `path`.
/// Return zero if the path has no separator.

        }
    }
    return &path[..extStart];
}

/// Strip prefix from path, and return the suffix.
fn stripPathPrefix(prefix: *[*[u8]], path: *[*[u8]]) -> ?*[*[u8]] {
/// Check a path prefix and return its segment count.
fn stripPathPrefix(prefix: &[*[u8]], path: &[*[u8]]) -> ?u32 {
    if prefix.len == 0 {
        return path;
        return 0;
    }
    if prefix.len > path.len {
        return nil;
    }
    for segment, i in prefix {
        if not mem::eq(segment, path[i]) {
            return nil;
        }
    }
    return &path[prefix.len..];
    return prefix.len;
}

lib/std/lang/module/printer.rad +7 -7

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

/// Format a u32 and allocate the result in the arena.
fn formatId(a: *mut alloc::Arena, id: u32) -> *[u8] {
fn formatId(a: &mut alloc::Arena, id: u32) -> *[u8] {
    let mut digits: [u8; 10] = undefined;
    let text = fmt::formatU32(id, &mut digits[..]);
    let ptr = try alloc::allocSlice(a, 1, 1, text.len) catch { return "?"; };
    let start = fmt::formatU32(id, &mut digits[..]);
    let ptr = try alloc::allocSlice(a, 1, 1, digits.len - start) catch { return "?"; };
    let slice = ptr as *mut [u8];
    try mem::copy(slice, text) catch { return "?"; };
    try mem::copy(slice, &digits[start..]) catch { return "?"; };
    return slice;
}

/// Convert a module state into an S-expression symbol.
fn stateToExpr(state: super::ModuleState) -> sexpr::Expr {

    }
}

/// Recursively convert a module entry and its descendants to an S-expression.
fn subtreeToExpr(
    a: *mut alloc::Arena,
    graph: *super::ModuleGraph,
    a: &mut alloc::Arena,
    graph: &super::ModuleGraph,
    entry: *super::ModuleEntry
) -> sexpr::Expr {
    let idText = formatId(a, entry.id as u32);
    let path = super::moduleQualifiedPath(entry);
    let mut pathBuf: *[sexpr::Expr] = &[];

        sexpr::Expr::List { head: "::", tail: pathBuf, multiline: false }
    ], childBuf);
}

/// Print the entire module graph in S-expression format.
export fn printGraph(graph: *super::ModuleGraph, arena: *mut alloc::Arena) {
export unsafe fn printGraph(graph: &super::ModuleGraph, arena: &mut alloc::Arena) {
    // Print all root modules.
    for i in 0..graph.entriesLen {
        let entry = &graph.entries[i];
        if entry.parent == nil {
            sexpr::print(subtreeToExpr(arena, graph, entry), 0);

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

    for i in 0..expected.len {
        try expectSliceEq(actual[i], expected[i]);
    }
}

@test fn testRegisterChildren() throws (testing::TestError) {
    let mut storage: [super::ModuleEntry; 4] = undefined;
@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 rootId = try super::registerFromPath(&mut graph, 0, nil, "src/root.rad") catch {
        throw testing::TestError::Failed;

    try testing::expect(parent.childrenLen == 2);
    try testing::expect(super::childAt(parent, 0) == firstId);
    try testing::expect(super::childAt(parent, 1) == secondId);
}

@test fn testRegisterChildReusesExisting() throws (testing::TestError) {
    let mut storage: [super::ModuleEntry; 4] = undefined;
@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 rootId = try super::registerFromPath(&mut graph, 0, nil, "src/main.rad") catch {
        throw testing::TestError::Failed;

    let mut components: [*[u8]; 8] = undefined;
    let result = super::parsePath(path, &mut components[..]);
    try testing::expect(result == nil);
}

@test fn testRegisterFromPathHierarchy() throws (testing::TestError) {
    let mut storage: [super::ModuleEntry; 8] = undefined;
@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);

    // Register root module.
    let stdId = try super::registerFromPath(&mut graph, 0, nil, "lib/std.rad") catch {

    try testing::expect(lang.childrenLen == 1);
    try testing::expect(super::childAt(lang, 0) == parserId);
    try testing::expect(parser.childrenLen == 0);
}

@test fn testRegisterFromPathMissingParent() throws (testing::TestError) {
    let mut storage: [super::ModuleEntry; 8] = undefined;
@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 rootId = try super::registerFromPath(&mut graph, 0, nil, "std.rad") catch {
        throw testing::TestError::Failed;

        return;
    };
    throw testing::TestError::Failed;
}

@test fn testRegisterFromPathDuplicateRoot() throws (testing::TestError) {
    let mut storage: [super::ModuleEntry; 8] = undefined;
@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 rootId = try super::registerFromPath(&mut graph, 0, nil, "std.rad") catch {
        throw testing::TestError::Failed;

        return;
    };
    throw testing::TestError::Failed;
}

@test fn testRegisterFromPathRegistersRoot() throws (testing::TestError) {
    let mut storage: [super::ModuleEntry; 8] = undefined;
@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 rootId = try super::registerFromPath(&mut graph, 0, nil, "lib/std.rad") catch {
        throw testing::TestError::Failed;

    try expectSliceEq(root.name, "std");
    try expectSliceEq(root.filePath, "lib/std.rad");
    try expectPathSegments(root, &["std"]);
}

@test fn testRegisterFromPathIgnoresLeadingDirectories() throws (testing::TestError) {
    let mut storage: [super::ModuleEntry; 8] = undefined;
@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 rootId = try super::registerFromPath(&mut graph, 0, nil, "src/pkg/root.rad") catch {
        throw testing::TestError::Failed;

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

    rootModuleId: ?u16,
}

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

    return pkg;
}

/// 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, filePath: *[u8]) -> u16
    throws (module::ModuleError)
{
    let modId = try module::registerFromPath(graph, pkg.id, pkg.rootModuleId, filePath);
    // First registered module becomes the root.
    if pkg.rootModuleId == nil {

lib/std/lang/parser.rad +132 -127

    current: scanner::Token,
    /// The most recently consumed token.
    previous: scanner::Token,
    /// Collection of errors encountered during parsing.
    errors: ErrorList,
    /// Arena for all node allocations.
    arena: *mut ast::NodeArena,
    /// Arena for node allocations. It must outlive the parser.
    arena: *unsafe mut ast::NodeArena,
    /// Allocator backed by the node arena.
    allocator: alloc::Allocator,
    /// Current parsing context (normal or conditional).
    context: Context,
}

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

/// Emit a `true` or `false` literal node.
fn nodeBool(p: *mut Parser, value: bool) -> *ast::Node {
unsafe fn nodeBool(p: &mut Parser, value: bool) -> *ast::Node {
    return node(p, ast::NodeValue::Bool(value));
}

/// Parse an integer literal while mapping shared errors into parser diagnostics.
fn parseIntLiteral(p: *mut Parser, text: *[u8]) -> fmt::IntLiteral
fn parseIntLiteral(p: &mut Parser, text: *[u8]) -> fmt::IntLiteral
    throws (ParseError)
{
    let literal = try fmt::parseInt(text) catch err {
        match err {
            case fmt::ParseError::Invalid =>

    };
    return literal;
}

/// Emit an integer type node.
fn nodeTypeInt(p: *mut Parser, width: u8, sign: ast::Signedness) -> *ast::Node {
unsafe fn nodeTypeInt(p: &mut Parser, width: u8, sign: ast::Signedness) -> *ast::Node {
    return node(p, ast::NodeValue::TypeSig(
        ast::TypeSig::Integer { width, sign }
    ));
}

/// Emit a number literal node with the provided literal metadata.
fn nodeNumber(p: *mut Parser, literal: fmt::IntLiteral) -> *ast::Node {
unsafe fn nodeNumber(p: &mut Parser, literal: fmt::IntLiteral) -> *ast::Node {
    return node(p, ast::NodeValue::Number(literal));
}

/// Emit a `super` node.
fn nodeSuper(p: *mut Parser) -> *ast::Node {
unsafe fn nodeSuper(p: &mut Parser) -> *ast::Node {
    return node(p, ast::NodeValue::Super);
}

/// Emit a single attribute node.
fn nodeAttribute(p: *mut Parser, attr: ast::Attribute) -> *ast::Node {
unsafe fn nodeAttribute(p: &mut Parser, attr: ast::Attribute) -> *ast::Node {
    return node(p, ast::NodeValue::Attribute(attr));
}

/// Emit a unary operator node.
fn nodeUnary(p: *mut Parser, op: ast::UnaryOp, value: *ast::Node) -> *ast::Node {
unsafe fn nodeUnary(p: &mut Parser, op: ast::UnaryOp, value: *ast::Node) -> *ast::Node {
    return node(p, ast::NodeValue::UnOp({ op, value }));
}

/// Parse one expression without inheriting a surrounding condition or pattern context.
fn parseNormalExpr(p: *mut Parser) -> *ast::Node throws (ParseError) {
unsafe fn parseNormalExpr(p: &mut Parser) -> *ast::Node throws (ParseError) {
    let saved = p.context;
    set p.context = Context::Normal;
    let expr = try parseExpr(p);
    set p.context = saved;
    return expr;
}

/// Parse a parenthesized expression without applying postfix operators.
fn parseParenthesized(p: *mut Parser) -> *ast::Node
unsafe fn parseParenthesized(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::LParen, "expected `(`");

    let expr = try parseNormalExpr(p);


    return expr;
}

/// Parse an array literal: `[a, b, c]` or `[item; count]`.
fn parseArrayLiteral(p: *mut Parser) -> *ast::Node
unsafe fn parseArrayLiteral(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::LBracket, "expected `[`");
    if consume(p, scanner::TokenKind::RBracket) { // Empty array: `[]`.
        let empty: *mut [*ast::Node] = &mut [];

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


    return node(p, ast::NodeValue::ArrayLit(items));
}

/// Parse a function call expression.
fn parseCall(p: *mut Parser, callee: *ast::Node) -> *ast::Node
unsafe fn parseCall(p: &mut Parser, callee: *ast::Node) -> *ast::Node
    throws (ParseError)
{
    let args = try parseList(
        p,
        scanner::TokenKind::LParen,

        ast::Call { callee, args }
    ));
}

/// Parse zero or more trailing `as` casts applied to `expr`.
fn parseAsCast(p: *mut Parser, expr: *ast::Node) -> *ast::Node
unsafe fn parseAsCast(p: &mut Parser, expr: *ast::Node) -> *ast::Node
    throws (ParseError)
{
    let mut result = expr;

    while consume(p, scanner::TokenKind::As) {

/// Parse an optional conditional expression suffix.
///
///   `<thenExpr> if <condition> else <elseExpr>`
///
/// If no `if` keyword follows, returns the input expression unchanged.
fn parseCondExpr(p: *mut Parser, thenExpr: *ast::Node) -> *ast::Node
unsafe fn parseCondExpr(p: &mut Parser, thenExpr: *ast::Node) -> *ast::Node
    throws (ParseError)
{
    // Only parse conditional expressions in normal context.
    // In conditional context, `if` is used for guards.
    if p.context <> Context::Normal {

        ast::CondExpr { condition, thenExpr, elseExpr }
    ));
}

/// Parse array subscript or slice expression after `[`.
fn parseSubscriptOrSlice(p: *mut Parser, container: *ast::Node) -> *ast::Node
unsafe fn parseSubscriptOrSlice(p: &mut Parser, container: *ast::Node) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::LBracket, "expected `[`");

    let mut index: *ast::Node = undefined;


    return node(p, ast::NodeValue::Subscript { container, index });
}

/// Parse postfix operators (eg. field access, function call etc.)
fn parsePostfix(p: *mut Parser, expr: *ast::Node) -> *ast::Node
unsafe fn parsePostfix(p: &mut Parser, expr: *ast::Node) -> *ast::Node
    throws (ParseError)
{
    let mut result = expr;

    loop {

    }
    return result;
}

/// Parse a conditional expression.
export fn parseCond(p: *mut Parser) -> *ast::Node throws (ParseError) {
export unsafe fn parseCond(p: &mut Parser) -> *ast::Node throws (ParseError) {
    let saved = p.context;
    set p.context = Context::Condition;
    let expr = try parseExpr(p);
    set p.context = saved;

    return expr;
}

/// Parse unary expression followed by optional `as` cast.
/// `as` has higher precedence than binary ops but lower than unary.
fn parseUnary(p: *mut Parser) -> *ast::Node throws (ParseError) {
unsafe fn parseUnary(p: &mut Parser) -> *ast::Node throws (ParseError) {
    let unary = try parseUnaryExpr(p);
    return try parseAsCast(p, unary);
}

/// Parse prefix unary expressions and defer to primary expressions otherwise.
fn parseUnaryExpr(p: *mut Parser) -> *ast::Node
unsafe fn parseUnaryExpr(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    match p.current.kind {
        case scanner::TokenKind::Not => {
            advance(p);

            return false,
    }
}

/// Build a range expression node with an optional start and end expression.
fn parseRangeExpr(p: *mut Parser, start: ?*ast::Node) -> *ast::Node
unsafe fn parseRangeExpr(p: &mut Parser, start: ?*ast::Node) -> *ast::Node
    throws (ParseError)
{
    let mut endExpr: ?*ast::Node = nil;

    if not isRangeTerminator(p.current.kind) {

        ast::Range { start, end: endExpr }
    ));
}

/// Parse binary expressions using precedence climbing.
fn parseBinary(p: *mut Parser, left: *ast::Node, minPrec: i32) -> *ast::Node
unsafe fn parseBinary(p: &mut Parser, left: *ast::Node, minPrec: i32) -> *ast::Node
    throws (ParseError)
{
    let mut result = left;

    loop {

        else => return true,
    }
}

/// Parse a primary leaf expression without postfix operators.
fn parseLeaf(p: *mut Parser) -> *ast::Node
unsafe fn parseLeaf(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    match p.current.kind {
        case scanner::TokenKind::True => {
            advance(p);

            advance(p);
            return nodeSuper(p);
        }
        case scanner::TokenKind::Number => {
            advance(p);
            let literal = try parseIntLiteral(p, p.previous.source);
            let source = p.previous.source;
            let literal = try parseIntLiteral(p, source);
            return nodeNumber(p, literal);
        }
        case scanner::TokenKind::LParen => {
            return try parseParenthesized(p);
        }

        }
    }
}

/// Parse a primary expression (leaf nodes followed by postfix operators).
fn parsePrimary(p: *mut Parser) -> *ast::Node
unsafe fn parsePrimary(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    let leaf = try parseLeaf(p);
    return try parsePostfix(p, leaf);
}

/// Parse a builtin function call like `@sizeOf(T)` or `@alignOf(T)`.
fn parseBuiltin(p: *mut Parser) -> *ast::Node
unsafe fn parseBuiltin(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    // Skip the '@' to get the name.
    let ident = p.current.source;
    advance(p);

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


/// Parse a single expression.
///
/// Parses unary and binary operators using precedence climbing.
/// Conditional expressions (`x if cond else y`) have lowest precedence.
export fn parseExpr(p: *mut Parser) -> *ast::Node
export unsafe fn parseExpr(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    let left = try parseUnary(p);
    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 {
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; }

        else => return nil,
    }
}

/// Parse an expression statement.
export fn parseExprStmt(p: *mut Parser) -> *ast::Node
export unsafe fn parseExprStmt(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    let expr = try parseExpr(p);
    return node(p, ast::NodeValue::ExprStmt(expr));
}

/// Parse a `set` statement assignment.
fn parseSetStmt(p: *mut Parser) -> *ast::Node
unsafe fn parseSetStmt(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    let target = try parseUnary(p);
    if not ast::isPlaceExpr(target) {
        throw failParsing(p, "invalid assignment target");

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

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

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


/// Try to parse an annotation like `@default`.
///
/// Returns `nil` if not a known annotation (e.g. `@sizeOf` or `@alignOf` which are builtins).
/// Only consumes tokens if a valid annotation is found.
fn tryParseAnnotation(p: *mut Parser) -> ?*ast::Node {
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[..];

}

/// Parse a single statement.
///
/// Dispatches to the appropriate statement parser based on the current token.
export fn parseStmt(p: *mut Parser) -> *ast::Node
export unsafe fn parseStmt(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    // TODO: Why is `parseStmt` checking for attributes?
    // We should have a `parseDecl` which is top-level, and `parseStmt` which
    // is inside functions.
    let attrs = parseAttributes(p);
    if let list = attrs {
        if ast::attributesContains(&list, ast::Attribute::Unsafe)
            and p.current.kind <> scanner::TokenKind::Fn
            and p.current.kind <> scanner::TokenKind::Mod
        {
            throw failParsing(p, "`unsafe` is only allowed on functions and modules");
            throw failParsing(p, "`unsafe` is only allowed on functions");
        }
        let allowed: bool =
            p.current.kind == scanner::TokenKind::Fn or
            p.current.kind == scanner::TokenKind::Union or
            p.current.kind == scanner::TokenKind::Record or

}

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

        }
    }
}

/// Parse a block of statements enclosed in curly braces.
export fn parseBlock(p: *mut Parser) -> *ast::Node
export unsafe fn parseBlock(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    let start = p.current;
    let mut blk = mkBlock(p, 64);



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

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

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

/// Parse the branch that follows `else` in let-else style constructs.
///
/// Allows either a block, a single statement like `return`,
/// or a standalone expression which is returned directly.
fn parseLetElseBranch(p: *mut Parser) -> *ast::Node
unsafe fn parseLetElseBranch(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    if check(p, scanner::TokenKind::LBrace) {
        return try parseBlock(p);
    }

    }
    return branch;
}

/// Allocate a new node from the parser's arena.
fn node(p: *mut Parser, value: ast::NodeValue) -> *mut ast::Node {
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(p.arena, span, value);
    let n = ast::allocNode(&mut *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;

        set node.span.length = 0;
    }
}

/// Save parser state for speculative parsing.
fn saveState(p: *Parser) -> SavedState {
unsafe fn saveState(p: &Parser) -> SavedState {
    return SavedState {
        parser: *p,
        arena: alloc::save(&p.arena.arena),
        nextId: p.arena.nextId,
    };
}

/// Restore parser state from a snapshot, fully undoing any
/// side effects of a failed speculative parse.
fn restoreState(p: *mut Parser, s: *SavedState) {
unsafe fn restoreState(p: &mut Parser, s: &SavedState) {
    set *p = s.parser;
    alloc::restore(&mut p.arena.arena, s.arena);
    set p.arena.nextId = s.nextId;
}

/// Report a parser error.
fn reportError(p: *mut Parser, token: scanner::Token, message: *[u8]) {
fn reportError(p: &mut Parser, token: scanner::Token, message: *[u8]) {
    assert message.len > 0;

    // Ignore errors once the error list is full.
    if p.errors.count < p.errors.list.len {
        set p.errors.list[p.errors.count] = Error { message, token };
        set p.errors.count += 1;
    }
}

/// Fail the parsing process with the given error.
fn failParsing(p: *mut Parser, err: *[u8]) -> ParseError {
    reportError(p, p.current, err);
fn failParsing(p: &mut Parser, err: *[u8]) -> ParseError {
    let token = p.current;
    reportError(p, token, err);
    return ParseError::UnexpectedToken;
}

/// Print all errors that have been collected during parsing.
export fn printErrors(p: *Parser) {
export fn printErrors(p: &Parser) {
    for i in 0..p.errors.count {
        let e = p.errors.list[i];
        if let loc = scanner::getLocation(
            p.scanner.sourceLoc, p.scanner.source, e.token.offset
        ) {

        io::print("\n");
    }
}

/// Check whether the current token matches the expected kind.
export fn check(p: *Parser, kind: scanner::TokenKind) -> bool {
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 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.
///
/// Syntax: `if let binding = scrutinee { ... }`
/// Syntax: `if let mut binding = scrutinee { ... }`
fn parseIfLet(p: *mut Parser) -> *ast::Node throws (ParseError) {
unsafe fn parseIfLet(p: &mut Parser) -> *ast::Node throws (ParseError) {
    try expect(p, scanner::TokenKind::Let, "expected `let`");

    // Parse pattern: either `case <pattern>`, `mut <ident>`, or simple `<ident>`.
    let mut pattern: *ast::Node = undefined;
    let mut kind = ast::PatternKind::Binding;

        elseBranch,
    }));
}

/// Parse a `while let` statement.
fn parseWhileLet(p: *mut Parser) -> *ast::Node
unsafe fn parseWhileLet(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Let, "expected `let`");

    // Parse pattern: either `case <pattern>`, `mut <ident>`, or simple `<ident>`.

        elseBranch,
    }));
}

/// Parse a `while` statement.
fn parseWhile(p: *mut Parser) -> *ast::Node
unsafe fn parseWhile(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::While, "expected `while`");

    // Check for `while let` or `while let case` syntax.

        condition, body, elseBranch,
    }));
}

/// Parse a `loop` statement.
fn parseLoop(p: *mut Parser) -> *ast::Node
unsafe fn parseLoop(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Loop, "expected `loop`");
    let body = try parseBlock(p);

    return node(p, ast::NodeValue::Loop { body });
}

/// Parse a `for` statement.
fn parseFor(p: *mut Parser) -> *ast::Node
unsafe fn parseFor(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::For, "expected `for`");

    let binding = try parseIdentOrPlaceholder(p, "expected identifier or `_`");

        binding, index, iterable, body, elseBranch,
    }));
}

/// Parse a `return` statement.
fn parseReturn(p: *mut Parser) -> *ast::Node
unsafe fn parseReturn(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Return, "expected `return`");

    // Speculatively try to parse a return value expression.

    }
    return node(p, ast::NodeValue::Return { value });
}

/// Parse a `throw` statement.
fn parseThrow(p: *mut Parser) -> *ast::Node
unsafe fn parseThrow(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Throw, "expected `throw`");
    let expr = try parseExpr(p);

    return node(p, ast::NodeValue::Throw { expr });
}

/// Parse a `panic` statement.
fn parsePanic(p: *mut Parser) -> *ast::Node
unsafe fn parsePanic(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Panic, "expected `panic`");

    // `panic { expr }`.

///
/// Forms:
///   `assert <expr>`
///   `assert <expr>, "message"`
///   `assert { <expr> }, "message"`
fn parseAssert(p: *mut Parser) -> *ast::Node
unsafe fn parseAssert(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Assert, "expected `assert`");

    // `assert { expr }` block form or `assert <expr>`.

    }
    return node(p, ast::NodeValue::Assert { condition, message });
}

/// Parse a `try` expression with optional `catch` clause(s).
fn parseTryExpr(p: *mut Parser) -> *ast::Node
unsafe fn parseTryExpr(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    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(p.arena, 4);
    let mut catches = ast::nodeSlice(&mut *p.arena, 4);

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


///               d
///           }
///       }
///   }
///
fn parseIf(p: *mut Parser) -> *ast::Node throws (ParseError) {
unsafe fn parseIf(p: &mut Parser) -> *ast::Node throws (ParseError) {
    try expect(p, scanner::TokenKind::If, "expected `if`");

    // Check for `if let` or `if let case` syntax.
    if check(p, scanner::TokenKind::Let) {
        return try parseIfLet(p);

        condition: cond, thenBranch, elseBranch,
    }));
}

/// Parse a `match` statement.
fn parseMatch(p: *mut Parser) -> *ast::Node
unsafe fn parseMatch(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    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(p.arena, 128);
    let mut prongs = ast::nodeSlice(&mut *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);

        ast::Match { subject, prongs }
    ));
}

/// Parse a single `match` prong.
fn parseMatchProng(p: *mut Parser) -> *ast::Node
unsafe fn parseMatchProng(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    let mut guard: ?*ast::Node = nil;

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

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

    ));
}

/// Parse a pattern expression used by `case` constructs.
/// Uses `Pattern` context to allow record literals but not conditional expressions.
fn parseMatchPattern(p: *mut Parser) -> *ast::Node
unsafe fn parseMatchPattern(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    let saved = p.context;
    set p.context = Context::Pattern;
    let pattern = try parseExpr(p);


    return pattern;
}

/// Parse an identifier.
fn parseIdent(p: *mut Parser, err: *[u8]) -> *ast::Node
unsafe fn parseIdent(p: &mut Parser, err: *[u8]) -> *ast::Node
    throws (ParseError)
{
    let source = try expect(p, scanner::TokenKind::Ident, err);
    return node(p, ast::NodeValue::Ident(source));
}

/// Parse either an identifier or a placeholder (`_`).
fn parseIdentOrPlaceholder(p: *mut Parser, err: *[u8]) -> *ast::Node
unsafe fn parseIdentOrPlaceholder(p: &mut Parser, err: *[u8]) -> *ast::Node
    throws (ParseError)
{
    if consume(p, scanner::TokenKind::Underscore) {
        return node(p, ast::NodeValue::Placeholder);
    }

}

/// Parse an alignment specifier.
///
/// Syntax: `align(N)` where N is a power of 2.
fn parseAlign(p: *mut Parser) -> *ast::Node
unsafe fn parseAlign(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Align, "expected `align`");
    let value = try parseParenthesized(p);
    return node(p, ast::NodeValue::Align { value });


/// Parse a comma-separated list of record fields.
/// The opening delimiter should already be consumed.
/// For labeled fields: `{ name: T, ... }`.
/// For unlabeled fields: `(T, T, ...)`.
fn parseRecordFields(
    p: *mut Parser,
unsafe fn parseRecordFields(
    p: &mut Parser,
    mode: RecordFieldMode
) -> *mut [*ast::Node]
    throws (ParseError)
{
    let terminator = scanner::TokenKind::RBrace if mode == RecordFieldMode::Labeled
        else scanner::TokenKind::RParen;
    let mut fields = ast::nodeSlice(p.arena, MAX_RECORD_FIELDS);
    let mut fields = ast::nodeSlice(&mut *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`).
fn parseDerives(p: *mut Parser) -> *mut [*ast::Node] throws (ParseError) {
    let mut derives = ast::nodeSlice(p.arena, 4);
unsafe fn parseDerives(p: &mut Parser) -> *mut [*ast::Node] throws (ParseError) {
    let mut derives = ast::nodeSlice(&mut *p.arena, 4);

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

    return derives;
}

/// Parse a single record literal field.
/// Can be either labeled, or shorthand.
fn parseRecordLitField(p: *mut Parser) -> *ast::Node
unsafe fn parseRecordLitField(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    let name = try parseIdent(p, "expected field name");
    if consume(p, scanner::TokenKind::Colon) {
        // Labeled field: `name: value`.

}

/// Parse a record literal body.
/// Eg. `{ x: 1, y: 2 }`
/// Eg. `{ x: 1, .. }`
fn parseRecordLit(p: *mut Parser, typeName: ?*ast::Node) -> *ast::Node
unsafe fn parseRecordLit(p: &mut Parser, typeName: ?*ast::Node) -> *ast::Node
    throws (ParseError)
{
    let mut fields = ast::nodeSlice(p.arena, MAX_RECORD_FIELDS);
    let mut fields = ast::nodeSlice(&mut *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.

    ));
}

/// Parse a named record declaration.
/// `record Point { x: i32, y: i32 }`, or `record Pair(i32, i32);`
fn parseRecordDecl(p: *mut Parser, attrs: ?ast::Attributes) -> *ast::Node
unsafe fn parseRecordDecl(p: &mut Parser, attrs: ?ast::Attributes) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Record, "expected `record`");

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

    }
}

/// Parse a union declaration.
/// Example: `union Color { Red, Green, Blue = 5 }`
fn parseUnionDecl(p: *mut Parser, attrs: ?ast::Attributes) -> *ast::Node
unsafe fn parseUnionDecl(p: &mut Parser, attrs: ?ast::Attributes) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Union, "expected `union`");

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

                ast::TypeSig::Record { fields, labeled: true }
            ));
        } else if consume(p, scanner::TokenKind::Equal) {
            // TODO: Support constant expressions.
            try expect(p, scanner::TokenKind::Number, "expected integer literal after `=`");
            let literal = try parseIntLiteral(p, p.previous.source);
            let source = p.previous.source;
            let literal = try parseIntLiteral(p, source);
            set explicitValue = nodeNumber(p, literal);
        }

        let variant = node(p, ast::NodeValue::UnionDeclVariant(
            ast::UnionDeclVariant {

        ast::UnionDecl { name, variants, attrs, derives }
    ));
}

/// Parse a function parameter.
fn parseFnParam(p: *mut Parser) -> *ast::Node
unsafe fn parseFnParam(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    let ntv = try parseNameTypeValue(p);
    let type = ntv.type
        else throw failParsing(p, "missing type in function parameter");

        ast::FnParam { name: ntv.name, type }
    ));
}

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

/// Parse a function type signature.
fn parseFnType(p: *mut Parser) -> *ast::Node
unsafe fn parseFnType(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    let isUnsafe = consume(p, scanner::TokenKind::Unsafe);
    try expect(p, scanner::TokenKind::Fn, "expected `fn`");
    let params = try parseList(
        p,
        scanner::TokenKind::LParen,
        scanner::TokenKind::RParen,

        set returnType = try parseType(p);
    }
    let throwList = try parseThrowList(p);
    let sig = ast::FnSig { params, returnType, throwList };
    return node(p, ast::NodeValue::TypeSig(
        ast::TypeSig::Fn(sig)
        ast::TypeSig::Fn { sig, isUnsafe }
    ));
}

/// Parse a function signature following the function name.
fn parseFnTypeSig(p: *mut Parser) -> ast::FnSig
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(p.arena, 8);
    let mut params = ast::nodeSlice(&mut *p.arena, 8);

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



    return ast::FnSig { params, returnType, throwList };
}

/// Parse a function declaration.
fn parseFnDecl(p: *mut Parser, attrs: ?ast::Attributes) -> *ast::Node
unsafe fn parseFnDecl(p: &mut Parser, attrs: ?ast::Attributes) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Fn, "expected `fn`");

    // Method syntax: `fn (recv: *Type) name(params) { body }`.


    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(p.arena, 4);
            let mut list = ast::nodeSlice(&mut *p.arena, 4);
            if let a = attrs {
                for i in 0..a.list.len {
                    list.append(a.list[i], p.allocator);
                }
            }

        ast::FnDecl { name, sig, body, attrs: fnAttrs }
    ));
}

/// Parse a pointer-like type after its ownership prefix.
fn parsePointerLikeType(
    p: *mut Parser,
unsafe fn parsePointerLikeType(
    p: &mut Parser,
    class: types::PointerClass,
) -> *ast::Node throws (ParseError) {
    let mutable = consume(p, scanner::TokenKind::Mut);

    if consume(p, scanner::TokenKind::LBracket) {

        ast::TypeSig::Pointer { class, valueType, mutable }
    ));
}

/// Parse an array type.
fn parseArrayType(p: *mut Parser) -> *ast::Node
unsafe fn parseArrayType(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::LBracket, "expected `[`");
    let itemType = try parseType(p);


    ));
}

/// Parse a type path: an identifier optionally followed by `::` scope access.
/// Returns an identifier node or a scope access chain.
fn parseTypePath(p: *mut Parser) -> *ast::Node
unsafe fn parseTypePath(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    let mut path: *ast::Node = undefined;
    if p.current.kind == scanner::TokenKind::Super {
        advance(p);

    }
    return path;
}

/// Parse a type annotation.
export fn parseType(p: *mut Parser) -> *ast::Node
export unsafe fn parseType(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    match p.current.kind {
        case scanner::TokenKind::Question => {
            advance(p);

        }
        case scanner::TokenKind::Opaque => {
            advance(p);
            return node(p, ast::NodeValue::TypeSig(ast::TypeSig::Opaque));
        }
        case scanner::TokenKind::Fn => {
        case scanner::TokenKind::Fn, scanner::TokenKind::Unsafe => {
            return try parseFnType(p);
        }
        else => {
            throw failParsing(p, "expected type");
        }


/// Parse a name, optional type, and optional value.
///
/// Used for record field declarations, variable declarations,
/// and record field initializations.
fn parseNameTypeValue(p: *mut Parser) -> NameTypeValue
unsafe fn parseNameTypeValue(p: &mut Parser) -> NameTypeValue
    throws (ParseError)
{
    let name = try parseIdentOrPlaceholder(p, "expected identifier or `_`");
    let mut type: ?*ast::Node = nil;
    let mut alignment: ?*ast::Node = nil;

    }
    return NameTypeValue { name, type, value, alignment };
}

/// Parse a constant declaration.
fn parseConst(p: *mut Parser, attrs: ?ast::Attributes) -> *ast::Node
unsafe fn parseConst(p: &mut Parser, attrs: ?ast::Attributes) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Constant, "expected `constant`");

    let ident = try parseIdent(p, "expected identifier in constant declaration");

        ast::ConstDecl { ident, type, value, attrs }
    ));
}

/// Parse a static declaration.
fn parseStatic(p: *mut Parser, attrs: ?ast::Attributes) -> *ast::Node
unsafe fn parseStatic(p: &mut Parser, attrs: ?ast::Attributes) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Static, "expected `static`");

    let ident = try parseIdent(p, "expected identifier in static declaration");

        ast::StaticDecl { ident, type, value, attrs }
    ));
}

/// Parse a `use` declaration.
fn parseUse(p: *mut Parser, attrs: ?ast::Attributes) -> *ast::Node
unsafe fn parseUse(p: &mut Parser, attrs: ?ast::Attributes) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Use, "expected `use`");

    // Allow `super` or identifier as the first part of the path.

        ast::Use { path, wildcard: false, attrs }
    ));
}

/// Parse a `mod` declaration.
fn parseMod(p: *mut Parser, attrs: ?ast::Attributes) -> *ast::Node
unsafe fn parseMod(p: &mut Parser, attrs: ?ast::Attributes) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Mod, "expected `mod`");
    let name = try parseIdent(p, "expected module name after `mod`");


///
/// Eg. `let case <pattern> = <expr> else { ... };`
/// Eg. `let case <pattern> = <expr> if <guard> else { ... };`
///
/// Expects `let case` tokens to have already been consumed.
fn parseLetCase(p: *mut Parser) -> *ast::Node throws (ParseError) {
unsafe fn parseLetCase(p: &mut Parser) -> *ast::Node throws (ParseError) {
    let pattern = try parseMatchPattern(p);

    try expect(p, scanner::TokenKind::Equal, "expected `=` after pattern");
    let expr = try parseCond(p);


/// Eg. `let mut <ident> = <expr> else { ... };`
/// Eg. `let <ident> = <expr> if <guard> else { ... };`
/// Eg. `mut <ident> = <expr>;`
///
/// Expects `let` or `mut` token to have already been consumed.
fn parseLet(p: *mut Parser, mutable: bool) -> *ast::Node throws (ParseError) {
unsafe fn parseLet(p: &mut Parser, mutable: bool) -> *ast::Node throws (ParseError) {
    let binding = try parseNameTypeValue(p);
    let value = binding.value
        else throw failParsing(p, "expected value initializer");

    // Check for optional `else` clause (let-else).

        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 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: *mut strings::Pool) -> *mut ast::Node
    throws (ParseError)
{
    let mut p = mkParser(sourceLoc, input, arena, pool);
    return try parseModule(&mut p) catch {
        printErrors(&p);


/// Parse a complete module into a block of top-level statements.
///
/// This is the main entry point for parsing an entire Radiance source file.
/// The parser must already be initialized with source code.
export fn parseModule(p: *mut Parser) -> *mut ast::Node
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);


    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 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 fn expect(p: &mut Parser, kind: scanner::TokenKind, message: *[u8]) -> *[u8]
    throws (ParseError)
{
    if not consume(p, kind) {
        reportError(p, p.current, message);
        let token = p.current;
        reportError(p, token, message);
        throw ParseError::UnexpectedToken;
    }
    return p.previous.source;
}


    }
}

/// Parse a trait declaration.
/// Syntax: `trait Name { fn (*Trait) method(...) -> T; ... }`
fn parseTraitDecl(p: *mut Parser, attrs: ?ast::Attributes) -> *ast::Node
unsafe fn parseTraitDecl(p: &mut Parser, attrs: ?ast::Attributes) -> *ast::Node
    throws (ParseError)
{
    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(p.arena, ast::MAX_TRAIT_METHODS);
    let mut methods = ast::nodeSlice(&mut *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);

    return node(p, ast::NodeValue::TraitDecl { name, supertraits, methods, attrs });
}

/// Parse a trait method signature.
/// Syntax: `fn (*Trait) fnord(<params>) -> ReturnType;`
fn parseTraitMethodSig(p: *mut Parser) -> *ast::Node
unsafe fn parseTraitMethodSig(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    let attrs = parseAttributes(p);
    try expect(p, scanner::TokenKind::Fn, "expected `fn`");
    try expect(p, scanner::TokenKind::LParen, "expected `(` before receiver");

/// Parse an instance block.
/// Syntax: `instance Trait for Type { fn (t: *mut Type) fnord(..) {..} }`
///
/// Instance declarations do not accept attributes (e.g. `export`).
/// Visibility is determined by the trait declaration itself.
fn parseInstanceDecl(p: *mut Parser) -> *ast::Node
unsafe fn parseInstanceDecl(p: &mut Parser) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Instance, "expected `instance`");
    let traitName = try parseTypePath(p);
    try expect(p, scanner::TokenKind::For, "expected `for` after trait name");
    let targetType = try parseTypePath(p);
    try expect(p, scanner::TokenKind::LBrace, "expected `{` after target type");

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

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

/// Parse a method declaration with a receiver.
/// Syntax: `fn (t: *mut Type) fnord(<params>) -> ReturnType { body }`
///
/// Used both inside `instance` blocks and as standalone methods at the top level.
/// Expects the `fn` token to have already been consumed.
fn parseMethodDecl(p: *mut Parser, attrs: ?ast::Attributes) -> *ast::Node
unsafe fn parseMethodDecl(p: &mut Parser, attrs: ?ast::Attributes) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::LParen, "expected `(` before receiver");

    let receiverName = try parseIdent(p, "expected receiver name");

        name, receiverName, receiverType, sig, body, attrs,
    });
}

/// Parse a comma-separated list enclosed by the given delimiters.
fn parseList(
    p: *mut Parser,
unsafe fn parseList(
    p: &mut Parser,
    open: scanner::TokenKind,
    close: scanner::TokenKind,
    parseItem: fn (*mut Parser) -> *ast::Node throws (ParseError)
    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(p.arena, 8);
    let mut items = ast::nodeSlice(&mut *p.arena, 8);

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


lib/std/lang/parser/tests.rad +182 -177

        try testing::expect(range.end == nil);
    }
}

/// Parse multiple statements from a string.
fn parseStmtsStr(input: *[u8]) -> *ast::Node
unsafe fn parseStmtsStr(input: *[u8]) -> *ast::Node
    throws (testing::TestError)
{
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let mut parser = super::mkParser(scanner::SourceLoc::String, input, &mut arena, &mut STRING_POOL);
    return try super::parseModule(&mut parser) catch {
        throw testing::TestError::Failed;
    };
}

/// Parse a single type from a string.
fn parseTypeStr(input: *[u8]) -> *ast::Node
unsafe fn parseTypeStr(input: *[u8]) -> *ast::Node
    throws (super::ParseError)
{
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let mut parser = super::mkParser(scanner::SourceLoc::String, input, &mut arena, &mut STRING_POOL);
    super::advance(&mut parser);


    return root;
}

/// Parse a single expression from a string.
export fn parseExprStr(input: *[u8]) -> *ast::Node
export unsafe fn parseExprStr(input: *[u8]) -> *ast::Node
    throws (super::ParseError)
{
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let mut parser = super::mkParser(scanner::SourceLoc::String, input, &mut arena, &mut STRING_POOL);
    super::advance(&mut parser);
    return try super::parseExpr(&mut parser);
}

/// Parse a single statement from a string.
fn parseStmtStr(input: *[u8]) -> *ast::Node
unsafe fn parseStmtStr(input: *[u8]) -> *ast::Node
    throws (super::ParseError)
{
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let mut parser = super::mkParser(scanner::SourceLoc::String, input, &mut arena, &mut STRING_POOL);
    super::advance(&mut parser);


    return root;
}

/// Parse an expression expected to be a number literal and return its payload.
fn parseNumberLiteral(text: *[u8]) -> fmt::IntLiteral
unsafe fn parseNumberLiteral(text: *[u8]) -> fmt::IntLiteral
    throws (testing::TestError)
{
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let mut parser = super::mkParser(scanner::SourceLoc::String, text, &mut arena, &mut STRING_POOL);
    super::advance(&mut parser);


    return lit;
}

/// Ensure that parsing the supplied literal source fails.
fn expectNumberLiteralFail(text: *[u8])
unsafe fn expectNumberLiteralFail(text: *[u8])
    throws (testing::TestError)
{
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let mut parser = super::mkParser(scanner::SourceLoc::String, text, &mut arena, &mut STRING_POOL);
    super::advance(&mut parser);

    }
    return block.statements[block.statements.len - 1];
}

/// Test parsing boolean literals (`true` and `false`).
@test fn testParseBool() throws (testing::TestError) {
@test unsafe fn testParseBool() throws (testing::TestError) {
    let r1 = try! parseExprStr("true");
    let case ast::NodeValue::Bool(v1) = r1.value if v1
        else throw testing::TestError::Failed;

    let r2 = try! parseExprStr("false");
    let case ast::NodeValue::Bool(v2) = r2.value if not v2
        else throw testing::TestError::Failed;
}

/// Test parsing number literals.
@test fn testParseNumber() throws (testing::TestError) {
@test unsafe fn testParseNumber() throws (testing::TestError) {
    let r1 = try! parseExprStr("4519");
    try expectNumber(r1, "4519");
}

/// Verify that decimal literals record magnitude and base metadata.
@test fn testParseDecimalLiteralMetadata() throws (testing::TestError) {
@test unsafe fn testParseDecimalLiteralMetadata() throws (testing::TestError) {
    let lit = try parseNumberLiteral("1234");
    try testing::expect(lit.magnitude == 1234);
    try testing::expect(lit.radix == fmt::Radix::Decimal);
}

/// Verify that hexadecimal literals record magnitude and radix metadata.
@test fn testParseNumberMetadata() throws (testing::TestError) {
@test unsafe fn testParseNumberMetadata() throws (testing::TestError) {
    let lit = try parseNumberLiteral("0xFF");
    try testing::expect(lit.magnitude == 0xFF);
    try testing::expect(lit.radix == fmt::Radix::Hex);
}

/// Verify that binary literals capture their radix.
@test fn testParseBinaryLiteralMetadata() throws (testing::TestError) {
@test unsafe fn testParseBinaryLiteralMetadata() throws (testing::TestError) {
    let lit = try parseNumberLiteral("0b1010");
    try testing::expect(lit.magnitude == 0b1010);
    try testing::expect(lit.radix == fmt::Radix::Binary);
}

/// Negative literals parse as unary negation of an unsigned number.
@test fn testParseNegativeLiteral() throws (testing::TestError) {
@test unsafe fn testParseNegativeLiteral() throws (testing::TestError) {
    let node = try! parseExprStr("-99");
    let case ast::NodeValue::UnOp(neg) = node.value
        else throw testing::TestError::Failed;
    try testing::expect(neg.op == ast::UnaryOp::Neg);
    let case ast::NodeValue::Number(lit) = neg.value.value
        else throw testing::TestError::Failed;
    try testing::expect(lit.magnitude == 99);
}

/// Unary plus is not part of the expression grammar.
@test fn testRejectUnaryPlus() throws (testing::TestError) {
@test unsafe fn testRejectUnaryPlus() throws (testing::TestError) {
    try expectNumberLiteralFail("+1");
    try expectNumberLiteralFail("+value");
    try expectNumberLiteralFail("+(value)");
}

/// Range expressions parse with explicit start and end bounds.
@test fn testParseRangeExpr() throws (testing::TestError) {
@test unsafe fn testParseRangeExpr() throws (testing::TestError) {
    let node = try! parseExprStr("0..5");
    try expectRangeNumbers(node, "0", "5");
}

/// Range expressions allow a missing end bound.
@test fn testParseRangeExprNoEnd() throws (testing::TestError) {
@test unsafe fn testParseRangeExprNoEnd() throws (testing::TestError) {
    let node = try! parseExprStr("0..");
    try expectRangeNumbers(node, "0", nil);
}

/// Range expressions allow a missing start bound.
@test fn testParseRangeExprNoStart() throws (testing::TestError) {
@test unsafe fn testParseRangeExprNoStart() throws (testing::TestError) {
    let node = try! parseExprStr("..5");
    try expectRangeNumbers(node, nil, "5");
}

/// Literals with out-of-range digits for their base are rejected.
@test fn testParseInvalidIntLiteral() throws (testing::TestError) {
@test unsafe fn testParseInvalidIntLiteral() throws (testing::TestError) {
    // 2^64 overflows u64.
    try expectNumberLiteralFail("18446744073709551616");
    try expectNumberLiteralFail("0x10000000000000000");
    try expectNumberLiteralFail("0x1G");
    try expectNumberLiteralFail("0b102");
}

/// Test parsing nil literal.
@test fn testParseNil() throws (testing::TestError) {
@test unsafe fn testParseNil() throws (testing::TestError) {
    let r1 = try! parseExprStr("nil");
    let case ast::NodeValue::Nil = r1.value
        else throw testing::TestError::Failed;
}

/// Test parsing undefined literal.
@test fn testParseUndefined() throws (testing::TestError) {
@test unsafe fn testParseUndefined() throws (testing::TestError) {
    let r1 = try! parseExprStr("undefined");
    let case ast::NodeValue::Undef = r1.value
        else throw testing::TestError::Failed;
}

/// Test parsing character literals.
@test fn testParseChar() throws (testing::TestError) {
@test unsafe fn testParseChar() throws (testing::TestError) {
    let r1 = try! parseExprStr("'a'");
    let case ast::NodeValue::Char(c1) = r1.value if c1 == 'a'
        else throw testing::TestError::Failed;

    let r2 = try! parseExprStr("'\\n'");

    let case ast::NodeValue::Char(c3) = r3.value if c3 == '\t'
        else throw testing::TestError::Failed;
}

/// Test parsing string literals.
@test fn testParseString() throws (testing::TestError) {
@test unsafe fn testParseString() throws (testing::TestError) {
    let r1 = try! parseExprStr("\"hello\"");
    let case ast::NodeValue::String(s1) = r1.value if mem::eq(s1, "hello")
        else throw testing::TestError::Failed;

    let r2 = try! parseExprStr("\"\"");
    let case ast::NodeValue::String(s2) = r2.value if s2.len == 0
        else throw testing::TestError::Failed;
}

/// Test string escape sequence processing.
@test fn testParseStringEscape() throws (testing::TestError) {
@test unsafe fn testParseStringEscape() throws (testing::TestError) {
    // Tab and newline.
    let r1 = try! parseExprStr("\"hello\\tworld\\n\"");
    let case ast::NodeValue::String(s1) = r1.value if s1.len == 12
        else throw testing::TestError::Failed;
    if s1[5] <> '\t' {

        throw testing::TestError::Failed;
    }
}

/// Test parsing placeholder/underscore.
@test fn testParsePlaceholder() throws (testing::TestError) {
@test unsafe fn testParsePlaceholder() throws (testing::TestError) {
    let r1 = try! parseExprStr("_");
    let case ast::NodeValue::Placeholder = r1.value
        else throw testing::TestError::Failed;
}

/// Test parsing array literals.
@test fn testParseArrayLiteral() throws (testing::TestError) {
@test unsafe fn testParseArrayLiteral() throws (testing::TestError) {
    let r1 = try! parseExprStr("[]");
    let case ast::NodeValue::ArrayLit(items1) = r1.value if items1.len == 0
        else throw testing::TestError::Failed;

    let r2 = try! parseExprStr("[1]");

    let case ast::NodeValue::ArrayLit(items3) = r3.value if items3.len == 3
        else throw testing::TestError::Failed;
}

/// Test parsing array repeat literals.
@test fn testParseArrayRepeatLiteral() throws (testing::TestError) {
@test unsafe fn testParseArrayRepeatLiteral() throws (testing::TestError) {
    let r1 = try! parseExprStr("[42; 10]");
    let case ast::NodeValue::ArrayRepeatLit(a) = r1.value
        else throw testing::TestError::Failed;

    try expectNumber(a.item, "42");
    try expectNumber(a.count, "10");
}

/// Test parsing a simple `if` statement without an `else` clause.
@test fn testParseIf() throws (testing::TestError) {
@test unsafe fn testParseIf() throws (testing::TestError) {
    let r1 = try parseStmtStr("if condition { body; }") catch {
        throw testing::TestError::Failed;
    };
    let case ast::NodeValue::If(n) = r1.value
        else throw testing::TestError::Failed;

    try expectBlockExprStmt(n.thenBranch, ast::NodeValue::Ident("body"));
    try testing::expect(n.elseBranch == nil);
}

/// Test parsing an `if-else` statement.
@test fn testParseIfElse() throws (testing::TestError) {
@test unsafe fn testParseIfElse() throws (testing::TestError) {
    let r1 = try! parseStmtStr("if condition { left; } else { right; }") catch {
        throw testing::TestError::Failed;
    };
    let case ast::NodeValue::If(n) = r1.value
        else throw testing::TestError::Failed;


    try expectBlockExprStmt(elseBranch, ast::NodeValue::Ident("right"));
}

/// Test parsing an `if-else if-else` chain.
@test fn testParseIfElseIf() throws (testing::TestError) {
@test unsafe fn testParseIfElseIf() throws (testing::TestError) {
    let root = try! parseStmtStr("if x { a; } else if y { b; } else { c; }") catch {
        throw testing::TestError::Failed;
    };
    let case ast::NodeValue::If(top) = root.value
        else throw testing::TestError::Failed;

        else throw testing::TestError::Failed;
    try expectBlockExprStmt(innerElse, ast::NodeValue::Ident("c"));
}

/// Test parsing a block with multiple statements where the last lacks a semicolon.
@test fn testParseBlockMultiStmt() throws (testing::TestError) {
@test unsafe fn testParseBlockMultiStmt() throws (testing::TestError) {
    let root = try! parseStmtStr("{ first; second; third }");
    let case ast::NodeValue::Block(body) = root.value
        else throw testing::TestError::Failed;
    try testing::expect(body.statements.len == 3);


        else throw testing::TestError::Failed;
    try expectIdent(thirdExpr, "third");
}

/// Test parsing a block that keeps a trailing `;` delimiter.
@test fn testParseBlockTrailingSemicolon() throws (testing::TestError) {
@test unsafe fn testParseBlockTrailingSemicolon() throws (testing::TestError) {
    let root = try! parseStmtStr("if cond { only; }") catch {
        throw testing::TestError::Failed;
    };
    let case ast::NodeValue::If(node) = root.value
        else throw testing::TestError::Failed;

        else throw testing::TestError::Failed;
    try expectIdent(expr, "only");
}

/// Test that missing delimiters between block statements produce an error.
@test fn testParseBlockMissingDelimiter() throws (testing::TestError) {
@test unsafe fn testParseBlockMissingDelimiter() throws (testing::TestError) {
    let parsed: ?*ast::Node =
        try? parseStmtStr("if cond { first second }");
    try testing::expect(parsed == nil);
}

/// Test parsing a `let` binding without a type annotation.
@test fn testParseLet() throws (testing::TestError) {
@test unsafe fn testParseLet() throws (testing::TestError) {
    let r1 = try! parseStmtStr("let x = y;") catch {
        throw testing::TestError::Failed;
    };
    let case ast::NodeValue::Let(n) = r1.value
        else throw testing::TestError::Failed;

    try testing::expect(not n.mutable);
    try testing::expect(n.type == nil);
}

/// Test parsing a `let` binding with a type annotation.
@test fn testParseLetTyped() throws (testing::TestError) {
@test unsafe fn testParseLetTyped() throws (testing::TestError) {
    let r1 = try! parseStmtStr("let x: i32 = y;");
    let case ast::NodeValue::Let(n) = r1.value
        else throw testing::TestError::Failed;

    try expectIdent(n.ident, "x");

        width: 4, sign: ast::Signedness::Signed
    });
}

/// Test parsing a `let` binding with alignment modifier.
@test fn testParseLetAlign() throws (testing::TestError) {
@test unsafe fn testParseLetAlign() throws (testing::TestError) {
    let r1 = try! parseStmtStr("let x: i32 align(16) = 13;");
    let case ast::NodeValue::Let(n) = r1.value
        else throw testing::TestError::Failed;

    try expectIdent(n.ident, "x");

        else throw testing::TestError::Failed;
    try expectNumber(a, "16");
}

/// Test parsing let-else statement.
@test fn testParseLetElse() throws (testing::TestError) {
@test unsafe fn testParseLetElse() throws (testing::TestError) {
    let root = try! parseStmtStr("let x = opt else { return };");
    let case ast::NodeValue::LetElse(letElse) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(letElse.pattern.pattern, "x");

        else throw testing::TestError::Failed;
    try testing::expect(elseBlock.statements.len == 1);
}

/// Test parsing let-else with single statement.
@test fn testParseLetElseSingleStmt() throws (testing::TestError) {
@test unsafe fn testParseLetElseSingleStmt() throws (testing::TestError) {
    let root = try! parseStmtStr("let y = val else return;");
    let case ast::NodeValue::LetElse(letElse) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(letElse.pattern.pattern, "y");

    let case ast::NodeValue::Return(_) = letElse.elseBranch.value
        else throw testing::TestError::Failed;
}

/// Test parsing let-else with expression branch.
@test fn testParseLetElseExpr() throws (testing::TestError) {
@test unsafe fn testParseLetElseExpr() throws (testing::TestError) {
    let root = try! parseStmtStr("let z = opt else y;");
    let case ast::NodeValue::LetElse(letElse) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(letElse.pattern.pattern, "z");
    try expectIdent(letElse.elseBranch, "y");
}

/// Test parsing let-case-else statement.
@test fn testParseLetCaseElse() throws (testing::TestError) {
@test unsafe fn testParseLetCaseElse() throws (testing::TestError) {
    let root = try! parseStmtStr("let case Variant(x) = opt else { return };");
    let case ast::NodeValue::LetElse(letElse) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(letElse.pattern.guard == nil);
}

/// Test parsing let-case-else with guard.
@test fn testParseLetCaseElseWithGuard() throws (testing::TestError) {
@test unsafe fn testParseLetCaseElseWithGuard() throws (testing::TestError) {
    let root = try! parseStmtStr("let case Variant(x) = opt if x > 0 else { return };");
    let case ast::NodeValue::LetElse(letElse) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(letElse.pattern.guard <> nil);

        else throw testing::TestError::Failed;
    try testing::expect(cmp.op == ast::BinaryOp::Gt);
}

/// Test parsing a `let mut` declaration.
@test fn testParseMut() throws (testing::TestError) {
@test unsafe fn testParseMut() throws (testing::TestError) {
    let r1 = try! parseStmtStr("let mut x = 42;");
    let case ast::NodeValue::Let(n) = r1.value
        else throw testing::TestError::Failed;

    try expectIdent(n.ident, "x");

    try testing::expect(n.mutable);
    try testing::expect(n.type == nil);
}

/// Test parsing a `let mut` declaration with type annotation.
@test fn testParseMutTyped() throws (testing::TestError) {
@test unsafe fn testParseMutTyped() throws (testing::TestError) {
    let r1 = try! parseStmtStr("let mut x: i32 = 42;");
    let case ast::NodeValue::Let(n) = r1.value
        else throw testing::TestError::Failed;

    try expectIdent(n.ident, "x");

        width: 4, sign: ast::Signedness::Signed
    });
}

/// Test parsing a `constant` declaration.
@test fn testParseConst() throws (testing::TestError) {
@test unsafe fn testParseConst() throws (testing::TestError) {
    let node = try! parseStmtStr("constant ANSWER: i32 = 42;");
    let case ast::NodeValue::ConstDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.ident, "ANSWER");

    });
    try expectNumber(decl.value, "42");
}

/// Test parsing a `static` declaration.
@test fn testParseStatic() throws (testing::TestError) {
@test unsafe fn testParseStatic() throws (testing::TestError) {
    let node = try! parseStmtStr("static COUNTER: i32 = 0;");
    let case ast::NodeValue::StaticDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.ident, "COUNTER");

    });
    try expectNumber(decl.value, "0");
}

/// Test parsing a `use` declaration.
@test fn testParseUse() throws (testing::TestError) {
@test unsafe fn testParseUse() throws (testing::TestError) {
    let node = try! parseStmtStr("use module::item;");
    let case ast::NodeValue::Use(decl) = node.value
        else throw testing::TestError::Failed;

    let case ast::NodeValue::ScopeAccess(scope) = decl.path.value

    try expectIdent(scope.parent, "module");
    try expectIdent(scope.child, "item");
}

/// Test parsing a `mod` declaration.
@test fn testParseMod() throws (testing::TestError) {
@test unsafe fn testParseMod() throws (testing::TestError) {
    let node = try! parseStmtStr("mod io;");
    let case ast::NodeValue::Mod(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "io");
    try testing::expect(decl.attrs == nil);
}

/// Test parsing a module declaration with attributes.
@test fn testParseModAttributes() throws (testing::TestError) {
@test unsafe fn testParseModAttributes() throws (testing::TestError) {
    let node = try! parseStmtStr("export mod io;");
    let case ast::NodeValue::Mod(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "io");

    try testing::expect(attr == ast::Attribute::Export);
    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Export));
}

/// Test parsing an optional type.
@test fn testParseTypeOptional() throws (testing::TestError) {
@test unsafe fn testParseTypeOptional() throws (testing::TestError) {
    let node = try! parseTypeStr("?i32");
    let case ast::NodeValue::TypeSig(optional) = node.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Optional(opt) = optional
        else throw testing::TestError::Failed;

    try expectIntType(opt, 4, ast::Signedness::Signed);
}

/// Parse an `i32` pointer type and verify its class and mutability.
fn expectI32Pointer(
unsafe fn expectI32Pointer(
    source: *[u8],
    class: types::PointerClass,
    mutable: bool,
) throws (testing::TestError) {
    let node = try! parseTypeStr(source);

    try expectIntType(valueType, 4, ast::Signedness::Signed);
    assert actualMutable == mutable;
}

/// Test parsing a mutable owned pointer.
@test fn testParseTypePointer() throws (testing::TestError) {
@test unsafe fn testParseTypePointer() throws (testing::TestError) {
    try expectI32Pointer("*mut i32", types::PointerClass::Owned, true);
}

/// Test parsing an immutable owned pointer.
@test fn testParseTypePointerImmutable() throws (testing::TestError) {
@test unsafe fn testParseTypePointerImmutable() throws (testing::TestError) {
    try expectI32Pointer("*i32", types::PointerClass::Owned, false);
}

/// Test parsing immutable and mutable references.
@test fn testParseTypeRef() throws (testing::TestError) {
@test unsafe fn testParseTypeRef() throws (testing::TestError) {
    try expectI32Pointer("&i32", types::PointerClass::Ref, false);
    try expectI32Pointer("&mut i32", types::PointerClass::Ref, true);
}

/// Test parsing immutable and mutable unsafe pointers.
@test fn testParseTypeUnsafePointer() throws (testing::TestError) {
@test unsafe fn testParseTypeUnsafePointer() throws (testing::TestError) {
    try expectI32Pointer("*unsafe i32", types::PointerClass::Unsafe, false);
    try expectI32Pointer("*unsafe mut i32", types::PointerClass::Unsafe, true);
}

/// Test parsing a slice type.
@test fn testParseTypeSlice() throws (testing::TestError) {
@test unsafe fn testParseTypeSlice() throws (testing::TestError) {
    let node = try! parseTypeStr("*[u8]");
    let case ast::NodeValue::TypeSig(sig) = node.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Slice { class, itemType, mutable } = sig
        else throw testing::TestError::Failed;

    try expectIntType(itemType, 1, ast::Signedness::Unsigned);
    assert not mutable;
}

/// Test parsing a mutable slice type.
@test fn testParseTypeSliceMutable() throws (testing::TestError) {
@test unsafe fn testParseTypeSliceMutable() throws (testing::TestError) {
    let node = try! parseTypeStr("*mut [u8]");
    let case ast::NodeValue::TypeSig(sig) = node.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Slice { class, itemType, mutable } = sig
        else throw testing::TestError::Failed;

    try expectIntType(itemType, 1, ast::Signedness::Unsigned);
    assert mutable;
}

/// Test parsing reference and unsafe slice classes.
@test fn testParseTypeSliceClasses() throws (testing::TestError) {
@test unsafe fn testParseTypeSliceClasses() throws (testing::TestError) {
    let refNode = try! parseTypeStr("&[u8]");
    let case ast::NodeValue::TypeSig(ast::TypeSig::Slice {
        class: refClass, ..
    }) = refNode.value else throw testing::TestError::Failed;
    assert refClass == types::PointerClass::Ref;

    }) = unsafeNode.value else throw testing::TestError::Failed;
    assert unsafeClass == types::PointerClass::Unsafe;
}

/// Test parsing trait object pointer classes.
@test fn testParseTypeTraitObjectClasses() throws (testing::TestError) {
@test unsafe fn testParseTypeTraitObjectClasses() throws (testing::TestError) {
    let ownedNode = try! parseTypeStr("*opaque Read");
    let case ast::NodeValue::TypeSig(ast::TypeSig::TraitObject {
        class: ownedClass, ..
    }) = ownedNode.value else throw testing::TestError::Failed;
    assert ownedClass == types::PointerClass::Owned;

    }) = unsafeNode.value else throw testing::TestError::Failed;
    assert unsafeClass == types::PointerClass::Unsafe;
}

/// Test parsing an array type.
@test fn testParseTypeArray() throws (testing::TestError) {
@test unsafe fn testParseTypeArray() throws (testing::TestError) {
    let node = try! parseTypeStr("[i32; 4]");
    let case ast::NodeValue::TypeSig(sig) = node.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Array { itemType, length } = sig
        else throw testing::TestError::Failed;

    try expectIntType(itemType, 4, ast::Signedness::Signed);
    try expectNumber(length, "4");
}

/// Test parsing a named record declaration without derives.
@test fn testParseRecordDecl() throws (testing::TestError) {
@test unsafe fn testParseRecordDecl() throws (testing::TestError) {
    let node = try! parseStmtStr("record R { x: bool, y: i32 }");
    let case ast::NodeValue::RecordDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "R");

        sign: ast::Signedness::Signed,
    });
}

/// Test parsing a record declaration with derives.
@test fn testParseRecordDeclDerives() throws (testing::TestError) {
@test unsafe fn testParseRecordDeclDerives() throws (testing::TestError) {
    let node = try! parseStmtStr("record R: Eq + Debug { field: i32 }");
    let case ast::NodeValue::RecordDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "R");

    try expectIdent(decl.derives[0], "Eq");
    try expectIdent(decl.derives[1], "Debug");
}

/// Test parsing a record declaration with field initializers.
@test fn testParseRecordDeclFieldDefaults() throws (testing::TestError) {
@test unsafe fn testParseRecordDeclFieldDefaults() throws (testing::TestError) {
    let node = try! parseStmtStr("record Config { size: opaque = 42, flag: bool = true }");
    let case ast::NodeValue::RecordDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "Config");

        else throw testing::TestError::Failed;
    try testing::expect(flagValue);
}

/// Test parsing an unlabeled record declaration.
@test fn testParseTupleRecordDecl() throws (testing::TestError) {
@test unsafe fn testParseTupleRecordDecl() throws (testing::TestError) {
    let node = try! parseStmtStr("record Pair(bool, i32);");
    let case ast::NodeValue::RecordDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "Pair");

        sign: ast::Signedness::Signed,
    });
}

/// Test parsing a single-field unlabeled record.
@test fn testParseTupleRecordSingleField() throws (testing::TestError) {
@test unsafe fn testParseTupleRecordSingleField() throws (testing::TestError) {
    let node = try! parseStmtStr("record R(bool);");
    let case ast::NodeValue::RecordDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "R");


    try expectFieldSig(decl.fields, 0, nil, ast::TypeSig::Bool);
}

/// Test parsing empty record literals.
@test fn testParseEmptyRecordLiteral() throws (testing::TestError) {
@test unsafe fn testParseEmptyRecordLiteral() throws (testing::TestError) {
    let r1 = try! parseExprStr("{}");
    let case ast::NodeValue::RecordLit(lit) = r1.value
        else throw testing::TestError::Failed;

    try testing::expect(lit.typeName == nil);

    try expectIdent(typeName, "Point");
    try testing::expect(lit2.fields.len == 0);
}

/// Test parsing a function type with parameters and return type.
@test fn testParseTypeFn() throws (testing::TestError) {
@test unsafe fn testParseTypeFn() throws (testing::TestError) {
    let node = try! parseTypeStr("fn (i32, *u8) -> bool");
    let case ast::NodeValue::TypeSig(sigValue) = node.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Fn(sig) = sigValue
    let case ast::TypeSig::Fn { sig, .. } = sigValue
        else throw testing::TestError::Failed;

    try testing::expect(sig.params.len == 2);

    let param0 = sig.params[0];


    try testing::expect(sig.returnType <> nil);
}

/// Test parsing a function type with a throws clause.
@test fn testParseTypeFnThrows() throws (testing::TestError) {
@test unsafe fn testParseTypeFnThrows() throws (testing::TestError) {
    let node = try! parseTypeStr("fn (i32) -> bool throws (Error, Other)");
    let case ast::NodeValue::TypeSig(sigValue) = node.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Fn(sig) = sigValue
    let case ast::TypeSig::Fn { sig, .. } = sigValue
        else throw testing::TestError::Failed;

    try testing::expect(sig.params.len == 1);
    try expectIntType(sig.params[0], 4, ast::Signedness::Signed);


        else throw testing::TestError::Failed;
    try expectType(returnType, ast::TypeSig::Bool);
}

/// Test parsing a function declaration without parameters.
@test fn testParseFnDeclEmpty() throws (testing::TestError) {
@test unsafe fn testParseFnDeclEmpty() throws (testing::TestError) {
    let node = try! parseStmtStr("fn main() {}");
    let case ast::NodeValue::FnDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "main");

    let case ast::NodeValue::Block(_) = body.value
        else throw testing::TestError::Failed;
}

/// Test parsing a function declaration with parameters and return type.
@test fn testParseFnDeclParams() throws (testing::TestError) {
@test unsafe fn testParseFnDeclParams() throws (testing::TestError) {
    let node = try! parseStmtStr("fn add(x: i32, y: *u8) -> bool {}");
    let case ast::NodeValue::FnDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "add");

            else throw testing::TestError::Failed;
    }
}

/// Test parsing a function declaration with a throws clause.
@test fn testParseFnDeclThrows() throws (testing::TestError) {
@test unsafe fn testParseFnDeclThrows() throws (testing::TestError) {
    let node = try! parseStmtStr("fn handle() throws (Error, Crash) {}");
    let case ast::NodeValue::FnDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "handle");

    let case ast::NodeValue::Block(_) = body.value
        else throw testing::TestError::Failed;
}

/// Test scanning source-level `void` produces an identifier, not a type keyword.
@test fn testParseTypeVoidRejected() throws (testing::TestError) {
@test unsafe fn testParseTypeVoidRejected() throws (testing::TestError) {
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let mut parser = super::mkParser(scanner::SourceLoc::String, "void", &mut arena, &mut STRING_POOL);
    super::advance(&mut parser);
    try testing::expect(super::check(&parser, scanner::TokenKind::Ident));
}

/// Test parsing the unsafe function modifier.
@test fn testParseUnsafeFnDecl() throws (testing::TestError) {
@test unsafe fn testParseUnsafeFnDecl() throws (testing::TestError) {
    let node = try! parseStmtStr("unsafe fn run() {}");
    let case ast::NodeValue::FnDecl(decl) = node.value
        else throw testing::TestError::Failed;
    let attrs = decl.attrs
        else throw testing::TestError::Failed;

    try testing::expect(attrs.list.len == 1);
    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Unsafe));
}

/// Test rejecting `unsafe` on declarations where it has no semantics.
@test fn testParseUnsafeUnsupportedDecl() throws (testing::TestError) {
@test unsafe fn testParseUnsafeUnsupportedDecl() throws (testing::TestError) {
    let recordDecl: ?*ast::Node = try? parseStmtStr("unsafe record R {}");
    try testing::expect(recordDecl == nil);
    let constDecl: ?*ast::Node = try? parseStmtStr("unsafe constant X = 1;");
    try testing::expect(constDecl == nil);
}

/// Test `unsafe` on the other declaration forms that support it.
@test fn testParseUnsafeMethodAndModule() throws (testing::TestError) {
    let moduleNode = try! parseStmtStr("unsafe mod io;");
    let case ast::NodeValue::Mod(moduleDecl) = moduleNode.value
        else throw testing::TestError::Failed;
    let moduleAttrs = moduleDecl.attrs else throw testing::TestError::Failed;
    assert ast::attributesContains(&moduleAttrs, ast::Attribute::Unsafe);

/// Test unsafe method declarations.
@test unsafe fn testParseUnsafeMethods() throws (testing::TestError) {
    let instanceNode = try! parseStmtStr(
        "instance Read for Value { unsafe fn (value: &Value) get() {} }"
    );
    let case ast::NodeValue::InstanceDecl { methods, .. } = instanceNode.value
        else throw testing::TestError::Failed;

    let case ast::NodeValue::MethodDecl { attrs, .. } = methods[0].value
        else throw testing::TestError::Failed;
    let methodAttrs = attrs else throw testing::TestError::Failed;
    assert ast::attributesContains(&methodAttrs, ast::Attribute::Unsafe);

    let mut printStorage: [u8; 4096] = undefined;
    static printStorage: [u8; 4096] = undefined;
    let mut printArena = alloc::new(&mut printStorage[..]);
    let methodExpr = printer::toExpr(&mut printArena, methods[0]);
    let case sexpr::Expr::Block { items: methodItems, .. } = methodExpr
        else throw testing::TestError::Failed;
    let case sexpr::Expr::List {

        else throw testing::TestError::Failed;
    assert mem::eq(traitAttr, "@unsafe");
}

/// Test parsing a function declaration with attributes.
@test fn testParseFnDeclAttributes() throws (testing::TestError) {
@test unsafe fn testParseFnDeclAttributes() throws (testing::TestError) {
    let node = try! parseStmtStr("export fn run();");
    let case ast::NodeValue::FnDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "run");

    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Extern));
    try testing::expect(decl.body == nil);
}

/// Test parsing a top-level function declaration with inferred extern from `;`.
@test fn testParseFnDeclInferredExtern() throws (testing::TestError) {
@test unsafe fn testParseFnDeclInferredExtern() throws (testing::TestError) {
    let node = try! parseStmtStr("fn run();");
    let case ast::NodeValue::FnDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "run");

    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Extern));
    try testing::expect(decl.body == nil);
}

/// Test parsing a top-level exported function declaration with inferred extern from `;`.
@test fn testParseFnDeclExportInferredExtern() throws (testing::TestError) {
@test unsafe fn testParseFnDeclExportInferredExtern() throws (testing::TestError) {
    let node = try! parseStmtStr("export fn run();");
    let case ast::NodeValue::FnDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "run");

    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Extern));
    try testing::expect(decl.body == nil);
}

/// Test parsing a scoped identifier type.
@test fn testParseTypeScopedIdent() throws (testing::TestError) {
@test unsafe fn testParseTypeScopedIdent() throws (testing::TestError) {
    let node = try! parseTypeStr("module::Type");
    let case ast::NodeValue::TypeSig(ts) = node.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Nominal(name) = ts
        else throw testing::TestError::Failed;

    try expectIdent(access.parent, "module");
    try expectIdent(access.child, "Type");
}

/// Test parsing the `bool` type.
@test fn testParseTypeBool() throws (testing::TestError) {
@test unsafe fn testParseTypeBool() throws (testing::TestError) {
    let node = try! parseTypeStr("bool");
    try expectType(node, ast::TypeSig::Bool);
}

/// Test parsing an unsigned integer type.
@test fn testParseTypeUnsigned() throws (testing::TestError) {
@test unsafe fn testParseTypeUnsigned() throws (testing::TestError) {
    let node = try! parseTypeStr("u8");
    try expectType(node, ast::TypeSig::Integer {
        width: 1,
        sign: ast::Signedness::Unsigned,
    });
}

/// Test parsing a simple `if let` statement without guard or else.
@test fn testParseIfLet() throws (testing::TestError) {
@test unsafe fn testParseIfLet() throws (testing::TestError) {
    let root = try! parseStmtStr("if let value = opt { body; }");
    let case ast::NodeValue::IfLet(node) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(node.pattern.pattern, "value");

    try expectBlockExprStmt(node.thenBranch, ast::NodeValue::Ident("body"));
    try testing::expect(node.elseBranch == nil);
}

/// Test parsing an `if let` statement with guard and else branches.
@test fn testParseIfLetGuardElse() throws (testing::TestError) {
@test unsafe fn testParseIfLetGuardElse() throws (testing::TestError) {
    let root = try! parseStmtStr(
        "if let value = opt; guard { body; } else { alt; }"
    );
    let case ast::NodeValue::IfLet(node) = root.value
        else throw testing::TestError::Failed;

        else throw testing::TestError::Failed;
    try expectBlockExprStmt(elseBranch, ast::NodeValue::Ident("alt"));
}

/// Test parsing an `if let` statement with an `else if` chain.
@test fn testParseIfLetElseIf() throws (testing::TestError) {
@test unsafe fn testParseIfLetElseIf() throws (testing::TestError) {
    let root = try! parseStmtStr(
        "if let value = opt { body; } else if cond { alt; }"
    );
    let case ast::NodeValue::IfLet(node) = root.value
        else throw testing::TestError::Failed;

    try expectBlockExprStmt(inner.thenBranch, ast::NodeValue::Ident("alt"));
    try testing::expect(inner.elseBranch == nil);
}

/// Test parsing `if let mut` binding.
@test fn testParseIfLetMut() throws (testing::TestError) {
@test unsafe fn testParseIfLetMut() throws (testing::TestError) {
    let root = try! parseStmtStr("if let mut value = opt { body; }");
    let case ast::NodeValue::IfLet(node) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(node.pattern.pattern, "value");

    try expectBlockExprStmt(node.thenBranch, ast::NodeValue::Ident("body"));
    try testing::expect(node.elseBranch == nil);
}

/// Test parsing `let mut ... else` binding.
@test fn testParseLetMutElse() throws (testing::TestError) {
@test unsafe fn testParseLetMutElse() throws (testing::TestError) {
    let root = try! parseStmtStr("let mut x = opt else { return };");
    let case ast::NodeValue::LetElse(letElse) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(letElse.pattern.pattern, "x");
    try testing::expect(letElse.pattern.mutable);
}

/// Test that `if let` without `mut` is not mutable.
@test fn testParseIfLetNotMutable() throws (testing::TestError) {
@test unsafe fn testParseIfLetNotMutable() throws (testing::TestError) {
    let root = try! parseStmtStr("if let value = opt { body; }");
    let case ast::NodeValue::IfLet(node) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(not node.pattern.mutable);
}

/// Test that `let ... else` without `mut` is not mutable.
@test fn testParseLetElseNotMutable() throws (testing::TestError) {
@test unsafe fn testParseLetElseNotMutable() throws (testing::TestError) {
    let root = try! parseStmtStr("let x = opt else { return };");
    let case ast::NodeValue::LetElse(letElse) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(not letElse.pattern.mutable);
}

/// Test parsing a simple `if let case` statement.
@test fn testParseIfCase() throws (testing::TestError) {
@test unsafe fn testParseIfCase() throws (testing::TestError) {
    let root = try! parseStmtStr("if let case pat = value { body; }");
    let case ast::NodeValue::IfLet(node) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(node.pattern.pattern, "pat");

    try expectBlockExprStmt(node.thenBranch, ast::NodeValue::Ident("body"));
    try testing::expect(node.elseBranch == nil);
}

/// Test parsing an `if let case` statement with guard and else branches.
@test fn testParseIfCaseGuardElse() throws (testing::TestError) {
@test unsafe fn testParseIfCaseGuardElse() throws (testing::TestError) {
    let root = try! parseStmtStr(
        "if let case pat = value; guard { body; } else { alt; }"
    );
    let case ast::NodeValue::IfLet(node) = root.value
        else throw testing::TestError::Failed;

        else throw testing::TestError::Failed;
    try expectBlockExprStmt(elseBranch, ast::NodeValue::Ident("alt"));
}

/// Test parsing an `if let case` statement with an `else if` chain.
@test fn testParseIfCaseElseIf() throws (testing::TestError) {
@test unsafe fn testParseIfCaseElseIf() throws (testing::TestError) {
    let root = try! parseStmtStr(
        "if let case pat = value { body; } else if cond { alt; }"
    );
    let case ast::NodeValue::IfLet(node) = root.value
        else throw testing::TestError::Failed;

    try expectBlockExprStmt(inner.thenBranch, ast::NodeValue::Ident("alt"));
    try testing::expect(inner.elseBranch == nil);
}

/// Test parsing a simple `while` loop without an `else` branch.
@test fn testParseWhile() throws (testing::TestError) {
@test unsafe fn testParseWhile() throws (testing::TestError) {
    let root = try! parseStmtStr("while cond { body; }");
    let case ast::NodeValue::While(loopNode) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(loopNode.condition, "cond");
    try expectBlockExprStmt(loopNode.body, ast::NodeValue::Ident("body"));
    try testing::expect(loopNode.elseBranch == nil);
}

/// Test parsing a `while` loop with an `else` branch.
@test fn testParseWhileElse() throws (testing::TestError) {
@test unsafe fn testParseWhileElse() throws (testing::TestError) {
    let root = try! parseStmtStr("while cond { body; } else { alt; }");
    let case ast::NodeValue::While(loopNode) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(loopNode.condition, "cond");

        else throw testing::TestError::Failed;
    try expectBlockExprStmt(elseBranch, ast::NodeValue::Ident("alt"));
}

/// Test parsing a simple `while let case` loop.
@test fn testParseWhileCase() throws (testing::TestError) {
@test unsafe fn testParseWhileCase() throws (testing::TestError) {
    let root = try! parseStmtStr("while let case pat = value { body; }");
    let case ast::NodeValue::WhileLet(node) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(node.pattern.pattern, "pat");

    try expectBlockExprStmt(node.body, ast::NodeValue::Ident("body"));
    try testing::expect(node.elseBranch == nil);
}

/// Test parsing a `while let case` loop with guard and else branches.
@test fn testParseWhileCaseGuardElse() throws (testing::TestError) {
@test unsafe fn testParseWhileCaseGuardElse() throws (testing::TestError) {
    let root = try! parseStmtStr(
        "while let case pat = value; guard { body; } else { alt; }"
    );
    let case ast::NodeValue::WhileLet(node) = root.value
        else throw testing::TestError::Failed;

        else throw testing::TestError::Failed;
    try expectBlockExprStmt(elseBranch, ast::NodeValue::Ident("alt"));
}

/// Test parsing a simple `try` expression without catch.
@test fn testParseTry() throws (testing::TestError) {
@test unsafe fn testParseTry() throws (testing::TestError) {
    let root = try! parseExprStr("try value");
    let case ast::NodeValue::Try(node) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(node.expr, "value");
    try testing::expect(node.catches.len == 0);
    try testing::expect(not node.shouldPanic);
}

/// Test that `try?` consumes a unary operand.
@test fn testParseTryOptionalUnary() throws (testing::TestError) {
@test unsafe fn testParseTryOptionalUnary() throws (testing::TestError) {
    let root = try! parseExprStr("try? -value");
    let case ast::NodeValue::Try(node) = root.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::UnOp(neg) = node.expr.value
        else throw testing::TestError::Failed;

    try expectIdent(neg.value, "value");
    try testing::expect(node.returnsOptional);
}

/// Test parsing a `try!` expression that panics on error.
@test fn testParseTryBang() throws (testing::TestError) {
@test unsafe fn testParseTryBang() throws (testing::TestError) {
    let root = try! parseExprStr("try! value");
    let case ast::NodeValue::Try(node) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(node.expr, "value");
    try testing::expect(node.catches.len == 0);
    try testing::expect(node.shouldPanic);
}

/// Test parsing a `try` expression with a `catch` block.
@test fn testParseTryCatchBlock() throws (testing::TestError) {
@test unsafe fn testParseTryCatchBlock() throws (testing::TestError) {
    let root = try! parseExprStr("try value catch { alt; }");
    let case ast::NodeValue::Try(node) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(node.expr, "value");

    try testing::expect(clause.typeNode == nil);
    try expectBlockExprStmt(clause.body, ast::NodeValue::Ident("alt"));
}

/// Test that `catch` without a block is rejected.
@test fn testParseTryCatchExprRejected() throws (testing::TestError) {
@test unsafe fn testParseTryCatchExprRejected() throws (testing::TestError) {
    let parsed: ?*ast::Node = try? parseExprStr("try value catch alternate");
    try testing::expect(parsed == nil);
}

/// Test parsing a `break` statement.
@test fn testParseBreak() throws (testing::TestError) {
@test unsafe fn testParseBreak() throws (testing::TestError) {
    let root = try! parseStmtStr("break");
    let case ast::NodeValue::Break= root.value
        else throw testing::TestError::Failed;
}

/// Test parsing a `continue` statement.
@test fn testParseContinue() throws (testing::TestError) {
@test unsafe fn testParseContinue() throws (testing::TestError) {
    let root = try! parseStmtStr("continue");
    let case ast::NodeValue::Continue= root.value
        else throw testing::TestError::Failed;
}

/// Test parsing a `return` statement without value.
@test fn testParseReturnVoid() throws (testing::TestError) {
@test unsafe fn testParseReturnVoid() throws (testing::TestError) {
    let root = try! parseStmtStr("return");
    let case ast::NodeValue::Return(retValue) = root.value
        else throw testing::TestError::Failed;

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

/// Test parsing a `return` statement with a value.
@test fn testParseReturnValue() throws (testing::TestError) {
@test unsafe fn testParseReturnValue() throws (testing::TestError) {
    let root = try! parseStmtStr("return result");
    let case ast::NodeValue::Return(retValue) = root.value
        else throw testing::TestError::Failed;

    let value = retValue
        else throw testing::TestError::Failed;
    try expectIdent(value, "result");
}

/// Test parsing a `throw` statement.
@test fn testParseThrow() throws (testing::TestError) {
@test unsafe fn testParseThrow() throws (testing::TestError) {
    let root = try! parseStmtStr("throw error");
    let case ast::NodeValue::Throw(throwExpr) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(throwExpr, "error");
}

/// Test parsing a `panic` statement without a message.
@test fn testParsePanicEmpty() throws (testing::TestError) {
@test unsafe fn testParsePanicEmpty() throws (testing::TestError) {
    let root = try! parseStmtStr("panic");
    let case ast::NodeValue::Panic(panicMsg) = root.value
        else throw testing::TestError::Failed;

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

/// Test parsing a `panic` statement with a message.
@test fn testParsePanicMessage() throws (testing::TestError) {
@test unsafe fn testParsePanicMessage() throws (testing::TestError) {
    let root = try! parseStmtStr("panic \"something went wrong\"");
    let case ast::NodeValue::Panic(panicMsg) = root.value
        else throw testing::TestError::Failed;

    let message = panicMsg

    let case ast::NodeValue::String(msgStr) = message.value if mem::eq(msgStr, "something went wrong")
        else throw testing::TestError::Failed;
}

/// Test parsing a `panic` statement with braces.
@test fn testParsePanicBraces() throws (testing::TestError) {
@test unsafe fn testParsePanicBraces() throws (testing::TestError) {
    let root = try! parseStmtStr("panic { \"error\" }");
    let case ast::NodeValue::Panic(panicMsg) = root.value
        else throw testing::TestError::Failed;

    let message = panicMsg

    let case ast::NodeValue::String(msgStr) = message.value if mem::eq(msgStr, "error")
        else throw testing::TestError::Failed;
}

/// Test parsing a simple `match` statement with one case.
@test fn testParseMatchSingle() throws (testing::TestError) {
@test unsafe fn testParseMatchSingle() throws (testing::TestError) {
    let root = try! parseStmtStr("match subject { case pattern => body }");
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(sw.subject, "subject");

        if mem::eq(name, "body")
        else throw testing::TestError::Failed;
}

/// Test parsing a `match` case with guard and multiple patterns.
@test fn testParseMatchGuard() throws (testing::TestError) {
@test unsafe fn testParseMatchGuard() throws (testing::TestError) {
    let root = try! parseStmtStr(
        "match subject { case left, right if cond => handle }"
    );
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

        else throw testing::TestError::Failed;
    try expectIdent(guard, "cond");
}

/// Test parsing `match` prongs whose bodies omit trailing semicolons.
@test fn testParseMatchReturnNoSemicolon() throws (testing::TestError) {
@test unsafe fn testParseMatchReturnNoSemicolon() throws (testing::TestError) {
    let root = try! parseStmtStr(
        "match subject { case First => return, case Second => return }"
    );
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

        else throw testing::TestError::Failed;
    try testing::expect(secondRetVal == nil);
}

/// Test parsing a `match` statement with multiple branches.
@test fn testParseMatchMultipleCases() throws (testing::TestError) {
@test unsafe fn testParseMatchMultipleCases() throws (testing::TestError) {
    let root = try! parseStmtStr(
        "match subject { case First => first, case Second => second }"
    );
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

            else throw testing::TestError::Failed;
    }
}

/// Test parsing a `match` case whose body is a block.
@test fn testParseMatchProngBlock() throws (testing::TestError) {
@test unsafe fn testParseMatchProngBlock() throws (testing::TestError) {
    let root = try! parseStmtStr("match subject { case Pattern => { body; } }");
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sw.prongs.len == 1);

        else throw testing::TestError::Failed;
    try expectBlockExprStmt(prong.body, ast::NodeValue::Ident("body"));
}

/// Test parsing a `match` statement with an `else` case.
@test fn testParseMatchElse() throws (testing::TestError) {
@test unsafe fn testParseMatchElse() throws (testing::TestError) {
    let root = try! parseStmtStr("match subject { else => body }");
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sw.prongs.len == 1);

        if mem::eq(name, "body")
        else throw testing::TestError::Failed;
}

/// Test parsing a `match` statement with a binding prong.
@test fn testParseMatchBinding() throws (testing::TestError) {
@test unsafe fn testParseMatchBinding() throws (testing::TestError) {
    let root = try! parseStmtStr("match subject { x => body }");
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sw.prongs.len == 1);

        else throw testing::TestError::Failed;
    try expectIdent(bodyStmt, "body");
}

/// Test parsing a `match` statement with a guarded binding prong.
@test fn testParseMatchBindingGuard() throws (testing::TestError) {
@test unsafe fn testParseMatchBindingGuard() throws (testing::TestError) {
    let root = try! parseStmtStr("match subject { x if x > 0 => body }");
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sw.prongs.len == 1);

        else throw testing::TestError::Failed;
    try testing::expect(binop.op == ast::BinaryOp::Gt);
}

/// Test parsing a `match` statement with a `_` wildcard.
@test fn testParseMatchWildcard() throws (testing::TestError) {
@test unsafe fn testParseMatchWildcard() throws (testing::TestError) {
    let root = try! parseStmtStr("match subject { _ => body }");
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sw.prongs.len == 1);

        else throw testing::TestError::Failed;
    try expectIdent(bodyStmt, "body");
}

/// Test parsing a `match` statement with a guarded `_` wildcard.
@test fn testParseMatchWildcardGuard() throws (testing::TestError) {
@test unsafe fn testParseMatchWildcardGuard() throws (testing::TestError) {
    let root = try! parseStmtStr("match subject { _ if cond => body }");
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sw.prongs.len == 1);

        else throw testing::TestError::Failed;
    try expectIdent(bodyStmt, "body");
}

/// Test parsing a `while let` loop with guard and else branches.
@test fn testParseWhileLet() throws (testing::TestError) {
@test unsafe fn testParseWhileLet() throws (testing::TestError) {
    let root = try! parseStmtStr(
        "while let value = opt; guard { body; } else { alt; }"
    );
    let case ast::NodeValue::WhileLet(loopNode) = root.value
        else throw testing::TestError::Failed;

        else throw testing::TestError::Failed;
    try expectBlockExprStmt(elseBranch, ast::NodeValue::Ident("alt"));
}

/// Test parsing a simple `loop` statement.
@test fn testParseLoop() throws (testing::TestError) {
@test unsafe fn testParseLoop() throws (testing::TestError) {
    let root = try! parseStmtStr("loop { body; }");
    let case ast::NodeValue::Loop(loopBody) = root.value
        else throw testing::TestError::Failed;

    try expectBlockExprStmt(loopBody, ast::NodeValue::Ident("body"));
}

/// Test parsing a `for` loop without index or else branches.
@test fn testParseFor() throws (testing::TestError) {
@test unsafe fn testParseFor() throws (testing::TestError) {
    let root = try! parseStmtStr("for item in items { body; }");
    let case ast::NodeValue::For(loopNode) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(loopNode.binding, "item");

    try expectBlockExprStmt(loopNode.body, ast::NodeValue::Ident("body"));
    try testing::expect(loopNode.elseBranch == nil);
}

/// Test parsing a `for` loop over a range expression.
@test fn testParseForRangeIterable() throws (testing::TestError) {
@test unsafe fn testParseForRangeIterable() throws (testing::TestError) {
    let root = try! parseStmtStr("for item in 0..5 {}");
    let case ast::NodeValue::For(loopNode) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(loopNode.binding, "item");

    try testing::expect(body.statements.len == 0);
    try testing::expect(loopNode.elseBranch == nil);
}

/// Test parsing a `for` loop with index and else branches.
@test fn testParseForIndexElse() throws (testing::TestError) {
@test unsafe fn testParseForIndexElse() throws (testing::TestError) {
    let root = try! parseStmtStr(
        "for value, idx in items { body; } else { alt; }"
    );
    let case ast::NodeValue::For(loopNode) = root.value
        else throw testing::TestError::Failed;

        else throw testing::TestError::Failed;
    try expectBlockExprStmt(elseBranch, ast::NodeValue::Ident("alt"));
}

/// Test parsing field access expression.
@test fn testParseFieldAccess() throws (testing::TestError) {
@test unsafe fn testParseFieldAccess() throws (testing::TestError) {
    let root = try! parseExprStr("obj.field");
    let case ast::NodeValue::FieldAccess(access) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(access.parent, "obj");
    try expectIdent(access.child, "field");
}

/// Test parsing scope access expression.
@test fn testParseScopeAccess() throws (testing::TestError) {
@test unsafe fn testParseScopeAccess() throws (testing::TestError) {
    let root = try! parseExprStr("module::item");
    let case ast::NodeValue::ScopeAccess(access) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(access.parent, "module");
    try expectIdent(access.child, "item");
}

/// Test parsing array subscript expression.
@test fn testParseArraySubscript() throws (testing::TestError) {
@test unsafe fn testParseArraySubscript() throws (testing::TestError) {
    let root = try! parseExprStr("array[index]");
    let case ast::NodeValue::Subscript { container, index } = root.value
        else throw testing::TestError::Failed;

    try expectIdent(container, "array");
    try expectIdent(index, "index");
}

/// Test parsing array slicing expressions.
@test fn testParseArraySlicing() throws (testing::TestError) {
@test unsafe fn testParseArraySlicing() throws (testing::TestError) {
    // Test `array[start..end]`.
    {
        let expr = try! parseExprStr("array[1..10]");
        let case ast::NodeValue::Subscript { container: subContainer, index: subIndex } = expr.value
            else throw testing::TestError::Failed;

        try testing::expect(range.end == nil);
    }
}

/// Test parsing function call expression.
@test fn testParseFunctionCall() throws (testing::TestError) {
@test unsafe fn testParseFunctionCall() throws (testing::TestError) {
    let root = try! parseExprStr("func(x, y)");
    let case ast::NodeValue::Call(call) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(call.callee, "func");

    try expectIdent(call.args[0], "x");
    try expectIdent(call.args[1], "y");
}

/// Test parsing chained postfix operators.
@test fn testParseChainedPostfix() throws (testing::TestError) {
@test unsafe fn testParseChainedPostfix() throws (testing::TestError) {
    let root = try! parseExprStr("obj.method(arg)[0]");
    let case ast::NodeValue::Subscript { container: subContainer, index: subIndex } = root.value
        else throw testing::TestError::Failed;

    let case ast::NodeValue::Call(call) = subContainer.value

    try testing::expect(call.args.len == 1);
    try expectIdent(call.args[0], "arg");
}

/// Test parsing a literal cast using `as`.
@test fn testParseAsCastLiteral() throws (testing::TestError) {
@test unsafe fn testParseAsCastLiteral() throws (testing::TestError) {
    let root = try! parseExprStr("1 as i32");
    let case ast::NodeValue::As(asExpr) = root.value
        else throw testing::TestError::Failed;

    let case ast::NodeValue::Number(_) = asExpr.value.value


    try expectIntType(asExpr.type, 4, ast::Signedness::Signed);
}

/// Test parsing a cast following chained postfix expressions.
@test fn testParseAsCastWithPostfix() throws (testing::TestError) {
@test unsafe fn testParseAsCastWithPostfix() throws (testing::TestError) {
    let root = try! parseExprStr("value.method(arg) as u32");
    let case ast::NodeValue::As(asExpr) = root.value
        else throw testing::TestError::Failed;

    let case ast::NodeValue::Call(call) = asExpr.value.value

    try expectIdent(call.args[0], "arg");
    try expectIntType(asExpr.type, 4, ast::Signedness::Unsigned);
}

/// Test parsing @sizeOf builtin.
@test fn testParseBuiltinSizeOf() throws (testing::TestError) {
@test unsafe fn testParseBuiltinSizeOf() throws (testing::TestError) {
    let expr = try! parseExprStr("@sizeOf(i32)");
    let case ast::NodeValue::BuiltinCall { kind: builtinKind, args: builtinArgs } = expr.value
        else throw testing::TestError::Failed;

    try testing::expect(builtinKind == ast::Builtin::SizeOf);

        sign: ast::Signedness::Signed,
    });
}

/// Test parsing @alignOf builtin.
@test fn testParseBuiltinAlignOf() throws (testing::TestError) {
@test unsafe fn testParseBuiltinAlignOf() throws (testing::TestError) {
    let expr = try! parseExprStr("@alignOf(i32)");
    let case ast::NodeValue::BuiltinCall { kind: builtinKind, args: builtinArgs } = expr.value
        else throw testing::TestError::Failed;

    try testing::expect(builtinKind == ast::Builtin::AlignOf);

        sign: ast::Signedness::Signed,
    });
}

/// Test parsing @sliceOf with varying argument counts.
@test fn testParseBuiltinSliceOf() throws (testing::TestError) {
@test unsafe fn testParseBuiltinSliceOf() throws (testing::TestError) {
    // Two arguments.
    {
        let expr = try! parseExprStr("@sliceOf(ptr, len)");
        let case ast::NodeValue::BuiltinCall { kind: builtinKind, args: builtinArgs } = expr.value
            else throw testing::TestError::Failed;

        try testing::expect(builtinArgs.len == 3);
    }
}

/// Test parsing prefix unary operators.
@test fn testParseUnaryOperators() throws (testing::TestError) {
@test unsafe fn testParseUnaryOperators() throws (testing::TestError) {
    {
        let notExpr = try! parseExprStr("not flag");
        let case ast::NodeValue::UnOp(notNode) = notExpr.value
            else throw testing::TestError::Failed;
        try testing::expect(notNode.op == ast::UnaryOp::Not);

        try expectIdent(bitNotNode.value, "mask");
    }
}

/// Test parsing dereference expressions.
@test fn testParseDereference() throws (testing::TestError) {
@test unsafe fn testParseDereference() throws (testing::TestError) {
    {
        let derefExpr = try! parseExprStr("*ptr");
        let case ast::NodeValue::Deref(target) = derefExpr.value
            else throw testing::TestError::Failed;
        try expectIdent(target, "ptr");

        try expectIdent(access.child, "field");
    }
}

/// Test parsing reference (address-of) expressions.
@test fn testParseRefs() throws (testing::TestError) {
@test unsafe fn testParseRefs() throws (testing::TestError) {
    {
        let refExpr = try! parseExprStr("&foo");
        let case ast::NodeValue::AddressOf(refNode) = refExpr.value
            else throw testing::TestError::Failed;
        try testing::expect(refNode.mutable == false);

        try expectIdent(access.child, "field");
    }
}

/// Test unary operator precedence relative to binary and postfix expressions.
@test fn testParseUnaryPrecedence() throws (testing::TestError) {
@test unsafe fn testParseUnaryPrecedence() throws (testing::TestError) {
    {
        let expr = try! parseExprStr("not a and b");
        let case ast::NodeValue::BinOp(bin) = expr.value
            else throw testing::TestError::Failed;
        try testing::expect(bin.op == ast::BinaryOp::And);

        try expectIdent(call.callee, "func");
    }
}

/// Test parsing assignment expressions.
@test fn testParseAssignment() throws (testing::TestError) {
@test unsafe fn testParseAssignment() throws (testing::TestError) {
    {
        let assign = try! parseStmtStr("set x = 1;");
        let case ast::NodeValue::Assign(node) = assign.value
            else throw testing::TestError::Failed;
        try expectIdent(node.left, "x");

        try expectIdent(access.child, "VAR");
    }
}

/// Test that assignment syntax requires the `set` statement.
@test fn testAssignmentRequiresSetKeyword() throws (testing::TestError) {
@test unsafe fn testAssignmentRequiresSetKeyword() throws (testing::TestError) {
    let assign: ?*ast::Node = try? parseStmtStr("x = 1;");
    try testing::expect(assign == nil);

    let compoundAssign: ?*ast::Node = try? parseStmtStr("x += 1;");
    try testing::expect(compoundAssign == nil);
}

/// Test that `set` requires an assignable target.
@test fn testSetRequiresAssignableTarget() throws (testing::TestError) {
@test unsafe fn testSetRequiresAssignableTarget() throws (testing::TestError) {
    let binTarget: ?*ast::Node = try? parseStmtStr("set x + y = 1;");
    try testing::expect(binTarget == nil);

    let condTarget: ?*ast::Node = try? parseStmtStr("set x if ok else y = 1;");
    try testing::expect(condTarget == nil);
}

/// Test parsing basic arithmetic binary operators (+, -, *, /, %).
@test fn testParseBinOpArithmetic() throws (testing::TestError) {
@test unsafe fn testParseBinOpArithmetic() throws (testing::TestError) {
    let add = try! parseExprStr("a + b");
    let case ast::NodeValue::BinOp(op1) = add.value
        else throw testing::TestError::Failed;
    try testing::expect(op1.op == ast::BinaryOp::Add);
    try expectIdent(op1.left, "a");

        else throw testing::TestError::Failed;
    try testing::expect(op5.op == ast::BinaryOp::Mod);
}

/// Test parsing comparison binary operators (==, <>).
@test fn testParseBinOpEq() throws (testing::TestError) {
@test unsafe fn testParseBinOpEq() throws (testing::TestError) {
    let eq = try! parseExprStr("a == b");
    let case ast::NodeValue::BinOp(op1) = eq.value
        else throw testing::TestError::Failed;
    try testing::expect(op1.op == ast::BinaryOp::Eq);


        else throw testing::TestError::Failed;
    try testing::expect(op2.op == ast::BinaryOp::Ne);
}

/// Test parsing comparison binary operators.
@test fn testParseBinOpGtLt() throws (testing::TestError) {
@test unsafe fn testParseBinOpGtLt() throws (testing::TestError) {
    let lt = try! parseExprStr("a < b");
    let case ast::NodeValue::BinOp(op1) = lt.value
        else throw testing::TestError::Failed;
    try testing::expect(op1.op == ast::BinaryOp::Lt);


        else throw testing::TestError::Failed;
    try testing::expect(op4.op == ast::BinaryOp::Gte);
}

/// Test parsing bitwise binary operators (&, |, ^, <<, >>).
@test fn testParseBinOpBitwise() throws (testing::TestError) {
@test unsafe fn testParseBinOpBitwise() throws (testing::TestError) {
    let bitAnd = try! parseExprStr("a & b");
    let case ast::NodeValue::BinOp(op1) = bitAnd.value
        else throw testing::TestError::Failed;
    try testing::expect(op1.op == ast::BinaryOp::BitAnd);


        else throw testing::TestError::Failed;
    try testing::expect(op5.op == ast::BinaryOp::Shr);
}

/// Test parsing logical binary operators (and, or).
@test fn testParseBinOpLogical() throws (testing::TestError) {
@test unsafe fn testParseBinOpLogical() throws (testing::TestError) {
    let andOp = try! parseExprStr("a and b");
    let case ast::NodeValue::BinOp(op1) = andOp.value
        else throw testing::TestError::Failed;
    try testing::expect(op1.op == ast::BinaryOp::And);
    try expectIdent(op1.left, "a");

    try expectIdent(op2.left, "x");
    try expectIdent(op2.right, "y");
}

/// Test operator precedence: multiplication before addition.
@test fn testParseBinOpPrecedenceMulAdd() throws (testing::TestError) {
@test unsafe fn testParseBinOpPrecedenceMulAdd() throws (testing::TestError) {
    let root = try! parseExprStr("a + b * c");
    let case ast::NodeValue::BinOp(add) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(add.op == ast::BinaryOp::Add);

    try expectIdent(mul.left, "b");
    try expectIdent(mul.right, "c");
}

/// Test operator precedence: shifts before bitwise operations.
@test fn testParseBinOpPrecedenceShiftBitwise() throws (testing::TestError) {
@test unsafe fn testParseBinOpPrecedenceShiftBitwise() throws (testing::TestError) {
    let root = try! parseExprStr("a & b << c");
    let case ast::NodeValue::BinOp(bitAnd) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(bitAnd.op == ast::BinaryOp::BitAnd);

    try expectIdent(shl.left, "b");
    try expectIdent(shl.right, "c");
}

/// Test operator precedence: comparison before logical AND.
@test fn testParseBinOpPrecedenceCompareLogical() throws (testing::TestError) {
@test unsafe fn testParseBinOpPrecedenceCompareLogical() throws (testing::TestError) {
    let root = try! parseExprStr("a < b and c > d");
    let case ast::NodeValue::BinOp(andOp) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(andOp.op == ast::BinaryOp::And);

    try expectIdent(gt.left, "c");
    try expectIdent(gt.right, "d");
}

/// Test left associativity of addition.
@test fn testParseBinOpAssociativityAdd() throws (testing::TestError) {
@test unsafe fn testParseBinOpAssociativityAdd() throws (testing::TestError) {
    let root = try! parseExprStr("a + b + c");
    let case ast::NodeValue::BinOp(add2) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(add2.op == ast::BinaryOp::Add);

    try expectIdent(add1.left, "a");
    try expectIdent(add1.right, "b");
}

/// Test complex expression with multiple operators and precedence.
@test fn testParseBinOpComplex() throws (testing::TestError) {
@test unsafe fn testParseBinOpComplex() throws (testing::TestError) {
    let root = try! parseExprStr("a + b * c - d / e");
    let case ast::NodeValue::BinOp(sub) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sub.op == ast::BinaryOp::Sub);

        else throw testing::TestError::Failed;
    try testing::expect(div.op == ast::BinaryOp::Div);
}

/// Test binary operators with parentheses override precedence.
@test fn testParseBinOpParentheses() throws (testing::TestError) {
@test unsafe fn testParseBinOpParentheses() throws (testing::TestError) {
    let root = try! parseExprStr("(a + b) * c");
    let case ast::NodeValue::BinOp(mul) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(mul.op == ast::BinaryOp::Mul);

    try expectIdent(add.left, "a");
    try expectIdent(add.right, "b");
}

/// Test parsing a simple union without payloads.
@test fn testParseEnumSimple() throws (testing::TestError) {
@test unsafe fn testParseEnumSimple() throws (testing::TestError) {
    let node = try! parseStmtStr("union Color { Red, Green, Blue }");
    let case ast::NodeValue::UnionDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "Color");

    try testing::expect(var2.type == nil);
    try testing::expect(var2.value == nil);
}

/// Test parsing a union with trailing comma.
@test fn testParseEnumTrailingComma() throws (testing::TestError) {
@test unsafe fn testParseEnumTrailingComma() throws (testing::TestError) {
    let node = try! parseStmtStr("union Letter { A, B, C, }");
    let case ast::NodeValue::UnionDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "Letter");
    try testing::expect(decl.variants.len == 3);
}

/// Test parsing a union with explicit values.
@test fn testParseEnumExplicitValues() throws (testing::TestError) {
@test unsafe fn testParseEnumExplicitValues() throws (testing::TestError) {
    let node = try! parseStmtStr("union Status { Ok = 0, Error = 1, Pending = 5 }");
    let case ast::NodeValue::UnionDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "Status");

    try testing::expect(var2.index == 2);
    try testing::expect(var2.value <> nil);
}

/// Test parsing a union with payload and tag-only variants.
@test fn testParseEnumWithPayloads() throws (testing::TestError) {
@test unsafe fn testParseEnumWithPayloads() throws (testing::TestError) {
    let node = try! parseStmtStr("union Result { Ok(bool), Error }");
    let case ast::NodeValue::UnionDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "Result");

    let errFields = try expectVariant(decl.variants[1], "Error", 1);
    try testing::expect(errFields == nil);
}

/// Test parsing a union with derives.
@test fn testParseEnumWithDerives() throws (testing::TestError) {
@test unsafe fn testParseEnumWithDerives() throws (testing::TestError) {
    let node = try! parseStmtStr("union Option: Debug + Eq { None, Some(i32) }");
    let case ast::NodeValue::UnionDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "Option");

    try expectIdent(var1.name, "Some");
    try testing::expect(var1.type <> nil);
}

/// Test parsing named record literals with named fields.
@test fn testParseNamedRecordLiteralNamed() throws (testing::TestError) {
@test unsafe fn testParseNamedRecordLiteralNamed() throws (testing::TestError) {
    let r1 = try! parseExprStr("Point { x: 5, y: 10 }");
    let case ast::NodeValue::RecordLit(lit) = r1.value
        else throw testing::TestError::Failed;

    let typeName = lit.typeName else throw testing::TestError::Failed;

    try expectIdent(label0, "x");
    try expectNumber(arg0.value, "5");
}

/// Test parsing anonymous record literals with named fields.
@test fn testParseAnonymousRecordLiteralNamed() throws (testing::TestError) {
@test unsafe fn testParseAnonymousRecordLiteralNamed() throws (testing::TestError) {
    let r1 = try! parseExprStr("{ x: 10, y: 20 }");
    let case ast::NodeValue::RecordLit(lit) = r1.value
        else throw testing::TestError::Failed;

    try testing::expect(lit.typeName == nil);

    try expectNumber(arg1.value, "20");
}

/// Test parsing record literals with shorthand field syntax.
/// `{ x, y }` is equivalent to `{ x: x, y: y }`.
@test fn testParseRecordLiteralShorthand() throws (testing::TestError) {
@test unsafe fn testParseRecordLiteralShorthand() throws (testing::TestError) {
    let r1 = try! parseExprStr("Point { x, y }");
    let case ast::NodeValue::RecordLit(lit) = r1.value
        else throw testing::TestError::Failed;

    let typeName = lit.typeName else throw testing::TestError::Failed;

    try expectIdent(arg1.value, "y");
    try testing::expect(label1 == arg1.value);
}

/// Test parsing record literals with mixed shorthand and explicit fields.
@test fn testParseRecordLiteralMixedShorthand() throws (testing::TestError) {
@test unsafe fn testParseRecordLiteralMixedShorthand() throws (testing::TestError) {
    let r1 = try! parseExprStr("Point { x, y: 10 }");
    let case ast::NodeValue::RecordLit(lit) = r1.value
        else throw testing::TestError::Failed;

    try testing::expect(lit.fields.len == 2);

    try expectIdent(label1, "y");
    try expectNumber(arg1.value, "10");
}

/// Test that positional brace initializers are rejected: `{ 1, 2 }`.
@test fn testParsePositionalBraceInitializerAnonymous() throws (testing::TestError) {
@test unsafe fn testParsePositionalBraceInitializerAnonymous() throws (testing::TestError) {
    let parsed: ?*ast::Node = try? parseExprStr("{ 1, 2 }");
    try testing::expect(parsed == nil);
}

/// Test that positional brace initializers are rejected: `Point { 1, 2 }`.
@test fn testParsePositionalBraceInitializerNamed() throws (testing::TestError) {
@test unsafe fn testParsePositionalBraceInitializerNamed() throws (testing::TestError) {
    let parsed: ?*ast::Node = try? parseExprStr("Point { 1, 2 }");
    try testing::expect(parsed == nil);
}

/// Test that mixed labeled/positional brace initializers are rejected: `Pt { x: 1, 2 }`.
@test fn testParseMixedBraceInitializer() throws (testing::TestError) {
@test unsafe fn testParseMixedBraceInitializer() throws (testing::TestError) {
    let parsed: ?*ast::Node = try? parseExprStr("Pt { x: 1, 2 }");
    try testing::expect(parsed == nil);
}

@test fn testParseModule() throws (testing::TestError) {
@test unsafe fn testParseModule() throws (testing::TestError) {
    let r = try! parseStmtsStr("fn f() {} fn g() {}");

    let case ast::NodeValue::Block(module) = r.value
        else throw testing::TestError::Failed;
    try testing::expect(module.statements.len == 2);

        else throw testing::TestError::Failed;
    try expectIdent(gDecl.name, "g");
}

/// Test parsing a simple conditional expression.
@test fn testParseCondExpr() throws (testing::TestError) {
@test unsafe fn testParseCondExpr() throws (testing::TestError) {
    let r = try! parseExprStr("a if cond else b") catch {
        throw testing::TestError::Failed;
    };
    let case ast::NodeValue::CondExpr(cond) = r.value
        else throw testing::TestError::Failed;

    try expectIdent(cond.condition, "cond");
    try expectIdent(cond.elseExpr, "b");
}

/// Test parsing a conditional expression with `as` casts.
@test fn testParseCondExprWithAsCast() throws (testing::TestError) {
@test unsafe fn testParseCondExprWithAsCast() throws (testing::TestError) {
    let r = try! parseExprStr("x as i32 if cond else y as i32") catch {
        throw testing::TestError::Failed;
    };
    let case ast::NodeValue::CondExpr(cond) = r.value
        else throw testing::TestError::Failed;

    try expectIdent(elseAs.value, "y");
    try expectIntType(elseAs.type, 4, ast::Signedness::Signed);
}

/// Test parsing a nested conditional expression (right-associative).
@test fn testParseCondExprNested() throws (testing::TestError) {
@test unsafe fn testParseCondExprNested() throws (testing::TestError) {
    let r = try! parseExprStr("a if x else b if y else c") catch {
        throw testing::TestError::Failed;
    };
    let case ast::NodeValue::CondExpr(outer) = r.value
        else throw testing::TestError::Failed;

    try expectIdent(inner.condition, "y");
    try expectIdent(inner.elseExpr, "c");
}

/// Test that trailing commas are allowed in all comma-separated lists.
@test fn testTrailingCommas() throws (testing::TestError) {
@test unsafe fn testTrailingCommas() throws (testing::TestError) {
    // Function call arguments.
    let call = try! parseExprStr("f(1, 2, 3,)");
    let case ast::NodeValue::Call(c) = call.value else throw testing::TestError::Failed;
    try testing::expect(c.args.len == 3);


    try testing::expect(items.len == 3);

    // Function type parameters.
    let fnType = try! parseTypeStr("fn (i32, bool,)");
    let case ast::NodeValue::TypeSig(sigValue) = fnType.value else throw testing::TestError::Failed;
    let case ast::TypeSig::Fn(sig) = sigValue else throw testing::TestError::Failed;
    let case ast::TypeSig::Fn { sig, .. } = sigValue else throw testing::TestError::Failed;
    try testing::expect(sig.params.len == 2);
    try testing::expect(sig.returnType == nil);

    // Throws lists.
    let throwsNode = try! parseStmtStr("fn handle() throws (Error, Other,) {}");
    let case ast::NodeValue::FnDecl(throwsDecl) = throwsNode.value else throw testing::TestError::Failed;
    try testing::expect(throwsDecl.sig.throwList.len == 2);
}

/// Unsafe function types preserve their call requirement and signature.
@test unsafe fn testParseUnsafeFunctionType() throws (testing::TestError) {
    let node = try! parseTypeStr("unsafe fn(&u32) -> u32 throws (Error)");
    let case ast::NodeValue::TypeSig(ast::TypeSig::Fn { sig, isUnsafe }) = node.value
        else throw testing::TestError::Failed;
    assert isUnsafe;
    assert sig.params.len == 1;
    assert sig.returnType <> nil;
    assert sig.throwList.len == 1;
}

lib/std/lang/resolver.rad +488 -408

    /// Coerce a concrete pointer to a trait object.
    TraitObject {
        /// Trait type information.
        traitInfo: *TraitType,
        /// Instance entry for v-table lookup.
        inst: *InstanceEntry,
        inst: *unsafe InstanceEntry,
    },
}

/// Result of resolving a module path.
record ResolvedModule: Copy {

    InvalidRefPosition,
    /// A reference cannot be bound to a local.
    RefBinding,
    /// Call arguments contain overlapping incompatible loans.
    BorrowConflict(*[u8]),
    /// Unsafe pointer operation outside an `unsafe` declaration.
    /// Unsafe pointer operation outside an `unsafe` function.
    UnsafeOperation,
    /// Safe code cannot call an `unsafe` function.
    UnsafeCall,
    /// Internal error.
    Internal,

        traitInfo: *TraitType,
        /// Method index in the v-table.
        methodIndex: u32,
    },
    /// Standalone method call metadata.
    MethodCall { method: *MethodEntry },
    MethodCall { method: *unsafe MethodEntry },
    /// Slice `.append(val, allocator)` method call.
    SliceAppend { elemType: *Type },
    /// Slice `.delete(index)` method call.
    SliceDelete { elemType: *Type },
}

/// Function-local exact-use checker state.
/// Read loop arrays only at indices below `loopDepth`.
/// `enterLinearLoop` initializes each slot before it increases `loopDepth`.
record LinearChecker: Copy {
    /// Resolver that owns the symbols and diagnostics.
    resolver: *mut Resolver,
    resolver: *unsafe mut Resolver,
    /// Binding count at entry to each active loop.
    loopMarks: [u32; MAX_LINEAR_LOOP_DEPTH],
    /// Available bindings at entry to each active loop.
    loopAvailable: [u64; MAX_LINEAR_LOOP_DEPTH],
    /// Available bindings shared by the exits from each active loop.

    /// 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: ?*FnType,
    currentFn: ?*unsafe FnType,
    /// Current module being analyzed.
    currentMod: u16,
    /// Nesting depth of unsafe modules and function bodies.
    unsafeDepth: u32,
    /// Whether the current function permits unsafe operations.
    inUnsafeFn: bool,
    /// Configuration for semantic analysis.
    config: Config,
    /// Unified arena for symbols, scopes, and nominal type.
    arena: alloc::Arena,
    /// Combined semantic metadata table indexed by node ID.

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

    ty: Type,
    next: ?*TypeNode,
}

/// Allocate and intern a type in the arena, returning a pointer for deduplication.
export fn allocType(self: *mut Resolver, ty: Type) -> *Type {
export fn allocType(self: &mut Resolver, ty: Type) -> *Type {
    // Search existing types for a match.
    let mut cursor = self.types;
    while let node = cursor {
        if node.ty == ty {
            return &node.ty;


    return &node.ty;
}

/// Allocate a nominal type descriptor and return a pointer to it.
fn allocNominalType(self: *mut Resolver, info: NominalType) -> *mut NominalType {
fn allocNominalType(self: &mut Resolver, info: NominalType) -> *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(
        &mut self.arena, @sizeOf(NominalType), @alignOf(NominalType)


    return entry;
}

/// Allocate a function type descriptor and return a pointer to it.
fn allocFnType(self: *mut Resolver, info: FnType) -> *FnType {
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];
        if err.node == node {
            return err;
        }

        pkgScope: storage.pkgScope,
        loopStack: undefined,
        loopDepth: 0,
        currentFn: nil,
        currentMod: 0,
        unsafeDepth: 0,
        inUnsafeFn: false,
        config,
        arena,
        nodeData: NodeDataTable { entries: storage.nodeData },
        types: nil,
        errors: @sliceOf(storage.errors.ptr, 0, storage.errors.len),

        methodsLen: 0,
    };
}

/// Return `true` if there are no errors in the diagnostics.
export fn success(diag: *Diagnostics) -> bool {
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 {

    }
    return &errs[index];
}

/// Record an error diagnostic and return an error sentinel suitable for throwing.
fn emitError(self: *mut Resolver, node: ?*ast::Node, kind: ErrorKind) -> ResolveError {
fn emitError(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 {
        return ResolveError::Failure;
    }
    // Don't record more than one error per node.


    return ResolveError::Failure;
}

/// Like [`emitError`], but for type mismatches specifically.
fn emitTypeMismatch(self: *mut Resolver, node: ?*ast::Node, mismatch: TypeMismatch) -> ResolveError {
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.
fn allocScope(self: *mut Resolver, owner: *ast::Node, capacity: u32) -> *mut Scope {
fn allocScope(self: &mut Resolver, owner: *ast::Node, capacity: u32) -> *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;
    }

}

/// 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 fn enterScope(self: *mut Resolver, owner: *ast::Node) -> *Scope {
export fn enterScope(self: &mut Resolver, owner: *ast::Node) -> *Scope {
    let scope = allocScope(self, owner, MAX_LOCAL_SYMBOLS);
    set scope.parent = self.scope;
    set self.scope = scope;
    return scope;
}

/// Enter a module scope. Returns an object that can be used to exit the scope.
export fn enterModuleScope(self: *mut Resolver, owner: *ast::Node, module: *module::ModuleEntry) -> ModuleScope {
export fn enterModuleScope(self: &mut Resolver, owner: *ast::Node, module: *module::ModuleEntry) -> ModuleScope {
    let prevScope = self.scope;
    let prevMod = self.currentMod;
    let scope = allocScope(self, owner, MAX_MODULE_SYMBOLS);

    set self.scope = scope;


    return ModuleScope { root: owner, entry: module, newScope: scope, prevScope, prevMod };
}

/// Enter a sub-module. Changes the current scope into that of the sub-module.
fn enterSubModule(self: *mut Resolver, name: *[u8], node: *ast::Node) -> ModuleScope throws (ResolveError) {
    let modEntry = module::findChild(self.moduleGraph, name, self.currentMod)
unsafe fn enterSubModule(self: &mut Resolver, name: *[u8], node: *ast::Node) -> ModuleScope throws (ResolveError) {
    let modEntry = module::findChild(&*self.moduleGraph, name, self.currentMod)
        else throw emitError(self, node, ErrorKind::UnresolvedSymbol(name));
    let modRoot = modEntry.ast
        else panic "enterSubModule: analyzing module that wasn't parsed";

    return enterModuleScope(self, modRoot, modEntry);
}

/// Exit a module scope, given the object returned by `enterModuleScope`.
export fn exitModuleScope(self: *mut Resolver, entry: ModuleScope) {
export fn exitModuleScope(self: &mut Resolver, entry: ModuleScope) {
    set self.scope = entry.prevScope;
    set self.currentMod = entry.prevMod;
}

/// Exit the most recent scope.
export fn exitScope(self: *mut Resolver) {
export 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 self.scope = parent;
}

/// Visit the body of a loop while tracking nesting depth.
fn visitLoop(self: *mut Resolver, body: *ast::Node) -> Type
unsafe fn visitLoop(self: &mut Resolver, body: *ast::Node) -> Type
    throws (ResolveError)
{
    assert self.loopDepth < MAX_LOOP_DEPTH, "visitLoop: loop nesting depth exceeded";
    set self.loopStack[self.loopDepth] = LoopCtx { hasBreak: false };
    set self.loopDepth += 1;

    }
    return Type::Never;
}

/// Require that loop control statements appear inside a loop.
fn ensureInsideLoop(self: *mut Resolver, node: *ast::Node) throws (ResolveError) {
fn ensureInsideLoop(self: &mut Resolver, node: *ast::Node) throws (ResolveError) {
    if self.loopDepth == 0 {
        throw emitError(self, node, ErrorKind::InvalidLoopControl);
    }
}

/// Bind a loop pattern to the provided type.
fn bindForLoopPattern(self: *mut Resolver, pattern: *ast::Node, ty: Type, mutable: bool)
unsafe fn bindForLoopPattern(self: &mut Resolver, pattern: *ast::Node, ty: Type, mutable: bool)
    throws (ResolveError)
{
    match pattern.value {
        case ast::NodeValue::Placeholder, ast::NodeValue::Ident(_) => {
            let _ = try bindValueIdent(self, pattern, pattern, ty, mutable, 0, 0);

        }
    }
}

/// Set the expected return type for a new function body.
fn enterFn(self: *mut Resolver, node: *ast::Node, ty: *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;
    set self.currentFn = ty as *unsafe FnType;
    enterScope(self, node);
}

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

/// Extract the identifier text from a node.
fn nodeName(self: *mut Resolver, node: *ast::Node) -> *[u8]
fn nodeName(self: &mut Resolver, node: *ast::Node) -> *[u8]
    throws (ResolveError)
{
    let case ast::NodeValue::Ident(name) = node.value
        else throw emitError(self, node, ErrorKind::ExpectedIdentifier);
    return name;
}

/// Associate a resolved symbol with an AST node.
fn setNodeSymbol(self: *mut Resolver, node: *ast::Node, symbol: *mut Symbol) {
fn setNodeSymbol(self: &mut Resolver, node: *ast::Node, symbol: *mut Symbol) {
    if let existingSym = self.nodeData.entries[node.id].sym {
        panic "setNodeSymbol: a symbol is already associated with this node";
    }
    set self.nodeData.entries[node.id].sym = symbol;
}

/// Associate a resolved type with an AST node and return it.
fn setNodeType(self: *mut Resolver, node: *ast::Node, ty: Type) -> Type {
fn setNodeType(self: &mut Resolver, node: *ast::Node, ty: Type) -> Type {
    if ty == Type::Unknown {
        // In this case, we simply don't associate a type.
        return ty;
    }
    set self.nodeData.entries[node.id].ty = ty;

    }
    return Type::Void;
}

/// Associate a coercion plan with an AST node.
fn setNodeCoercion(self: *mut Resolver, node: *ast::Node, coercion: Coercion) -> Coercion {
fn setNodeCoercion(self: &mut Resolver, node: *ast::Node, coercion: Coercion) -> Coercion {
    if coercion == Coercion::Identity {
        return coercion;
    }
    set self.nodeData.entries[node.id].coercion = coercion;

    return coercion;
}

/// Associate a constant value with an AST node.
fn setNodeConstValue(self: *mut Resolver, node: *ast::Node, value: ConstValue) {
fn setNodeConstValue(self: &mut Resolver, node: *ast::Node, value: ConstValue) {
    set self.nodeData.entries[node.id].constValue = value;
}

/// Associate a record field index with a record literal field node.
fn setRecordFieldIndex(self: *mut Resolver, node: *ast::Node, index: u32) {
fn setRecordFieldIndex(self: &mut Resolver, node: *ast::Node, index: u32) {
    set self.nodeData.entries[node.id].extra = NodeExtra::RecordField { index };
}

/// Associate slice range metadata with a subscript expression.
fn setSliceRangeInfo(self: *mut Resolver, node: *ast::Node, info: SliceRangeInfo) {
fn setSliceRangeInfo(self: &mut Resolver, node: *ast::Node, info: SliceRangeInfo) {
    set self.nodeData.entries[node.id].extra = NodeExtra::SliceRange(info);
}

/// Associate union variant metadata with a pattern or constructor node.
fn setVariantInfo(self: *mut Resolver, node: *ast::Node, ordinal: u32, tag: u32) {
fn setVariantInfo(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: *TraitType, methodIndex: u32) {
    set self.nodeData.entries[node.id].extra = NodeExtra::TraitMethodCall { traitInfo, methodIndex };
}

/// Associate for-loop metadata with a for-loop node.
fn setForLoopInfo(self: *mut Resolver, node: *ast::Node, info: ForLoopInfo) {
fn setForLoopInfo(self: &mut Resolver, node: *ast::Node, info: ForLoopInfo) {
    set self.nodeData.entries[node.id].extra = NodeExtra::ForLoop(info);
}

/// Retrieve the constant value associated with a node, if any.
export fn constValueEntry(self: *Resolver, node: *ast::Node) -> ?ConstValue {
export fn constValueEntry(self: &Resolver, node: *ast::Node) -> ?ConstValue {
    return self.nodeData.entries[node.id].constValue;
}

/// Get the resolved record field index for a record literal field node.
export fn recordFieldIndexFor(self: *Resolver, node: *ast::Node) -> ?u32 {
export fn recordFieldIndexFor(self: &Resolver, node: *ast::Node) -> ?u32 {
    if let case NodeExtra::RecordField { index } = self.nodeData.entries[node.id].extra {
        return index;
    }
    return nil;
}

/// Get the slice range metadata for a subscript expression with a range index.
export fn sliceRangeInfoFor(self: *Resolver, node: *ast::Node) -> ?SliceRangeInfo {
export fn sliceRangeInfoFor(self: &Resolver, node: *ast::Node) -> ?SliceRangeInfo {
    if let case NodeExtra::SliceRange(info) = self.nodeData.entries[node.id].extra {
        return info;
    }
    return nil;
}

/// Get the for-loop metadata for a for-loop node.
export fn forLoopInfoFor(self: *Resolver, node: *ast::Node) -> ?ForLoopInfo {
export fn forLoopInfoFor(self: &Resolver, node: *ast::Node) -> ?ForLoopInfo {
    if let case NodeExtra::ForLoop(info) = self.nodeData.entries[node.id].extra {
        return info;
    }
    return nil;
}

/// Associate match prong metadata with a match prong node.
fn setProngCatchAll(self: *mut Resolver, node: *ast::Node, catchAll: bool) {
fn setProngCatchAll(self: &mut Resolver, node: *ast::Node, catchAll: bool) {
    set self.nodeData.entries[node.id].extra = NodeExtra::MatchProng { catchAll };
}

/// Check if a prong is catch-all.
export fn isProngCatchAll(self: *Resolver, node: *ast::Node) -> bool {
export fn isProngCatchAll(self: &Resolver, node: *ast::Node) -> bool {
    if let case NodeExtra::MatchProng { catchAll } = self.nodeData.entries[node.id].extra {
        return catchAll;
    }
    return false;
}

/// Set match metadata.
fn setMatchConst(self: *mut Resolver, node: *ast::Node, isConst: bool) {
fn setMatchConst(self: &mut Resolver, node: *ast::Node, isConst: bool) {
    set self.nodeData.entries[node.id].extra = NodeExtra::Match { isConst };
}

/// Check if a match has all constant patterns.
export fn isMatchConst(self: *Resolver, node: *ast::Node) -> bool {
export fn isMatchConst(self: &Resolver, node: *ast::Node) -> bool {
    if let case NodeExtra::Match { isConst } = self.nodeData.entries[node.id].extra {
        return isConst;
    }
    return false;
}

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

/// Get the scope associated with a node.
export fn scopeFor(self: *Resolver, node: *ast::Node) -> ?*mut Scope {
export fn scopeFor(self: &Resolver, node: *ast::Node) -> ?*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) -> ?*mut Symbol {
    return self.nodeData.entries[node.id].sym;
}

/// Get the coercion plan associated with a node, if any.
export fn coercionFor(self: *Resolver, node: *ast::Node) -> ?Coercion {
export fn coercionFor(self: &Resolver, node: *ast::Node) -> ?Coercion {
    let c = self.nodeData.entries[node.id].coercion;
    if c == Coercion::Identity {
        return nil;
    }
    return c;
}

/// Get the module ID for a symbol by walking up its scope chain.
export fn moduleIdForSymbol(self: *Resolver, sym: *Symbol) -> ?u16 {
export fn moduleIdForSymbol(self: &Resolver, sym: *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 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.
fn allocSymbol(self: *mut Resolver, data: SymbolData, name: *[u8], node: *ast::Node, attrs: u32) -> *mut Symbol {
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;
    set *sym = Symbol { name, data, attrs, node, moduleId: nil };

    return sym;
}

/// Check that a type is boolean, otherwise throw an error.
fn checkBoolean(self: *mut Resolver, node: *ast::Node) -> Type throws (ResolveError) {
unsafe fn checkBoolean(self: &mut Resolver, node: *ast::Node) -> Type throws (ResolveError) {
    return try checkEqual(self, node, Type::Bool);
}

/// Check that a type is numeric, otherwise throw an error.
fn checkNumeric(self: *mut Resolver, node: *ast::Node) -> Type throws (ResolveError) {
unsafe fn checkNumeric(self: &mut Resolver, node: *ast::Node) -> Type throws (ResolveError) {
    let ty = try infer(self, node);
    if not isNumericType(ty) {
        throw emitError(self, node, ErrorKind::ExpectedNumeric);
    }
    return ty;

        }
    }
}

/// Get the layout of a type or value.
export fn getLayout(self: *Resolver, node: *ast::Node, ty: Type) -> Layout {
export 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 UnionLayoutInfo { layout: unionLayout, valOffset: unionValOffset, isAllVoid };
}

/// Compute the discriminant tag for a variant, advancing the iota counter.
/// If the variant has an explicit `= N` value, uses that; otherwise uses iota.
fn variantTag(variantDecl: ast::UnionDeclVariant, iota: *mut u32) -> u32 {
fn variantTag(variantDecl: ast::UnionDeclVariant, iota: &mut u32) -> u32 {
    let mut tag: u32 = *iota;
    if let valueNode = variantDecl.value {
        let case ast::NodeValue::Number(lit) = valueNode.value
            else panic "variantTag: expected number literal";
        set tag = lit.magnitude as u32;

        }
    }
}

/// Ensure all nested nominal types in a type are resolved.
fn ensureTypeResolved(self: *mut Resolver, ty: Type, site: *ast::Node) throws (ResolveError) {
unsafe fn ensureTypeResolved(self: &mut Resolver, ty: Type, site: *ast::Node) throws (ResolveError) {
    match ty {
        case Type::Nominal(info) => try ensureNominalResolved(self, info, site),
        case Type::Slice { item, .. } => try ensureTypeResolved(self, *item, site),
        case Type::Pointer { .. } => {}, // Pointers have fixed layout, don't recurse.
        case Type::Array(arr) => try ensureTypeResolved(self, *arr.item, site),

        else => {},
    }
}

/// Ensure a nominal type has its body resolved.
fn ensureNominalResolved(self: *mut Resolver, tyInfo: *NominalType, site: *ast::Node)
unsafe fn ensureNominalResolved(self: &mut Resolver, tyInfo: *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.
fn isListAssignable(self: *mut Resolver, targetType: Type, items: *mut [*ast::Node]) -> bool {
unsafe fn isListAssignable(self: &mut Resolver, targetType: Type, items: *mut [*ast::Node]) -> bool {
    for itemNode in items {
        let elemTy = typeFor(self, itemNode)
            else return false;
        if let _ = isAssignable(self, targetType, elemTy, itemNode) {
            // Do nothing.

fn pointerClassesAssignable(
    to: types::PointerClass,
    from: types::PointerClass,
) -> bool {
    return to == from or (
        to == types::PointerClass::Owned
        and from == types::PointerClass::Ref
        to == types::PointerClass::Ref
        and from == types::PointerClass::Owned
    );
}

/// Check if the `from` type is assignable to the `to` type, and return a
/// coercion plan if so.
fn isAssignable(self: *mut Resolver, to: Type, from: Type, rval: *ast::Node) -> ?Coercion {
unsafe fn isAssignable(self: &mut Resolver, to: Type, from: Type, rval: *ast::Node) -> ?Coercion {
    return isAssignableValue(self, to, from, rval, true);
}

/// Check assignment while preserving function safety in referenced storage.
unsafe fn isAssignableValue(
    self: &mut Resolver, to: Type, from: Type, rval: *ast::Node,
    allowFnSafetyCoercion: bool
) -> ?Coercion {
    if to == Type::Unknown or from == Type::Unknown {
        return nil;
    }
    if from == Type::Undefined {
        // TODO: Don't let `undefined` be used in place of functions and other

            return Coercion::Identity;
        }
        if lhsMutable and not rhsMutable {
            return nil;
        }
        return isAssignable(self, *lhsTarget, *rhsTarget, rval);
        return isAssignableValue(self, *lhsTarget, *rhsTarget, rval, false);
    }
    if let case Type::TraitObject { class: lhsClass, traitInfo: lhsTraitInfo, mutable: lhsMutable } = to {
        if let case Type::Pointer { class: rhsClass, target: rhsTarget, mutable: rhsMutable } = from {
            if not pointerClassesAssignable(lhsClass, rhsClass)
                or (lhsMutable and not rhsMutable)

        }
        // Allow coercion from `*[T]` to `*[opaque]`, and mutable counterparts.
        if *lhsItem == Type::Opaque {
            return Coercion::Identity;
        }
        return isAssignable(self, *lhsItem, *rhsItem, rval);
        return isAssignableValue(self, *lhsItem, *rhsItem, rval, false);
    }
    match to {
        case Type::Array(lhs) => {
            let case Type::Array(rhs) = from
                else return nil;

                        return Coercion::Identity;
                    }
                    return nil;
                }
                case ast::NodeValue::ArrayRepeatLit(repeat) => {
                    return isAssignable(self, *lhs.item, *rhs.item, repeat.item);
                    return isAssignableValue(self, *lhs.item, *rhs.item, repeat.item, allowFnSafetyCoercion);
                }
                else => {
                    if typesEqual(*lhs.item, *rhs.item) {
                        return Coercion::Identity;
                    }


        case Type::Optional(inner) => {
            if from == Type::Nil {
                return Coercion::OptionalLift(to);
            }
            if let _ = isAssignable(self, *inner, from, rval) {
            if let _ = isAssignableValue(self, *inner, from, rval, allowFnSafetyCoercion) {
                return Coercion::OptionalLift(to);
            }
            if let case Type::Optional(fromInner) = from {
                return isAssignable(self, *inner, *fromInner, rval);
                return isAssignableValue(self, *inner, *fromInner, rval, allowFnSafetyCoercion);
            }
            return nil;
        }

        case Type::Fn(toInfo) => {
            // Allow function type structural matching.
            if let case Type::Fn(fromInfo) = from {
                if fnTypeEqual(toInfo, fromInfo) {
                if fnTypeEqual(toInfo, fromInfo) or (
                    allowFnSafetyCoercion and toInfo.isUnsafe and not fromInfo.isUnsafe
                    and fnSignatureEqual(toInfo, fromInfo)
                ) {
                    return Coercion::Identity;
                }
            }
            return nil;
        }

    }
    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 {
    if a.paramTypes.len <> b.paramTypes.len {
        return false;
    }
    if a.throwList.len <> b.throwList.len {
        return false;

    return false;
}

/// Check if the `from` type is assignable to the `to` type, and return a
/// coercion plan if so, or throw an error if not.
fn expectAssignable(self: *mut Resolver, to: Type, from: Type, site: *ast::Node) -> Coercion throws (ResolveError) {
unsafe fn expectAssignable(self: &mut Resolver, to: Type, from: Type, site: *ast::Node) -> Coercion throws (ResolveError) {
    // Ensure any nested nominal types are resolved before checking assignability.
    try ensureTypeResolved(self, to, site);
    if let coercion = isAssignable(self, to, from, site) {
        return setNodeCoercion(self, site, coercion);
    }

        actual: from,
    });
}

/// Check that a type is optional, otherwise throw an error.
fn checkOptional(self: *mut Resolver, node: *ast::Node) -> *Type
unsafe fn checkOptional(self: &mut Resolver, node: *ast::Node) -> *Type
    throws (ResolveError)
{
    if let case Type::Optional(inner) = try infer(self, node) {
        return inner;
    }
    throw emitError(self, node, ErrorKind::ExpectedOptional);
}

/// Check that a node's type is equal to the expected type.
fn checkEqual(self: *mut Resolver, node: *ast::Node, expected: Type) -> Type
unsafe fn checkEqual(self: &mut Resolver, node: *ast::Node, expected: Type) -> Type
    throws (ResolveError)
{
    let actualTy = try visit(self, node, expected);
    if actualTy <> expected {
        throw emitTypeMismatch(self, node, TypeMismatch { expected, actual: actualTy });

    return actualTy;
}

/// Bind an identifier in the given scope.
fn bindIdent(
    self: *mut Resolver,
    self: &mut Resolver,
    name: *[u8],
    owner: *ast::Node,
    data: SymbolData,
    attrs: u32,
    scope: *mut Scope


    return sym;
}

/// Add a symbol to the given scope.
fn addSymbolToScope(self: *mut Resolver, sym: *mut Symbol, scope: *mut Scope, site: *ast::Node) throws (ResolveError) {
fn addSymbolToScope(self: &mut Resolver, sym: *mut Symbol, scope: *mut Scope, site: *ast::Node) throws (ResolveError) {
    for i in 0..scope.symbolsLen {
        if scope.symbols[i].name == sym.name {
            throw emitError(self, site, ErrorKind::DuplicateBinding(sym.name));
        }
    }

    set scope.symbolsLen += 1;
}

/// Bind a value identifier in the current scope.
/// Returns `nil` if the identifier is a placeholder (`_`).
fn bindValueIdent(
    self: *mut Resolver,
unsafe fn bindValueIdent(
    self: &mut Resolver,
    ident: *ast::Node,
    owner: *ast::Node,
    type: Type,
    mutable: bool,
    alignment: u32,

        setNodeType(self, owner, type);
        return nil;
    }
    let name = try nodeName(self, ident);
    let data = SymbolData::Value { mutable, alignment, type, addressTaken: false };
    let sym = try bindIdent(self, name, owner, data, attrs, self.scope);
    let scope = self.scope;
    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 {

    return sym;
}

/// Bind a constant identifier in the current scope.
fn bindConstIdent(
    self: *mut Resolver,
    self: &mut Resolver,
    ident: *ast::Node,
    owner: *ast::Node,
    type: Type,
    val: ?ConstValue,
    attrs: u32
) -> *mut Symbol throws (ResolveError) {
    let name = try nodeName(self, ident);
    let data = SymbolData::Constant { type, value: val };
    let sym = try bindIdent(self, name, owner, data, attrs, self.scope);
    let scope = self.scope;
    let sym = try bindIdent(self, name, owner, data, attrs, scope);
    setNodeType(self, owner, type);
    setNodeType(self, ident, type);

    return sym;
}

/// Bind a module identifier in the given scope.
/// This is used when declaring modules with `mod` or
/// importing modules with `use`.
fn bindModuleIdent(
    self: *mut Resolver,
    self: &mut Resolver,
    entry: *module::ModuleEntry,
    scope: *mut Scope,
    owner: *ast::Node,
    attrs: u32,
    bindingScope: *mut Scope

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

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

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

    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"]`.
/// Returns a slice of the segments that were written.
/// Return the number of segments written to the buffer.
fn flattenPath(
    self: *mut Resolver,
    self: &mut Resolver,
    node: *ast::Node,
    buf: *mut [*[u8]]
) -> *[*[u8]] throws (ResolveError) {
    let mut out: *[*[u8]] = &[];
    buf: &mut [*[u8]]
) -> u32 throws (ResolveError) {
    let mut out: u32 = 0;

    match node.value {
        case ast::NodeValue::Ident(name) if name.len > 0 => {
            assert buf.len >= 1, "flattenPath: invalid output buffer size";
            set buf[0] = name;
            set out = &buf[..1];
            set out = 1;
        }
        case ast::NodeValue::ScopeAccess(access) => {
            // Recursively flatten parent path.
            let parent = try flattenPath(self, access.parent, buf);
            assert parent.len < buf.len, "flattenPath: invalid output buffer size";
            assert parent < buf.len, "flattenPath: invalid output buffer size";
            let child = try nodeName(self, access.child);
            set buf[parent.len] = child;
            set out = &buf[..parent.len + 1];
            set buf[parent] = child;
            set out = parent + 1;
        }
        case ast::NodeValue::Super => {
            // `super` is handled by scope adjustment in `checkSuperAccess`.
            // Return empty prefix so the path continues from the next segment.
            set out = &buf[..0];
            set out = 0;
            return out;
        }
        else => {
            // Fallthrough to error.
        }
    }
    if out.len < 1 {
    if out < 1 {
        throw emitError(self, node, ErrorKind::InvalidIdentifier(node));
    }
    return out;
}


    }
}

/// Get the parent module scope for the current module.
/// Returns the scope of the parent module, or `nil` if this is a root module.
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) -> ?*mut Scope throws (ResolveError) {
    let currentMod = module::get(&*self.moduleGraph, self.currentMod)
        else throw emitError(self, node, ErrorKind::Internal);
    let parentId = currentMod.parent
        else return nil; // No parent module.

    return self.moduleScopes[parentId as u32];
}

/// Check if a node has `super` at its root (e.g. `super::x` or `super::Union::Variant`).
/// Returns the parent scope and the original node so `flattenPath` can strip `super`.
fn checkSuperAccess(
    self: *mut Resolver,
unsafe fn checkSuperAccess(
    self: &mut Resolver,
    node: *ast::Node
) -> ?SuperAccessResult throws (ResolveError) {
    // TODO: Maybe we should deal with `super` after the path is flattened.
    if let case ast::NodeValue::ScopeAccess(access) = node.value {
        // Direct super access: `super::x`.

    return symModuleId == currentModuleId;
}

/// Resolve an access node (eg. `lang::resolver::MAX_ERRORS`) to a symbol,
/// starting from the given scope.
fn resolveAccess(
    self: *mut Resolver,
unsafe fn resolveAccess(
    self: &mut Resolver,
    node: *ast::Node,
    access: ast::Access,
    scope: *Scope
) -> *mut Symbol throws (ResolveError) {
    // Handle `super` access by adjusting scope and node.

        set pathNode = superAccess.child;
    }
    // TODO: It doesn't make sense that `flattenPath` handles identifiers and scope access,
    // while this function requires a scope access.
    let mut buffer: [*[u8]; 32] = undefined;
    let path = try flattenPath(self, pathNode, &mut buffer[..]);
    let pathLen = try flattenPath(self, pathNode, &mut buffer[..]);

    return try resolvePath(self, node, access, path, startScope);
    return try resolvePath(self, node, access, &buffer[..pathLen], startScope);
}

/// Resolve a path (eg. ["lang", "resolver", "MAX_ERRORS"]) to a symbol,
/// starting from the given scope.
fn resolvePath(
    self: *mut Resolver,
unsafe fn resolvePath(
    self: &mut Resolver,
    node: *ast::Node,
    access: ast::Access,
    path: *[*[u8]],
    path: &[*[u8]],
    scope: *Scope
) -> *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));
    let suffix = &path[1..];

    // Check visibility for symbol.
    if not isSymbolVisible(sym, scope, self.scope) {
        throw emitError(self, node, ErrorKind::UnresolvedSymbol(root));
    }
    // End condition.
    if suffix.len == 0 {
    if path.len == 1 {
        return sym;
    }
    // Otherwise, we need to enter the next scope with the path suffix.
    match sym.data {
        case SymbolData::Module { scope, .. } => {
            return try resolvePath(self, node, access, suffix, scope);
            return try resolvePath(self, node, access, &path[1..], scope);
        }
        case SymbolData::Type(ty) => {
            // Lazily resolve union body if not yet done.
            try ensureNominalResolved(self, ty, node);

            if let case NominalType::Union(unionType) = *ty {
                // TODO: Recurse with variant so we consolidate everything.
                if suffix.len > 1 {
                if path.len > 2 {
                    throw emitError(self, node, ErrorKind::InvalidScopeAccess);
                }
                let variantName = suffix[0];
                let variantName = path[1];
                let variantSym = try resolveUnionVariantAccess(
                    self, node, access, unionType, variantName
                );
                // TODO: This shouldn't be here.
                setNodeType(self, node, Type::Nominal(ty));

    throw emitError(self, node, ErrorKind::InvalidScopeAccess);
}

/// Resolve a module path (e.g., `foo::bar::baz`) to a module entry and scope.
/// This traverses the module hierarchy, checking visibility at each step.
fn resolveModulePath(
    self: *mut Resolver,
unsafe fn resolveModulePath(
    self: &mut Resolver,
    module: *ast::Node
) -> ResolvedModule throws (ResolveError) {
    let mut startScope = self.scope;
    let mut pathNode = module;


    if let superAccess = try checkSuperAccess(self, module) {
        set startScope = superAccess.scope;
        set pathNode = superAccess.child;
    }
    let mut pathBuf: [*[u8]; 16] = undefined;
    let path = try flattenPath(self, pathNode, &mut pathBuf[..]);
    if path.len == 0 {
    let pathLen = try flattenPath(self, pathNode, &mut pathBuf[..]);
    if pathLen == 0 {
        throw emitError(self, module, ErrorKind::UnresolvedSymbol(""));
    }
    let parentName = path[0];
    let parentName = pathBuf[0];

    // First, check if this is a sub-module of the start scope.
    if let sym = findSymbolInScope(startScope, parentName) {
        return try resolveModulePathRecursive(self, module, &path[1..], sym);
        return try resolveModulePathRecursive(self, module, &pathBuf[1..pathLen], sym);
    }
    // Not a sub-module, so look in the global scope for a package root.
    let sym = findSymbolInScope(self.pkgScope, parentName)
        else throw emitError(self, module, ErrorKind::UnresolvedSymbol(parentName));

    return try resolveModulePathRecursive(self, module, &path[1..], sym);
    return try resolveModulePathRecursive(self, module, &pathBuf[1..pathLen], sym);
}

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


        childSym
    );
}

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

            setNodeSymbol(self, node, sym);

            return ty;
        }
        case ast::NodeValue::ScopeAccess(access) => {
            let sym = try resolveAccess(self, node, access, self.scope);
            let scope = self.scope;
            let sym = try resolveAccess(self, node, access, scope);
            let case SymbolData::Type(ty) = sym.data
                else throw emitError(self, node, ErrorKind::Internal);

            setNodeSymbol(self, node, sym);


/// Visit a top-level declaration in the declaration phase.
/// This binds all names and analyzes signatures, types, and initializers.
/// Function bodies are deferred to the definition phase.
///
/// Nb. User-defined types are already handled by this point.
fn visitDecl(self: *mut Resolver, node: *ast::Node) throws (ResolveError) {
unsafe fn visitDecl(self: &mut Resolver, node: *ast::Node) throws (ResolveError) {
    match node.value {
        case ast::NodeValue::FnDecl(_),
             ast::NodeValue::ConstDecl(_),
             ast::NodeValue::Mod(_),
             ast::NodeValue::Use(_) => {

            // Ignore non-declaration nodes.
        }
    }
}

/// Require the current declaration to be unsafe.
fn requireUnsafe(self: *mut Resolver, node: *ast::Node) throws (ResolveError) {
    if self.unsafeDepth == 0 {
/// Require the current function to be unsafe.
fn requireUnsafe(self: &mut Resolver, node: *ast::Node) throws (ResolveError) {
    if not self.inUnsafeFn {
        throw emitError(self, node, ErrorKind::UnsafeOperation);
    }
}

/// Reject calls from safe code through unsafe function types.
fn checkUnsafeCall(self: *mut Resolver, node: *ast::Node, info: *FnType)
fn checkUnsafeCall(self: &mut Resolver, node: *ast::Node, info: *FnType)
    throws (ResolveError)
{
    if info.isUnsafe and self.unsafeDepth == 0 {
    if info.isUnsafe and not self.inUnsafeFn {
        throw emitError(self, node, ErrorKind::UnsafeCall);
    }
}

/// Visit a top-level definition, recursing into sub-modules.
fn visitDef(self: *mut Resolver, node: *ast::Node) throws (ResolveError) {
unsafe fn visitDef(self: &mut Resolver, node: *ast::Node) throws (ResolveError) {
    match node.value {
        case ast::NodeValue::FnDecl(decl) => {
            try resolveFnDeclBody(self, node, decl) catch {
                return;
            };

            }
            let modName = try nodeName(self, decl.name);
            let submod = try enterSubModule(self, modName, node);
            let case ast::NodeValue::Block(block) = submod.root.value
                else panic "visitDef: expected block for module root";
            let mut isUnsafe = false;
            if let attrs = decl.attrs {
                set isUnsafe = ast::attributesContains(&attrs, ast::Attribute::Unsafe);
            }
            if isUnsafe {
                set self.unsafeDepth += 1;
            }
            try resolveModuleDefs(self, &block) catch e {
                if isUnsafe { set self.unsafeDepth -= 1; }
                exitModuleScope(self, submod);
                throw e;
            };
            if isUnsafe {
                set self.unsafeDepth -= 1;
            }
            exitModuleScope(self, submod);
        }
        case ast::NodeValue::RecordDecl(_),
             ast::NodeValue::UnionDecl(_),
             ast::NodeValue::Use(_),

        }
    }
}

/// Try to infer a node's type.
fn infer(self: *mut Resolver, node: *ast::Node) -> Type throws (ResolveError) {
unsafe fn infer(self: &mut Resolver, node: *ast::Node) -> Type throws (ResolveError) {
    return try visit(self, node, Type::Unknown);
}

/// Reject nested references while allowing a direct parameter reference.
fn validateValueTypeReferences(self: *mut Resolver, node: *ast::Node, ty: Type)
fn validateValueTypeReferences(self: &mut Resolver, node: *ast::Node, ty: Type)
    throws (ResolveError)
{
    if isRefType(ty) {
        if let case Type::Pointer { target, .. } = ty {
            if containsRef(*target) {

        throw emitError(self, node, ErrorKind::InvalidRefPosition);
    }
}

/// Require a type that may be stored or escape a call.
fn ensureStorableType(self: *mut Resolver, node: *ast::Node, ty: Type)
fn ensureStorableType(self: &mut Resolver, node: *ast::Node, ty: Type)
    throws (ResolveError)
{
    if containsRef(ty) {
        throw emitError(self, node, ErrorKind::InvalidRefPosition);
    }
}

/// Resolve a type signature node.
fn resolveValueType(self: *mut Resolver, node: *ast::Node) -> Type throws (ResolveError) {
unsafe fn resolveValueType(self: &mut Resolver, node: *ast::Node) -> Type throws (ResolveError) {
    let ty = try visit(self, node, Type::Unknown);
    // Opaque value types are not allowed.
    if ty == Type::Opaque {
        throw emitError(self, node, ErrorKind::OpaqueTypeNotAllowed);
    }
    try validateValueTypeReferences(self, node, ty);
    return ty;
}

/// Analyze a node's type and check that it can be assigned to the expected type.
fn checkAssignable(self: *mut Resolver, node: *ast::Node, expected: Type) -> Type throws (ResolveError) {
unsafe fn checkAssignable(self: &mut Resolver, node: *ast::Node, expected: Type) -> Type throws (ResolveError) {
    let actual = try visit(self, node, expected);
    let _ = try expectAssignable(self, expected, actual, node);
    return actual;
}

/// Analyze a node and propagate the resolved type.
/// The `hint` parameter provides type context for inference and validation.
/// When `nil`, the type must be inferred from the expression itself.
fn visit(self: *mut Resolver, node: *ast::Node, hint: Type) -> Type
unsafe fn visit(self: &mut Resolver, node: *ast::Node, hint: Type) -> Type
    throws (ResolveError)
{
    if let ty = typeFor(self, node) {
        return ty;
    }

        }
    }
}

/// Visit an optional node when present.
fn visitOptional(self: *mut Resolver, node: ?*ast::Node, hint: Type) -> ?Type
unsafe fn visitOptional(self: &mut Resolver, node: ?*ast::Node, hint: Type) -> ?Type
    throws (ResolveError)
{
    if let n = node {
        return try visit(self, n, hint);
    }
    return nil;
}

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

    }
    return Type::Void;
}

/// Collect attribute flags applied to a declaration.
fn resolveAttributes(self: *mut Resolver, attrs: ?ast::Attributes) -> u32 {
fn resolveAttributes(self: &mut Resolver, attrs: ?ast::Attributes) -> u32 {
    let list = attrs else return 0;
    let attrNodes = list.list;
    let mut mask: u32 = 0;

    for node in attrNodes {

    }
    return mask;
}

/// Ensure the `default` attribute is only applied to functions.
fn ensureDefaultAttrNotAllowed(self: *mut Resolver, node: *ast::Node, attrs: u32)
fn ensureDefaultAttrNotAllowed(self: &mut Resolver, node: *ast::Node, attrs: u32)
    throws (ResolveError)
{
    let defaultBit = ast::Attribute::Default as u32;
    if (attrs & defaultBit) <> 0 {
        throw emitError(self, node, ErrorKind::DefaultAttrOnlyOnFn);
    }
}

/// Analyze a block node, allocating a nested lexical scope.
fn resolveBlock(self: *mut Resolver, node: *ast::Node, block: ast::Block) -> Type
unsafe fn resolveBlock(self: &mut Resolver, node: *ast::Node, block: ast::Block) -> Type
    throws (ResolveError)
{
    enterScope(self, node);
    let blockTy = try visitList(self, block.statements) catch {
        // One of the statements in the block failed analysis. We simply proceed


    return setNodeType(self, node, blockTy);
}

/// Analyze a `let` declaration and bind its identifier.
fn resolveLet(self: *mut Resolver, node: *ast::Node, decl: ast::Let) -> Type
unsafe fn resolveLet(self: &mut Resolver, node: *ast::Node, decl: ast::Let) -> Type
    throws (ResolveError)
{
    let mut alignment: u32 = 0; // Zero is default.
    let mut bindingTy = Type::Unknown;


        else => return false,
    }
}

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

            return ConstValue::Int(constIntFromBits(raw, bits, true)),
    }
}

/// Return the constant `u32` value for a slice bound when known.
fn constSliceIndex(self: *mut Resolver, node: *ast::Node) -> ?u32 {
fn constSliceIndex(self: &mut Resolver, node: *ast::Node) -> ?u32 {
    let value = constValueEntry(self, node)
        else return nil;
    let case ConstValue::Int(int) = value
        else return nil;
    if int.negative {

/// This function ensures that a node represents a valid, non-negative integer constant
/// that fits within a machine word. It is used for contexts requiring compile-time
/// non-negative integers, such as array sizes and alignment specifications.
///
/// Returns the unsigned magnitude of the constant as `u32`.
fn checkSizeInt(self: *mut Resolver, node: *ast::Node) -> u32
unsafe fn checkSizeInt(self: &mut Resolver, node: *ast::Node) -> u32
    throws (ResolveError)
{
    // First traverse the node expect a numeric type.
    let _ = try checkNumeric(self, node);



/// Check that constructor arguments match record fields.
///
/// Verifies argument count matches field count, and that each argument is
/// assignable to its corresponding field type.
fn checkRecordConstructorArgs(self: *mut Resolver, node: *ast::Node, args: *mut [*ast::Node], recInfo: RecordType)
unsafe fn checkRecordConstructorArgs(self: &mut Resolver, node: *ast::Node, args: *mut [*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.
fn checkRecordArity(self: *mut Resolver, args: *mut [*ast::Node], recInfo: RecordType, pattern: *ast::Node) throws (ResolveError) {
fn checkRecordArity(self: &mut Resolver, args: *mut [*ast::Node], recInfo: RecordType, pattern: *ast::Node) throws (ResolveError) {
    if args.len <> recInfo.fields.len {
        throw emitError(self, pattern, ErrorKind::RecordFieldCountMismatch(CountMismatch {
            expected: recInfo.fields.len as u32,
            actual: args.len,
        }));
    }
}

/// Helper for analyzing `constant` and `static` declarations.
fn resolveConstOrStatic(
    self: *mut Resolver,
unsafe fn resolveConstOrStatic(
    self: &mut Resolver,
    node: *ast::Node,
    ident: *ast::Node,
    typeNode: *ast::Node,
    valueNode: *ast::Node,
    attrList: ?ast::Attributes,


    return Type::Void;
}

/// Analyze a function declaration signature and bind the function name.
fn resolveFnDecl(self: *mut Resolver, node: *ast::Node, decl: ast::FnDecl) -> Type
unsafe fn resolveFnDecl(self: &mut Resolver, node: *ast::Node, decl: ast::FnDecl) -> Type
    throws (ResolveError)
{
    let attrMask = resolveAttributes(self, decl.attrs);
    let mut retTy = Type::Void;
    if let retNode = decl.sig.returnType {


    return ty;
}

/// Analyze a function body.
fn resolveFnDeclBody(self: *mut Resolver, node: *ast::Node, decl: ast::FnDecl) throws (ResolveError) {
unsafe fn resolveFnDeclBody(self: &mut Resolver, node: *ast::Node, decl: ast::FnDecl) throws (ResolveError) {
    let sym = symbolFor(self, node) else {
        // The function declaration failed to type check, therefore
        // no symbol was associated with it.
        return;
    };

        throw emitError(self, node, ErrorKind::FnMissingBody);
    }
}

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

    let missingReturn = try checkExecutableBody(self, fnType, receiverName, params, body) catch e {
        exitFn(self);
        if isUnsafe { set self.unsafeDepth -= 1; }
        set self.inUnsafeFn = wasUnsafe;
        throw e;
    };
    exitFn(self);
    if isUnsafe {
        set self.unsafeDepth -= 1;
    }
    set self.inUnsafeFn = wasUnsafe;
    if missingReturn {
        throw emitError(self, body, ErrorKind::FnMissingReturn);
    }
}

/// Check parameters, body types, and ownership.
/// Return whether a required return is missing.
fn checkExecutableBody(
    self: *mut Resolver,
unsafe fn checkExecutableBody(
    self: &mut Resolver,
    fnType: *FnType,
    receiverName: ?*ast::Node,
    params: *mut [*ast::Node],
    body: *ast::Node,
) -> bool throws (ResolveError) {

    try checkLinearFn(self, receiverName, params, body);
    return false;
}

/// Analyze a function parameter and bind its identifier.
fn resolveFnParam(self: *mut Resolver, node: *ast::Node, param: ast::FnParam) -> Type
unsafe fn resolveFnParam(self: &mut Resolver, node: *ast::Node, param: ast::FnParam) -> Type
    throws (ResolveError)
{
    let ty = try resolveValueType(self, param.type);
    let _ = try bindValueIdent(self, param.name, node, ty, false, 0, 0);


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

/// Resolve compiler-known ownership markers from a derive list.
fn resolveOwnershipMarkers(self: *mut Resolver, derives: *mut [*ast::Node]) -> OwnershipMarkers
unsafe fn resolveOwnershipMarkers(self: &mut Resolver, derives: *mut [*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.
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: *mut [*ast::Node], labeled: bool) -> RecordType
    throws (ResolveError)
{
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut result: *mut [RecordField] = &mut [];
    let mut currentOffset: u32 = 0;

        declaredCopy: false,
    };
}

/// Resolve record field types for a named record declaration.
fn resolveRecordBody(self: *mut Resolver, node: *ast::Node, decl: ast::RecordDecl)
unsafe fn resolveRecordBody(self: &mut Resolver, node: *ast::Node, decl: ast::RecordDecl)
    throws (ResolveError)
{
    // Get the type symbol that was bound to this declaration node.
    // If there's no symbol, it's because an earlier phase failed.
    let sym = symbolFor(self, node)


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

/// Bind a type name.
fn bindTypeName(self: *mut Resolver, node: *ast::Node, name: *ast::Node, attrs: ?ast::Attributes) -> *mut Symbol
fn bindTypeName(self: &mut Resolver, node: *ast::Node, name: *ast::Node, attrs: ?ast::Attributes) -> *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.
fn allocTraitType(self: *mut Resolver, name: *[u8]) -> *mut TraitType {
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;
    set *entry = TraitType { name, methods: &mut [], supertraits: &mut [] };

    return entry;
}

/// Bind a trait name in the current scope.
fn bindTraitName(self: *mut Resolver, node: *ast::Node, name: *ast::Node, attrs: ?ast::Attributes) -> *mut Symbol
fn bindTraitName(self: &mut Resolver, node: *ast::Node, name: *ast::Node, attrs: ?ast::Attributes) -> *mut Symbol
    throws (ResolveError)
{
    let attrMask = resolveAttributes(self, attrs);
    try ensureDefaultAttrNotAllowed(self, node, attrMask);

    let traitName = try nodeName(self, name);
    let traitType = allocTraitType(self, traitName);
    let data = SymbolData::Trait(traitType);
    let sym = try bindIdent(self, traitName, node, data, attrMask, self.scope);
    let scope = self.scope;
    let sym = try bindIdent(self, traitName, node, data, attrMask, scope);

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

    return sym;

    }
    return nil;
}

/// Resolve a trait declaration body: supertrait methods, then own methods.
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: *mut [*ast::Node], methods: *mut [*ast::Node])
    throws (ResolveError)
{
    let sym = symbolFor(self, node)
        else return;
    let case SymbolData::Trait(traitType) = sym.data

    }
}

/// Resolve a name path node to a symbol.
/// Used for trait and type references in instance declarations and trait objects.
fn resolveNamePath(self: *mut Resolver, node: *ast::Node) -> *mut Symbol
unsafe fn resolveNamePath(self: &mut Resolver, node: *ast::Node) -> *mut Symbol
    throws (ResolveError)
{
    match node.value {
        case ast::NodeValue::Ident(name) => {
            let sym = findAnySymbol(self.scope, name)
                else throw emitError(self, node, ErrorKind::UnresolvedSymbol(name));
            return sym;
        }
        case ast::NodeValue::ScopeAccess(access) => {
            return try resolveAccess(self, node, access, self.scope);
            let scope = self.scope;
            return try resolveAccess(self, node, access, scope);
        }
        else => {
            throw emitError(self, node, ErrorKind::ExpectedIdentifier);
        }
    }
}

/// Resolve an instance declaration.
/// Validates that the trait exists, the target type exists, and all methods
/// match the trait's signatures.
fn resolveInstanceDecl(
    self: *mut Resolver,
unsafe fn resolveInstanceDecl(
    self: &mut Resolver,
    node: *ast::Node,
    traitName: *ast::Node,
    targetType: *ast::Node,
    methods: *mut [*ast::Node]
) throws (ResolveError) {


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

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

    }
}

/// Resolve a method body shared by instance methods and standalone methods.
/// Binds the receiver and parameters, then type-checks the body.
fn resolveMethodBody(
    self: *mut Resolver,
unsafe fn resolveMethodBody(
    self: &mut Resolver,
    node: *ast::Node,
    receiverName: *ast::Node,
    sig: ast::FnSig,
    body: *ast::Node,
) throws (ResolveError) {

/// Resolve a standalone method declaration (signature only).
/// Validates the receiver type and registers the method in the method table.

/// Extract the type name from a resolved receiver type node.
fn receiverTypeName(
    self: *mut Resolver,
    self: &mut Resolver,
    receiverType: *ast::Node,
) -> *[u8] throws (ResolveError) {
    let case ast::NodeValue::TypeSig(ast::TypeSig::Pointer { valueType, .. }) =
        receiverType.value
        else throw emitError(self, receiverType, ErrorKind::TraitReceiverMismatch);


    return sym.name;
}

/// Resolve and register a standalone method declaration.
fn resolveMethodDecl(
    self: *mut Resolver,
unsafe fn resolveMethodDecl(
    self: &mut Resolver,
    node: *ast::Node,
    name: *ast::Node,
    receiverName: *ast::Node,
    receiverType: *ast::Node,
    sig: ast::FnSig,

    };
    set self.methodsLen += 1;
}

/// Look up an instance entry by trait and concrete type.
fn findInstance(self: *Resolver, traitInfo: *TraitType, concreteType: Type) -> ?*InstanceEntry {
unsafe fn findInstance(self: &Resolver, traitInfo: *TraitType, concreteType: Type) -> ?*unsafe InstanceEntry {
    for i in 0..self.instancesLen {
        let entry = &self.instances[i];
        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 by concrete type and name.
export fn findMethod(self: *Resolver, concreteType: Type, name: *[u8]) -> ?*MethodEntry {
export unsafe fn findMethod(self: &Resolver, concreteType: Type, name: *[u8]) -> ?*unsafe MethodEntry {
    for i in 0..self.methodsLen {
        let entry = &self.methods[i];
        let entry: *unsafe MethodEntry = &self.methods[i];
        if typesEqual(entry.concreteType, concreteType) and entry.name == name {
            return entry;
        }
    }
    return nil;
}

/// Look up a standalone method entry by its symbol.
export fn findMethodBySymbol(self: *Resolver, sym: *mut Symbol) -> ?*MethodEntry {
export unsafe fn findMethodBySymbol(self: &Resolver, sym: *mut Symbol) -> ?*unsafe MethodEntry {
    for i in 0..self.methodsLen {
        let entry = &self.methods[i];
        let entry: *unsafe MethodEntry = &self.methods[i];
        if entry.symbol == sym {
            return entry;
        }
    }
    return nil;
}

/// Resolve union variant types after all type names are bound (Phase 2 of type resolution).
fn resolveUnionBody(self: *mut Resolver, node: *ast::Node, decl: ast::UnionDecl)
unsafe fn resolveUnionBody(self: &mut Resolver, node: *ast::Node, decl: ast::UnionDecl)
    throws (ResolveError)
{
    // Get the type symbol that was bound to this declaration node.
    // If there's no symbol, it's because an earlier phase failed.
    let sym = symbolFor(self, node)

        declaredCopy: markers.copy,
    });
}

/// Check if a module should be analyzed based on its attributes and build configuration.
fn shouldAnalyzeModule(self: *Resolver, attrs: ?ast::Attributes) -> bool {
fn shouldAnalyzeModule(self: &Resolver, attrs: ?ast::Attributes) -> bool {
    if let attributes = attrs {
        // Skip test modules unless we're building in test mode.
        if ast::attributesContains(&attributes, ast::Attribute::Test) and not self.config.buildTest {
            return false;
        }
    }
    return true;
}

/// Analyze a module during the graph analysis phase.
fn resolveModGraph(self: *mut Resolver, node: *ast::Node, decl: ast::Mod)
unsafe fn resolveModGraph(self: &mut Resolver, node: *ast::Node, decl: ast::Mod)
    throws (ResolveError)
{
    if not shouldAnalyzeModule(self, decl.attrs) {
        return;
    }


    exitModuleScope(self, submod);
}

/// Analyze a module in the declaration phase.
fn resolveModDecl(self: *mut Resolver, node: *ast::Node, decl: ast::Mod)
unsafe fn resolveModDecl(self: &mut Resolver, node: *ast::Node, decl: ast::Mod)
    throws (ResolveError)
{
    if not shouldAnalyzeModule(self, decl.attrs) {
        return;
    }


    exitModuleScope(self, submod);
}

/// Analyze a `use` statement and create a symbol for the imported module.
fn resolveUse(self: *mut Resolver, node: *ast::Node, decl: ast::Use) -> Type
unsafe fn resolveUse(self: &mut Resolver, node: *ast::Node, decl: ast::Use) -> Type
    throws (ResolveError)
{
    let resolved = try resolveModulePath(self, decl.path);
    let attrMask = resolveAttributes(self, decl.attrs);


                if let existing = findSymbolInScope(self.scope, sym.name) {
                    if existing == sym {
                        continue;
                    }
                }
                try addSymbolToScope(self, sym, self.scope, node);
                let scope = self.scope;
                try addSymbolToScope(self, sym, scope, node);
            }
        }
    } else {
        // Regular module import.
        try bindModuleIdent(self, resolved.entry, resolved.scope, node, attrMask, self.scope);
        let scope = self.scope;
        try bindModuleIdent(self, resolved.entry, resolved.scope, node, attrMask, scope);
    }
    return Type::Void;
}

/// Analyze a standard `if` statement.
fn resolveIf(self: *mut Resolver, node: *ast::Node, cond: ast::If) -> Type
unsafe fn resolveIf(self: &mut Resolver, node: *ast::Node, cond: ast::If) -> Type
    throws (ResolveError)
{
    try checkBoolean(self, cond.condition);
    let thenTy = try visit(self, cond.thenBranch, Type::Void);
    let elseTy = try visitOptional(self, cond.elseBranch, Type::Void);

    return setNodeType(self, node, unifyBranches(thenTy, elseTy));
}

/// Analyze a conditional expression.
fn resolveCondExpr(self: *mut Resolver, node: *ast::Node, cond: ast::CondExpr) -> Type
unsafe fn resolveCondExpr(self: &mut Resolver, node: *ast::Node, cond: ast::CondExpr) -> Type
    throws (ResolveError)
{
    try checkBoolean(self, cond.condition);
    let thenTy = try infer(self, cond.thenExpr);
    let elseTy = try infer(self, cond.elseExpr);


    return setNodeType(self, node, thenTy);
}

/// Analyze a pattern match structure (used by if-let, while-let).
fn resolvePatternMatch(self: *mut Resolver, node: *ast::Node, pat: *ast::PatternMatch)
unsafe fn resolvePatternMatch(self: &mut Resolver, node: *ast::Node, pat: &ast::PatternMatch)
    throws (ResolveError)
{
    match pat.kind {
        case ast::PatternKind::Case => {
            // Analyze pattern against scrutinee type.

        try checkBoolean(self, guard);
    }
}

/// Analyze an `if let` or `if let case` pattern binding.
fn resolveIfLet(self: *mut Resolver, node: *ast::Node, cond: ast::IfLet) -> Type
unsafe fn resolveIfLet(self: &mut Resolver, node: *ast::Node, cond: ast::IfLet) -> Type
    throws (ResolveError)
{
    enterScope(self, node);
    try resolvePatternMatch(self, node, &cond.pattern);



/// Analyze a case pattern for match, if-case, let-case, or while-case.
///
/// At the top level, bare identifiers are compared against existing values.
/// Inside destructuring patterns (arrays, records), identifiers become bindings.
fn resolveCasePattern(
    self: *mut Resolver,
unsafe fn resolveCasePattern(
    self: &mut Resolver,
    pattern: *ast::Node,
    scrutineeTy: Type,
    mode: IdentMode,
    matchBy: MatchBy
) throws (ResolveError) {

        }
    }
}

/// Analyze a traditional `while` loop.
fn resolveWhile(self: *mut Resolver, node: *ast::Node, loopNode: ast::While) -> Type
unsafe fn resolveWhile(self: &mut Resolver, node: *ast::Node, loopNode: ast::While) -> Type
    throws (ResolveError)
{
    try checkBoolean(self, loopNode.condition);
    try visitLoop(self, loopNode.body);
    try visitOptional(self, loopNode.elseBranch, Type::Void);

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

/// Analyze a `while let` loop with pattern binding.
fn resolveWhileLet(self: *mut Resolver, node: *ast::Node, loopNode: ast::WhileLet) -> Type
unsafe fn resolveWhileLet(self: &mut Resolver, node: *ast::Node, loopNode: ast::WhileLet) -> Type
    throws (ResolveError)
{
    enterScope(self, node);
    try resolvePatternMatch(self, node, &loopNode.pattern);



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

/// Analyze a `for` loop, binding iteration variables.
fn resolveFor(self: *mut Resolver, node: *ast::Node, forStmt: ast::For) -> Type
unsafe fn resolveFor(self: &mut Resolver, node: *ast::Node, forStmt: ast::For) -> Type
    throws (ResolveError)
{
    let iterableTy = try infer(self, forStmt.iterable);

    // Extract binding names for the lowerer.


/// Check whether a pattern contains nested sub-patterns that further
/// refine the match beyond the outer variant (e.g. nested union variant
/// tests or literal comparisons). Used to allow the same outer variant
/// to appear in multiple match arms.
fn hasNestedRefiningPattern(self: *Resolver, pattern: *ast::Node) -> bool {
fn hasNestedRefiningPattern(self: &Resolver, pattern: *ast::Node) -> bool {
    for i in 0..patternSubCount(pattern) {
        if let sub = patternSubElement(pattern, i) {
            if isRefiningPattern(self, sub) {
                return true;
            }


/// Check whether a single pattern node is a refining pattern that tests
/// a value rather than just binding it. Union variants, literals, and
/// scope accesses are refining; identifiers, placeholders, and plain
/// record destructurings are not.
fn isRefiningPattern(self: *Resolver, pattern: *ast::Node) -> bool {
fn isRefiningPattern(self: &Resolver, pattern: *ast::Node) -> bool {
    match pattern.value {
        case ast::NodeValue::Ident(_), ast::NodeValue::Placeholder =>
            return false,
        case ast::NodeValue::RecordLit(_), ast::NodeValue::Call(_) => {
            if let keyNode = patternVariantKeyNode(pattern) {

    return true;
}

/// Analyze a match prong, checking for duplicate catch-alls. Returns the
/// unified match type.
fn resolveMatchProng(
    self: *mut Resolver,
unsafe fn resolveMatchProng(
    self: &mut Resolver,
    prongNode: *ast::Node,
    prong: ast::MatchProng,
    subjectTy: Type,
    state: *mut MatchState,
    state: &mut MatchState,
    matchType: Type,
    matchBy: MatchBy
) -> Type throws (ResolveError) {
    // Whether this prong is catch-all.
    let mut isCatchAll = false;

    return try visitMatchProng(self, prongNode, prong, subjectTy, matchType, matchBy);
}

/// Analyze a `match` expression. Dispatches to specialized functions based on
/// the subject type.
fn resolveMatch(self: *mut Resolver, node: *ast::Node, sw: ast::Match) -> Type
unsafe fn resolveMatch(self: &mut Resolver, node: *ast::Node, sw: ast::Match) -> Type
    throws (ResolveError)
{
    let subjectTy = try infer(self, sw.subject);
    let subject = unwrapMatchSubject(subjectTy);


    };
    return ty;
}

/// Analyze a `match` expression on an optional subject.
fn resolveMatchOptional(
    self: *mut Resolver,
unsafe fn resolveMatchOptional(
    self: &mut Resolver,
    node: *ast::Node,
    sw: ast::Match,
    innerTy: *Type,
    matchBy: MatchBy
) -> Type throws (ResolveError)

    }
    return setNodeType(self, node, matchType);
}

/// Analyze a `match` expression on a union subject.
fn resolveMatchUnion(
    self: *mut Resolver,
unsafe fn resolveMatchUnion(
    self: &mut Resolver,
    node: *ast::Node,
    sw: ast::Match,
    subjectTy: Type,
    info: UnionType,
    matchBy: MatchBy

    return setNodeType(self, node, matchType);
}

/// Analyze a `match` expression on a generic subject type. Requires exhaustiveness:
/// booleans must cover both `true` and `false`, other types require a catch-all.
fn resolveMatchGeneric(self: *mut Resolver, node: *ast::Node, sw: ast::Match, subjectTy: Type) -> Type
unsafe fn resolveMatchGeneric(self: &mut Resolver, node: *ast::Node, sw: ast::Match, subjectTy: Type) -> Type
    throws (ResolveError)
{
    let prongs = sw.prongs;
    let mut state = MatchState { catchAll: false, isConst: true };
    let mut matchType = Type::Never;


    return setNodeType(self, node, matchType);
}

/// Analyze a single `match` prong branch. Returns the unified match type.
fn visitMatchProng(
    self: *mut Resolver,
unsafe fn visitMatchProng(
    self: &mut Resolver,
    node: *ast::Node,
    prongNode: ast::MatchProng,
    subjectTy: Type,
    matchType: Type,
    matchBy: MatchBy


    return unifyBranches(matchType, prongTy);
}

/// Analyze the contents of a `match` prong while inside the prong scope.
fn resolveMatchProngBody(
    self: *mut Resolver,
unsafe fn resolveMatchProngBody(
    self: &mut Resolver,
    prong: ast::MatchProng,
    subjectTy: Type,
    matchBy: MatchBy
) -> Type throws (ResolveError) {
    match prong.arm {

    }
    return try visit(self, prong.body, Type::Void);
}

/// Ensure a scope access pattern references a compatible union variant.
fn resolveUnionScopePattern(
    self: *mut Resolver,
unsafe fn resolveUnionScopePattern(
    self: &mut Resolver,
    pattern: *ast::Node,
    access: ast::Access,
    subjectTy: Type,
    unionType: UnionType
) throws (ResolveError) {

        throw emitError(self, pattern, ErrorKind::UnionVariantPayloadMissing(variant.name));
    }
}

/// Validate and bind a union constructor call used as a `match` pattern.
fn resolveUnionCallPattern(
    self: *mut Resolver,
unsafe fn resolveUnionCallPattern(
    self: &mut Resolver,
    pattern: *ast::Node,
    call: ast::Call,
    subjectTy: Type,
    unionType: UnionType,
    matchBy: MatchBy

        throw emitError(self, pattern, ErrorKind::UnionVariantPayloadUnexpected(variant.name));
    }
}

/// Bind the payload introduced by a union constructor pattern.
fn bindUnionPatternPayload(
    self: *mut Resolver,
unsafe fn bindUnionPatternPayload(
    self: &mut Resolver,
    pattern: *ast::Node,
    call: ast::Call,
    variantName: *[u8],
    payloadTy: Type,
    matchBy: MatchBy


    try bindRecordPatternFields(self, pattern, recInfo, matchBy);
}

/// Bind a pattern variable. For ref matches, wraps the type in a pointer.
fn bindPatternVar(self: *mut Resolver, binding: *ast::Node, ty: Type, matchBy: MatchBy)
unsafe fn bindPatternVar(self: &mut Resolver, binding: *ast::Node, ty: Type, matchBy: MatchBy)
    throws (ResolveError)
{
    let mut bindTy = ty;
    match matchBy {
        case MatchBy::Value => {}

        }
    }
}

/// Bind record pattern fields to variables in the current scope.
fn bindRecordPatternFields(
    self: *mut Resolver,
unsafe fn bindRecordPatternFields(
    self: &mut Resolver,
    pattern: *ast::Node,
    recInfo: RecordType,
    matchBy: MatchBy
) throws (ResolveError) {
    match pattern.value {

        else => throw emitError(self, pattern, ErrorKind::Internal)
    }
}

/// Validate and bind a record literal pattern for matching labeled union variants.
fn resolveUnionRecordPattern(
    self: *mut Resolver,
unsafe fn resolveUnionRecordPattern(
    self: &mut Resolver,
    pattern: *ast::Node,
    lit: ast::RecordLit,
    subjectTy: Type,
    unionType: UnionType,
    matchBy: MatchBy


    try bindRecordPatternFields(self, pattern, recInfo, matchBy);
}

/// Analyze a pattern appearing in a union case.
fn resolveUnionPattern(
    self: *mut Resolver,
unsafe fn resolveUnionPattern(
    self: &mut Resolver,
    pattern: *ast::Node,
    subjectTy: Type,
    unionType: UnionType,
    matchBy: MatchBy
) throws (ResolveError) {

    }
    return false;
}

/// Analyze a `let-else` guard.
fn resolveLetElse(self: *mut Resolver, node: *ast::Node, letElse: ast::LetElse) -> Type
unsafe fn resolveLetElse(self: &mut Resolver, node: *ast::Node, letElse: ast::LetElse) -> Type
    throws (ResolveError)
{
    let pat = &letElse.pattern;
    let pat = letElse.pattern;
    let exprTy = try infer(self, pat.scrutinee);

    match pat.kind {
        case ast::PatternKind::Binding => {
            // Simple binding requires an optional expression.

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

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

    return setNodeType(self, node, Type::U32);
}

/// Validate call arguments against a function type: check argument count,
/// type-check each argument, and verify that throwing functions use `try`.
fn checkCallArgs(self: *mut Resolver, node: *ast::Node, call: ast::Call, info: *FnType, ctx: CallCtx)
unsafe fn checkCallArgs(self: &mut Resolver, node: *ast::Node, call: ast::Call, info: *FnType, ctx: CallCtx)
    throws (ResolveError)
{
    if ctx == CallCtx::Normal and info.throwList.len > 0 {
        throw emitError(self, node, ErrorKind::MissingTry);
    }

        try checkAssignable(self, argNode, expectedTy);
    }
}

/// Analyze a function call expression.
fn resolveCall(self: *mut Resolver, node: *ast::Node, call: ast::Call, ctx: CallCtx) -> Type
unsafe fn resolveCall(self: &mut Resolver, node: *ast::Node, call: ast::Call, ctx: CallCtx) -> Type
    throws (ResolveError)
{
    // Intercept method calls on slices before inferring the callee.
    if let case ast::NodeValue::FieldAccess(access) = call.callee.value {
        let parentTy = try infer(self, access.parent);

    // Associate return type to call.
    return setNodeType(self, node, *info.returnType);
}

/// Resolve `slice.append(val, allocator)`.
fn resolveSliceAppend(
    self: *mut Resolver,
unsafe fn resolveSliceAppend(
    self: &mut Resolver,
    node: *ast::Node,
    parent: *ast::Node,
    parentType: Type,
    args: *mut [*ast::Node],
    elemType: *Type,

    // Return the parent's type so the caller can rebind:
    return setNodeType(self, node, parentType);
}

/// Resolve `slice.delete(index)`.
fn resolveSliceDelete(
    self: *mut Resolver,
unsafe fn resolveSliceDelete(
    self: &mut Resolver,
    node: *ast::Node,
    parent: *ast::Node,
    args: *mut [*ast::Node],
    elemType: *Type,
    mutable: bool


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

/// Analyze an assignment expression.
fn resolveAssign(self: *mut Resolver, node: *ast::Node, assign: ast::Assign) -> Type
unsafe fn resolveAssign(self: &mut Resolver, node: *ast::Node, assign: ast::Assign) -> Type
    throws (ResolveError)
{
    // Slice assignment: `slice[range] = value`.
    if let case ast::NodeValue::Subscript { container, index } = assign.left.value {
        if let case ast::NodeValue::Range(range) = index.value {


    return setNodeType(self, node, leftTy);
}

/// Ensure slice range bounds are valid `u32` values.
fn checkSliceRangeIndices(self: *mut Resolver, range: ast::Range) throws (ResolveError) {
unsafe fn checkSliceRangeIndices(self: &mut Resolver, range: ast::Range) throws (ResolveError) {
    if let start = range.start {
        try checkIndex(self, start);
    }
    if let end = range.end {
        try checkIndex(self, end);
    }
}

/// Emit an error when a slice range with compile-tyime values exceeds the array length.
fn validateArraySliceBounds(self: *mut Resolver, range: ast::Range, length: u32, site: *ast::Node) throws (ResolveError) {
fn validateArraySliceBounds(self: &mut Resolver, range: ast::Range, length: u32, site: *ast::Node) throws (ResolveError) {
    let mut startVal: ?u32 = nil;
    let mut endVal: ?u32 = length;

    if let startNode = range.start {
        if let val = constSliceIndex(self, startNode) {

}

/// Check that an index expression has an unsigned integer type.
/// Accepts `u8`, `u16`, `u32` and unsuffixed integer literals.
/// Smaller types are widened to `u32` via a numeric cast coercion.
fn checkIndex(self: *mut Resolver, indexNode: *ast::Node) throws (ResolveError) {
unsafe fn checkIndex(self: &mut Resolver, indexNode: *ast::Node) throws (ResolveError) {
    let indexTy = try visit(self, indexNode, Type::U32);
    if indexTy == Type::Int or indexTy == Type::U32 {
        let _ = try expectAssignable(self, Type::U32, indexTy, indexNode);
        return;
    }

        }
    }
}

/// Analyze an array or slice subscript expression.
fn resolveSubscript(self: *mut Resolver, node: *ast::Node, container: *ast::Node, indexNode: *ast::Node) -> Type
unsafe fn resolveSubscript(self: &mut Resolver, node: *ast::Node, container: *ast::Node, indexNode: *ast::Node) -> Type
    throws (ResolveError)
{
    // Range subscripts always require `&` to form a slice.
    if let case ast::NodeValue::Range(range) = indexNode.value {
        let _ = try infer(self, indexNode);

        }
    }
}

/// Find a record field by name.
fn findRecordField(s: *RecordType, fieldName: *[u8]) -> ?u32 {
fn findRecordField(s: &RecordType, fieldName: *[u8]) -> ?u32 {
    for field, i in s.fields {
        if let name = field.name {
            if name == fieldName {
                return i;
            }

    }
    return nil;
}

/// Analyze a union constructor call with payload.
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: *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.
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: *NominalType) -> Type
    throws (ResolveError)
{
    let case NominalType::Record(recInfo) = *recordType
        else panic "resolveRecordConstructorCall: not a record type";


    return setNodeType(self, node, Type::Nominal(recordType));
}

/// Resolve the type name of a record literal, handling both record types and
/// union variant payloads like `Union::Variant { ... }`.
fn resolveRecordLitType(
    self: *mut Resolver, node: *ast::Node, typeIdent: *ast::Node
unsafe fn resolveRecordLitType(
    self: &mut Resolver, node: *ast::Node, typeIdent: *ast::Node
) -> ResolvedRecordLitType
    throws (ResolveError)
{
    // Check if this is a scope access that might be a union variant.
    if let case ast::NodeValue::ScopeAccess(access) = typeIdent.value {
        let sym = try resolveAccess(self, typeIdent, access, self.scope);
        let scope = self.scope;
        let sym = try resolveAccess(self, typeIdent, access, scope);

        // Check if resolved symbol is a union variant.
        if let case SymbolData::Variant { type, decl, ordinal, index } = sym.data {
            // Get the union type from the variant's declaration.
            let declSym = symbolFor(self, decl)

        resultType: Type::Nominal(tyInfo),
    };
}

/// Analyze a record literal expression.
fn resolveRecordLit(self: *mut Resolver, node: *ast::Node, lit: ast::RecordLit, hint: Type) -> Type
unsafe fn resolveRecordLit(self: &mut Resolver, node: *ast::Node, lit: ast::RecordLit, hint: Type) -> Type
    throws (ResolveError)
{
    // If no type name, infer an anonymous tuple type.
    let typeIdent = lit.typeName else {
        return try resolveAnonRecordLit(self, node, lit, hint);

    }
    return setNodeType(self, node, resultType);
}

/// Analyze an anonymous record literal, checking fields against the hint type.
fn resolveAnonRecordLit(self: *mut Resolver, node: *ast::Node, lit: ast::RecordLit, hint: Type) -> Type
unsafe fn resolveAnonRecordLit(self: &mut Resolver, node: *ast::Node, lit: ast::RecordLit, hint: Type) -> Type
    throws (ResolveError)
{
    // Unwrap optional hint to get the inner record type.
    let mut innerHint = hint;
    if let case Type::Optional(inner) = hint {

    }
    return setNodeType(self, node, innerHint);
}

/// Analyze an array literal expression.
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: *mut [*ast::Node], hint: Type) -> Type
    throws (ResolveError)
{
    let length = items.len;
    let mut expectedTy: Type = Type::Unknown;


    let arrayTy = Type::Array(ArrayType { item: allocType(self, expectedTy), length });
    return setNodeType(self, node, arrayTy);
}

/// Analyze an array repeat literal expression.
fn resolveArrayRepeat(self: *mut Resolver, node: *ast::Node, lit: ast::ArrayRepeatLit, hint: Type) -> Type
unsafe fn resolveArrayRepeat(self: &mut Resolver, node: *ast::Node, lit: ast::ArrayRepeatLit, hint: Type) -> Type
    throws (ResolveError)
{
    let mut itemHint = hint;
    if let case Type::Array(ary) = hint {
        set itemHint = *ary.item;

    return setNodeType(self, node, arrayTy);
}

/// Resolve union variant access.
fn resolveUnionVariantAccess(
    self: *mut Resolver,
    self: &mut Resolver,
    node: *ast::Node,
    access: ast::Access,
    unionType: UnionType,
    variantName: *[u8]
) -> *mut Symbol throws (ResolveError) {

    }
    throw emitError(self, access.child, ErrorKind::UnresolvedSymbol(variantName));
}

/// Analyze a scope access expression.
fn resolveScopeAccess(self: *mut Resolver, node: *ast::Node, access: ast::Access) -> Type
unsafe fn resolveScopeAccess(self: &mut Resolver, node: *ast::Node, access: ast::Access) -> Type
    throws (ResolveError)
{
    let sym = try resolveAccess(self, node, access, self.scope);
    let scope = self.scope;
    let sym = try resolveAccess(self, node, access, scope);
    let mut ty: Type = undefined;

    match sym.data {
        case SymbolData::Value { type, .. } => {
            setNodeSymbol(self, node, sym);

    }
    return setNodeType(self, node, ty);
}

/// Analyze a field access expression.
fn resolveFieldAccess(self: *mut Resolver, node: *ast::Node, access: ast::Access) -> Type
unsafe fn resolveFieldAccess(self: &mut Resolver, node: *ast::Node, access: ast::Access) -> Type
    throws (ResolveError)
{
    let parentTy = try infer(self, access.parent);
    if isUnsafePointerType(parentTy) {
        try requireUnsafe(self, access.parent);

        }
    }
}

/// Determine whether an expression can yield a mutable location for borrowing.
fn canBorrowMutFrom(self: *mut Resolver, node: *ast::Node) -> bool
unsafe fn canBorrowMutFrom(self: &mut Resolver, node: *ast::Node) -> bool
    throws (ResolveError)
{
    match node.value {
        case ast::NodeValue::Ident(name) => {
            let sym = findValueSymbol(self.scope, name)

            return false;
        }
    }
}

/// Return the storage class of an addressed location.
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 types::PointerClass::Owned,
                    else => {}
                }
            }
        }
        case ast::NodeValue::FieldAccess(access) => {
            if let ty = typeFor(self, access.parent) {
                if let case Type::Pointer { class, .. } = ty {
                    return class;
                }
            }
            return addressStorageClass(self, access.parent);
        }
        case ast::NodeValue::Subscript { container, .. } => {
            if let ty = typeFor(self, container) {
                if let case Type::Slice { class, .. } = autoDeref(ty) {
                    return class;
                }
                if let case Type::Pointer { class, .. } = ty {
                    return class;
                }
            }
            return addressStorageClass(self, container);
        }
        case ast::NodeValue::Deref(target) => {
            if let ty = typeFor(self, target) {
                if let case Type::Pointer { class, .. } = ty {
                    return class;
                }
            }
            return addressStorageClass(self, target);
        }
        else => {}
    }
    return types::PointerClass::Ref;
}

/// Select an address type without extending the target storage lifetime.
fn addressClass(self: &mut Resolver, target: *ast::Node, hint: Type) -> types::PointerClass
    throws (ResolveError)
{
    if isUnsafePointerType(hint) {
        try requireUnsafe(self, target);
        return types::PointerClass::Unsafe;
    }
    if isRefType(hint) {
        return types::PointerClass::Ref;
    }
    match target.value {
        case ast::NodeValue::ArrayLit(_), ast::NodeValue::ArrayRepeatLit(_) => {
            if isConstExpr(self, target) {
                return types::PointerClass::Owned;
            }
        }
        else => {}
    }
    return addressStorageClass(self, target);
}

/// Analyze an address-of expression.
fn resolveAddressOf(self: *mut Resolver, node: *ast::Node, addr: ast::AddressOf, hint: Type) -> Type
unsafe fn resolveAddressOf(self: &mut Resolver, node: *ast::Node, addr: ast::AddressOf, hint: Type) -> Type
    throws (ResolveError)
{
    // Checked and unsafe pointer contexts require a reference source.
    let class = types::PointerClass::Ref
        if isRefType(hint) or isUnsafePointerType(hint)
        else types::PointerClass::Owned;
    if addr.mutable {
        if not try canBorrowMutFrom(self, addr.target) {
            throw emitError(self, addr.target, ErrorKind::ImmutableBinding);
        }
    }

                    else => {
                        throw emitError(self, container, ErrorKind::ExpectedIndexable);
                    }
                }
            }
            let class = try addressClass(self, addr.target, hint);
            let sliceTy = Type::Slice { class, item, mutable: addr.mutable };
            let alloc = allocType(self, sliceTy);
            setSliceRangeInfo(self, node, SliceRangeInfo {
                itemType: item,
                mutable: addr.mutable,

    let mut targetHint: Type = Type::Unknown;
    if let case Type::Slice { item, .. } = hint {
        set targetHint = Type::Array(ArrayType { item, length: 0 });
    }
    let targetTy = try visit(self, addr.target, targetHint);
    let class = try addressClass(self, addr.target, hint);

    // Mark local variable symbols as address-taken so the lowerer
    // allocates a stack slot eagerly.
    if let case ast::NodeValue::Ident(name) = addr.target.value {
        if let sym = findValueSymbol(self.scope, name) {

    };
    return setNodeType(self, node, pointerTy);
}

/// Analyze a dereference expression.
fn resolveDeref(self: *mut Resolver, node: *ast::Node, targetNode: *ast::Node, hint: Type) -> Type
unsafe fn resolveDeref(self: &mut Resolver, node: *ast::Node, targetNode: *ast::Node, hint: Type) -> Type
    throws (ResolveError)
{
    let operandTy = try visit(self, targetNode, hint);
    if let case Type::Pointer { class, target, .. } = operandTy {
        if class == types::PointerClass::Unsafe {

    }
    return false;
}

/// Analyze an `as` cast expression.
fn resolveAs(self: *mut Resolver, node: *ast::Node, expr: ast::As) -> Type
unsafe fn resolveAs(self: &mut Resolver, node: *ast::Node, expr: ast::As) -> Type
    throws (ResolveError)
{
    let targetTy = try infer(self, expr.type);
    let sourceTy = try visit(self, expr.value, targetTy);
    if isUnsafePointerType(sourceTy) or isUnsafePointerType(targetTy) {

        to: targetTy,
    }));
}

/// Analyze a range expression.
fn resolveRange(self: *mut Resolver, node: *ast::Node, range: ast::Range) -> Type
unsafe fn resolveRange(self: &mut Resolver, node: *ast::Node, range: ast::Range) -> Type
    throws (ResolveError)
{
    let mut start: ?*Type = nil;
    let mut end: ?*Type = nil;


}

/// Analyze a `try` expression and its handlers.
/// The `expected` type is used to determine if the value is discarded (`Void`)
/// or if the catch expression needs type checking.
fn resolveTry(self: *mut Resolver, node: *ast::Node, tryExpr: ast::Try, hint: Type) -> Type
unsafe fn resolveTry(self: &mut Resolver, node: *ast::Node, tryExpr: ast::Try, hint: Type) -> Type
    throws (ResolveError)
{
    let call = tryExpr.expr;
    let case ast::NodeValue::Call(callExpr) = call.value
        else throw emitError(self, call, ErrorKind::TryNonThrowing);

    return setNodeType(self, node, tryResultTy);
}

/// Check that a `catch` body is assignable to the expected result type, but only
/// in expression context (`hint` is neither `Unknown` nor `Void`).
fn checkCatchBody(self: *mut Resolver, body: *ast::Node, resultTy: Type, hint: Type)
unsafe fn checkCatchBody(self: &mut Resolver, body: *ast::Node, resultTy: Type, hint: Type)
    throws (ResolveError)
{
    if hint <> Type::Unknown and hint <> Type::Void {
        try checkAssignable(self, body, resultTy);
    }

/// Resolve catch clauses for a `try ... catch` expression.
///
/// For a single untyped catch (with or without binding), resolves the catch
/// body and returns the result type. Multi-error callees with inferred bindings
/// are rejected; you must use typed catches.
fn resolveTryCatches(
    self: *mut Resolver,
unsafe fn resolveTryCatches(
    self: &mut Resolver,
    node: *ast::Node,
    catches: *mut [*ast::Node],
    calleeInfo: *FnType,
    resultTy: Type,
    hint: Type


/// Resolve typed catch clauses (`catch e as T {..} catch e as S {..}`).
///
/// Validates that each type annotation is in the callee's throw list, that
/// there are no duplicate catch types, and that the clauses are exhaustive.
fn resolveTypedCatches(
    self: *mut Resolver,
unsafe fn resolveTypedCatches(
    self: &mut Resolver,
    node: *ast::Node,
    catches: *mut [*ast::Node],
    calleeInfo: *FnType,
    resultTy: Type,
    hint: Type

    }
    return resultTy;
}

/// Analyze a `throw` statement.
fn resolveThrow(self: *mut Resolver, node: *ast::Node, expr: *ast::Node) -> Type
unsafe fn resolveThrow(self: &mut Resolver, node: *ast::Node, expr: *ast::Node) -> Type
    throws (ResolveError)
{
    let fnInfo = self.currentFn
        else throw emitError(self, node, ErrorKind::ThrowRequiresThrows);
    if fnInfo.throwList.len == 0 {

    }
    throw emitError(self, expr, ErrorKind::ThrowIncompatibleError);
}

/// Analyze a `return` statement.
fn resolveReturn(self: *mut Resolver, node: *ast::Node, retVal: ?*ast::Node) -> Type
unsafe fn resolveReturn(self: &mut Resolver, node: *ast::Node, retVal: ?*ast::Node) -> Type
    throws (ResolveError)
{
    let f = self.currentFn
        else throw emitError(self, node, ErrorKind::UnexpectedReturn);
    let expected = *f.returnType;

    }
}

/// Try to constant-fold a binary operation on two resolved operands.
/// Only folds when the result type is concrete.
fn tryFoldBinOp(self: *mut Resolver, node: *ast::Node, binop: ast::BinOp, resultTy: Type) {
fn tryFoldBinOp(self: &mut Resolver, node: *ast::Node, binop: ast::BinOp, resultTy: Type) {
    let leftVal = constValueEntry(self, binop.left)
        else return;
    let rightVal = constValueEntry(self, binop.right)
        else return;


        }
    }
}

/// Analyze a binary expression.
fn resolveBinOp(self: *mut Resolver, node: *ast::Node, binop: ast::BinOp) -> Type
unsafe fn resolveBinOp(self: &mut Resolver, node: *ast::Node, binop: ast::BinOp) -> Type
    throws (ResolveError)
{
    let mut resultTy = Type::Unknown;

    match binop.op {


    return setNodeType(self, node, resultTy);
}

/// Analyze a unary expression.
fn resolveUnOp(self: *mut Resolver, node: *ast::Node, unop: ast::UnOp) -> Type
unsafe fn resolveUnOp(self: &mut Resolver, node: *ast::Node, unop: ast::UnOp) -> Type
    throws (ResolveError)
{
    let mut resultTy = Type::Unknown;

    match unop.op {

    };
    return setNodeType(self, node, resultTy);
}

/// Resolve a type signature node and set its type.
fn inferTypeSig(self: *mut Resolver, node: *ast::Node, sig: ast::TypeSig) -> Type
unsafe fn inferTypeSig(self: &mut Resolver, node: *ast::Node, sig: ast::TypeSig) -> Type
    throws (ResolveError)
{
    let resolved = try resolveTypeSig(self, node, sig);

    return setNodeType(self, node, resolved);
}

/// Convert a type signature node into a type value.
fn resolveTypeSig(self: *mut Resolver, node: *ast::Node, sig: ast::TypeSig) -> Type
unsafe fn resolveTypeSig(self: &mut Resolver, node: *ast::Node, sig: ast::TypeSig) -> Type
    throws (ResolveError)
{
    match sig {
        case ast::TypeSig::Void => {
            return Type::Void;

                }
            }
            let nominalTy = allocNominalType(self, NominalType::Record(recordType));
            return Type::Nominal(nominalTy);
        }
        case ast::TypeSig::Fn(t) => {
        case ast::TypeSig::Fn { sig: t, isUnsafe } => {
            let a = alloc::arenaAllocator(&mut self.arena);
            let mut paramTypes: *mut [*Type] = &mut [];
            let mut throwList: *mut [*Type] = &mut [];

            if t.params.len > MAX_FN_PARAMS {

            }
            let fnType = FnType {
                paramTypes: &paramTypes[..],
                returnType: retType,
                throwList: &throwList[..],
                isUnsafe: false,
                isUnsafe,
                localCount: 0,
            };
            return Type::Fn(allocFnType(self, fnType));
        }
        // Resolve an opaque trait object signature.

        else => return true,
    }
}

/// Analyze a standalone expression by wrapping it in a synthetic function.
export fn resolveExpr(
    self: *mut Resolver, expr: *ast::Node, arena: *mut ast::NodeArena
export unsafe fn resolveExpr(
    self: &mut Resolver, expr: *ast::Node, arena: &mut ast::NodeArena
) -> Diagnostics throws (ResolveError) {
    let a = alloc::arenaAllocator(&mut arena.arena);
    let exprStmt = ast::synthNode(arena, ast::NodeValue::ExprStmt(expr));
    let bodyStmts = ast::nodeSlice(arena, 1).append(exprStmt, a);
    let module = ast::synthFnModule(arena, ANALYZE_EXPR_FN_NAME, bodyStmts);


    return Diagnostics { errors: self.errors };
}

/// Analyze a parsed module root, ie. a block of top-level statements.
export fn resolveModuleRoot(self: *mut Resolver, root: *ast::Node) -> Diagnostics throws (ResolveError) {
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 {

}

/// 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.
fn resolveModuleGraph(self: *mut Resolver, block: *ast::Block) throws (ResolveError) {
unsafe fn resolveModuleGraph(self: &mut Resolver, block: &ast::Block) throws (ResolveError) {
    try bindTypeNames(self, block);

    for node in block.statements {
        if let case ast::NodeValue::Mod(decl) = node.value {
            try resolveModGraph(self, node, decl);

    }
}

/// Bind all type names in a module.
/// Skips declarations that have already been bound.
fn bindTypeNames(self: *mut Resolver, block: *ast::Block) throws (ResolveError) {
fn bindTypeNames(self: &mut Resolver, block: &ast::Block) throws (ResolveError) {
    for node in block.statements {
        match node.value {
            case ast::NodeValue::RecordDecl(decl) => {
                if symbolFor(self, node) == nil {
                    try bindTypeName(self, node, decl.name, decl.attrs) catch {};

        }
    }
}

/// Resolve all type bodies in a module.
fn resolveTypeBodies(self: *mut Resolver, block: *ast::Block) throws (ResolveError) {
unsafe fn resolveTypeBodies(self: &mut Resolver, block: &ast::Block) throws (ResolveError) {
    for node in block.statements {
        match node.value {
            case ast::NodeValue::RecordDecl(decl) => {
                try resolveRecordBody(self, node, decl) catch {
                    // Continue resolving other types even if one fails.

/// previous pass.
///
/// This function uses a two-phase approach:
/// Phase 1: Bind all type names to allow forward references and mutual recursion.
/// Phase 2: Resolve type bodies, ie. field types, variant types, etc.
fn resolveModuleDecls(res: *mut Resolver, block: *ast::Block) throws (ResolveError) {
unsafe fn resolveModuleDecls(res: &mut Resolver, block: &ast::Block) throws (ResolveError) {
    // Phase 1: Bind all type names as placeholders.
    try bindTypeNames(res, block);
    // Phase 2: Process imports so names available from the module graph can
    // be used in function signatures.
    for node in block.statements {

        try visitDecl(res, stmt);
    }
}

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

/// Return whether a tracked binding is still available.
fn linearBindingAvailable(env: *LinearEnv, index: u32) -> bool {
fn linearBindingAvailable(env: &LinearEnv, index: u32) -> bool {
    return (env.available & ((1 as u64) << (index as u64))) <> 0;
}

/// Add a local binding when its resolved type moves by value.
fn addLinearBinding(checker: *mut LinearChecker, env: *mut LinearEnv, node: *ast::Node)
unsafe fn addLinearBinding(checker: &mut LinearChecker, env: &mut LinearEnv, node: *ast::Node)
    throws (ResolveError)
{
    let sym = symbolFor(checker.resolver, node) else return;
    let sym = symbolFor(&mut *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(checker.resolver, node, ErrorKind::Internal);
        throw emitError(&mut *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) {
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));
}

/// Require exact-use bindings introduced after `start` to be consumed.
fn finishLinearScope(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
unsafe fn finishLinearScope(
    checker: &mut LinearChecker,
    env: &mut LinearEnv,
    start: u32,
) throws (ResolveError) {
    if not env.terminated {
        for i in start..env.len {
            if linearBindingAvailable(env, i) {
                let sym = env.symbols[i];
                let case SymbolData::Value { type: ty, .. } = sym.data
                    else panic "finishLinearScope: expected value symbol";
                if isLinear(ty) {
                    throw emitError(
                        checker.resolver,
                        &mut *checker.resolver,
                        sym.node,
                        ErrorKind::LinearNotConsumed(sym.name),
                    );
                }
            }

    }
    set env.len = start;
}

/// Move or consume a tracked identifier once.
fn consumeLinearIdent(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
unsafe fn consumeLinearIdent(
    checker: &mut LinearChecker,
    env: &mut LinearEnv,
    node: *ast::Node,
) throws (ResolveError) {
    let sym = symbolFor(checker.resolver, node) else return;
    let sym = symbolFor(&mut *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(checker.resolver, node, kind);
        throw emitError(&mut *checker.resolver, node, kind);
    }
    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.
fn joinLinearBranches(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
    left: *LinearEnv,
    right: *LinearEnv,
unsafe fn joinLinearBranches(
    checker: &mut LinearChecker,
    env: &mut LinearEnv,
    left: &LinearEnv,
    right: &LinearEnv,
    node: *ast::Node,
) throws (ResolveError) {
    if left.terminated and right.terminated {
        set *env = *left;
        set env.terminated = true;

            let sym = left.symbols[i];
            let case SymbolData::Value { type: ty, .. } = sym.data
                else panic "joinLinearBranches: expected value symbol";
            if isLinear(ty) {
                throw emitError(
                    checker.resolver,
                    &mut *checker.resolver,
                    node,
                    ErrorKind::LinearBranchMismatch(sym.name),
                );
            }
            set available &= ~((1 as u64) << (i as u64));

    set *env = *left;
    set env.available = available;
}

/// Require all available exact-use bindings to be consumed at a function exit.
fn finishLinearExit(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
unsafe fn finishLinearExit(
    checker: &mut LinearChecker,
    env: &mut LinearEnv,
) throws (ResolveError) {
    for i in 0..env.len {
        if linearBindingAvailable(env, i) {
            let sym = env.symbols[i];
            let case SymbolData::Value { type: ty, .. } = sym.data
                else panic "finishLinearExit: expected value symbol";
            if isLinear(ty) {
                throw emitError(
                    checker.resolver,
                    &mut *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) -> ?*mut Symbol {
    match node.value {
        case ast::NodeValue::Ident(_) => return symbolFor(self, node),
        case ast::NodeValue::AddressOf(addr) => return linearRootSymbol(self, addr.target),
        case ast::NodeValue::FieldAccess(access) =>
            return linearRootSymbol(self, access.parent),

        else => return nil,
    }
}

/// Add the value identifiers introduced by a pattern.
fn addLinearPatternBindings(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
unsafe fn addLinearPatternBindings(
    checker: &mut LinearChecker,
    env: &mut LinearEnv,
    pattern: *ast::Node,
) throws (ResolveError) {
    match pattern.value {
        case ast::NodeValue::Ident(_) => try addLinearBinding(checker, env, pattern),
        case ast::NodeValue::Call(call) => {

        else => {}
    }
}

/// Check a lexical block and exact-use of locals introduced in it.
fn checkLinearBlock(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
unsafe fn checkLinearBlock(
    checker: &mut LinearChecker,
    env: &mut LinearEnv,
    node: *ast::Node,
) throws (ResolveError) {
    let start = env.len;
    let case ast::NodeValue::Block(block) = node.value
        else panic "checkLinearBlock: expected block";

    try finishLinearScope(checker, env, start);
}

/// Push a repeated-control-flow boundary.
/// Initialize all loop state at this depth before increasing `loopDepth`.
fn enterLinearLoop(checker: *mut LinearChecker, env: *LinearEnv) {
fn enterLinearLoop(checker: &mut LinearChecker, env: &LinearEnv) {
    assert checker.loopDepth < MAX_LINEAR_LOOP_DEPTH, "linear loop nesting overflow";
    let depth = checker.loopDepth;
    set checker.loopMarks[depth] = env.len;
    set checker.loopAvailable[depth] = env.available;
    set checker.loopExitAvailable[depth] = env.available;

    set checker.loopBreakSeen[depth] = false;
    set checker.loopDepth += 1;
}

/// Require a repeated body's outer bindings to match its entry state.
fn checkLinearLoopBackEdge(
    checker: *mut LinearChecker,
    env: *LinearEnv,
unsafe fn checkLinearLoopBackEdge(
    checker: &mut LinearChecker,
    env: &LinearEnv,
    node: *ast::Node,
) throws (ResolveError) {
    if env.terminated {
        return;
    }

    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(
                checker.resolver,
                &mut *checker.resolver,
                node,
                ErrorKind::LinearBranchMismatch(sym.name),
            );
        }
    }
}

/// Record the ownership state of a loop's condition-false exit.
fn setLinearLoopNaturalExit(checker: *mut LinearChecker, env: *LinearEnv) {
fn setLinearLoopNaturalExit(checker: &mut LinearChecker, env: &LinearEnv) {
    assert checker.loopDepth > 0, "linear loop exit outside loop";
    let depth = checker.loopDepth - 1;
    set checker.loopExitAvailable[depth] = env.available;
    set checker.loopHasNaturalExit[depth] = true;
}

/// Require a break exit to agree with every other exit from this loop.
fn checkLinearLoopBreak(
    checker: *mut LinearChecker,
    env: *LinearEnv,
unsafe fn checkLinearLoopBreak(
    checker: &mut LinearChecker,
    env: &LinearEnv,
    node: *ast::Node,
) throws (ResolveError) {
    assert checker.loopDepth > 0, "linear loop break outside loop";
    let depth = checker.loopDepth - 1;
    let mark = checker.loopMarks[depth];

        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(
                    checker.resolver,
                    &mut *checker.resolver,
                    node,
                    ErrorKind::LinearBranchMismatch(sym.name),
                );
            }
        }

    }
    set checker.loopBreakSeen[depth] = true;
}

/// Pop a repeated-control-flow boundary.
fn exitLinearLoop(checker: *mut LinearChecker) {
fn exitLinearLoop(checker: &mut LinearChecker) {
    assert checker.loopDepth > 0, "exitLinearLoop: not in loop";
    set checker.loopDepth -= 1;
}

/// Check a conditional and merge its ownership states.
fn checkLinearIf(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
unsafe fn checkLinearIf(
    checker: &mut LinearChecker,
    env: &mut LinearEnv,
    node: *ast::Node,
    conditional: ast::If,
) throws (ResolveError) {
    try checkLinearNode(checker, env, conditional.condition, LinearUse::Consume);
    let base = *env;

    }
    try joinLinearBranches(checker, env, &thenEnv, &elseEnv, node);
}

/// Check an expression conditional and merge its ownership states.
fn checkLinearCondExpr(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
unsafe fn checkLinearCondExpr(
    checker: &mut LinearChecker,
    env: &mut LinearEnv,
    node: *ast::Node,
    conditional: ast::CondExpr,
    usage: LinearUse,
) throws (ResolveError) {
    try checkLinearNode(checker, env, conditional.condition, LinearUse::Consume);

    try checkLinearNode(checker, &mut elseEnv, conditional.elseExpr, usage);
    try joinLinearBranches(checker, env, &thenEnv, &elseEnv, node);
}

/// Check a match expression, including ownership transferred into patterns.
fn checkLinearMatch(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
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);
    let base = *env;

            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(checker.resolver, prongNode, ErrorKind::LinearDiscard);
                    throw emitError(&mut *checker.resolver, prongNode, ErrorKind::LinearDiscard);
                }
            }
        }
        if let guard = prong.guard {
            try checkLinearNode(checker, &mut branch, guard, LinearUse::Consume);
        }
        try checkLinearNode(checker, &mut branch, prong.body, LinearUse::Discard);
        try finishLinearScope(checker, &mut branch, bindingsStart);
        if haveResult {
            try joinLinearBranches(checker, &mut result, &result, &branch, node);
            let previous = result;
        try joinLinearBranches(checker, &mut result, &previous, &branch, node);
        } else {
            set result = branch;
            set haveResult = true;
        }
    }

        set *env = result;
    }
}

/// Check call-scoped loans and argument ownership transfers.
fn checkLinearCall(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
unsafe fn checkLinearCall(
    checker: &mut LinearChecker,
    env: &mut LinearEnv,
    node: *ast::Node,
    call: ast::Call,
) throws (ResolveError) {
    try checkLinearNode(checker, env, call.callee, LinearUse::Observe);
    let mut fnInfo: ?*FnType = nil;
    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(checker.resolver, call.callee) {
            if let calleeTy = typeFor(&mut *checker.resolver, call.callee) {
                if let case Type::Fn(info) = calleeTy {
                    set fnInfo = info;
                }
            }
        }

            }
            else => {}
        }
        if haveReceiver {
            if receiverClass <> types::PointerClass::Unsafe {
                let root = linearRootSymbol(checker.resolver, access.parent);
                let root = linearRootSymbol(&mut *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];
        let root = linearRootSymbol(checker.resolver, arg);
        let root = linearRootSymbol(&mut *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(
                                checker.resolver,
                                &mut *checker.resolver,
                                arg,
                                ErrorKind::BorrowConflict(rootSym.name),
                            );
                        }
                    }

        }
    }
}

/// Check a pattern conditional. Linear scrutinees require an exhaustive match.
fn checkLinearIfLet(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
unsafe fn checkLinearIfLet(
    checker: &mut LinearChecker,
    env: &mut LinearEnv,
    node: *ast::Node,
    conditional: ast::IfLet,
) throws (ResolveError) {
    if let subjectTy = typeFor(checker.resolver, conditional.pattern.scrutinee);
    if let subjectTy = typeFor(&mut *checker.resolver, conditional.pattern.scrutinee);
        isLinear(subjectTy)
    {
        throw emitError(
            checker.resolver,
            &mut *checker.resolver,
            conditional.pattern.scrutinee,
            ErrorKind::LinearPartialMove,
        );
    }
    try checkLinearNode(

    }
    try joinLinearBranches(checker, env, &thenEnv, &elseEnv, node);
}

/// Check one expression or statement under an ownership-use context.
fn checkLinearNode(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
unsafe fn checkLinearNode(
    checker: &mut LinearChecker,
    env: &mut LinearEnv,
    node: *ast::Node,
    usage: LinearUse,
) throws (ResolveError) {
    if env.terminated {
        return;

            if usage == LinearUse::Consume {
                try consumeLinearIdent(checker, env, node);
            }
        }
        case ast::NodeValue::ExprStmt(expr) => {
            if let exprTy = typeFor(checker.resolver, expr) {
            if let exprTy = typeFor(&mut *checker.resolver, expr) {
                if isLinear(exprTy) {
                    throw emitError(checker.resolver, expr, ErrorKind::LinearDiscard);
                    throw emitError(&mut *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(checker.resolver, binding.ident);
                if let bindingTy = typeFor(&mut *checker.resolver, binding.ident);
                    isLinear(bindingTy)
                {
                    throw emitError(
                        checker.resolver,
                        &mut *checker.resolver,
                        binding.value,
                        ErrorKind::LinearUndefined,
                    );
                }
            }
            try checkLinearNode(checker, env, binding.value, LinearUse::Consume);
            try addLinearBinding(checker, env, node);
            if isUndefined {
                markLinearBindingUnavailable(checker.resolver, env, node);
                markLinearBindingUnavailable(&mut *checker.resolver, env, node);
            }
        }
        case ast::NodeValue::Assign(assign) => {
            let mut target: ?u32 = nil;
            let mut targetLinear = false;
            if let leftTy = typeFor(checker.resolver, assign.left) {
            if let leftTy = typeFor(&mut *checker.resolver, assign.left) {
                if isMoveOnly(leftTy) {
                    set targetLinear = isLinear(leftTy);
                    if let case ast::NodeValue::Ident(_) = assign.left.value {
                        if let sym = symbolFor(checker.resolver, assign.left) {
                        if let sym = symbolFor(&mut *checker.resolver, assign.left) {
                            set target = findLinearBinding(env, sym);
                        }
                    }
                    if target == nil {
                        throw emitError(
                            checker.resolver,
                            &mut *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(
                        checker.resolver,
                        &mut *checker.resolver,
                        assign.left,
                        ErrorKind::LinearOverwrite,
                    );
                }
                set env.available |= (1 as u64) << (index as u64);

        case ast::NodeValue::Call(call) => try checkLinearCall(checker, env, node, call),
        case ast::NodeValue::AddressOf(addr) => {
            try checkLinearNode(checker, env, addr.target, LinearUse::Borrow);
        }
        case ast::NodeValue::Deref(target) => {
            if let resultTy = typeFor(checker.resolver, node) {
            if let resultTy = typeFor(&mut *checker.resolver, node) {
                if isMoveOnly(resultTy) and usage == LinearUse::Consume {
                    throw emitError(checker.resolver, node, ErrorKind::LinearPartialMove);
                    throw emitError(&mut *checker.resolver, node, ErrorKind::LinearPartialMove);
                }
            }
            try checkLinearNode(checker, env, target, LinearUse::Observe);
        }
        case ast::NodeValue::FieldAccess(access) => {
            if let resultTy = typeFor(checker.resolver, node) {
            if let resultTy = typeFor(&mut *checker.resolver, node) {
                if isMoveOnly(resultTy) and usage == LinearUse::Consume {
                    throw emitError(checker.resolver, node, ErrorKind::LinearPartialMove);
                    throw emitError(&mut *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(checker.resolver, node) {
            if let resultTy = typeFor(&mut *checker.resolver, node) {
                if isMoveOnly(resultTy) and usage == LinearUse::Consume {
                    throw emitError(checker.resolver, node, ErrorKind::LinearPartialMove);
                    throw emitError(&mut *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(checker.resolver, repeat.item) {
            if let itemTy = typeFor(&mut *checker.resolver, repeat.item) {
                if not isCopy(itemTy) {
                    throw emitError(
                        checker.resolver,
                        &mut *checker.resolver,
                        repeat.item,
                        ErrorKind::LinearDiscard,
                    );
                }
            }

        }
        case ast::NodeValue::IfLet(conditional) => {
            try checkLinearIfLet(checker, env, node, conditional);
        }
        case ast::NodeValue::LetElse(binding) => {
            if let subjectTy = typeFor(checker.resolver, binding.pattern.scrutinee);
            if let subjectTy = typeFor(&mut *checker.resolver, binding.pattern.scrutinee);
                isLinear(subjectTy)
            {
                throw emitError(
                    checker.resolver,
                    &mut *checker.resolver,
                    binding.pattern.scrutinee,
                    ErrorKind::LinearPartialMove,
                );
            }
            try checkLinearNode(

                    checker,
                    &mut guardFallbackEnv,
                    binding.elseBranch,
                    LinearUse::Consume,
                );
                let previous = fallbackEnv;
                try joinLinearBranches(
                    checker,
                    &mut fallbackEnv,
                    &fallbackEnv,
                    &previous,
                    &guardFallbackEnv,
                    binding.elseBranch,
                );
            }
            if let case ast::PatternKind::Binding = binding.pattern.kind {

                if let binding = catchClause.binding {
                    try addLinearBinding(checker, &mut branch, binding);
                }
                try checkLinearNode(checker, &mut branch, catchClause.body, usage);
                try finishLinearScope(checker, &mut branch, start);
                try joinLinearBranches(checker, env, env, &branch, node);
                let previous = *env;
                try joinLinearBranches(checker, env, &previous, &branch, node);
            }
        }
        case ast::NodeValue::While(whileStmt) => {
            enterLinearLoop(checker, env);
            try checkLinearNode(checker, env, whileStmt.condition, LinearUse::Consume);

                );
                try joinLinearBranches(checker, env, &conditionExit, &elseEnv, node);
            }
        }
        case ast::NodeValue::WhileLet(whileStmt) => {
            if let subjectTy = typeFor(checker.resolver, whileStmt.pattern.scrutinee);
            if let subjectTy = typeFor(&mut *checker.resolver, whileStmt.pattern.scrutinee);
                isLinear(subjectTy)
            {
                throw emitError(
                    checker.resolver,
                    &mut *checker.resolver,
                    whileStmt.pattern.scrutinee,
                    ErrorKind::LinearPartialMove,
                );
            }
            let base = *env;

            try addLinearPatternBindings(checker, &mut bodyEnv, whileStmt.pattern.pattern);
            if let guard = whileStmt.pattern.guard {
                try checkLinearNode(checker, &mut bodyEnv, guard, LinearUse::Consume);
                let mut guardExit = bodyEnv;
                try finishLinearScope(checker, &mut guardExit, start);
                let previous = conditionExit;
                try joinLinearBranches(
                    checker,
                    &mut conditionExit,
                    &conditionExit,
                    &previous,
                    &guardExit,
                    guard,
                );
            }
            setLinearLoopNaturalExit(checker, &conditionExit);

                );
                try joinLinearBranches(checker, env, &conditionExit, &elseEnv, node);
            }
        }
        case ast::NodeValue::For(forStmt) => {
            if let iterableTy = typeFor(checker.resolver, forStmt.iterable) {
            if let iterableTy = typeFor(&mut *checker.resolver, forStmt.iterable) {
                if isLinear(iterableTy) {
                    throw emitError(
                        checker.resolver,
                        &mut *checker.resolver,
                        forStmt.iterable,
                        ErrorKind::LinearPartialMove,
                    );
                }
            }

        else => {}
    }
}

/// Check exact-use ownership for one resolved function.
fn checkLinearFn(
    self: *mut Resolver,
unsafe fn checkLinearFn(
    self: &mut Resolver,
    receiver: ?*ast::Node,
    params: *mut [*ast::Node],
    body: *ast::Node,
) throws (ResolveError) {
    let mut checker = LinearChecker {
        resolver: self,
        resolver: self as *unsafe mut Resolver,
        loopMarks: undefined,
        loopAvailable: undefined,
        loopExitAvailable: undefined,
        loopHasNaturalExit: undefined,
        loopBreakSeen: undefined,

    try checkLinearNode(&mut checker, &mut env, body, LinearUse::Discard);
    try finishLinearScope(&mut checker, &mut env, 0);
}

/// Analyze module definitions. This pass analyzes function bodies, recursing into sub-modules.
fn resolveModuleDefs(self: *mut Resolver, block: *ast::Block) throws (ResolveError) {
unsafe fn resolveModuleDefs(self: &mut Resolver, block: &ast::Block) throws (ResolveError) {
    for stmt in block.statements {
        try visitDef(self, stmt);
    }
}

/// Resolve all packages.
export fn resolve(self: *mut Resolver, graph: *module::ModuleGraph, packages: *[Pkg]) -> Diagnostics throws (ResolveError) {
    set self.moduleGraph = graph;
/// The graph must outlive later uses of the resolver.
export unsafe fn resolve(self: &mut Resolver, graph: &module::ModuleGraph, packages: &[Pkg]) -> Diagnostics throws (ResolveError) {
    set self.moduleGraph = graph as *unsafe module::ModuleGraph;

    // 1. Bind all package roots to enable cross-package references.
    for i in 0..packages.len {
        let pkg = &packages[i];
        let pkg = packages[i];
        // Enter a new scope for the module.
        let enter = enterModuleScope(self, pkg.rootAst, pkg.rootEntry);
        // Bind the package root module name in the global package scope.
        try bindModuleIdent(self, pkg.rootEntry, enter.newScope, pkg.rootAst, 0, self.pkgScope);
        let scope = self.pkgScope;
        try bindModuleIdent(self, pkg.rootEntry, enter.newScope, pkg.rootAst, 0, scope);

        exitModuleScope(self, enter);
    }
    // 2. Resolve each package's contents.
    for i in 0..packages.len {
        let pkg = &packages[i];
        let pkg = packages[i];
        let diags = try resolvePackage(self, pkg.rootEntry, pkg.rootAst);
        if not success(&diags) {
            return diags;
        }
    }
    return Diagnostics { errors: self.errors };
}

/// Resolve a package.
fn resolvePackage(self: *mut Resolver, rootEntry: *module::ModuleEntry, node: *ast::Node) -> Diagnostics throws (ResolveError) {
unsafe fn resolvePackage(self: &mut Resolver, rootEntry: *module::ModuleEntry, node: *ast::Node) -> Diagnostics throws (ResolveError) {
    let rootId = rootEntry.id;
    let scope = self.moduleScopes[rootId as u32]
        else panic "resolvePackage: module scope not found";

    // Set up the module scope for this package.

lib/std/lang/resolver/printer.rad +5 -5

        }
    }
}

/// Print a single diagnostic entry.
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

        }
        case super::ErrorKind::BorrowConflict(name) => {
            printQuoted("conflicting call-scoped loans of '", name);
        }
        case super::ErrorKind::UnsafeOperation => {
            io::print("unsafe pointer operation requires an unsafe declaration");
            io::print("unsafe pointer operation requires an unsafe function");
        }
        case super::ErrorKind::UnsafeCall => {
            io::print("calling an unsafe function requires an unsafe declaration");
            io::print("calling an unsafe function requires an unsafe function");
        }
        case super::ErrorKind::Internal => {
            io::print("internal compiler error");
        }
        case super::ErrorKind::RecordFieldOutOfOrder { .. } => {

    }
    io::print("\n");
}

/// Entry point for printing resolver diagnostics in vim quickfix format.
export fn printDiagnostics(diag: *super::Diagnostics, res: *super::Resolver) {
export unsafe fn printDiagnostics(diag: &super::Diagnostics, res: &super::Resolver) {
    for i in 0..diag.errors.len {
        printError(&diag.errors[i], res);
    }
}

lib/std/lang/resolver/tests.rad +530 -443

        errors: &mut ERROR_STORAGE[..],
    };
}

/// Construct a resolver backed by test storage and a synthetic module graph.
fn testResolver() -> super::Resolver {
unsafe fn testResolver() -> super::Resolver {
    // TODO: This should be initialized only once.
    for i in 0..LITERALS.len {
        strings::intern(&mut STRING_POOL, LITERALS[i]);
    }
    // TODO: Use local static for this.


    return res;
}

/// Resolve a block of statements by wrapping them in a synthetic function.
fn resolveStatements(
    self: *mut super::Resolver, block: ast::Block, arena: *mut ast::NodeArena
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, root: module.fnBody };
}

/// Parse and analyze an expression string for testing.
fn resolveExprStr(self: *mut super::Resolver, stmt: *[u8]) -> TestResult throws (testing::TestError) {
unsafe fn resolveExprStr(self: &mut super::Resolver, stmt: *[u8]) -> TestResult throws (testing::TestError) {
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut p = parser::mkParser(scanner::SourceLoc::String, stmt, &mut arena, &mut STRING_POOL);
    parser::advance(&mut p);

    let expr = try parser::parseExpr(&mut p) catch {

    return TestResult { diagnostics, root: expr };
}

/// Parse and analyze a module string for testing.
/// Use this for code with `fn`, `record`, `union`, etc. at the top level.
fn resolveProgramStr(self: *mut super::Resolver, stmt: *[u8]) -> TestResult throws (testing::TestError) {
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 {
        panic "resolveProgramStr: parsing failed";
    };
    let diagnostics = try super::resolveModuleRoot(self, stmt) catch {

    return TestResult { diagnostics, root: stmt };
}

/// Parse and analyze a block of statements (eg. inside a function body) for testing.
/// Use this for code with `let` bindings and expressions, not module-level declarations.
fn resolveBlockStr(self: *mut super::Resolver, stmt: *[u8]) -> TestResult throws (testing::TestError) {
unsafe fn resolveBlockStr(self: &mut super::Resolver, stmt: *[u8]) -> TestResult throws (testing::TestError) {
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let parsed = try parser::parse(scanner::SourceLoc::String, stmt, &mut arena, &mut STRING_POOL) catch {
        panic "resolveBlockStr: parsing failed";
    };
    let case ast::NodeValue::Block(block) = parsed.value

        root: analysis.root,
    };
}

/// Resolve a module with the full resolution process.
fn resolveModuleTree(
    res: *mut super::Resolver,
unsafe fn resolveModuleTree(
    res: &mut super::Resolver,
    rootId: u16
) -> TestResult throws (testing::TestError) {
    let root = module::get(&MODULE_GRAPH, rootId)
        else throw testing::TestError::Failed;
    let rootAst = root.ast
        else throw testing::TestError::Failed;
    let packages: *[super::Pkg] = &[super::Pkg {
    let packages = [super::Pkg {
        rootEntry: root,
        rootAst,
    }];
    let diagnostics = try super::resolve(res, &MODULE_GRAPH, packages) catch {
    let diagnostics = try super::resolve(res, &MODULE_GRAPH, &packages[..]) catch {
        throw testing::TestError::Failed;
    };
    return TestResult { diagnostics, root: rootAst };
}

/// Register a module in the graph and attach a parsed AST to it.
/// If parentId is nil, registers as a root module.
fn registerModule(
    graph: *mut module::ModuleGraph,
unsafe fn registerModule(
    graph: &mut module::ModuleGraph,
    parentId: ?u16,
    name: *[u8],
    code: *[u8],
    arena: *mut ast::NodeArena
    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 {

    };
    return modId;
}

/// Ensure an expression statement produces the expected type and return the expression node.
fn expectExprStmtType(self: *super::Resolver, node: *ast::Node, expected: super::Type) -> *ast::Node
fn expectExprStmtType(self: &super::Resolver, node: *ast::Node, expected: super::Type) -> *ast::Node
    throws (testing::TestError)
{
    let case ast::NodeValue::ExprStmt(expr) = node.value
        else throw testing::TestError::Failed;
    try expectType(self, expr, expected);

    return expr;
}

/// Assert that the test result contains no diagnostic errors.
fn expectNoErrors(r: *TestResult) throws (testing::TestError) {
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;
}

/// Check if two error kinds match.
fn errorKindMatches(actual: *super::ErrorKind, expected: super::ErrorKind) -> bool {
fn errorKindMatches(actual: &super::ErrorKind, expected: super::ErrorKind) -> bool {
    if let case super::ErrorKind::DuplicateBinding(expectedName) = expected {
        if let case super::ErrorKind::DuplicateBinding(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;

    }
    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;
}

/// Ensure an expression resolves to the expected type annotation.
fn expectType(self: *super::Resolver, expr: *ast::Node, expected: super::Type)
fn expectType(self: &super::Resolver, expr: *ast::Node, expected: super::Type)
    throws (testing::TestError)
{
    let actual = super::typeFor(self, expr)
        else throw testing::TestError::Failed;


        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);
    try testing::expect(mismatch.actual == actual);
}

/// Resolve a program and require successful analysis.
fn expectAnalyzeOk(program: *[u8]) throws (testing::TestError) {
unsafe fn expectAnalyzeOk(program: *[u8]) throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Require an inferred integer type mismatch.
fn expectIntMismatch(program: *[u8], expected: super::Type)
unsafe fn expectIntMismatch(program: *[u8], expected: super::Type)
    throws (testing::TestError)
{
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);

    }
    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
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)

    }
    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
fn getTypeInScopeOf(a: &super::Resolver, blk: *ast::Node, name: *[u8]) -> *super::NominalType
    throws (testing::TestError)
{
    let scope = super::scopeFor(a, blk)
        else throw testing::TestError::Failed;
    let sym = super::findSymbolInScope(scope, name)

        else throw testing::TestError::Failed;
    return ty;
}

/// Return the resolved type of a syntax node.
fn typeOf(a: *super::Resolver, node: *ast::Node) -> super::Type
fn typeOf(a: &super::Resolver, node: *ast::Node) -> super::Type
    throws (testing::TestError)
{
    let ty = super::typeFor(a, node)
        else throw testing::TestError::Failed;
    return ty;


    return *target;
}

/// Verify that a node has a constant integer value with the expected magnitude.
fn expectConstInt(a: *super::Resolver, node: *ast::Node, expected: u32)
fn expectConstInt(a: &super::Resolver, node: *ast::Node, expected: u32)
    throws (testing::TestError)
{
    let constVal = super::constValueEntry(a, node)
        else throw testing::TestError::Failed;



    try testing::expect(int.magnitude == expected);
}

/// Resolve an expression that should evaluate to a constant, and verify it equals the expected value.
fn resolveAndExpectConstExpr(expr: *[u8], expected: u32)
unsafe fn resolveAndExpectConstExpr(expr: *[u8], expected: u32)
    throws (testing::TestError)
{
    let mut a = testResolver();
    let result = try resolveExprStr(&mut a, expr);
    try expectNoErrors(&result);
    try expectType(&a, result.root, super::Type::U32);
    try expectConstInt(&a, result.root, expected);
}

/// Resolve a statement that should evaluate to a constant, and verify it equals the expected value.
fn resolveAndExpectConstStmt(expr: *[u8], expected: u32)
unsafe fn resolveAndExpectConstStmt(expr: *[u8], expected: u32)
    throws (testing::TestError)
{
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, expr);
    try expectNoErrors(&result);

    try expectConstInt(&a, expr, expected);
}

// Tests ///////////////////////////////////////////////////////////////////////

@test fn testResolveLit() throws (testing::TestError) {
@test unsafe fn testResolveLit() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveExprStr(&mut a, "true");

    try expectNoErrors(&result);
    try expectType(&a, result.root, super::Type::Bool);
}

@test fn testResolveStringLiteralType() throws (testing::TestError) {
@test unsafe fn testResolveStringLiteralType() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveExprStr(&mut a, "\"hello\"");

    try expectNoErrors(&result);
    let ty = try typeOf(&a, result.root);
    let elemTy = try expectSliceType(ty, false);
    try testing::expect(elemTy == super::Type::U8);
}

@test fn testResolveAsNumeric() throws (testing::TestError) {
@test unsafe fn testResolveAsNumeric() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "1 as u32");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::U32);

        let x = try getBlockStmt(result.root, 1);
        try expectExprStmtType(&a, x, super::Type::U8);
    }
}

@test fn testResolveAsInvalid() throws (testing::TestError) {
@test unsafe fn testResolveAsInvalid() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "true as u32");

    try expectErrorKind(
        &result,

            to: super::Type::U32,
        })
    );
}

@test fn testResolveAsUnionToInt() throws (testing::TestError) {
@test unsafe fn testResolveAsUnionToInt() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Color { Red } Color::Red as u32;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let red = try getBlockStmt(result.root, 1);
    try expectExprStmtType(&a, red, super::Type::U32);
}

@test fn testResolveBinding() throws (testing::TestError) {
@test unsafe fn testResolveBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveBlockStr(&mut a, "let x: bool = true; x;");
    let stmt = try parser::tests::getBlockLastStmt(result.root);

    try expectNoErrors(&result);

    let case super::SymbolData::Value { type: valType, .. } = sym.data
        else throw testing::TestError::Failed;
    try testing::expect(valType == super::Type::Bool);
}

@test fn testResolveBindingInvalid() throws (testing::TestError) {
@test unsafe fn testResolveBindingInvalid() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveBlockStr(&mut a, "let x: i32 = true;");
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::I32, super::Type::Bool);
}

@test fn testResolveDuplicateBinding() throws (testing::TestError) {
@test unsafe fn testResolveDuplicateBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveBlockStr(&mut a, "let x: bool = true; let x: u8 = 1;");
    let stmt = try parser::tests::getBlockLastStmt(result.root);
    try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("x"));
}

@test fn testResolveConstLiteralValue() throws (testing::TestError) {
@test unsafe fn testResolveConstLiteralValue() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "constant ANSWER: i32 = 42;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);


    let case super::SymbolData::Constant { type: constType, .. } = sym.data
        else throw testing::TestError::Failed;
    try testing::expect(constType == super::Type::I32);
}

@test fn testResolveConstRequiresConstantExpr() throws (testing::TestError) {
@test unsafe fn testResolveConstRequiresConstantExpr() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn value() -> i32 { return 1 } fn main() { constant ANSWER: i32 = value(); }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectErrorKind(&result, super::ErrorKind::ConstExprRequired);


        else throw testing::TestError::Failed;
    let case ast::NodeValue::Call(_) = errNode.value
        else throw testing::TestError::Failed;
}

@test fn testResolveStaticLiteralValue() throws (testing::TestError) {
@test unsafe fn testResolveStaticLiteralValue() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "static COUNTER: i32 = 0;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);


    let case super::SymbolData::Value { type: valType, .. } = sym.data
        else throw testing::TestError::Failed;
    try testing::expect(valType == super::Type::I32);
}

@test fn testResolveStaticRequiresConstantExpr() throws (testing::TestError) {
@test unsafe fn testResolveStaticRequiresConstantExpr() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn seed() -> i32 { return 1; } static COUNTER: i32 = seed();";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectErrorKind(&result, super::ErrorKind::ConstExprRequired);


        else throw testing::TestError::Failed;
    let case ast::NodeValue::Call(_) = errNode.value
        else throw testing::TestError::Failed;
}

@test fn testSymbolStoresFnAttributes() throws (testing::TestError) {
@test unsafe fn testSymbolStoresFnAttributes() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "@default export fn f() { return; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);


    try testing::expect(ast::hasAttribute(sym.attrs, ast::Attribute::Export));
    try testing::expect(ast::hasAttribute(sym.attrs, ast::Attribute::Default));
    try testing::expectNot(ast::hasAttribute(sym.attrs, ast::Attribute::Extern));
}

@test fn testSymbolStoresRecordAttributes() throws (testing::TestError) {
@test unsafe fn testSymbolStoresRecordAttributes() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "export record S { value: i32 }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);



    try testing::expect(ast::hasAttribute(sym.attrs, ast::Attribute::Export));
    try testing::expectNot(ast::hasAttribute(sym.attrs, ast::Attribute::Default));
}

@test fn testDefaultAttributeRejectedOnRecord() throws (testing::TestError) {
@test unsafe fn testDefaultAttributeRejectedOnRecord() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "@default record T { value: i32 }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::DefaultAttrOnlyOnFn);
}

@test fn testDefaultAttributeRejectedOnUnion() throws (testing::TestError) {
@test unsafe fn testDefaultAttributeRejectedOnUnion() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "@default union Result { Ok, Err }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::DefaultAttrOnlyOnFn);
}

@test fn testResolveArrayLiteralTyped() throws (testing::TestError) {
@test unsafe fn testResolveArrayLiteralTyped() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 2] = [1, 2];");
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 0);

    let arrayTy = try typeOf(&a, decl.value);
    let elemTy = try expectArrayType(arrayTy, 2);
    try testing::expect(elemTy == super::Type::I32);
}

@test fn testResolveArrayLiteralElementMismatch() throws (testing::TestError) {
@test unsafe fn testResolveArrayLiteralElementMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [bool; 2] = [true, 1];");
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
}

@test fn testResolveArrayLiteralCannotInfer() throws (testing::TestError) {
@test unsafe fn testResolveArrayLiteralCannotInfer() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs = [1, 2];");
    try expectErrorKind(&result, super::ErrorKind::CannotInferType);
}

@test fn testResolveArrayLiteralOverflow() throws (testing::TestError) {
@test unsafe fn testResolveArrayLiteralOverflow() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [u8; 2] = [1, 256];");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

@test fn testResolveArrayLiteralTooFewElements() throws (testing::TestError) {
@test unsafe fn testResolveArrayLiteralTooFewElements() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 2] = [1];");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

@test fn testResolveArrayLiteralTooManyElements() throws (testing::TestError) {
@test unsafe fn testResolveArrayLiteralTooManyElements() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 2] = [1, 2, 3];");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

@test fn testResolveArrayLiteralEmptyWithAnnotation() throws (testing::TestError) {
@test unsafe fn testResolveArrayLiteralEmptyWithAnnotation() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 0] = [];");
    try expectNoErrors(&result);
}

@test fn testResolveNestedArrayLiteralTyped() throws (testing::TestError) {
@test unsafe fn testResolveNestedArrayLiteralTyped() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let grid: [[i32; 2]; 2] = [[1, 2], [3, 4]];");
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 0);

    let rowTy = try expectArrayType(gridTy, 2);
    let elemTy = try expectArrayType(rowTy, 2);
    try testing::expect(elemTy == super::Type::I32);
}

@test fn testResolveArrayLiteralWithOptionalElems() throws (testing::TestError) {
@test unsafe fn testResolveArrayLiteralWithOptionalElems() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [?i32; 2] = [1, 2];");
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 0);

    let case super::Type::Optional(inner) = elemTy
        else throw testing::TestError::Failed;
    try testing::expect(*inner == super::Type::I32);
}

@test fn testResolveArrayLiteralOptionalMismatch() throws (testing::TestError) {
@test unsafe fn testResolveArrayLiteralOptionalMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [?bool; 2] = [1, 2];");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

@test fn testResolveArrayRepeatBasic() throws (testing::TestError) {
@test unsafe fn testResolveArrayRepeatBasic() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 3] = [42; 3];");
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 0);

    let arrayTy = try typeOf(&a, decl.value);
    let elemTy = try expectArrayType(arrayTy, 3);
    try testing::expect(elemTy == super::Type::I32);
}

@test fn testResolveArrayRepeatWithExpression() throws (testing::TestError) {
@test unsafe fn testResolveArrayRepeatWithExpression() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 5] = [3 + 2; 5];");
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 0);

    let arrayTy = try typeOf(&a, decl.value);
    let elemTy = try expectArrayType(arrayTy, 5);
    try testing::expect(elemTy == super::Type::I32);
}

@test fn testResolveArrayRepeatLiteralArithmetic() throws (testing::TestError) {
@test unsafe fn testResolveArrayRepeatLiteralArithmetic() throws (testing::TestError) {
    let mut a = testResolver();
    // `3 * 1` folds to a compile-time constant, so the repeat count is valid.
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 3] = [42; 3 * 1];");
    try expectNoErrors(&result);
}

@test fn testResolveArrayRepeatNonConstCount() throws (testing::TestError) {
@test unsafe fn testResolveArrayRepeatNonConstCount() throws (testing::TestError) {
    let mut a = testResolver();
    // A function call is not a constant expression.
    let result = try resolveProgramStr(&mut a, "fn f() -> u32 { return 3; } let xs: [i32; 3] = [42; f()];");
    try expectErrorKind(&result, super::ErrorKind::ConstExprRequired);
}

@test fn testResolveArrayRepeatCountMismatch() throws (testing::TestError) {
@test unsafe fn testResolveArrayRepeatCountMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 4] = [1; 3];");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

@test fn testResolveArrayIndex() throws (testing::TestError) {
@test unsafe fn testResolveArrayIndex() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [i32; 3] = [1, 2, 3]; xs[1];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 1);
    try expectExprStmtType(&a, stmt, super::Type::I32);
}

@test fn testResolveSliceIndex() throws (testing::TestError) {
@test unsafe fn testResolveSliceIndex() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [i32; 4] = [1, 2, 3, 4]; let slice = &xs[1..]; slice[1];";
    let program = "static xs: [i32; 4] = [1, 2, 3, 4]; let slice = &xs[1..]; slice[1];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let sliceStmt = try getBlockStmt(result.root, 1);
    let case ast::NodeValue::Let(sliceDecl) = sliceStmt.value


    let indexStmt = try getBlockStmt(result.root, 2);
    try expectExprStmtType(&a, indexStmt, super::Type::I32);
}

@test fn testResolveSliceFields() throws (testing::TestError) {
@test unsafe fn testResolveSliceFields() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[1..]; slice.len; slice.ptr;";
    let program = "static xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[1..]; slice.len; slice.ptr;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let lenStmt = try getBlockStmt(result.root, 2);
    let case ast::NodeValue::ExprStmt(lenExpr) = lenStmt.value

    let ptrTy = try typeOf(&a, ptrExpr);
    let targetTy = try expectPointerType(ptrTy, false);
    try testing::expect(targetTy == super::Type::I32);
}

@test fn testResolveSliceLiteralImmutable() throws (testing::TestError) {
@test unsafe fn testResolveSliceLiteralImmutable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let slice: *[i32] = &[1, 2, 3];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Empty array literal infers element type from slice annotation.
@test fn testResolveSliceLiteralEmpty() throws (testing::TestError) {
@test unsafe fn testResolveSliceLiteralEmpty() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let slice: *[i32] = &[];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Nested array literal should infer inner element type from slice annotation.
@test fn testResolveSliceLiteralNestedArray() throws (testing::TestError) {
@test unsafe fn testResolveSliceLiteralNestedArray() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let slice: *[[i32; 2]] = &[[1, 2], [3, 4]];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test fn testResolveSliceFromArray() throws (testing::TestError) {
@test unsafe fn testResolveSliceFromArray() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[..];";
        let program = "static xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[..];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "let xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[0..3];";
        let program = "static xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[0..3];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "let xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[..3];";
        let program = "static xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[..3];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "let xs: [u8; 2] = [1, 2]; let slice = &xs[1..1];";
        let program = "static xs: [u8; 2] = [1, 2]; let slice = &xs[1..1];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test fn testResolveSliceLiteralMutableRequiresMut() throws (testing::TestError) {
@test unsafe fn testResolveSliceLiteralMutableRequiresMut() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let slice: *mut [i32] = &[1, 2, 3];";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

@test fn testResolveSliceLiteralMutable() throws (testing::TestError) {
@test unsafe fn testResolveSliceLiteralMutable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let slice: *mut [i32] = &mut [1, 2, 3];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test fn testResolvePointerMutableAssignmentRequiresMut() throws (testing::TestError) {
@test unsafe fn testResolvePointerMutableAssignmentRequiresMut() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let x: i32 = 0; let ptr: *mut i32 = &x;";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

@test fn testResolvePointerMutableToImmutableAssignment() throws (testing::TestError) {
@test unsafe fn testResolvePointerMutableToImmutableAssignment() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let mut x: i32 = 0; let mptr: *mut i32 = &mut x; let ptr: *i32 = mptr;";
    let program = "static x: i32 = 0; let mptr: *mut i32 = &mut x; let ptr: *i32 = mptr;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test fn testResolveAddressOfRequiresMutableBinding() throws (testing::TestError) {
@test unsafe fn testResolveAddressOfRequiresMutableBinding() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let x: i32 = 0; let ptr = &mut x;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    } {
        let mut a = testResolver();
        let program = "let mut x: i32 = 0; let ptr = &mut x;";
        let program = "let mut x: i32 = 0; &mut x;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test fn testResolveAddressOfSliceRequiresMutableBinding() throws (testing::TestError) {
@test unsafe fn testResolveAddressOfSliceRequiresMutableBinding() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let xs: [i32; 3] = [1, 2, 3]; let slice = &mut xs[..];";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    } {
        let mut a = testResolver();
        let program = "let mut xs: [i32; 3] = [1, 2, 3]; let slice = &mut xs[..];";
        let program = "let mut xs: [i32; 3] = [1, 2, 3]; &mut xs[..];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test fn testResolveSliceCannotAssignToArray() throws (testing::TestError) {
@test unsafe fn testResolveSliceCannotAssignToArray() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: *[u8] = &[1, 2]; let ys: [u8; 2] = xs;";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

@test fn testResolveSliceSyntaxRequiresAddressOf() throws (testing::TestError) {
@test unsafe fn testResolveSliceSyntaxRequiresAddressOf() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [u8; 2] = [1, 2]; xs[..];";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::SliceRequiresAddress);
}

@test fn testResolveSliceResliceRequiresAddressOf() throws (testing::TestError) {
@test unsafe fn testResolveSliceResliceRequiresAddressOf() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(s: *[u8]) -> *[u8] { return s[..]; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::SliceRequiresAddress);
}

@test fn testResolveSliceRangeOutOfBounds() throws (testing::TestError) {
@test unsafe fn testResolveSliceRangeOutOfBounds() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let xs: [u8; 2] = [1, 2]; let slice = &xs[..3];";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::SliceRangeOutOfBounds);

        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::SliceRangeOutOfBounds);
    }
}

@test fn testResolveArrayLenConstValue() throws (testing::TestError) {
@test unsafe fn testResolveArrayLenConstValue() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [i32; 3] = [1, 2, 3]; constant LEN: u32 = xs.len;";
    let result = try resolveBlockStr(&mut a, program);
    try expectNoErrors(&result);


        else throw testing::TestError::Failed;
    try testing::expect(lenVal.magnitude == 3);
    try testing::expect(not lenVal.negative);
}

@test fn testResolveIndexNonIndexable() throws (testing::TestError) {
@test unsafe fn testResolveIndexNonIndexable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let flag: bool = true; flag[0];";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ExpectedIndexable);
}

@test fn testResolveSliceFieldUnknown() throws (testing::TestError) {
@test unsafe fn testResolveSliceFieldUnknown() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [i32; 2] = [1, 2]; (&xs[0..]).unknown;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::SliceFieldUnknown("unknown"));
}

@test fn testResolveArrayFieldUnknown() throws (testing::TestError) {
@test unsafe fn testResolveArrayFieldUnknown() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [i32; 2] = [1, 2]; xs.field;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ArrayFieldUnknown("field"));
}

@test fn testResolveIfConditionRequiresBool() throws (testing::TestError) {
@test unsafe fn testResolveIfConditionRequiresBool() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "if 42 {}");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);

        let result = try resolveProgramStr(&mut a, "if true {}");
        try expectNoErrors(&result);
    }
}

@test fn testResolveIfLetScopeBinding() throws (testing::TestError) {
@test unsafe fn testResolveIfLetScopeBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let opt: ?i32 = 42; if let x = opt { x }");
    try expectNoErrors(&result);

    // Get the if-let statement and verify `x` has type `i32`.

        else throw testing::TestError::Failed;

    try testing::expect(valType == super::Type::I32);
}

@test fn testResolveIfLetScopeBindingError() throws (testing::TestError) {
@test unsafe fn testResolveIfLetScopeBindingError() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let opt: ?i32 = 42; if let x = opt { x } else { x }");
    let err = try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("x"));

    // Verify the error comes from the else branch (offset 48).

        else throw testing::TestError::Failed;
    try testing::expect(errNode.span.offset == 48);
}

/// Tests that `if let` with a condition expression binds the variable in scope.
@test fn testResolveIfLetConditionBindsVariable() throws (testing::TestError) {
@test unsafe fn testResolveIfLetConditionBindsVariable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; if let x = opt; x == 1 { x }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test fn testResolveWhileConditionRequiresBool() throws (testing::TestError) {
@test unsafe fn testResolveWhileConditionRequiresBool() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "while 1 {}");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);

        let result = try resolveProgramStr(&mut a, "while true {}");
        try expectNoErrors(&result);
    }
}

@test fn testResolveWhileLetBindingScope() throws (testing::TestError) {
@test unsafe fn testResolveWhileLetBindingScope() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let mut opt: ?i32 = 42; while let x = opt; x > 0 { x; opt; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("x"));
    }
}

@test fn testResolveForArrayBindsElementType() throws (testing::TestError) {
@test unsafe fn testResolveForArrayBindsElementType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [i32; 2] = [1, 2]; for x in xs { x; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);


    let bindingTy = super::typeFor(&a, loopNode.binding)
        else throw testing::TestError::Failed;
    try testing::expect(bindingTy == super::Type::I32);
}

@test fn testResolveForIndexedLoopBindsIndex() throws (testing::TestError) {
@test unsafe fn testResolveForIndexedLoopBindsIndex() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [bool; 3] = [true; 3]; for value, idx in xs { value; idx; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);


    let indexTy = super::typeFor(&a, indexNode)
        else throw testing::TestError::Failed;
    try testing::expect(indexTy == super::Type::U32);
}

@test fn testResolveForSliceIterable() throws (testing::TestError) {
@test unsafe fn testResolveForSliceIterable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [i32; 3] = [1, 2, 3]; for x in &xs[..] { x; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);


    let bindingTy = super::typeFor(&a, loopNode.binding)
        else throw testing::TestError::Failed;
    try testing::expect(bindingTy == super::Type::I32);
}

@test fn testResolveForRequiresIterable() throws (testing::TestError) {
@test unsafe fn testResolveForRequiresIterable() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "for x in true { x; }");
    try expectErrorKind(&result, super::ErrorKind::ExpectedIterable);
}

@test fn testResolveForRangeBoundsMustNumeric() throws (testing::TestError) {
@test unsafe fn testResolveForRangeBoundsMustNumeric() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveBlockStr(&mut a, "for i in 0..true { i; }");
    try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
}

@test fn testResolveMatchPatternTypeMismatch() throws (testing::TestError) {
@test unsafe fn testResolveMatchPatternTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let val: i32 = 0; match val { case true => {} }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::I32, super::Type::Bool);
}

@test fn testResolveMatchUnionVariantTypeMismatch() throws (testing::TestError) {
@test unsafe fn testResolveMatchUnionVariantTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union First { A }  union Second { B } fn run(val: First) { match val { case Second::B => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);

    let firstTy = try getTypeInScopeOf(&a, result.root, "First");
    let secondTy = try getTypeInScopeOf(&a, result.root, "Second");
    try expectTypeMismatch(err, super::Type::Nominal(firstTy), super::Type::Nominal(secondTy));
}

@test fn testResolveMatchUnionPayloadMissing() throws (testing::TestError) {
@test unsafe fn testResolveMatchUnionPayloadMissing() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some(i32) } fn run(val: Opt) { match val { case Opt::Some => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnionVariantPayloadMissing("Some"));
}

@test fn testResolveMatchUnionVoidVariantExplicitDiscriminant() throws (testing::TestError) {
@test unsafe fn testResolveMatchUnionVoidVariantExplicitDiscriminant() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some = 5 } fn run(val: Opt) { match val { case Opt::Some => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test fn testResolveMatchUnionPayloadUnexpected() throws (testing::TestError) {
@test unsafe fn testResolveMatchUnionPayloadUnexpected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { None } fn run(val: Opt) { match val { case Opt::None(x) => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnionVariantPayloadUnexpected("None"));
}

@test fn testResolveMatchUnionUnknownVariant() throws (testing::TestError) {
@test unsafe fn testResolveMatchUnionUnknownVariant() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some, None } fn run(value: Opt) { match value { case Opt::Unknown => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("Unknown"));
}

@test fn testResolveMatchUnionNonExhaustive() throws (testing::TestError) {
@test unsafe fn testResolveMatchUnionNonExhaustive() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "union Opt { Some, None } fn run(value: Opt) { match value { case Opt::Some => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnionMatchNonExhaustive("None"));

        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test fn testResolveMatchUnionNonExhaustiveExplicitDiscriminants() throws (testing::TestError) {
@test unsafe fn testResolveMatchUnionNonExhaustiveExplicitDiscriminants() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union U { A = 3, B = 9 } fn run(value: U) { match value { case U::A => {}, case U::B => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test fn testResolveMatchUnionBindingScope() throws (testing::TestError) {
@test unsafe fn testResolveMatchUnionBindingScope() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some(i32), None } fn f(value: Opt) { match value { case Opt::Some(x) if x > 0 => { x; } else => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);


    let case super::SymbolData::Value { type: payloadValType, .. } = payloadSym.data
        else throw testing::TestError::Failed;
    try testing::expect(payloadValType == super::Type::I32);
}

@test fn testResolveMatchUnionPatternNonUnionType() throws (testing::TestError) {
@test unsafe fn testResolveMatchUnionPatternNonUnionType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some, None } fn f(value: Opt) { match value { case true => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let optionTy = try getTypeInScopeOf(&a, result.root, "Opt");
    try expectTypeMismatch(err, super::Type::Nominal(optionTy), super::Type::Bool);
}

@test fn testResolveMatchGuardForms() throws (testing::TestError) {
@test unsafe fn testResolveMatchGuardForms() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn first(value: i32) { match value { case _ if true => {}, else => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that a binding prong binds the subject to the identifier.
@test fn testResolveMatchBindingProng() throws (testing::TestError) {
@test unsafe fn testResolveMatchBindingProng() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(value: i32) -> i32 { match value { x => return x } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that a binding prong with guard can use the bound variable.
@test fn testResolveMatchBindingProngGuard() throws (testing::TestError) {
@test unsafe fn testResolveMatchBindingProngGuard() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(value: i32) -> i32 { match value { x if x > 0 => return x, _ => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that a binding prong covers all union variants for exhaustiveness.
@test fn testResolveMatchBindingProngExhaustive() throws (testing::TestError) {
@test unsafe fn testResolveMatchBindingProngExhaustive() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union U { A, B, C } fn f(u: U) -> i32 { match u { x => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that `case x =>` fails if `x` is not in scope, since bare identifiers
/// in case patterns are values to compare against, not bindings.
@test fn testResolveMatchCaseUndefinedIdent() throws (testing::TestError) {
@test unsafe fn testResolveMatchCaseUndefinedIdent() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(n: i32) -> i32 { match n { case x => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("x"));
}

/// Test matching on optionals: exhaustiveness and type unwrapping.
@test fn testResolveMatchOptional() throws (testing::TestError) {
@test unsafe fn testResolveMatchOptional() throws (testing::TestError) {
    {
        // Exhaustive: binding + nil case.
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) { match opt { v => {}, case nil => {} } }";
        let result = try resolveProgramStr(&mut a, program);

        try expectNoErrors(&result);
    }
}

/// Test that match on non-union types requires exhaustiveness.
@test fn testResolveMatchGenericExhaustive() throws (testing::TestError) {
@test unsafe fn testResolveMatchGenericExhaustive() throws (testing::TestError) {
    {
        // Match on i32 without catch-all should error.
        let mut a = testResolver();
        let program = "fn f(x: i32) { match x { case 1 => {} } }";
        let result = try resolveProgramStr(&mut a, program);

        try expectNoErrors(&result);
    }
}

/// Test that match on bool requires both true and false cases.
@test fn testResolveMatchBoolExhaustive() throws (testing::TestError) {
@test unsafe fn testResolveMatchBoolExhaustive() throws (testing::TestError) {
    {
        // Match on bool with both cases is fine.
        let mut a = testResolver();
        let program = "fn f(x: bool) { match x { case true => {}, case false => {} } }";
        let result = try resolveProgramStr(&mut a, program);

        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test fn testResolveBreakRequiresLoop() throws (testing::TestError) {
@test unsafe fn testResolveBreakRequiresLoop() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "break;");
        try expectErrorKind(&result, super::ErrorKind::InvalidLoopControl);
    } {

        let result = try resolveProgramStr(&mut a, "loop { break }");
        try expectNoErrors(&result);
    }
}

@test fn testResolveContinueRequiresLoop() throws (testing::TestError) {
@test unsafe fn testResolveContinueRequiresLoop() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "continue;");
        try expectErrorKind(&result, super::ErrorKind::InvalidLoopControl);
    } {

        let result = try resolveProgramStr(&mut a, "while true { continue }");
        try expectNoErrors(&result);
    }
}

@test fn testResolveFnTypeVoidNoParams() throws (testing::TestError) {
@test unsafe fn testResolveFnTypeVoidNoParams() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn f() {} f();");
    try expectNoErrors(&result);

    let blockNode = result.root;

            else throw testing::TestError::Failed;
        try expectType(&a, callExpr, *fnTy.returnType);
    }
}

@test fn testResolveFnTypeReturnsValue() throws (testing::TestError) {
@test unsafe fn testResolveFnTypeReturnsValue() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f() -> i32 { return 1; } f();";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);


            else throw testing::TestError::Failed;
        try expectType(&a, callExpr, *fnTy.returnType);
    }
}

@test fn testResolveFnTypeSingleParam() throws (testing::TestError) {
@test unsafe fn testResolveFnTypeSingleParam() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(x: i8) {} let x: i8 = 1; f(x);";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);


            else throw testing::TestError::Failed;
        try expectType(&a, callExpr, *fnTy.returnType);
    }
}

@test fn testResolveFnTypeMultipleParams() throws (testing::TestError) {
@test unsafe fn testResolveFnTypeMultipleParams() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(x: i8, y: i32) {} let x: i8 = 1; let y: i32 = 2; f(x, y);";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);


            else throw testing::TestError::Failed;
        try expectType(&a, callExpr, *fnTy.returnType);
    }
}

@test fn testResolveFnRecursiveCall() throws (testing::TestError) {
@test unsafe fn testResolveFnRecursiveCall() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn flip(b: bool) -> bool { if b { return false; } return flip(false); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);


        try testing::expect(*fnTy.paramTypes[0] == super::Type::Bool);
        try testing::expect(*fnTy.returnType == super::Type::Bool);
    }
}

@test fn testResolveFnCallMissingArgument() throws (testing::TestError) {
@test unsafe fn testResolveFnCallMissingArgument() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(x: i8) {} f();";
    let result = try resolveProgramStr(&mut a, program);
    // Expect an error when a required parameter is omitted.
    try expectErrorKind(&result, super::ErrorKind::FnArgCountMismatch(super::CountMismatch {
        expected: 1,
        actual: 0,
    }));
}

@test fn testResolveFnCallExtraArgument() throws (testing::TestError) {
@test unsafe fn testResolveFnCallExtraArgument() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f() {} f(1);";
    let result = try resolveProgramStr(&mut a, program);
    // Passing more arguments than declared should fail.
    try expectErrorKind(&result, super::ErrorKind::FnArgCountMismatch(super::CountMismatch {
        expected: 0,
        actual: 1,
    }));
}

@test fn testResolveFnCallArgumentTypeMismatch() throws (testing::TestError) {
@test unsafe fn testResolveFnCallArgumentTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(x: i8) {} f(true);";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    // The argument type (bool) should not match the parameter type (i8).
    try expectTypeMismatch(err, super::Type::I8, super::Type::Bool);
}

@test fn testResolveFnReturnTypeMismatch() throws (testing::TestError) {
@test unsafe fn testResolveFnReturnTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f() -> i32 { return true; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::I32, super::Type::Bool);
}

@test fn testResolveFnReturnVoid() throws (testing::TestError) {
@test unsafe fn testResolveFnReturnVoid() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f() { return; }");
        try expectNoErrors(&result);
    } {

        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::I32, super::Type::Void);
    }
}

@test fn testResolveFnMissingReturn() throws (testing::TestError) {
@test unsafe fn testResolveFnMissingReturn() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f() -> i32 {}");
        try expectErrorKind(&result, super::ErrorKind::FnMissingReturn);
    } {

        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::FnMissingReturn);
    }
}

@test fn testResolveFnAllPathsReturn() throws (testing::TestError) {
@test unsafe fn testResolveFnAllPathsReturn() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn h(flag: bool) -> i32 { if flag { return 1; } else { return 2; } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that match statements with returns in all branches don't require a
/// return at the end of the function.
@test fn testResolveFnMatchAllPathsReturn() throws (testing::TestError) {
@test unsafe fn testResolveFnMatchAllPathsReturn() throws (testing::TestError) {
    {
        // Union match with all variants returning.
        let mut a = testResolver();
        let program = "union E { A, B } fn f(e: E) -> i32 { match e { case E::A => return 1, case E::B => return 2 } }";
        let result = try resolveProgramStr(&mut a, program);

        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::FnMissingReturn);
    }
}

@test fn testResolveAssign() throws (testing::TestError) {
@test unsafe fn testResolveAssign() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let mut x: i32 = 0; set x = 1;");
        try expectNoErrors(&result);
    } {

        let result = try resolveProgramStr(&mut a, "let mut x: ?i32 = 0; set x = nil;");
        try expectNoErrors(&result);
    }
}

@test fn testResolveAssignSubscript() throws (testing::TestError) {
@test unsafe fn testResolveAssignSubscript() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let mut xs: [u8; 2] = [0, 1]; set xs[0] = 9;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
    {
        let mut a = testResolver();
        let program = "let mut xs: [u8; 2] = [0, 1]; let slice: *mut [u8] = &mut xs[..]; set slice[0] = 1;";
        let program = "static xs: [u8; 2] = [0, 1]; let slice: *mut [u8] = &mut xs[..]; set slice[0] = 1;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
    {
        let mut a = testResolver();
        let program = "let mut xs: [u8; 2] = [0, 1]; let mut slice: *[u8] = &xs[..]; set slice[0] = 1;";
        let program = "static xs: [u8; 2] = [0, 1]; let mut slice: *[u8] = &xs[..]; set slice[0] = 1;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
    {
        let mut a = testResolver();

        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
    {
        let mut a = testResolver();
        let program = "let mut xs: [u8; 2] = [0, 1]; let slice: *[u8] = &xs[..]; set slice[0] = 1;";
        let program = "static xs: [u8; 2] = [0, 1]; let slice: *[u8] = &xs[..]; set slice[0] = 1;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
}

@test fn testResolveAssignIntegerLits() throws (testing::TestError) {
@test unsafe fn testResolveAssignIntegerLits() throws (testing::TestError) {
    try expectAnalyzeOk("let x: i8 = 127;");
    try expectAnalyzeOk("let x: i8 = 0x7F;");
    try expectAnalyzeOk("let x: i8 = -128;");
    try expectAnalyzeOk("let x: u8 = 255;");
    try expectAnalyzeOk("let x: u8 = 0b11111111;");

    try expectIntMismatch("let x: i64 = -9223372036854775809;", super::Type::I64);
    try expectIntMismatch("constant LIMIT: u8 = 512;", super::Type::U8);
    try expectIntMismatch("constant LIMIT: u8 = -5;", super::Type::U8);
}

@test fn testNilCoercions() throws (testing::TestError) {
@test unsafe fn testNilCoercions() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let opt: ?i32 = nil;");
        try expectNoErrors(&result);
    } {

        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test fn testOptionalComparedWithNil() throws (testing::TestError) {
@test unsafe fn testOptionalComparedWithNil() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = nil; opt == nil; nil == opt; opt == 1; 1 == opt; opt == opt; nil == nil;";
    let result = try resolveBlockStr(&mut a, program);
    try expectNoErrors(&result);


        let stmt = try getBlockStmt(result.root, i);
        try expectExprStmtType(&a, stmt, super::Type::Bool);
    }
}

@test fn testResolveRecordLiteralAllFieldsSet() throws (testing::TestError) {
@test unsafe fn testResolveRecordLiteralAllFieldsSet() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } let p = Pt { x: 1, y: 2 };";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test fn testResolveRecordLiteralMissingField() throws (testing::TestError) {
@test unsafe fn testResolveRecordLiteralMissingField() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } let p = Pt { x: 1 };";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::RecordFieldMissing("y"));
}

@test fn testResolveRecordLiteralFieldTypeMismatch() throws (testing::TestError) {
@test unsafe fn testResolveRecordLiteralFieldTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } let p = Pt { x: true, y: 2 };";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::I32, super::Type::Bool);

        else throw testing::TestError::Failed;
    let case ast::NodeValue::Bool(_) = errNode.value
        else throw testing::TestError::Failed;
}

@test fn testResolveRecordLiteralExtraField() throws (testing::TestError) {
@test unsafe fn testResolveRecordLiteralExtraField() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } let p = Pt { x: 1, z: 3, y: 2 };";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::RecordFieldCountMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Test that anonymous record literals with labels can be passed to functions expecting named records.
@test fn testResolveAnonRecordLabeledToNamedRecord() throws (testing::TestError) {
@test unsafe fn testResolveAnonRecordLabeledToNamedRecord() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) -> i32 { return p.x; } foo({ x: 1, y: 2 });";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that anonymous record with wrong field name causes out of order error.
@test fn testResolveAnonRecordWrongFieldName() throws (testing::TestError) {
@test unsafe fn testResolveAnonRecordWrongFieldName() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) {} foo({ x: 1, z: 2 });";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::RecordFieldOutOfOrder { field: _, prev: _ } = err.kind
        else throw testing::TestError::Failed;
}

/// Test that anonymous record with wrong field type causes type mismatch.
@test fn testResolveAnonRecordWrongFieldType() throws (testing::TestError) {
@test unsafe fn testResolveAnonRecordWrongFieldType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) {} foo({ x: true, y: 2 });";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Test that anonymous record with missing field causes a missing field error.
@test fn testResolveAnonRecordMissingField() throws (testing::TestError) {
@test unsafe fn testResolveAnonRecordMissingField() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) {} foo({ x: 1 });";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::RecordFieldMissing("y"));
}

/// Test that anonymous record with extra field causes a count mismatch error.
@test fn testResolveAnonRecordExtraField() throws (testing::TestError) {
@test unsafe fn testResolveAnonRecordExtraField() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) {} foo({ x: 1, y: 2, z: 3 });";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::RecordFieldCountMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Test that anonymous record fields can be coerced (e.g., i32 to optional).
@test fn testResolveAnonRecordFieldCoercion() throws (testing::TestError) {
@test unsafe fn testResolveAnonRecordFieldCoercion() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Opt { x: ?i32 } fn foo(p: Opt) {} foo({ x: 42 });";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that arrays of anonymous records with labeled fields are allowed.
@test fn testResolveAnonRecordArray() throws (testing::TestError) {
@test unsafe fn testResolveAnonRecordArray() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } constant ARR: [Pt; 2] = [{ x: 1, y: 2 }, { x: 3, y: 4 }];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that arrays of anonymous records with extra fields cause count mismatch.
@test fn testResolveAnonRecordArrayMismatch() throws (testing::TestError) {
@test unsafe fn testResolveAnonRecordArrayMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } constant ARR: [Pt; 2] = [{ x: 1, y: 2 }, { x: 3, y: 4, z: 5 }];";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::RecordFieldCountMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Test that unlabeled record declarations are analyzed correctly.
@test fn testResolveUnlabeledRecordDecl() throws (testing::TestError) {
@test unsafe fn testResolveUnlabeledRecordDecl() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record R(i32, bool);";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);


    try testing::expect(recordType.fields.len == 2);
    try testing::expect(recordType.fields[0].name == nil);
    try testing::expect(recordType.fields[1].name == nil);
}

@test fn testResolveLabeledRecordDecl() throws (testing::TestError) {
@test unsafe fn testResolveLabeledRecordDecl() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record R { x: i32, y: i32 }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);


    try testing::expect(recordType.fields.len == 2);
    try testing::expect(recordType.fields[0].name <> nil);
    try testing::expect(recordType.fields[1].name <> nil);
}

@test fn testResolveRecordFieldAccessValid() throws (testing::TestError) {
@test unsafe fn testResolveRecordFieldAccessValid() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: u8 } let p = Pt { x: 1, y: 2 }; p.y;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let fieldStmt = try getBlockStmt(result.root, 2);
    try expectExprStmtType(&a, fieldStmt, super::Type::U8);
}

@test fn testResolveRecordFieldAccessUnknownField() throws (testing::TestError) {
@test unsafe fn testResolveRecordFieldAccessUnknownField() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32 } let p = Pt { x: 1 }; p.y;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::RecordFieldUnknown("y"));
}

@test fn testResolveRecordFieldAccessOnFunctionReturn() throws (testing::TestError) {
@test unsafe fn testResolveRecordFieldAccessOnFunctionReturn() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } fn make() -> Pt { return Pt { x: 5, y: 10 }; } make().x;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 2);
    try expectExprStmtType(&a, stmt, super::Type::I32);
}

@test fn testResolveRecordFieldAccessChained() throws (testing::TestError) {
@test unsafe fn testResolveRecordFieldAccessChained() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record C { value: i32 } record B { c: C } record A { b: B } let a = A { b: B { c: C { value: 100 } } }; a.b.c.value;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 4);
    try expectExprStmtType(&a, stmt, super::Type::I32);
}

@test fn testResolveRecordFieldAccessOnInteger() throws (testing::TestError) {
@test unsafe fn testResolveRecordFieldAccessOnInteger() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let x: i32 = 42; x.field;";
    let result = try resolveBlockStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ExpectedRecord);
}

@test fn testResolveRecordFieldAccessOnArray() throws (testing::TestError) {
@test unsafe fn testResolveRecordFieldAccessOnArray() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let arr: [i32; 3] = [1, 2, 3]; arr.field;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ArrayFieldUnknown("field"));
}

@test fn testResolveRecordFieldAccessOnBool() throws (testing::TestError) {
@test unsafe fn testResolveRecordFieldAccessOnBool() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let b: bool = true; b.field;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ExpectedRecord);
}

@test fn testResolveRecordFieldAccessOnOptional() throws (testing::TestError) {
@test unsafe fn testResolveRecordFieldAccessOnOptional() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32 } let opt: ?Pt = Pt { x: 5 }; opt.x;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ExpectedRecord);
}

/// Records may reference themselves through pointers without causing resolution errors.
@test fn testResolveRecordSelfReferentialPointer() throws (testing::TestError) {
@test unsafe fn testResolveRecordSelfReferentialPointer() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record A { next: *A }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Mutually recursive records should resolve without infinite loops.
@test fn testResolveRecordMutuallyRecursive() throws (testing::TestError) {
@test unsafe fn testResolveRecordMutuallyRecursive() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record A { b: *B } record B { a: *A }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Unions may reference themselves through pointers without causing resolution errors.
@test fn testResolveUnionSelfReferentialPointerAllowed() throws (testing::TestError) {
@test unsafe fn testResolveUnionSelfReferentialPointerAllowed() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union List { Cons(*List), Nil }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Mutually recursive unions should resolve without infinite loops.
@test fn testResolveUnionMutuallyRecursive() throws (testing::TestError) {
@test unsafe fn testResolveUnionMutuallyRecursive() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union A { HasB(*B), None } union B { HasA(*A), None }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Unions with record payloads containing slice references to self should resolve.
/// This matches the pattern in sexpr.rad: `List { tail: *[Expr] }`.
@test fn testResolveUnionRecordPayloadWithSliceSelfRef() throws (testing::TestError) {
@test unsafe fn testResolveUnionRecordPayloadWithSliceSelfRef() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Expr { Null, List { head: *[u8], tail: *[Expr] } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test fn testUndefinedCoercions() throws (testing::TestError) {
@test unsafe fn testUndefinedCoercions() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let count: i32 = undefined;");
        try expectNoErrors(&result);
    } {

        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test fn testResolveBlockVoid() throws (testing::TestError) {
@test unsafe fn testResolveBlockVoid() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "{ 42; }");
    try expectNoErrors(&result);

    let block = try getBlockStmt(result.root, 0);
    try expectType(&a, block, super::Type::Void);
}

@test fn testResolveBlockNever() throws (testing::TestError) {
@test unsafe fn testResolveBlockNever() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "{ panic; }");
    try expectNoErrors(&result);

    let block = try getBlockStmt(result.root, 0);
    try expectType(&a, block, super::Type::Never);
}

@test fn testResolveIfAllBranchesNever() throws (testing::TestError) {
@test unsafe fn testResolveIfAllBranchesNever() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "if true { panic; } else { panic; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 0);
    try expectType(&a, stmt, super::Type::Never);
}

@test fn testResolveIfMixedBranchesNotNever() throws (testing::TestError) {
@test unsafe fn testResolveIfMixedBranchesNotNever() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "if true { panic; } else {}";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 0);
    try expectType(&a, stmt, super::Type::Void);
}

@test fn testResolveLetElse() throws (testing::TestError) {
@test unsafe fn testResolveLetElse() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; let value = opt else panic; value;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);


    }
    // The let-else statement itself should be typed as void.
    try expectType(&a, letElseNode, super::Type::Void);
}

@test fn testResolveLetElseDefaultValue() throws (testing::TestError) {
@test unsafe fn testResolveLetElseDefaultValue() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = nil; let value = opt else 42; value;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test fn testResolveLetElseRequiresDivergentElse() throws (testing::TestError) {
@test unsafe fn testResolveLetElseRequiresDivergentElse() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = nil; let value = opt else {}; value;";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::I32, super::Type::Void);
}

@test fn testResolveLetElseRequiresOptional() throws (testing::TestError) {
@test unsafe fn testResolveLetElseRequiresOptional() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let x: i32 = 42; let value = x else panic;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ExpectedOptional);
}

/// Test that `if let mut` produces a mutable binding.
@test fn testResolveIfLetMut() throws (testing::TestError) {
@test unsafe fn testResolveIfLetMut() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; if let mut v = opt { set v = v + 1; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that `if let` (without mut) rejects assignment.
@test fn testResolveIfLetImmutable() throws (testing::TestError) {
@test unsafe fn testResolveIfLetImmutable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; if let v = opt { set v = 1; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

/// Test that `let mut ... else` produces a mutable binding.
@test fn testResolveLetMutElse() throws (testing::TestError) {
@test unsafe fn testResolveLetMutElse() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; let mut v = opt else panic; set v = v + 1;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that `let ... else` (without mut) rejects assignment.
@test fn testResolveLetElseImmutable() throws (testing::TestError) {
@test unsafe fn testResolveLetElseImmutable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; let v = opt else panic; set v = 1;";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

@test fn testResolveLetCaseElse() throws (testing::TestError) {
@test unsafe fn testResolveLetCaseElse() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let case _ = 1 else panic;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test fn testResolveLetCaseElseRequiresDivergentElse() throws (testing::TestError) {
@test unsafe fn testResolveLetCaseElseRequiresDivergentElse() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let case _ = 1 else {};";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::Int, super::Type::Void);
}

@test fn testResolveTryValidPropagation() throws (testing::TestError) {
@test unsafe fn testResolveTryValidPropagation() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn fallible() throws (i32) {} fn caller() throws (i32) { try fallible() }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test fn testResolveTryRequiresThrowsClause() throws (testing::TestError) {
@test unsafe fn testResolveTryRequiresThrowsClause() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn fallible() throws (i32) {} fn caller() { try fallible() }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TryRequiresThrows);
}

@test fn testResolveTryIncompatibleError() throws (testing::TestError) {
@test unsafe fn testResolveTryIncompatibleError() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn fallible() throws (i32) {} fn caller() throws (i8) { try fallible() }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TryIncompatibleError);
}

@test fn testResolveTryNonThrowing() throws (testing::TestError) {
@test unsafe fn testResolveTryNonThrowing() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn safe() {} fn caller() throws (i32) { try safe() }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TryNonThrowing);
}

@test fn testResolveTryCatchBlockMatchesResult() throws (testing::TestError) {
@test unsafe fn testResolveTryCatchBlockMatchesResult() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Error { Fail } fn fallible() -> u32 throws (Error) { throw Error::Fail; return 0; } fn caller() -> u32 { return try fallible() catch { return 42; }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test fn testResolveTryCatchBlockDiverges() throws (testing::TestError) {
@test unsafe fn testResolveTryCatchBlockDiverges() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Error { Fail } fn fallible() -> u32 throws (Error) { throw Error::Fail; return 0; } fn caller() -> u32 { return try fallible() catch { return 7; }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test fn testResolveTryCatchBlockMustDiverge() throws (testing::TestError) {
@test unsafe fn testResolveTryCatchBlockMustDiverge() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Error { Fail } fn fallible() -> u32 throws (Error) { throw Error::Fail; return 0; } fn caller() -> u32 { return try fallible() catch { 7; }; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::U32, super::Type::Void);
}

@test fn testResolveCallMissingTry() throws (testing::TestError) {
@test unsafe fn testResolveCallMissingTry() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn fallible() throws (i32) {} fn caller() { fallible() }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::MissingTry);
}

/// Test that `try?` converts errors to optionals without requiring caller to throw.
@test fn testResolveTryOptionalConvertsToOptional() throws (testing::TestError) {
@test unsafe fn testResolveTryOptionalConvertsToOptional() throws (testing::TestError) {
    // `try?` should wrap the return type in optional and not require caller to throw.
    {
        let mut a = testResolver();
        let program = "record S {} fn fallible() -> *S throws (i32) { panic; } fn caller() -> ?*S { return try? fallible(); }";
        let result = try resolveProgramStr(&mut a, program);

        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test fn testResolveThrowValid() throws (testing::TestError) {
@test unsafe fn testResolveThrowValid() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn fail() throws (i32) { throw 1; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test fn testResolveThrowRequiresThrowsClause() throws (testing::TestError) {
@test unsafe fn testResolveThrowRequiresThrowsClause() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn fail() { throw 1; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ThrowRequiresThrows);
}

@test fn testResolveThrowIncompatibleError() throws (testing::TestError) {
@test unsafe fn testResolveThrowIncompatibleError() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn fail() throws (i32) { throw true; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ThrowIncompatibleError);
}

// Binary operation tests //////////////////////////////////////////////////////

@test fn testResolveBinaryOpArithmetic() throws (testing::TestError) {
@test unsafe fn testResolveBinaryOpArithmetic() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "4 + 4");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);

        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::I32);
    }
}

@test fn testResolveBinaryOpComparison() throws (testing::TestError) {
@test unsafe fn testResolveBinaryOpComparison() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "5 == 5");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);

        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::Bool);
    }
}

@test fn testResolveBinaryOpLogical() throws (testing::TestError) {
@test unsafe fn testResolveBinaryOpLogical() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: bool = true; let y: bool = false; x and y;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);

        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
    }
}

@test fn testResolveBinaryOpArithmeticTypeMismatch() throws (testing::TestError) {
@test unsafe fn testResolveBinaryOpArithmeticTypeMismatch() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "4 + true");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
    } {

        let result = try resolveProgramStr(&mut a, "1 + (true * 3)");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
    }
}

@test fn testResolveBinaryOpLogicalTypeMismatch() throws (testing::TestError) {
@test unsafe fn testResolveBinaryOpLogicalTypeMismatch() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "42 and true");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);

        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
    }
}

@test fn testResolveBinaryOpComparisonTypeMismatch() throws (testing::TestError) {
@test unsafe fn testResolveBinaryOpComparisonTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "true < false");
    try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
}

// Unary operation tests ///////////////////////////////////////////////////////

@test fn testResolveUnaryOpNot() throws (testing::TestError) {
@test unsafe fn testResolveUnaryOpNot() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "not true");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);

        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Bool, super::Type::I32);
    }
}

@test fn testResolveUnaryOpNeg() throws (testing::TestError) {
@test unsafe fn testResolveUnaryOpNeg() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "-42");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);

        let result = try resolveBlockStr(&mut a, "let x: bool = false; -x;");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
    }
}

@test fn testResolveUnaryOpBitNot() throws (testing::TestError) {
@test unsafe fn testResolveUnaryOpBitNot() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "~42");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);

        let result = try resolveBlockStr(&mut a, "let x: bool = false; ~x;");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
    }
}

@test fn testResolveUnaryOpNested() throws (testing::TestError) {
@test unsafe fn testResolveUnaryOpNested() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "not not true");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);

//     try expectNoErrors(&result);
// }

// Dereference tests //////////////////////////////////////////////////////////

@test fn testResolveDeref() throws (testing::TestError) {
@test unsafe fn testResolveDeref() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: i32 = 42; let ptr: *i32 = &x; *ptr;");
        let result = try resolveBlockStr(&mut a, "static x: i32 = 42; let ptr: *i32 = &x; *ptr;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::I32);
    } {
        let mut a = testResolver();

        let result = try resolveBlockStr(&mut a, "let x: i32 = 5; *x;");
        try expectErrorKind(&result, super::ErrorKind::ExpectedPointer);
    }
}

@test fn testResolveAssignDeref() throws (testing::TestError) {
@test unsafe fn testResolveAssignDeref() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let mut x: i32 = 0; let ptr: *mut i32 = &mut x; set *ptr = 42;";
        let program = "static x: i32 = 0; let ptr: *mut i32 = &mut x; set *ptr = 42;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "let mut x: i32 = 0; let ptr: *i32 = &x; set *ptr = 42;";
        let program = "static x: i32 = 0; let ptr: *i32 = &x; set *ptr = 42;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    } {
        let mut a = testResolver();
        let program = "let mut x: i32 = 0; let mut ptr: *i32 = &x; set *ptr = 42;";
        let program = "static x: i32 = 0; let mut ptr: *i32 = &x; set *ptr = 42;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    } {
        let mut a = testResolver();
        let program = "let mut x: u8 = 0; let mut ptr: *mut u8 = &mut x; set *ptr = 255;";
        let program = "static x: u8 = 0; let mut ptr: *mut u8 = &mut x; set *ptr = 255;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

// Type inference tests ///////////////////////////////////////////////////////

@test fn testResolveBasicTypeInference() throws (testing::TestError) {
@test unsafe fn testResolveBasicTypeInference() throws (testing::TestError) {
    {
        // Boolean literals are unambiguous.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let x = true; x;");
        try expectNoErrors(&result);

    }
}

// Union tests /////////////////////////////////////////////////////////////////

@test fn testResolveUnionVariantWithoutPayload() throws (testing::TestError) {
@test unsafe fn testResolveUnionVariantWithoutPayload() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Status { Ok, Error } Status::Ok;";
    let result = try resolveProgramStr(&mut a, program);

    let ty = try getTypeInScopeOf(&a, result.root, "Status");

    let stmt = try getBlockStmt(result.root, 1);
    try expectExprStmtType(&a, stmt, super::Type::Nominal(ty));
    try expectNoErrors(&result);
}

@test fn testResolveUnionVariantWithPayload() throws (testing::TestError) {
@test unsafe fn testResolveUnionVariantWithPayload() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union R { Ok(i32), Err(bool) } R::Ok(42);";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);


    try expectExprStmtType(&a, stmt, super::Type::Nominal(ty));

    // TODO: Test payload type.
}

@test fn testResolveUnionVariantWithoutPayloadExplicitDiscriminant() throws (testing::TestError) {
@test unsafe fn testResolveUnionVariantWithoutPayloadExplicitDiscriminant() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union R { Ok = 7, Err = 11 } R::Ok;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let ty = try getTypeInScopeOf(&a, result.root, "R");
    let stmt = try getBlockStmt(result.root, 1);
    try expectExprStmtType(&a, stmt, super::Type::Nominal(ty));
}

@test fn testResolveUnionVariantPayloadTypeMismatch() throws (testing::TestError) {
@test unsafe fn testResolveUnionVariantPayloadTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union R { Ok(i32), Error(bool) } R::Ok(true);";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::I32, super::Type::Bool);

        else throw testing::TestError::Failed;
    let case ast::NodeValue::Bool(_) = errNode.value
        else throw testing::TestError::Failed;
}

@test fn testResolveUnionVariantUnexpectedPayload() throws (testing::TestError) {
@test unsafe fn testResolveUnionVariantUnexpectedPayload() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Status { Ok, Error } Status::Ok(42);";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);


        else throw testing::TestError::Failed;
    let case ast::NodeValue::Call(_) = node.value
        else throw testing::TestError::Failed;
}

@test fn testResolveUnionVariantUnknown() throws (testing::TestError) {
@test unsafe fn testResolveUnionVariantUnknown() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Status { Ok, Error } Status::Unknown;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("Unknown"));
}

@test fn testResolveScopeAccessUndefinedType() throws (testing::TestError) {
@test unsafe fn testResolveScopeAccessUndefinedType() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "Unknown::X;");
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("Unknown"));
}

@test fn testResolveUnionVariantVoidPayload() throws (testing::TestError) {
@test unsafe fn testResolveUnionVariantVoidPayload() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union R { Success(i32), Pending } R::Pending;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);



    let stmt = try getBlockStmt(result.root, 1);
    try expectExprStmtType(&a, stmt, super::Type::Nominal(ty));
}

@test fn testResolveUnionVariantRecordPayload() throws (testing::TestError) {
@test unsafe fn testResolveUnionVariantRecordPayload() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record P { x: i32, y: i32 } union S { Point(P), Num(u32) } S::Point(P { x: 10, y: 20 });";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let ty = try getTypeInScopeOf(&a, result.root, "S");
    let stmt = try getBlockStmt(result.root, 2);
    try expectExprStmtType(&a, stmt, super::Type::Nominal(ty));
}

@test fn testResolveBuiltinSizeOf() throws (testing::TestError) {
@test unsafe fn testResolveBuiltinSizeOf() throws (testing::TestError) {
    try resolveAndExpectConstExpr("@sizeOf(u8)", 1);
    try resolveAndExpectConstExpr("@sizeOf(u16)", 2);
    try resolveAndExpectConstExpr("@sizeOf(u32)", 4);
    try resolveAndExpectConstExpr("@sizeOf(i32)", 4);
    try resolveAndExpectConstExpr("@sizeOf(bool)", 1);

    try resolveAndExpectConstStmt("union T { A, B(u16), C }; @sizeOf(T);", 4);
    try resolveAndExpectConstStmt("union T { A(u32), B(u16), C(u16) }; @sizeOf(T);", 8);
    try resolveAndExpectConstStmt("union T { A(u32), B(u16), C([u8; 16]) }; @sizeOf(T);", 20);
}

@test fn testResolveBuiltinAlignOf() throws (testing::TestError) {
@test unsafe fn testResolveBuiltinAlignOf() throws (testing::TestError) {
    try resolveAndExpectConstExpr("@alignOf(u8)", 1);
    try resolveAndExpectConstExpr("@alignOf(u16)", 2);
    try resolveAndExpectConstExpr("@alignOf(u32)", 4);
    try resolveAndExpectConstExpr("@alignOf(i32)", 4);
    try resolveAndExpectConstExpr("@alignOf(bool)", 1);

    try resolveAndExpectConstStmt("record T { x: u32, y: u8, z: u8 }; @alignOf(T);", 4);
    try resolveAndExpectConstStmt("union T { A, B, C }; @alignOf(T);", 1);
    try resolveAndExpectConstStmt("union T { A, B(u32), C }; @alignOf(T);", 4);
}

@test fn testResolveBuiltinSizeOfRecord() throws (testing::TestError) {
@test unsafe fn testResolveBuiltinSizeOfRecord() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record T { x: u8, y: u32 } @sizeOf(T);";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 1);
    let expr = try expectExprStmtType(&a, stmt, super::Type::U32);
    try expectConstInt(&a, expr, 8);
}

@test fn testResolveBuiltinSizeOfUnion() throws (testing::TestError) {
@test unsafe fn testResolveBuiltinSizeOfUnion() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Result { Ok(u32), Err(u8) } @sizeOf(Result);";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 1);
    let expr = try expectExprStmtType(&a, stmt, super::Type::U32);
    try expectConstInt(&a, expr, 8);
}

@test fn testResolveAlignAnnotation() throws (testing::TestError) {
@test unsafe fn testResolveAlignAnnotation() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u8 align(8) = 0;");
        try expectNoErrors(&result);


            else throw testing::TestError::Failed;
        try testing::expect(val == 7);
    }
}

@test fn testResolveVoidAssignmentError() throws (testing::TestError) {
@test unsafe fn testResolveVoidAssignmentError() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn voidFn() {} let _ = voidFn();";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::CannotAssignVoid);


//
// Module Declaration Tests
//

@test fn testResolveEmptyMod() throws (testing::TestError) {
@test unsafe fn testResolveEmptyMod() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut graph = &mut MODULE_GRAPH;

    let rootId = try registerModule(graph, nil, "root", "mod child;", &mut arena);
    let childId = try registerModule(graph, rootId, "child", "{}", &mut arena);
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

@test fn testResolveModuleCannotAccessParentScope() throws (testing::TestError) {
@test unsafe fn testResolveModuleCannotAccessParentScope() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root and util modules.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod util; export fn helper() {}", &mut arena);

    let case super::ErrorKind::UnresolvedSymbol(name) = err.kind
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(name, "helper"));
}

@test fn testResolveModuleAccessPrivateSubModule() throws (testing::TestError) {
@test unsafe fn testResolveModuleAccessPrivateSubModule() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root and util modules.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod util; fn main() { util::helper(); }", &mut arena);

    // Resolve should succeed: parent can access child.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

@test fn testResolveSiblingModulesCannotAccessDirectly() throws (testing::TestError) {
@test unsafe fn testResolveSiblingModulesCannotAccessDirectly() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with two sibling modules.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod paul; export mod patrick;", &mut arena);

    let case super::ErrorKind::UnresolvedSymbol(name) = err.kind
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(name, "patrick"));
}

@test fn testResolveSiblingModulesViaRoot() throws (testing::TestError) {
@test unsafe fn testResolveSiblingModulesViaRoot() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with two sibling modules.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod paul; export mod patrick;", &mut arena);

    // Resolve should succeed: siblings can access each other via root.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

@test fn testResolveModuleMutualRecursion() throws (testing::TestError) {
@test unsafe fn testResolveModuleMutualRecursion() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with two sibling modules that call each other.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod left; export mod right;", &mut arena);

    // Resolve should succeed: cyclic use is allowed.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

@test fn testResolveAccessModuleType() throws (testing::TestError) {
@test unsafe fn testResolveAccessModuleType() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with types module containing a record.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod types; mod app;", &mut arena);

    // Resolve should succeed: types can be accessed.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

@test fn testResolveAccessModuleConstant() throws (testing::TestError) {
@test unsafe fn testResolveAccessModuleConstant() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with constants module.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);

    // Resolve should succeed: constants can be accessed.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

@test fn testResolveRootSymbolMustBeImported() throws (testing::TestError) {
@test unsafe fn testResolveRootSymbolMustBeImported() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register deeply nested modules: `root::app::services::auth`.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod main; export fn helper() -> i32 { return 42; }", &mut arena);

    // Resolve should fail: the `root` module must be imported.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("root"));
}

@test fn testResolveUseImportsNestedSymbol() throws (testing::TestError) {
@test unsafe fn testResolveUseImportsNestedSymbol() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register deeply nested modules: `root::app::services::auth`.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod app; mod main;", &mut arena);

    // Resolve should succeed: use imports the module symbol.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

@test fn testResolveUseNonExistentModule() throws (testing::TestError) {
@test unsafe fn testResolveUseNonExistentModule() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with app trying to use a non-existent module.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod app;", &mut arena);

    // Resolve should fail: module doesn't exist.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("unknown"));
}

@test fn testResolveUsePrivateFn() throws (testing::TestError) {
@test unsafe fn testResolveUsePrivateFn() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with util module containing a private function.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod util; mod app;", &mut arena);

    // Resolve should fail: function is not public.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("private"));
}

@test fn testResolveUsePrivateMod() throws (testing::TestError) {
@test unsafe fn testResolveUsePrivateMod() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with public and private child modules.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod main; mod private;", &mut arena);

    // Resolve should fail: module is not public.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("private"));
}

@test fn testResolveUsePublicMod() throws (testing::TestError) {
@test unsafe fn testResolveUsePublicMod() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with public and private child modules.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod main; export mod public;", &mut arena);

    // Resolve should succeed: module is public.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

@test fn testResolveUseNonPublicType() throws (testing::TestError) {
@test unsafe fn testResolveUseNonPublicType() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with types module containing a private record.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod types; mod app;", &mut arena);

    // Resolve should fail: record is not public.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("Priv"));
}

@test fn testResolveImportPublicType() throws (testing::TestError) {
@test unsafe fn testResolveImportPublicType() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with types module containing a public record.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod types; mod app;", &mut arena);

    // Resolve should succeed: record is public.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

@test fn testResolveUseNonPublicStatic() throws (testing::TestError) {
@test unsafe fn testResolveUseNonPublicStatic() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with statics module containing a private static.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod statics; mod app;", &mut arena);

    // Resolve should fail: static is not public.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("PRIVATE"));
}

@test fn testResolveImportPublicStatic() throws (testing::TestError) {
@test unsafe fn testResolveImportPublicStatic() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with statics module containing a public static.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod statics; mod app;", &mut arena);

    // Resolve should succeed: static is public.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

@test fn testResolveAccessSuper() throws (testing::TestError) {
@test unsafe fn testResolveAccessSuper() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

        // Test function access.

        try expectNoErrors(&result);
    }
}

/// Test nested super access to union variants (e.g. `super::E::A`).
@test fn testResolveSuperUnionVariant() throws (testing::TestError) {
@test unsafe fn testResolveSuperUnionVariant() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod c; export union E { A, B }", &mut arena);
    let childId = try registerModule(&mut MODULE_GRAPH, rootId, "c",

        &mut arena);
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

@test fn testResolveUseSuper() throws (testing::TestError) {
@test unsafe fn testResolveUseSuper() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with a function, and a child module that uses super to access it.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod joe; export mod kate;", &mut arena);

    // Resolve should succeed - super allows accessing parent module.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

@test fn testResolveModNotFound() throws (testing::TestError) {
@test unsafe fn testResolveModNotFound() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root that declares a module that doesn't exist.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod unknown;", &mut arena);

    let case super::ErrorKind::UnresolvedSymbol(name) = err.kind
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(name, "unknown"));
}

@test fn testResolveDuplicateSubModule() throws (testing::TestError) {
@test unsafe fn testResolveDuplicateSubModule() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root that declares a module twice.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod child; mod child;", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("child"));
}

@test fn testResolveUseSubModule() throws (testing::TestError) {
@test unsafe fn testResolveUseSubModule() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root that declares and imports the same module.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod child; use child;", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("child"));
}

@test fn testResolveDuplicateUse() throws (testing::TestError) {
@test unsafe fn testResolveDuplicateUse() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register a module that imports the same module twice.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod child", &mut arena);

    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("root"));
}

/// Test that opaque pointers are allowed in record fields.
@test fn testOpaquePointerInRecordField() throws (testing::TestError) {
@test unsafe fn testOpaquePointerInRecordField() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "record T { x: *opaque }");
    try expectNoErrors(&result);
}

/// You cannot use `@sizeOf` or `@alignOf` on opaque type.
@test fn testOpaqueTypeNoSizeOfAlignOf() throws (testing::TestError) {
@test unsafe fn testOpaqueTypeNoSizeOfAlignOf() throws (testing::TestError) {
    let mut a = testResolver();

    let result1 = try resolveExprStr(&mut a, "@sizeOf(opaque)");
    let err1 = try expectError(&result1);
    try expectErrorKind(&result1, super::ErrorKind::OpaqueTypeNotAllowed);

    let err2 = try expectError(&result2);
    try expectErrorKind(&result2, super::ErrorKind::OpaqueTypeNotAllowed);
}

/// Test that immutable slice/pointer parameters cannot be borrowed mutably.
@test fn testMutableBorrowFromImmutablePointer() throws (testing::TestError) {
@test unsafe fn testMutableBorrowFromImmutablePointer() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(p: *i32) { let x = &mut *p; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

/// Test that immutable slice parameters cannot be borrowed mutably.
@test fn testMutableBorrowFromImmutableSlice() throws (testing::TestError) {
@test unsafe fn testMutableBorrowFromImmutableSlice() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(s: *[i32]) { let x: *mut i32 = &mut s[0]; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

/// Test that mutable pointer parameters can be borrowed mutably.
@test fn testMutableBorrowFromMutablePointer() throws (testing::TestError) {
@test unsafe fn testMutableBorrowFromMutablePointer() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(p: *mut i32) { let x: *mut i32 = &mut *p; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that mutable slice parameters can be borrowed mutably.
@test fn testMutableBorrowFromMutableSlice() throws (testing::TestError) {
@test unsafe fn testMutableBorrowFromMutableSlice() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(s: *mut [i32]) { let x: *mut i32 = &mut s[0]; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test borrowing mutably from a field access on a call returning `*mut`.
@test fn testMutableBorrowFromCallReturningMutablePointer() throws (testing::TestError) {
@test unsafe fn testMutableBorrowFromCallReturningMutablePointer() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Box { x: i32 } fn idBox(b: *mut Box) -> *mut Box { return b; } fn f() { let mut b = Box { x: 1 }; let px: *mut i32 = &mut idBox(&mut b).x; }";
    let program = "record Box { x: i32 } fn idBox(b: *mut Box) -> *mut Box { return b; } fn f() { static b: Box = Box { x: 1 }; let px: *mut i32 = &mut idBox(&mut b).x; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that calls returning immutable pointers cannot be mutably borrowed.
@test fn testMutableBorrowFromCallReturningImmutablePointer() throws (testing::TestError) {
@test unsafe fn testMutableBorrowFromCallReturningImmutablePointer() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Box { x: i32 } fn idBox(b: *Box) -> *Box { return b; } fn f() { let b = Box { x: 1 }; let px: *mut i32 = &mut idBox(&b).x; }";
    let program = "record Box { x: i32 } fn idBox(b: *Box) -> *Box { return b; } fn f() { constant b: Box = Box { x: 1 }; let px: *mut i32 = &mut idBox(&b).x; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

/// Test borrowing mutably from a public static through scope access.
@test fn testMutableBorrowFromScopeAccessStatic() throws (testing::TestError) {
@test unsafe fn testMutableBorrowFromScopeAccessStatic() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod statics; mod app;", &mut arena);
    let staticsId = try registerModule(&mut MODULE_GRAPH, rootId, "statics", "export static COUNTER: i32 = 0;", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

/// Test that constants through scope access cannot be mutably borrowed.
@test fn testMutableBorrowFromScopeAccessConstant() throws (testing::TestError) {
@test unsafe fn testMutableBorrowFromScopeAccessConstant() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export constant LIMIT: i32 = 7;", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

/// Test that mutable bindings of immutable pointers cannot borrow mutably through the pointer.
@test fn testMutableBorrowFromMutableBindingOfPointer() throws (testing::TestError) {
@test unsafe fn testMutableBorrowFromMutableBindingOfPointer() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f() { let mut x: i32 = 1; let p: *i32 = &x; let y = &mut *p; }";
    let program = "fn f() { static x: i32 = 1; let p: *i32 = &x; let y = &mut *p; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

/// Test that mutable pointer to immutable slice cannot be assigned through index.
/// This tests the case where we have `*mut *[T]`; the outer pointer is mutable but
/// the inner slice is immutable, so we shouldn't be able to mutate the elements.
@test fn testAssignThroughMutablePointerToImmutableSlice() throws (testing::TestError) {
@test unsafe fn testAssignThroughMutablePointerToImmutableSlice() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(slice: *[i32]) { let p: *mut *[i32] = &mut slice; set p[0] = 1; }";
    let result = try resolveProgramStr(&mut a, program);

    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

/// Test that mutable slice parameters can be assigned through index.
@test fn testAssignThroughMutableSliceParam() throws (testing::TestError) {
@test unsafe fn testAssignThroughMutableSliceParam() throws (testing::TestError) {
    {
        // Mutable slice param: direct assignment should work
        let mut a = testResolver();
        let program = "fn f(slice: *mut [i32]) { set slice[0] = 1; }";
        let result = try resolveProgramStr(&mut a, program);

        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
}

/// Test range end type coercion with assignable types.
@test fn testRangeEndTypeCoercion() throws (testing::TestError) {
@test unsafe fn testRangeEndTypeCoercion() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn f(end: u32) { for i in 0..end {} }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

        try expectNoErrors(&result);
    }
}

/// Mixed-width range bounds require an explicit cast.
@test fn testRangeEndTypeSubType() throws (testing::TestError) {
@test unsafe fn testRangeEndTypeSubType() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn f(start: i8, end: u32) { for i in start..end {} }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);

        try expectNoErrors(&result);
    }
}

/// Test that try-catch expressions in statement context accept mismatched types.
@test fn testTryCatchInStatementContextTypeMismatchOk() throws (testing::TestError) {
@test unsafe fn testTryCatchInStatementContextTypeMismatchOk() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f() { try g() catch {}; } fn g() -> bool throws (i32) { panic; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that try-catch blocks in value context require divergence or void.
@test fn testTryCatchInValueContextTypeMismatch() throws (testing::TestError) {
@test unsafe fn testTryCatchInValueContextTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f() -> bool { return try g() catch {}; } fn g() -> bool throws (i32) { panic; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::Bool, super::Type::Void);
}

/// Test that try-catch blocks in value context work when they diverge.
@test fn testTryCatchInValueContextDiverges() throws (testing::TestError) {
@test unsafe fn testTryCatchInValueContextDiverges() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f() -> bool { return try g() catch { return false; }; } fn g() -> bool throws (i32) { panic; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that `try?` lifts result type to optional.
@test fn testTryOptionalLiftsToOptional() throws (testing::TestError) {
@test unsafe fn testTryOptionalLiftsToOptional() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S {} fn f() -> ?*S { return try? g(); } fn g() -> *S throws (i32) { panic; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that record fields can be assigned if the record binding is mutable.
@test fn testMutableAssignToMutableRecordBinding() throws (testing::TestError) {
@test unsafe fn testMutableAssignToMutableRecordBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S { x: i32 } fn f() { let mut s = S { x: 1 }; set s.x = 2; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that record fields cannot be assigned if the record binding is immutable.
@test fn testMutableAssignToImmutableRecordBinding() throws (testing::TestError) {
@test unsafe fn testMutableAssignToImmutableRecordBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S { x: i32 } fn f() { let s = S { x: 1 }; set s.x = 2; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

/// Test that record fields can be assigned through a mutable pointer.
@test fn testMutableAssignToMutablePointerToRecord() throws (testing::TestError) {
@test unsafe fn testMutableAssignToMutablePointerToRecord() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S { x: i32 } fn f(p: *mut S) { set p.x = 2; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that record fields cannot be assigned through an immutable pointer.
@test fn testMutableAssignToImmutablePointerToRecord() throws (testing::TestError) {
@test unsafe fn testMutableAssignToImmutablePointerToRecord() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S { x: i32 } fn f(p: *S) { set p.x = 2; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

// Opaque pointer tests.

/// You can assign any pointer (*T) to an opaque pointer (*opaque) without a cast.
@test fn testOpaquePointerAutoCoercion() throws (testing::TestError) {
@test unsafe fn testOpaquePointerAutoCoercion() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn f(x: i32) { let mut ptr: *i32 = &x; let o: *opaque = ptr; set ptr = o as *i32; }");
    let result = try resolveProgramStr(&mut a, "fn f(x: *i32) { let mut ptr: *i32 = x; let o: *opaque = ptr; set ptr = o as *i32; }");
    try expectNoErrors(&result);
}

/// You cannot assign an opaque pointer to a non-opaque pointer without a cast.
@test fn testOpaquePointerNoReverseCoercion() throws (testing::TestError) {
@test unsafe fn testOpaquePointerNoReverseCoercion() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn f(a: i32) { let o: *opaque = &a; let ptr: *i32 = o; }");
    let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let ptr: *i32 = o; }");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(mismatch) = err.kind
        else throw testing::TestError::Failed;
    let case super::Type::Pointer { target: expectedTarget, .. } = mismatch.expected
        else throw testing::TestError::Failed;

    try testing::expect(*expectedTarget == super::Type::I32);
    try testing::expect(*actualTarget == super::Type::Opaque);
}

/// You cannot have a value of type `opaque` (function parameter).
@test fn testOpaqueValue() throws (testing::TestError) {
@test unsafe fn testOpaqueValue() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(x: opaque) {}");
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::OpaqueTypeNotAllowed);

        try expectErrorKind(&result, super::ErrorKind::OpaqueTypeNotAllowed);
    }
}

/// You cannot dereference an opaque pointer, you have to cast it first.
@test fn testOpaquePointerNoDereference() throws (testing::TestError) {
@test unsafe fn testOpaquePointerNoDereference() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn f(a: i32) { let o: *opaque = &a; let x = *o; }");
    let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let x = *o; }");
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::OpaqueTypeDeref);
}

/// Test that you can dereference after casting.
@test fn testOpaquePointerDereferenceAfterCast() throws (testing::TestError) {
@test unsafe fn testOpaquePointerDereferenceAfterCast() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn f() { let o: *opaque = undefined; let x = *(o as *i32); }");
    try expectNoErrors(&result);
}

/// You cannot do pointer arithmetic with an opaque pointer.
@test fn testOpaquePointerNoArithmetic() throws (testing::TestError) {
@test unsafe fn testOpaquePointerNoArithmetic() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(a: i32) { let o: *opaque = &a; let x = o + 1; }");
        let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let x = o + 1; }");
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::OpaquePointerArithmetic);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(a: i32) { let o: *opaque = &a; let x = 1 + o; }");
        let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let x = 1 + o; }");
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::OpaquePointerArithmetic);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(a: i32) { let o: *opaque = &a; let x = o - 1; }");
        let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let x = o - 1; }");
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::OpaquePointerArithmetic);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(a: i32) { let o: *opaque = &a; let x = 1 - o; }");
        let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let x = 1 - o; }");
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::OpaquePointerArithmetic);
    }
}

// Wildcard import/reexport tests.

/// Test transitive re-export.
@test fn testWildcardReexportTransitive() throws (testing::TestError) {
@test unsafe fn testWildcardReexportTransitive() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod a; export mod b;", &mut arena);
    let aId = try registerModule(&mut MODULE_GRAPH, rootId, "a", "use root::b; fn main() -> i32 { return b::helper() + b::MAX; }", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

/// Test that wildcard import can access public symbols.
@test fn testWildcardImportPublicOnly() throws (testing::TestError) {
@test unsafe fn testWildcardImportPublicOnly() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod b; mod a;", &mut arena);
    let bId = try registerModule(&mut MODULE_GRAPH, rootId, "b", "export record Value { number: i32 } export fn public() -> i32 { return 1; } fn private() -> i32 { return 2; }", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

/// Test that wildcard import cannot access private symbols.
@test fn testWildcardImportSkipsPrivate() throws (testing::TestError) {
@test unsafe fn testWildcardImportSkipsPrivate() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod b; mod a;", &mut arena);
    let bId = try registerModule(&mut MODULE_GRAPH, rootId, "b", "export fn public() -> i32 { return 1; } fn private() -> i32 { return 2; }", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("private"));
}

/// Test that a constant array can use another constant as its length.
@test fn testConstArrayWithConstLength() throws (testing::TestError) {
@test unsafe fn testConstArrayWithConstLength() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "constant LEN: u32 = 3; constant ARR: [i32; LEN] = [1, 2, 3];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);


        else throw testing::TestError::Failed;
    try testing::expect(arrType.length == 3);
}

/// Test that a record field can use a constant as its array length.
@test fn testRecordFieldWithConstArrayLength() throws (testing::TestError) {
@test unsafe fn testRecordFieldWithConstArrayLength() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "constant SIZE: u32 = 4; record Buffer { data: [i32; SIZE], }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that a constant can have a record literal value (lazy record body resolution).
@test fn testConstWithRecordLiteral() throws (testing::TestError) {
@test unsafe fn testConstWithRecordLiteral() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Point { x: i32, y: i32 } constant ORIGIN: Point = Point { x: 0, y: 0 };";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that a constant can have a union variant value (lazy union body resolution).
@test fn testConstWithUnionVariant() throws (testing::TestError) {
@test unsafe fn testConstWithUnionVariant() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Color { Red, Green, Blue } constant DEFAULT: Color = Color::Red;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that record field types can reference imported types.
///
/// This tests that `use` statements are processed before record body resolution,
/// allowing record fields to use types from imported modules.
@test fn testRecordFieldUsesImportedType() throws (testing::TestError) {
@test unsafe fn testRecordFieldUsesImportedType() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod types; mod scanner;", &mut arena);
    let typesId = try registerModule(&mut MODULE_GRAPH, rootId, "types", "export record Pool { count: u32 }", &mut arena);


/// Test that imported constants can be used in array size expressions.
///
/// This tests that constant values are propagated through scope access expressions,
/// enabling compile-time evaluation of array sizes using imported constants.
@test fn testImportedConstantInArraySize() throws (testing::TestError) {
@test unsafe fn testImportedConstantInArraySize() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export constant SIZE: u32 = 8;", &mut arena);


/// Test that `if let case` binds payload variables in the then branch.
///
/// When using `if let case Union::Variant(x) = expr { ... }`, the variable `x` should
/// be bound to the payload value within the then branch scope.
@test fn testResolveIfCaseBindsPayload() throws (testing::TestError) {
@test unsafe fn testResolveIfCaseBindsPayload() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some(i32), None } fn f(value: Opt) -> i32 { if let case Opt::Some(x) = value { return x; } return 0; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that `if let case` payload binding is scoped to the then branch.
///
/// The payload variable should not be accessible outside the then branch.
@test fn testResolveIfCasePayloadScopeError() throws (testing::TestError) {
@test unsafe fn testResolveIfCasePayloadScopeError() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some(i32), None } fn f(value: Opt) -> i32 { if let case Opt::Some(x) = value {} return x; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::UnresolvedSymbol(name) = err.kind


/// Test that `let case` binds payload variables in the current scope.
///
/// When using `let case Union::Variant(x) = expr else { ... }`, the variable `x`
/// should be bound in the scope after the statement.
@test fn testResolveLetCaseElseBindsPayload() throws (testing::TestError) {
@test unsafe fn testResolveLetCaseElseBindsPayload() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some(i32), None } fn f(value: Opt) -> i32 { let case Opt::Some(x) = value else panic; return x; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that function pointers with identical signatures are assignable.
///
/// Two function types with the same parameters, return type, and throw list
/// should be considered structurally equal, even if they are separate allocations.
@test fn testFnPointerAssignability() throws (testing::TestError) {
@test unsafe fn testFnPointerAssignability() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn apply(f: fn(i32) -> i32, x: i32) -> i32 { return f(x); } fn double(n: i32) -> i32 { return n * 2; } apply(double, 5);";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that function pointers with different parameter types are not assignable.
@test fn testFnPointerParamMismatch() throws (testing::TestError) {
@test unsafe fn testFnPointerParamMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn apply(f: fn(i32) -> i32, x: i32) -> i32 { return f(x); } fn other(n: i8) -> i32 { return n as i32; } apply(other, 5);";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Test that function pointers with different return types are not assignable.
@test fn testFnPointerReturnMismatch() throws (testing::TestError) {
@test unsafe fn testFnPointerReturnMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn apply(f: fn(i32) -> i32, x: i32) -> i32 { return f(x); } fn other(n: i32) -> i8 { return n as i8; } apply(other, 5);";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind


/// Test that named records use nominal typing, not structural.
///
/// Two different named record types with identical fields should NOT be
/// assignable to each other, because they are distinct nominal types.
@test fn testNamedRecordNominalTyping() throws (testing::TestError) {
@test unsafe fn testNamedRecordNominalTyping() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Point { x: i32, y: i32 } record Vec2 { x: i32, y: i32 } fn take(p: Point) -> i32 { return p.x; } let v = Vec2 { x: 1, y: 2 }; take(v);";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Test that union variants with labeled record payloads can be constructed.
@test fn testUnionVariantAnonRecordPayload() throws (testing::TestError) {
@test unsafe fn testUnionVariantAnonRecordPayload() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Event { Click { x: i32, y: i32 }, Key { code: u32 } } let e = Event::Click { x: 10, y: 20 };";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that unlabeled record literals with positional fields work correctly.
///
/// When a record is declared with positional fields (e.g., `record R(i32, bool)`),
/// the literal must use constructor call syntax with positional arguments.
@test fn testResolveUnlabeledRecordLitValid() throws (testing::TestError) {
@test unsafe fn testResolveUnlabeledRecordLitValid() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record R(i32, bool); let r: R = R(1, true);";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that using brace syntax for an unlabeled record causes an error.
@test fn testResolveUnlabeledRecordLitStyleMismatch() throws (testing::TestError) {
@test unsafe fn testResolveUnlabeledRecordLitStyleMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record R(i32); let r = R { x: 1 };";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::RecordFieldStyleMismatch);
}

/// Test that providing too many fields for an unlabeled record causes count mismatch.
@test fn testResolveUnlabeledRecordLitTooManyFields() throws (testing::TestError) {
@test unsafe fn testResolveUnlabeledRecordLitTooManyFields() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record R(i32, bool); let r = R(1, true, 3);";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::RecordFieldCountMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Test that match pattern with wrong number of bindings causes count mismatch.
@test fn testResolveMatchPatternWrongBindingCount() throws (testing::TestError) {
@test unsafe fn testResolveMatchPatternWrongBindingCount() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Event { Click { x: i32, y: i32 } } fn f(e: Event) { match e { case Event::Click(a) => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::RecordFieldCountMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Test that shorthand field syntax works in record literals.
/// `Point { x, y }` should be equivalent to `Point { x: x, y: y }`.
@test fn testResolveRecordLiteralShorthand() throws (testing::TestError) {
@test unsafe fn testResolveRecordLiteralShorthand() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Point { x: i32, y: i32 } fn f() { let x: i32 = 1; let y: i32 = 2; let p = Point { x, y }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test shorthand field syntax with mixed explicit and shorthand fields.
@test fn testResolveRecordLiteralMixedShorthand() throws (testing::TestError) {
@test unsafe fn testResolveRecordLiteralMixedShorthand() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Point { x: i32, y: i32 } fn f() { let x: i32 = 5; let p = Point { x, y: 10 }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test record-style union variant patterns with shorthand syntax.
@test fn testResolveMatchRecordPatternShorthand() throws (testing::TestError) {
@test unsafe fn testResolveMatchRecordPatternShorthand() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Shape { Rect { width: i32, height: i32 } } fn f(s: Shape) -> i32 { match s { case Shape::Rect { width, height } => return width + height } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test record pattern with mixed shorthand and explicit labels.
@test fn testResolveMatchRecordPatternMixed() throws (testing::TestError) {
@test unsafe fn testResolveMatchRecordPatternMixed() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Shape { Rect { width: i32, height: i32 } } fn f(s: Shape) -> i32 { match s { case Shape::Rect { width, height: h } => return width + h } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test record pattern with fields in reverse order.
@test fn testResolveMatchRecordPatternReversed() throws (testing::TestError) {
@test unsafe fn testResolveMatchRecordPatternReversed() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Shape { Rect { width: i32, height: i32 } } fn f(s: Shape) -> i32 { match s { case Shape::Rect { height: h, width: w } => return w + h } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test record pattern with shorthand syntax in reverse order.
/// Pattern `{ height, width }` binds all fields using shorthand, but not in definition order.
@test fn testResolveMatchRecordPatternShorthandReversed() throws (testing::TestError) {
@test unsafe fn testResolveMatchRecordPatternShorthandReversed() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Shape { Rect { width: i32, height: i32 } } fn f(s: Shape) -> i32 { match s { case Shape::Rect { height, width } => return width + height } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test record pattern with `..` ignoring fields.
@test fn testResolveMatchRecordPatternIgnoreRest() throws (testing::TestError) {
@test unsafe fn testResolveMatchRecordPatternIgnoreRest() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "union G { Point { x: i32, y: i32, z: i32 } } fn f(g: G) -> i32 { match g { case G::Point { x, .. } => return x } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

        try expectNoErrors(&result);
    }
}

/// Test standalone record pattern matching with unlabeled patterns.
@test fn testResolveMatchStandaloneRecordUnlabeledPattern() throws (testing::TestError) {
@test unsafe fn testResolveMatchStandaloneRecordUnlabeledPattern() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S(i32); fn f(s: S) -> i32 { match s { case S(x) => return x, else => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test standalone record pattern matching with labeled patterns.
/// Pattern syntax: `T { x }` matches a named record and binds x to the field.
@test fn testResolveMatchStandaloneRecordLabeledPattern() throws (testing::TestError) {
@test unsafe fn testResolveMatchStandaloneRecordLabeledPattern() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record T { x: i32 } fn f(t: T) -> i32 { match t { case T { x } => return x, else => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test standalone record pattern with multiple fields.
/// Pattern syntax: `R(a, b)` matches an unlabeled record with multiple fields.
@test fn testResolveMatchStandaloneRecordMultipleFields() throws (testing::TestError) {
@test unsafe fn testResolveMatchStandaloneRecordMultipleFields() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record R(bool, u8); fn f(r: R) -> u8 { match r { case R(_, x) => return x, else => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test standalone record pattern with wrong field count.
/// Pattern `S(x, y)` should fail for a single-field record.
@test fn testResolveMatchStandaloneRecordWrongFieldCount() throws (testing::TestError) {
@test unsafe fn testResolveMatchStandaloneRecordWrongFieldCount() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S(i32); fn f(s: S) -> i32 { match s { case S(x, y) => return x + y, else => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::RecordFieldCountMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Test array pattern matching with element bindings.
/// Pattern syntax: `[x, y]` matches an array and binds elements.
@test fn testResolveMatchArrayPattern() throws (testing::TestError) {
@test unsafe fn testResolveMatchArrayPattern() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(arr: [i32; 2]) -> i32 { match arr { case [x, y] => return x + y } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test array pattern with placeholder elements.
/// Pattern syntax: `[_, y]` ignores first element.
@test fn testResolveMatchArrayPatternPlaceholder() throws (testing::TestError) {
@test unsafe fn testResolveMatchArrayPatternPlaceholder() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(arr: [i32; 2]) -> i32 { match arr { case [_, y] => return y } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test identifier pattern that binds the whole value.
/// Pattern syntax: `x` matches any value and binds it.
@test fn testResolveMatchIdentPattern() throws (testing::TestError) {
@test unsafe fn testResolveMatchIdentPattern() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(val: i32) -> i32 { match val { x => return x } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test numeric literal pattern matching.
@test fn testResolveMatchNumericLiteralPattern() throws (testing::TestError) {
@test unsafe fn testResolveMatchNumericLiteralPattern() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(val: i32) -> i32 { match val { case 42 => return 1, else => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test string literal pattern matching.
@test fn testResolveMatchStringLiteralPattern() throws (testing::TestError) {
@test unsafe fn testResolveMatchStringLiteralPattern() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(val: *[u8]) -> i32 { match val { case \"hello\" => return 1, else => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test boolean literal pattern matching.
@test fn testResolveMatchBoolLiteralPattern() throws (testing::TestError) {
@test unsafe fn testResolveMatchBoolLiteralPattern() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(val: bool) -> i32 { match val { case true => return 1, case false => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test @sliceOf with correct arguments succeeds.
@test fn testResolveSliceOfCorrect() throws (testing::TestError) {
@test unsafe fn testResolveSliceOfCorrect() throws (testing::TestError) {
    // Immutable pointer.
    {
        let mut a = testResolver();
        let program = "fn f(ptr: *u8, len: u32) -> *[u8] { return @sliceOf(ptr, len); }";
        let result = try resolveProgramStr(&mut a, program);

        try expectNoErrors(&result);
    }
}

/// Test @sliceOf with wrong argument count produces an error.
@test fn testResolveSliceOfWrongArgCount() throws (testing::TestError) {
@test unsafe fn testResolveSliceOfWrongArgCount() throws (testing::TestError) {
    // No arguments.
    {
        let mut a = testResolver();
        let program = "fn f() -> *[u8] { return @sliceOf(); }";
        let result = try resolveProgramStr(&mut a, program);

        try testing::expect(mismatch.actual == 4);
    }
}

/// Test @sliceOf with wrong argument types produces errors.
@test fn testResolveSliceOfWrongArgTypes() throws (testing::TestError) {
@test unsafe fn testResolveSliceOfWrongArgTypes() throws (testing::TestError) {
    // Non-pointer first argument.
    {
        let mut a = testResolver();
        let program = "fn f(val: u32, len: u32) -> *[u8] { return @sliceOf(val, len); }";
        let result = try resolveProgramStr(&mut a, program);

            else throw testing::TestError::Failed;
    }
}

/// Test @sliceOf with 3 arguments (ptr, len, cap) succeeds.
@test fn testResolveSliceOfWithCap() throws (testing::TestError) {
@test unsafe fn testResolveSliceOfWithCap() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn f(ptr: *u8, len: u32, cap: u32) -> *[u8] { return @sliceOf(ptr, len, cap); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

        try expectNoErrors(&result);
    }
}

/// Test @sliceOf with 3 arguments but wrong cap type.
@test fn testResolveSliceOfCapWrongType() throws (testing::TestError) {
@test unsafe fn testResolveSliceOfCapWrongType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(ptr: *u8, len: u32, cap: bool) -> *[u8] { return @sliceOf(ptr, len, cap); }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Test .cap field access on slices resolves to u32.
@test fn testResolveSliceCapField() throws (testing::TestError) {
@test unsafe fn testResolveSliceCapField() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(s: *[u8]) -> u32 { return s.cap; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test `.append()` on immutable slice produces an error.
@test fn testResolveSliceAppendImmutable() throws (testing::TestError) {
@test unsafe fn testResolveSliceAppendImmutable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn f(s: *[i32], a: A) { s.append(1, a); }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::ImmutableBinding = err.kind
        else throw testing::TestError::Failed;
}

/// Test `.append()` with wrong argument count produces an error.
@test fn testResolveSliceAppendWrongArgCount() throws (testing::TestError) {
@test unsafe fn testResolveSliceAppendWrongArgCount() throws (testing::TestError) {
    // Too few arguments.
    {
        let mut a = testResolver();
        let program = "fn f(s: *mut [i32]) { s.append(1); }";
        let result = try resolveProgramStr(&mut a, program);

        try testing::expect(m.actual == 3);
    }
}

/// Test `.append()` with correct arguments succeeds.
@test fn testResolveSliceAppendCorrect() throws (testing::TestError) {
@test unsafe fn testResolveSliceAppendCorrect() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn f(s: *mut [i32], a: A) { s.append(1, a); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test `.append()` with wrong element type produces an error.
@test fn testResolveSliceAppendWrongElemType() throws (testing::TestError) {
@test unsafe fn testResolveSliceAppendWrongElemType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn f(s: *mut [i32], a: A) { s.append(true, a); }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Test `.delete()` on immutable slice produces an error.
@test fn testResolveSliceDeleteImmutable() throws (testing::TestError) {
@test unsafe fn testResolveSliceDeleteImmutable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(s: *[i32]) { s.delete(0); }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::ImmutableBinding = err.kind
        else throw testing::TestError::Failed;
}

/// Test `.delete()` with wrong argument count produces an error.
@test fn testResolveSliceDeleteWrongArgCount() throws (testing::TestError) {
@test unsafe fn testResolveSliceDeleteWrongArgCount() throws (testing::TestError) {
    // No arguments.
    {
        let mut a = testResolver();
        let program = "fn f(s: *mut [i32]) { s.delete(); }";
        let result = try resolveProgramStr(&mut a, program);

        try testing::expect(m.actual == 2);
    }
}

/// Test `.delete()` with correct arguments succeeds.
@test fn testResolveSliceDeleteCorrect() throws (testing::TestError) {
@test unsafe fn testResolveSliceDeleteCorrect() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(s: *mut [i32]) { s.delete(0); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test `.delete()` with wrong argument type produces an error.
@test fn testResolveSliceDeleteWrongArgType() throws (testing::TestError) {
@test unsafe fn testResolveSliceDeleteWrongArgType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(s: *mut [i32]) { s.delete(true); }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Test `match &opt` produces immutable pointer bindings.
@test fn testResolveMatchRefUnionBinding() throws (testing::TestError) {
@test unsafe fn testResolveMatchRefUnionBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some(i32), None } fn f() { let opt = Opt::Some(42); match &opt { case Opt::Some(x) => { *x; } else => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);


    try testing::expect(not mutable);
    try testing::expect(*target == super::Type::I32);
}

/// Test `match &mut opt` produces mutable pointer bindings.
@test fn testResolveMatchMutRefUnionBinding() throws (testing::TestError) {
@test unsafe fn testResolveMatchMutRefUnionBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some(i32), None } fn f() { let mut opt = Opt::Some(42); match &mut opt { case Opt::Some(x) => { *x; } else => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);


    try testing::expect(mutable);
    try testing::expect(*target == super::Type::I32);
}

/// Non-constant integer widening must use an explicit cast.
@test fn testResolveIntegerWideningRequiresCast() throws (testing::TestError) {
@test unsafe fn testResolveIntegerWideningRequiresCast() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = x;");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::U32, super::Type::U8);

        try expectNoErrors(&result);
    }
}

/// Mixed-width integer binary ops require an explicit cast.
@test fn testResolveIntegerWideningBinOpRequiresCast() throws (testing::TestError) {
@test unsafe fn testResolveIntegerWideningBinOpRequiresCast() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = 2; let z: u32 = x | y;");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::U8, super::Type::U32);

        try expectNoErrors(&result);
    }
}

/// A mutable slice pointer should be assignable to an immutable slice pointer.
@test fn testResolveMutSliceAssignableToImmutSlice() throws (testing::TestError) {
@test unsafe fn testResolveMutSliceAssignableToImmutSlice() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveBlockStr(&mut a, "let mut arr: [i32; 3] = [1, 2, 3]; let p: *mut [i32] = &mut arr[..]; let q: *[i32] = p;");
    let result = try resolveBlockStr(&mut a, "static arr: [i32; 3] = [1, 2, 3]; let p: *mut [i32] = &mut arr[..]; let q: *[i32] = p;");
    try expectNoErrors(&result);
}

/// Comprehensive tests for `as` cast expressions.
@test fn testResolveAsCasts() throws (testing::TestError) {
@test unsafe fn testResolveAsCasts() throws (testing::TestError) {
    { // Pointer to numeric.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: i32 = 0; let p = &x; p as u32;");
        let result = try resolveBlockStr(&mut a, "static x: i32 = 0; let p = &x; p as u32;");
        try expectNoErrors(&result);
    } { // Function pointer to numeric.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let f: fn() = undefined; f as u32;");
        try expectNoErrors(&result);

        try expectNoErrors(&result);
    }
}

/// Tests for invalid `as` casts that should be rejected.
@test fn testResolveAsCastsInvalid() throws (testing::TestError) {
@test unsafe fn testResolveAsCastsInvalid() throws (testing::TestError) {
    { // Pointer to slice is invalid.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let p: *i32 = undefined; p as *[i32];");
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind

            else throw testing::TestError::Failed;
    }
}

/// Test that catch binding is available in catch block scope.
@test fn testResolveTryCatchBinding() throws (testing::TestError) {
@test unsafe fn testResolveTryCatchBinding() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "union Error { Fail } fn fallible() -> u32 throws (Error) { throw Error::Fail; } fn caller() -> u32 { return try fallible() catch err { return 0; }; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

        try expectNoErrors(&result);
    }
}

/// Test that duplicate union variant patterns are detected.
@test fn testResolveMatchDuplicateUnionPattern() throws (testing::TestError) {
@test unsafe fn testResolveMatchDuplicateUnionPattern() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "union U { A, B } fn f(u: U) { match u { case U::A => {}, case U::A => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::DuplicateMatchPattern);

        try expectNoErrors(&result);
    }
}

/// Test that duplicate bool patterns are detected.
@test fn testResolveMatchDuplicateBoolPattern() throws (testing::TestError) {
@test unsafe fn testResolveMatchDuplicateBoolPattern() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn f(x: bool) { match x { case true => {}, case true => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::DuplicateMatchPattern);

        try expectErrorKind(&result, super::ErrorKind::DuplicateMatchPattern);
    }
}

/// Test that duplicate nil patterns in optional match are detected.
@test fn testResolveMatchDuplicateOptionalPattern() throws (testing::TestError) {
@test unsafe fn testResolveMatchDuplicateOptionalPattern() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) { match opt { v => {}, case nil => {}, case nil => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::DuplicateMatchPattern);

        try expectErrorKind(&result, super::ErrorKind::DuplicateMatchPattern);
    }
}

/// Test that guarded match arms are not considered duplicates.
@test fn testResolveMatchGuardedNotDuplicate() throws (testing::TestError) {
@test unsafe fn testResolveMatchGuardedNotDuplicate() throws (testing::TestError) {
    {
        // Guarded union variant followed by same variant is fine.
        let mut a = testResolver();
        let program = "union U { A, B } fn f(u: U) { match u { case U::A if true => {}, case U::A => {}, case U::B => {} } }";
        let result = try resolveProgramStr(&mut a, program);

        try expectNoErrors(&result);
    }
}

/// Test that unreachable else is detected when all union variants are covered.
@test fn testResolveMatchUnreachableElseUnion() throws (testing::TestError) {
@test unsafe fn testResolveMatchUnreachableElseUnion() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "union U { A, B } fn f(u: U) { match u { case U::A => {}, case U::B => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnreachableElse);

        try expectNoErrors(&result);
    }
}

/// Test that unreachable else is detected when both bool cases are covered.
@test fn testResolveMatchUnreachableElseBool() throws (testing::TestError) {
@test unsafe fn testResolveMatchUnreachableElseBool() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn f(x: bool) { match x { case true => {}, case false => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnreachableElse);

        try expectNoErrors(&result);
    }
}

/// Test that unreachable else is detected when both optional cases are covered.
@test fn testResolveMatchUnreachableElseOptional() throws (testing::TestError) {
@test unsafe fn testResolveMatchUnreachableElseOptional() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) { match opt { v => {}, case nil => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnreachableElse);

    }
}

// --- Multi-error typed catch tests ---

@test fn testTypedCatchExhaustive() throws (testing::TestError) {
@test unsafe fn testTypedCatchExhaustive() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrA { return 0; } catch e as ErrB { return 1; }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test fn testTypedCatchNonExhaustive() throws (testing::TestError) {
@test unsafe fn testTypedCatchNonExhaustive() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrA { return 0; }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TryCatchNonExhaustive);
}

@test fn testTypedCatchDuplicate() throws (testing::TestError) {
@test unsafe fn testTypedCatchDuplicate() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrA { return 0; } catch e as ErrA { return 1; }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TryCatchDuplicateType);
}

@test fn testTypedCatchWithCatchAll() throws (testing::TestError) {
@test unsafe fn testTypedCatchWithCatchAll() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrA { return 0; } catch { return 1; }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test fn testTypedCatchWrongType() throws (testing::TestError) {
@test unsafe fn testTypedCatchWrongType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union ErrA { A } union ErrB { B } union ErrC { C } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrC { return 0; } catch e as ErrA { return 1; }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TryIncompatibleError);
}

@test fn testInferredCatchMultiError() throws (testing::TestError) {
@test unsafe fn testInferredCatchMultiError() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e { return 0; }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TryCatchMultiError);
}

@test fn testResolveInstanceMissingMethod() throws (testing::TestError) {
@test unsafe fn testResolveInstanceMissingMethod() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "trait S { fn (*S) f() -> i32; } record R { x: i32 } instance S for R {}";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::MissingTraitMethod("f"));
}

@test fn testResolveInstanceUnknownMethod() throws (testing::TestError) {
@test unsafe fn testResolveInstanceUnknownMethod() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "trait S { fn (*S) f() -> i32; } record R { x: i32 } instance S for R { fn (self: *R) x() -> i32 { return 0; } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("x"));
}

@test fn testResolveTraitDuplicateMethodRejected() throws (testing::TestError) {
@test unsafe fn testResolveTraitDuplicateMethodRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "trait Adder { fn (*mut Adder) add(n: i32) -> i32; fn (*mut Adder) add(n: i32) -> i32; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("add"));
}

@test fn testResolveInstanceReceiverTypeMustMatchTarget() throws (testing::TestError) {
@test unsafe fn testResolveInstanceReceiverTypeMustMatchTarget() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Counter { value: i32 } record Wrong { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Wrong) add(n: i32) -> i32 { return n; } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

@test fn testResolveTraitMethodThrowsRequireTry() throws (testing::TestError) {
@test unsafe fn testResolveTraitMethodThrowsRequireTry() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Error { Fail } record Counter { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32 throws (Error); } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 throws (Error) { throw Error::Fail; return n; } } fn caller(a: *mut opaque Adder) -> i32 { return a.add(1); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::MissingTry);
}

/// Trait declares immutable receiver (*Trait) but instance uses mutable (*mut Type).
/// The instance method could mutate through what was originally an immutable pointer.
@test fn testResolveInstanceMutReceiverOnImmutableTrait() throws (testing::TestError) {
@test unsafe fn testResolveInstanceMutReceiverOnImmutableTrait() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Counter { value: i32 } trait Reader { fn (*Reader) read() -> i32; } instance Reader for Counter { fn (c: *mut Counter) read() -> i32 { set c.value = c.value + 1; return c.value; } }";
    let result = try resolveProgramStr(&mut a, program);
    // Should reject: instance declares *mut receiver but trait only requires immutable.
    try expectErrorKind(&result, super::ErrorKind::ReceiverMutabilityMismatch);
}

/// Instance method declares different parameter types than the trait.
/// The resolver should reject the mismatch rather than silently using the trait's types.
@test fn testResolveInstanceParamTypeMismatch() throws (testing::TestError) {
@test unsafe fn testResolveInstanceParamTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Acc { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Acc { fn (a: *mut Acc) add(n: u8) -> i32 { set a.value = a.value + n as i32; return a.value; } }";
    let result = try resolveProgramStr(&mut a, program);
    // Should reject: instance param type u8 doesn't match trait param type i32.
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Duplicate instance declarations for the same (trait, type) pair should be rejected.
@test fn testResolveInstanceDuplicateRejected() throws (testing::TestError) {
@test unsafe fn testResolveInstanceDuplicateRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Counter { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { set c.value = c.value + n; return c.value; } } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { set c.value = c.value + n + 100; return c.value; } }";
    let result = try resolveProgramStr(&mut a, program);
    // Should reject: duplicate instance for (Adder, Counter).
    try expectErrorKind(&result, super::ErrorKind::DuplicateInstance);
}

/// Trait method receiver must point to the declaring trait type.
@test fn testResolveTraitReceiverMismatch() throws (testing::TestError) {
@test unsafe fn testResolveTraitReceiverMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Other { x: i32 } trait Foo { fn (*mut Other) bar() -> i32; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TraitReceiverMismatch);
}

/// Using a trait name as a value expression should be rejected.
@test fn testResolveTraitNameAsValueRejected() throws (testing::TestError) {
@test unsafe fn testResolveTraitNameAsValueRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "trait Foo { fn (*Foo) bar() -> i32; } fn test() -> i32 { let x = Foo; return 0; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnexpectedTraitName);
}

/// Cross-module trait: coerce to trait object and dispatch from a different module.
@test fn testResolveTraitCrossModuleCoercion() throws (testing::TestError) {
@test unsafe fn testResolveTraitCrossModuleCoercion() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod defs; mod app;", &mut arena);
    let defsId = try registerModule(&mut MODULE_GRAPH, rootId, "defs", "export record Counter { value: i32 } export trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { set c.value = c.value + n; return c.value; } }", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::defs; fn test() -> i32 { let mut c = defs::Counter { value: 10 }; let a: *mut opaque defs::Adder = &mut c; return a.add(5); }", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::defs; fn test() -> i32 { static c: defs::Counter = defs::Counter { value: 10 }; let a: *mut opaque defs::Adder = &mut c; return a.add(5); }", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

/// Instance in a different module from trait and type.
@test fn testResolveInstanceCrossModule() throws (testing::TestError) {
@test unsafe fn testResolveInstanceCrossModule() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod defs; export mod impls; mod app;", &mut arena);
    let defsId = try registerModule(&mut MODULE_GRAPH, rootId, "defs", "export record Counter { value: i32 } export trait Adder { fn (*mut Adder) add(n: i32) -> i32; }", &mut arena);
    let implsId = try registerModule(&mut MODULE_GRAPH, rootId, "impls", "use root::defs; instance defs::Adder for defs::Counter { fn (c: *mut defs::Counter) add(n: i32) -> i32 { set c.value = c.value + n; return c.value; } }", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::defs; fn test() -> i32 { let mut c = defs::Counter { value: 10 }; let a: *mut opaque defs::Adder = &mut c; return a.add(5); }", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::defs; fn test() -> i32 { static c: defs::Counter = defs::Counter { value: 10 }; let a: *mut opaque defs::Adder = &mut c; return a.add(5); }", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

/// Calling a mutable-receiver trait method on an immutable trait object
/// must be rejected.
@test fn testResolveTraitMutMethodOnImmutableObject() throws (testing::TestError) {
@test unsafe fn testResolveTraitMutMethodOnImmutableObject() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Counter { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { set c.value = c.value + n; return c.value; } } fn caller(a: *opaque Adder) -> i32 { return a.add(1); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

/// Immutable methods on an immutable trait object should be accepted.
@test fn testResolveTraitImmutableMethodOnImmutableObject() throws (testing::TestError) {
@test unsafe fn testResolveTraitImmutableMethodOnImmutableObject() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Counter { value: i32 } trait Reader { fn (*Reader) get() -> i32; } instance Reader for Counter { fn (c: *Counter) get() -> i32 { return c.value; } } fn caller(r: *opaque Reader) -> i32 { return r.get(); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Both mutable and immutable methods on a mutable trait object should work.
@test fn testResolveTraitMixedMethodsOnMutableObject() throws (testing::TestError) {
@test unsafe fn testResolveTraitMixedMethodsOnMutableObject() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Counter { value: i32 } trait Ops { fn (*mut Ops) inc(); fn (*Ops) get() -> i32; } instance Ops for Counter { fn (c: *mut Counter) inc() { set c.value = c.value + 1; } fn (c: *Counter) get() -> i32 { return c.value; } } fn caller(o: *mut opaque Ops) -> i32 { o.inc(); return o.get(); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Instance method body type must match the trait return type.
/// The trait declares `-> i32` but the body returns `bool`.
@test fn testResolveInstanceReturnTypeMismatch() throws (testing::TestError) {
@test unsafe fn testResolveInstanceReturnTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record R { x: i32 } trait T { fn (*T) get() -> i32; } instance T for R { fn (r: *R) get() -> bool { return true; } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Diamond supertrait inheritance: traits B and C both extend A.
/// Declaring them independently should work fine.
@test fn testResolveTraitDiamondSupertrait() throws (testing::TestError) {
@test unsafe fn testResolveTraitDiamondSupertrait() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "trait A { fn (*A) f() -> i32; } trait B: A { fn (*B) g() -> i32; } trait C: A { fn (*C) h() -> i32; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Diamond supertrait with a combined trait that would cause duplicate
/// method names should be detected.
@test fn testResolveTraitDiamondDuplicateMethod() throws (testing::TestError) {
@test unsafe fn testResolveTraitDiamondDuplicateMethod() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "trait A { fn (*A) f() -> i32; } trait B: A { fn (*B) g() -> i32; } trait C: A { fn (*C) h() -> i32; } trait D: B + C { fn (*D) i() -> i32; }";
    let result = try resolveProgramStr(&mut a, program);
    // B inherits `f` from A, C inherits `f` from A. D: B + C sees duplicate `f`.
    try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("f"));
}

/// Supertrait instance must exist when declaring a combined trait instance.
@test fn testResolveInstanceMissingSupertraitInstance() throws (testing::TestError) {
@test unsafe fn testResolveInstanceMissingSupertraitInstance() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "trait Base { fn (*Base) f() -> i32; } trait Child: Base { fn (*Child) g() -> i32; } record R { x: i32 } instance Child for R { fn (r: *R) g() -> i32 { return r.x; } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::MissingSupertraitInstance("Base"));
}

/// Instance method omits return type when the trait declares `-> i32`.
/// This is rejected -- the return type must be stated explicitly.
@test fn testResolveInstanceReturnTypeOmitted() throws (testing::TestError) {
@test unsafe fn testResolveInstanceReturnTypeOmitted() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record R { x: i32 } trait T { fn (*T) get() -> i32; } instance T for R { fn (r: *R) get() { } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Instance method declares throws but the trait method does not throw.
@test fn testResolveInstanceThrowsMismatchExtra() throws (testing::TestError) {
@test unsafe fn testResolveInstanceThrowsMismatchExtra() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union E { Fail } record R { x: i32 } trait T { fn (*T) get() -> i32; } instance T for R { fn (r: *R) get() -> i32 throws (E) { return r.x; } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::FnThrowCountMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Instance method declares a different throws type than the trait.
@test fn testResolveInstanceThrowsMismatchWrongType() throws (testing::TestError) {
@test unsafe fn testResolveInstanceThrowsMismatchWrongType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union E1 { Fail } union E2 { Oops } record R { x: i32 } trait T { fn (*T) get() -> i32 throws (E1); } instance T for R { fn (r: *R) get() -> i32 throws (E2) { return r.x; } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Instance method omits throws clause when trait declares throws.
/// This is rejected -- the throws clause must match exactly.
@test fn testResolveInstanceThrowsOmitted() throws (testing::TestError) {
@test unsafe fn testResolveInstanceThrowsOmitted() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union E { Fail } record R { x: i32 } trait T { fn (*T) get() -> i32 throws (E); } instance T for R { fn (r: *R) get() -> i32 { throw E::Fail; return r.x; } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::FnThrowCountMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Instance method correctly matches the trait's throws clause.
@test fn testResolveInstanceThrowsMatch() throws (testing::TestError) {
@test unsafe fn testResolveInstanceThrowsMatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union E { Fail } record R { x: i32 } trait T { fn (*T) get() -> i32 throws (E); } instance T for R { fn (r: *R) get() -> i32 throws (E) { throw E::Fail; return r.x; } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

// Constant expression folding tests //////////////////////////////////////////

/// Resolve a program and verify that the constant at the given statement index
/// has the expected integer magnitude.
fn expectConstFold(program: *[u8], stmtIdx: u32, expected: u64)
unsafe fn expectConstFold(program: *[u8], stmtIdx: u32, expected: u64)
    throws (testing::TestError)
{
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

        else throw testing::TestError::Failed;
    try testing::expect(intVal.magnitude == expected);
}

/// Test arithmetic constant folding: add, sub, mul, div.
@test fn testConstExprArithmetic() throws (testing::TestError) {
@test unsafe fn testConstExprArithmetic() throws (testing::TestError) {
    try expectConstFold("constant A: i32 = 10; constant B: i32 = 20; constant C: i32 = A + B;", 2, 30);
    try expectConstFold("constant A: i32 = 50; constant B: i32 = 20; constant C: i32 = A - B;", 2, 30);
    try expectConstFold("constant A: i32 = 6; constant B: i32 = 7; constant C: i32 = A * B;", 2, 42);
    try expectConstFold("constant A: i32 = 100; constant B: i32 = 5; constant C: i32 = A / B;", 2, 20);
}

/// Test bitwise constant folding: and, or, xor.
@test fn testConstExprBitwise() throws (testing::TestError) {
@test unsafe fn testConstExprBitwise() throws (testing::TestError) {
    try expectConstFold("constant A: i32 = 0xFF; constant B: i32 = 0x0F; constant C: i32 = A & B;", 2, 0x0F);
    try expectConstFold("constant A: i32 = 0xF0; constant B: i32 = 0x0F; constant C: i32 = A | B;", 2, 0xFF);
    try expectConstFold("constant A: i32 = 0xFF; constant B: i32 = 0x0F; constant C: i32 = A ^ B;", 2, 0xF0);
}

/// Test shift constant folding.
@test fn testConstExprShift() throws (testing::TestError) {
@test unsafe fn testConstExprShift() throws (testing::TestError) {
    try expectConstFold("constant A: i32 = 1; constant B: i32 = A << 4;", 1, 16);
    try expectConstFold("constant A: i32 = 32; constant B: i32 = A >> 2;", 1, 8);
}

/// Test chained constant expressions (C depends on A + B, D depends on C).
@test fn testConstExprChained() throws (testing::TestError) {
@test unsafe fn testConstExprChained() throws (testing::TestError) {
    try expectConstFold("constant A: i32 = 10; constant B: i32 = 20; constant C: i32 = A + B; constant D: i32 = C * 2;", 3, 60);
}

/// Test constant expression used as array size.
@test fn testConstExprAsArraySize() throws (testing::TestError) {
@test unsafe fn testConstExprAsArraySize() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "constant A: u32 = 2; constant B: u32 = 3; constant SIZE: u32 = A + B; constant ARR: [i32; SIZE] = [1, 2, 3, 4, 5];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);


    try testing::expect(arrType.length == 5);
}

/// Test cross-module constant expression: a constant in one module references
/// a constant from another module via scope access.
@test fn testCrossModuleConstExpr() throws (testing::TestError) {
@test unsafe fn testCrossModuleConstExpr() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export constant BASE: i32 = 100;", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

/// Test cross-module constant expression used as array size.
@test fn testCrossModuleConstExprArraySize() throws (testing::TestError) {
@test unsafe fn testCrossModuleConstExprArraySize() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export constant WIDTH: u32 = 8; export constant HEIGHT: u32 = 4;", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

/// Test that non-constant expressions in constant declarations are still rejected.
@test fn testConstExprNonConstRejected() throws (testing::TestError) {
@test unsafe fn testConstExprNonConstRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn value() -> i32 { return 1; } constant BAD: i32 = value() + 1;";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::ConstExprRequired = err.kind
        else throw testing::TestError::Failed;
}

/// Test unary negation in constant expressions.
@test fn testConstExprUnaryNeg() throws (testing::TestError) {
@test unsafe fn testConstExprUnaryNeg() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "constant A: i32 = 10; constant B: i32 = -A;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test unary not in constant expressions.
@test fn testConstExprUnaryNot() throws (testing::TestError) {
@test unsafe fn testConstExprUnaryNot() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "constant A: bool = true; constant B: bool = not A;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test `as` casts in constant expressions: widening, narrowing, sign changes, chaining.
@test fn testConstExprCast() throws (testing::TestError) {
@test unsafe fn testConstExprCast() throws (testing::TestError) {
    try expectConstFold("constant A: i32 = 42; constant B: u64 = A as u64;", 1, 42);
    try expectConstFold("constant A: u64 = 10; constant B: u8 = A as u8;", 1, 10);
    try expectConstFold("constant A: i32 = 7; constant B: u32 = A as u32;", 1, 7);
    try expectConstFold("constant A: u32 = 100; constant B: i32 = A as i32;", 1, 100);
    try expectConstFold("constant A: u8 = 5; constant B: u64 = (A as u32) as u64;", 1, 5);

    try expectConstFold("constant A: u32 = (3 + 4) as u32 + 1;", 0, 8);
    try expectConstFold("constant A: i32 = (2 as i32) * (3 + 4);", 0, 14);
}

/// Test `as` cast in constant expressions used as array size.
@test fn testConstExprCastAsArraySize() throws (testing::TestError) {
@test unsafe fn testConstExprCastAsArraySize() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "constant LEN: u64 = 4; constant SIZE: u32 = LEN as u32; constant ARR: [i32; SIZE] = [1, 2, 3, 4];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);


        else throw testing::TestError::Failed;
    try testing::expect(arrType.length == 4);
}

/// Test unsuffixed integer literals in constant expressions.
@test fn testConstExprUnsuffixedLiterals() throws (testing::TestError) {
@test unsafe fn testConstExprUnsuffixedLiterals() throws (testing::TestError) {
    try expectConstFold("constant A: u32 = 4 * 4;", 0, 16);
    try expectConstFold("constant B: u32 = 10; constant C: u32 = B * 2;", 1, 20);
    try expectConstFold("constant D: u32 = 3 + 7;", 0, 10);
    try expectConstFold("constant E: u32 = 2 * 3 + 4;", 0, 10);
    try expectConstFold("constant F: i32 = -(3 + 4);", 0, 7);
}

/// References cannot escape through return types.
@test fn testRefReturnRejected() throws (testing::TestError) {
@test unsafe fn testRefReturnRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Once {} fn bad(value: &u32) -> &u32 { return value; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
}

/// Case-pattern fallbacks must terminate instead of synthesizing bindings.
@test fn testCaseLetElseFallbackMustTerminate() throws (testing::TestError) {
@test unsafe fn testCaseLetElseFallbackMustTerminate() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Value { Item(u32) } fn run(value: Value) { let case Value::Item(item) = value else value; item; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::LinearLetElseMustTerminate);
}

/// Case bindings are unavailable on the pattern-failure path.
@test fn testCaseLetElseFallbackCannotUseBinding() throws (testing::TestError) {
@test unsafe fn testCaseLetElseFallbackCannotUseBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Value { Item(u32) } fn run(value: Value) { let case Value::Item(item) = value else item; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("item"));
}

/// Unsafe pointer dereference requires an unsafe declaration.
@test fn testUnsafePointerOperationRejected() throws (testing::TestError) {
@test unsafe fn testUnsafePointerOperationRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Once {} fn load(pointer: *unsafe u32) -> u32 { return *pointer; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
}

/// Unsafe pointers remain freely copyable inside an unsafe declaration.
@test fn testUnsafePointerOperationAllowed() throws (testing::TestError) {
@test unsafe fn testUnsafePointerOperationAllowed() throws (testing::TestError) {
    let program = "record Marker: Once {} unsafe fn load(pointer: *unsafe u32) -> u32 { return *pointer; }";
    try expectAnalyzeOk(program);
}

/// Safe code cannot call a function that accepts unsafe operations.
@test fn testUnsafeFunctionCallRejected() throws (testing::TestError) {
@test unsafe fn testUnsafeFunctionCallRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Once {} unsafe fn load(pointer: *unsafe u32) -> u32 { return *pointer; } fn run(pointer: *unsafe u32) -> u32 { return load(pointer); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnsafeCall);
}

/// Unsafe function values retain their call-site safety requirement.
@test fn testUnsafeFunctionAliasCallRejected() throws (testing::TestError) {
@test unsafe fn testUnsafeFunctionAliasCallRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "unsafe fn dangerous() -> u32 { return 42; } fn run() -> u32 { let alias = dangerous; return alias(); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnsafeCall);
}

/// References cannot be embedded in aggregate fields.
@test fn testRefFieldRejected() throws (testing::TestError) {
@test unsafe fn testRefFieldRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Once {} record Bad { value: &u32 }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
}

/// Trait methods may use reference receivers.
@test fn testTraitRefReceiver() throws (testing::TestError) {
@test unsafe fn testTraitRefReceiver() throws (testing::TestError) {
    let program = "record Marker: Once {} record Value { number: i32 } trait Read { fn (&Read) get() -> i32; } instance Read for Value { fn (value: &Value) get() -> i32 { return value.number; } } fn inspect(object: &opaque Read) -> i32 { return object.get(); } fn call(value: &Value) -> i32 { return inspect(value); }";
    try expectAnalyzeOk(program);
}

/// Trait implementations must preserve the receiver pointer class.
@test fn testTraitReceiverClassMismatch() throws (testing::TestError) {
@test unsafe fn testTraitReceiverClassMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Value { number: i32 } trait Read { fn (&Read) get() -> i32; } instance Read for Value { fn (value: *Value) get() -> i32 { return value.number; } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TraitReceiverMismatch);
}

/// Unmarked composite values may be discarded.
@test fn testAffineCompositeMayBeDiscarded() throws (testing::TestError) {
@test unsafe fn testAffineCompositeMayBeDiscarded() throws (testing::TestError) {
    let program = "record Value { number: u32 } fn run() { let value = Value { number: 1 }; }";
    try expectAnalyzeOk(program);
}

/// A by-value use moves an unmarked composite value.
@test fn testAffineCompositeUseAfterMoveRejected() throws (testing::TestError) {
@test unsafe fn testAffineCompositeUseAfterMoveRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Value { number: u32 } fn take(value: Value) {} fn run() { let value = Value { number: 1 }; take(value); take(value); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::AffineUseAfterMove("value"));
}

/// Affine values may move on only one branch when not used later.
@test fn testAffineConditionalMoveMayBeDiscarded() throws (testing::TestError) {
@test unsafe fn testAffineConditionalMoveMayBeDiscarded() throws (testing::TestError) {
    let program = "record Value { number: u32 } fn take(value: Value) {} fn run(condition: bool) { let value = Value { number: 1 }; if condition { take(value); } }";
    try expectAnalyzeOk(program);
}

/// A `Copy` composite remains available after a by-value use.
@test fn testCopyCompositeMayBeReused() throws (testing::TestError) {
@test unsafe fn testCopyCompositeMayBeReused() throws (testing::TestError) {
    let program = "record Value: Copy { number: u32 } fn take(value: Value) {} fn run() { let value = Value { number: 1 }; take(value); take(value); }";
    try expectAnalyzeOk(program);
}

/// A `Copy` composite may contain only copy values.
@test fn testCopyCompositeRejectsAffineField() throws (testing::TestError) {
@test unsafe fn testCopyCompositeRejectsAffineField() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Inner { number: u32 } record Outer: Copy { inner: Inner }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::CopyContainsNonCopy);
}

/// A composite cannot carry conflicting ownership markers.
@test fn testConflictingOwnershipMarkersRejected() throws (testing::TestError) {
@test unsafe fn testConflictingOwnershipMarkersRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Value: Copy + Once { number: u32 }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ConflictingOwnershipMarkers);
}

/// Linear composites still require one consuming use.
@test fn testLinearCompositeMustBeConsumed() throws (testing::TestError) {
@test unsafe fn testLinearCompositeMustBeConsumed() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Token: Once { number: u32 } fn run() { let token = Token { number: 1 }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::LinearNotConsumed("token"));
}

/// The compiler-known marker cannot be derived more than once.
@test fn testDuplicateOnceMarkerRejected() throws (testing::TestError) {
@test unsafe fn testDuplicateOnceMarkerRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Token: Once + Once { value: u32 }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("Once"));
}

/// A `Once` marker does not change legacy pointer inference.
@test fn testOnceMarkerKeepsLegacyPointerInference() throws (testing::TestError) {
    let program = "record Marker: Once {} fn run() { let value: u32 = 0; let pointer: *u32 = &value; pointer; }";
    try expectAnalyzeOk(program);
/// Stack storage cannot produce a safe stored pointer or slice.
@test unsafe fn testStackPointerRejected() throws (testing::TestError) {
    let programs = &[
        "fn run() { let value: u32 = 0; let pointer: *u32 = &value; }",
        "fn run() -> *u32 { let value: u32 = 0; return &value; }",
        "fn run(value: u32) -> *u32 { return &value; }",
        "record Cell { value: u32 } fn run() { let cell = Cell { value: 1 }; let pointer: *u32 = &cell.value; }",
        "fn run() { let values = [1, 2]; let pointer: *i32 = &values[0]; }",
        "fn run() { let values = [1, 2]; let slice: *[i32] = &values[..]; }",
        "fn run(value: i32) { let slice: *[i32] = &[value]; }",
        "fn run(value: &u32) -> *u32 { return value; }",
        "fn run(value: &u32) -> *u32 { return &*value; }",
        "fn run(values: &[u32]) -> *[u32] { return values; }",
        "fn run(values: &[u32]) -> *[u32] { return &values[..]; }",
        "fn run(values: &[u32]) -> *u32 { return values.ptr; }",
        "fn run() -> *i32 { return &[1, 2][0]; }",
        "fn run() -> *[i32] { return &[1, 2][..]; }",
        "fn run(value: *u32) -> **u32 { return &value; }",
        "fn run(values: *[u32]) -> *u32 { return &values.len; }",
        "unsafe fn run(value: *unsafe u32) -> *u32 { return &*value; }",
        "fn run() { let value: u32 = 7; let pointer: *unsafe u32 = &value; }",
        "record Cell { value: u32 } fn run(value: &Cell) -> *u32 { return &value.value; }",
        "record Cell { value: *u32 } fn run(value: &u32) -> Cell { return Cell { value }; }",
        "fn run(value: &u32) -> *[u32] { return @sliceOf(value, 1); }",
    ];
    for program in programs {
        let mut resolver = testResolver();
        let result = try resolveProgramStr(&mut resolver, program);
        let _ = try expectError(&result);
    }
}

/// Stack values can be borrowed for a call.
@test unsafe fn testStackBorrowAllowed() throws (testing::TestError) {
    try expectAnalyzeOk("fn read(value: &u32) -> u32 { return *value; } fn run() -> u32 { let value: u32 = 7; return read(&value); }");
    try expectAnalyzeOk("fn write(values: &mut [u32]) { set values[0] = 7; } fn run() { let mut values: [u32; 2] = [1, 2]; write(&mut values[..]); }");
}

/// Unsafe declarations can store raw pointers to stack values.
@test unsafe fn testUnsafeStackPointerAllowed() throws (testing::TestError) {
    try expectAnalyzeOk("unsafe fn run() { let mut value: u32 = 0; let pointer: *unsafe mut u32 = &mut value as *unsafe mut u32; set *pointer = 7; }");
    try expectAnalyzeOk("unsafe fn run() { let mut values: [u32; 2] = [1, 2]; let slice: *unsafe mut [u32] = &mut values[..] as *unsafe mut [u32]; set slice[0] = 7; }");
    try expectAnalyzeOk("unsafe fn run() { let value: u32 = 7; let pointer: *unsafe u32 = &value; }");
    try expectAnalyzeOk("unsafe fn run() { let values: [u32; 2] = [1, 2]; let slice: *unsafe [u32] = &values[..]; }");
}

/// Permanent storage can produce safe stored pointers and slices.
@test unsafe fn testPermanentPointerAllowed() throws (testing::TestError) {
    try expectAnalyzeOk("static VALUE: u32 = 7; fn run() -> *u32 { return &VALUE; }");
    try expectAnalyzeOk("static VALUES: [u32; 2] = [1, 2]; fn run() -> *[u32] { return &VALUES[..]; }");
    try expectAnalyzeOk("fn run() -> *[u32] { return &[1, 2]; }");
    try expectAnalyzeOk("fn run(value: *u32) -> *u32 { return &*value; }");
    try expectAnalyzeOk("fn run(values: *[u32]) -> *[u32] { return &values[..]; }");
    try expectAnalyzeOk("record Cell { value: u32 } fn run(value: *Cell) -> *u32 { return &value.value; }");
    try expectAnalyzeOk("fn run(values: *[u32]) -> *u32 { return &values[0]; }");
    try expectAnalyzeOk("fn run(values: *[u32]) -> *u32 { return values.ptr; }");
    try expectAnalyzeOk("fn run(value: *u32) -> *[u32] { return @sliceOf(value, 1); }");
}

/// References are rejected from every nested or storable type position.
@test fn testNestedRefPositionsRejected() throws (testing::TestError) {
@test unsafe fn testNestedRefPositionsRejected() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "record Marker: Once {} union Bad { Value(&u32) }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);

        try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
    }
}

/// Function pointer parameter references remain call-scoped and valid.
@test fn testFunctionPointerRefParameterAllowed() throws (testing::TestError) {
@test unsafe fn testFunctionPointerRefParameterAllowed() throws (testing::TestError) {
    let program = "record Marker: Once {} fn invoke(callback: fn(&u32), value: &u32) { callback(value); }";
    try expectAnalyzeOk(program);
}

/// Pointer and slice casts cannot change reference ownership.
@test fn testRefCastClassPreserved() throws (testing::TestError) {
@test unsafe fn testRefCastClassPreserved() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn cast(value: &u32) { value as *u32; }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);

            else throw testing::TestError::Failed;
    }
}

/// Every operation that interprets an unsafe address requires an unsafe declaration.
@test fn testUnsafePointerOperationsRejected() throws (testing::TestError) {
@test unsafe fn testUnsafePointerOperationsRejected() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn cast(pointer: *unsafe u32) -> u64 { return pointer as u64; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);

        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    }
}

/// Unsafe declarations may compose unsafe operations and calls.
@test fn testUnsafePointerOperationsAllowed() throws (testing::TestError) {
@test unsafe fn testUnsafePointerOperationsAllowed() throws (testing::TestError) {
    let program = "record Marker: Once {} unsafe fn load(pointer: *unsafe u32) -> u32 { return *pointer; } unsafe fn run(pointer: *unsafe u32) -> u32 { let next = pointer + 1; let same = pointer == next; return load(pointer); }";
    try expectAnalyzeOk(program);
}

/// Unsafe code may drop a checked reference to an unsafe pointer.
@test fn testUnsafePointerFromReference() throws (testing::TestError) {
@test unsafe fn testUnsafePointerFromReference() throws (testing::TestError) {
    let program = "record Marker: Once {} unsafe fn store(pointer: *unsafe mut u32) { set *pointer = 42; } unsafe fn run() { let mut value: u32 = 0; store(&mut value as *unsafe mut u32); }";
    try expectAnalyzeOk(program);
}

/// Dropping a reference to an unsafe pointer cannot add mutability.
@test fn testUnsafePointerCastCannotAddMutability() throws (testing::TestError) {
@test unsafe fn testUnsafePointerCastCannotAddMutability() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Once {} unsafe fn run(value: &u32) { value as *unsafe mut u32; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::InvalidAsCast(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Recursive cast validation cannot hide a checked-to-unsafe transition.
@test fn testNestedUnsafePointerCastRejected() throws (testing::TestError) {
@test unsafe fn testNestedUnsafePointerCastRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Once {} fn run(value: **u32) { value as **unsafe u32; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::InvalidAsCast(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Unsafe code may drop a checked slice reference to an unsafe slice.
@test fn testUnsafeSliceFromReference() throws (testing::TestError) {
@test unsafe fn testUnsafeSliceFromReference() throws (testing::TestError) {
    let program = "record Marker: Once {} unsafe fn run(values: &[u32]) { let raw: *unsafe [u32] = values as *unsafe [u32]; }";
    try expectAnalyzeOk(program);
}

/// Slice casts cannot add mutability.
@test fn testSliceCastCannotAddMutability() throws (testing::TestError) {
@test unsafe fn testSliceCastCannotAddMutability() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Once {} fn run(values: &[u32]) { values as &mut [u32]; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::InvalidAsCast(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Mutable unsafe receivers do not create checked exclusive loans.
@test fn testUnsafeReceiverDoesNotBorrowExclusively() throws (testing::TestError) {
@test unsafe fn testUnsafeReceiverDoesNotBorrowExclusively() throws (testing::TestError) {
    let program = "record Marker: Once {} record Value { number: u32 } unsafe fn (value: *unsafe mut Value) update(other: *unsafe mut Value) {} unsafe fn run(value: *unsafe mut Value) { value.update(value); }";
    try expectAnalyzeOk(program);
}

/// Unsafe instance-method attributes enable unsafe operations in the body.
@test fn testUnsafeInstanceMethodBody() throws (testing::TestError) {
@test unsafe fn testUnsafeInstanceMethodBody() throws (testing::TestError) {
    let program = "record Marker: Once {} record Value { number: u32 } trait Read { unsafe fn (*unsafe Read) get() -> u32; } instance Read for Value { unsafe fn (value: *unsafe Value) get() -> u32 { return value.number; } }";
    try expectAnalyzeOk(program);
}

/// Unsafe instance methods cannot implement safe trait contracts.
@test fn testUnsafeInstanceMethodSafetyMismatch() throws (testing::TestError) {
@test unsafe fn testUnsafeInstanceMethodSafetyMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Value {} trait Read { fn (&Read) get(); } instance Read for Value { unsafe fn (value: &Value) get() {} }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TraitMethodSafetyMismatch);
}

/// Unsafe trait methods retain their call-site requirement through dispatch.
@test fn testUnsafeTraitMethodCallRejected() throws (testing::TestError) {
@test unsafe fn testUnsafeTraitMethodCallRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Once {} record Value { number: u32 } trait Read { unsafe fn (&Read) get() -> u32; } instance Read for Value { unsafe fn (value: &Value) get() -> u32 { return value.number; } } fn inspect(object: &opaque Read) -> u32 { return object.get(); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnsafeCall);
}

/// An unsafe callback retains its requirement at an indirect call.
@test unsafe fn testUnsafeCallbackCallRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a,
        "fn run(callback: unsafe fn() -> u32) -> u32 { return callback(); }");
    try expectErrorKind(&result, super::ErrorKind::UnsafeCall);
}

/// An unsafe function cannot enter a safe callback slot.
@test unsafe fn testUnsafeCallbackAssignmentRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a,
        "unsafe fn load() -> u32 { return 1; } fn run() { let callback: fn() -> u32 = load; }");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// A safe function can enter an unsafe callback slot.
@test unsafe fn testSafeCallbackIntoUnsafeSlot() throws (testing::TestError) {
    try expectAnalyzeOk(
        "fn load() -> u32 { return 1; } unsafe fn run() -> u32 { let callback: unsafe fn() -> u32 = load; return callback(); }");
}

/// Borrowed callback storage must preserve its function safety type.
@test unsafe fn testBorrowedCallbackSafetyInvariant() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a,
        "fn replace(slot: &mut unsafe fn()) {} fn load() {} fn run() { let mut callback: fn() = load; replace(&mut callback); }");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

lib/std/lang/scanner.rad +13 -13


    return Scanner { sourceLoc, source, token: 0, cursor: 0, pool };
}

/// Check if we've reached the end of input.
export fn isEof(s: *Scanner) -> bool {
export fn isEof(s: &Scanner) -> bool {
    return s.cursor >= s.source.len;
}

/// Get the current character, if any.
export fn current(s: *Scanner) -> ?u8 {
export fn current(s: &Scanner) -> ?u8 {
    if isEof(s) {
        return nil;
    }
    return s.source[s.cursor];
}

/// Peek at the next character without advancing the scanner.
fn peek(s: *Scanner) -> ?u8 {
fn peek(s: &Scanner) -> ?u8 {
    if s.cursor + 1 >= s.source.len {
        return nil;
    }
    return s.source[s.cursor + 1];
}

/// Advance scanner and return the character that was consumed.
fn advance(s: *mut Scanner) -> u8 {
fn advance(s: &mut Scanner) -> u8 {
    let ch = s.source[s.cursor];
    set s.cursor += 1;
    return ch;
}

/// Consume the expected character if it matches the current position.
fn consume(s: *mut Scanner, expected: u8) -> bool {
fn consume(s: &mut Scanner, expected: u8) -> bool {
    if let c = current(s); c == expected {
        advance(s);
        return true;
    }
    return false;
}

/// Create a token from the current scanner state.
fn tok(s: *Scanner, kind: TokenKind) -> Token {
fn tok(s: &Scanner, kind: TokenKind) -> Token {
    return Token { kind, source: &s.source[s.token..s.cursor], offset: s.token };
}

/// Create an invalid token with the given message.
export fn invalid(offset: u32, message: *[u8]) -> Token {
    return Token { kind: TokenKind::Invalid, source: message, offset };
}

/// Skip whitespace characters and line comments.
fn skipWhitespace(s: *mut Scanner) {
fn skipWhitespace(s: &mut Scanner) {
    while let ch = current(s) {
        match ch {
            case ' ', '\n', '\r', '\t' => advance(s),
            case '/' => {
                if let c = peek(s); c == '/' {

        }
    }
}

/// Scan numeric literal (decimal, hex, or binary).
fn scanNumber(s: *mut Scanner) -> Token {
fn scanNumber(s: &mut Scanner) -> Token {
    // Check for hex literal (`0x` or `0X` prefix).
    if s.source[s.cursor - 1] == '0' {
        if let ch = current(s); ch == 'x' or ch == 'X' {
            advance(s);
            // Must have at least one hex digit after `0x`.

        }
    }
    return tok(s, TokenKind::Number);
}

fn scanDelimited(s: *mut Scanner, delim: u8, kind: TokenKind) -> ?Token {
fn scanDelimited(s: &mut Scanner, delim: u8, kind: TokenKind) -> ?Token {
    while let ch = current(s); ch <> delim {
        if not char::isPrint(ch) {
            return invalid(s.token, "invalid character");
        }
        if consume(s, '\\') { // Consume escapes

    }
    return tok(s, kind);
}

/// Scan string literal enclosed in double quotes.
fn scanString(s: *mut Scanner) -> Token {
fn scanString(s: &mut Scanner) -> Token {
    if let tok = scanDelimited(s, '"', TokenKind::String) {
        return tok;
    }
    return invalid(s.token, "unterminated string");
}

/// Scan character literal enclosed in single quotes.
fn scanChar(s: *mut Scanner) -> Token {
fn scanChar(s: &mut Scanner) -> Token {
    if let tok = scanDelimited(s, '\'', TokenKind::Char) {
        return tok;
    }
    return invalid(s.token, "unterminated character");
}

    }
    return TokenKind::Ident;
}

/// Scan an identifier, keyword, or label.
fn scanIdentifier(s: *mut Scanner) -> Token {
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 tok(s, kind);
}

/// Scan the next token.
export fn next(s: *mut Scanner) -> Token {
export 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/sexpr.rad +14 -14

/// 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: *mut u32 },
    Buffer { buf: *mut [u8], pos: *unsafe mut u32 },
}

/// An S-expression element.
export union Expr: Copy {
    /// An empty expression.

    /// A block with a name, inline items, and child statements on separate lines.
    Block { name: *[u8], items: *[Expr], children: *[Expr] },
}

/// Allocate an array of Expr in the arena.
export fn allocExprs(arena: *mut alloc::Arena, len: u32) -> *mut [Expr] throws (alloc::AllocError) {
export fn allocExprs(arena: &mut alloc::Arena, len: u32) -> *mut [Expr] throws (alloc::AllocError) {
    if len == 0 {
        throw alloc::AllocError::OutOfMemory;
    }
    let ptr = try alloc::allocSlice(arena, @sizeOf(Expr), @alignOf(Expr), len);
    return ptr as *mut [Expr];
}

/// Allocate and copy items into the arena.
export fn allocItems(a: *mut alloc::Arena, items: *[Expr]) -> *[Expr] {
export fn allocItems(a: &mut alloc::Arena, items: &[Expr]) -> *[Expr] {
    if items.len == 0 {
        return &[];
    }
    let buf = try! allocExprs(a, items.len);
    for item, i in items {

export fn str(s: *[u8]) -> Expr {
    return Expr::Str(s);
}

/// Shorthand for creating a list.
export fn list(a: *mut alloc::Arena, head: *[u8], tail: *[Expr]) -> Expr {
export fn list(a: &mut alloc::Arena, head: *[u8], tail: &[Expr]) -> Expr {
    return Expr::List { head, tail: allocItems(a, tail), multiline: false };
}

/// Shorthand for creating a bracket-delimited vector.
export fn vec(a: *mut alloc::Arena, items: *[Expr]) -> Expr {
export fn vec(a: &mut alloc::Arena, items: &[Expr]) -> Expr {
    return Expr::Vec { items: allocItems(a, items) };
}

/// Shorthand for creating a block with inline items and child expressions.
export fn block(a: *mut alloc::Arena, name: *[u8], items: *[Expr], children: *[Expr]) -> Expr {
export fn block(a: &mut alloc::Arena, name: *[u8], items: &[Expr], children: &[Expr]) -> Expr {
    return Expr::Block { name, items: allocItems(a, items), children: allocItems(a, children) };
}

/// Write a string to the output target.
export fn write(out: *mut Output, s: *[u8]) {
export unsafe fn write(out: &mut Output, s: &[u8]) {
    match *out {
        case Output::Stdout => io::print(s),
        case Output::Buffer { buf, pos } => {
            let remaining = buf.len - *pos;
            let toWrite = remaining if s.len > remaining else s.len;

        }
    }
}

/// Emit indentation to the output target.
fn indentTo(out: *mut Output, depth: u32) {
unsafe fn indentTo(out: &mut Output, depth: u32) {
    for _ in 0..depth {
        write(out, "  ");
    }
}

/// Print a single character with escaping to the output target.
export fn printEscapedTo(out: *mut Output, c: u8) {
export unsafe fn printEscapedTo(out: &mut Output, c: u8) {
    match c {
        case '\n' => write(out, "\\n"),
        case '\r' => write(out, "\\r"),
        case '\t' => write(out, "\\t"),
        case '\\' => write(out, "\\\\"),

        else => write(out, &[c]),
    }
}

/// Print a quoted string with escape sequences to the output target.
export fn printStringTo(out: *mut Output, s: *[u8]) {
export unsafe fn printStringTo(out: &mut Output, s: &[u8]) {
    write(out, "\"");
    for i in 0..s.len {
        printEscapedTo(out, s[i]);
    }
    write(out, "\"");
}

/// Print a character literal with escape sequences to the output target.
export fn printCharTo(out: *mut Output, c: u8) {
export unsafe fn printCharTo(out: &mut Output, c: u8) {
    write(out, "'");
    printEscapedTo(out, c);
    write(out, "'");
}

/// Print an S-expression to the given output target at the given depth.
export fn printTo(expr: Expr, depth: u32, out: *mut Output) {
export unsafe fn printTo(expr: Expr, depth: u32, out: &mut Output) {
    match expr {
        case Expr::Null => {},
        case Expr::Sym(s) => write(out, s),
        case Expr::Str(s) => printStringTo(out, s),
        case Expr::Char(c) => printCharTo(out, c),

        }
    }
}

/// Print an S-expression to stdout at the given indentation depth.
export fn print(expr: Expr, depth: u32) {
export unsafe fn print(expr: Expr, depth: u32) {
    let mut out = Output::Stdout;
    printTo(expr, depth, &mut out);
}

/// Emit indentation for `depth` levels to stdout.
export fn indent(depth: u32) {
export unsafe fn indent(depth: u32) {
    let mut out = Output::Stdout;
    indentTo(&mut out, depth);
}


lib/std/mem.rad +4 -4

    /// Buffer is too small.
    BufferTooSmall,
}

/// Copy bytes between two slices. Returns the number of bytes copied.
export fn copy(into: *mut [u8], from: *[u8]) -> u32 throws (MemoryError) {
export fn copy(into: &mut [u8], from: &[u8]) -> u32 throws (MemoryError) {
    if into.len < from.len {
        throw MemoryError::BufferTooSmall;
    }
    for x, i in from {
        set into[i] = x;

    return from.len;
}

/// Strip a byte-level prefix from the input, and return the suffix.
/// Returns `nil` if the prefix wasn't found.
export fn stripPrefix(prefix: *[u8], input: *[u8]) -> ?*[u8] {
export fn stripPrefix(prefix: &[u8], input: *[u8]) -> ?*[u8] {
    if prefix.len == 0 {
        return input;
    }
    if prefix.len > input.len {
        return nil;

    }
    return count;
}

/// Check whether two byte slices have the same length and contents.
export fn eq(a: *[u8], b: *[u8]) -> bool {
export fn eq(a: &[u8], b: &[u8]) -> bool {
    if a.len <> b.len {
        return false;
    }
    if a.ptr == b.ptr {
        return true;

}

/// Compare two byte slices lexicographically.
///
/// Returns `-1` when `a < b`, `1` when `a > b`, and `0` when equal.
export fn cmp(a: *[u8], b: *[u8]) -> i32 {
export fn cmp(a: &[u8], b: &[u8]) -> i32 {
    let aLen = a.len;
    let bLen = b.len;

    let common = bLen if bLen < aLen else aLen;
    for i in 0..common {

lib/std/sys/unix.rad +18 -14

/// Special value representing current working directory for `openat()`.
constant AT_FDCWD: i64 = -100;

/// Opens a file at the given path and returns a file descriptor.
/// Returns a negative value on error.
export fn open(path: *[u8], flags: OpenFlags) -> i64 {
export fn open(path: &[u8], flags: OpenFlags) -> i64 {
    return intrinsics::ecall(56, AT_FDCWD, path.ptr as i64, *flags, 0);
}

/// Opens a file at the given path with mode, returns a file descriptor.
export fn openOpts(path: *[u8], flags: OpenFlags, mode: i64) -> i64 {
export fn openOpts(path: &[u8], flags: OpenFlags, mode: i64) -> i64 {
    return intrinsics::ecall(56, AT_FDCWD, path.ptr as i64, *flags, mode);
}

/// Reads from a file descriptor into the provided buffer.
/// Returns the number of bytes read, or a negative value on error.
export fn read(fd: i64, buf: *mut [u8]) -> i64 {
export fn read(fd: i64, buf: &mut [u8]) -> i64 {
    return intrinsics::ecall(63, fd, buf.ptr as i64, buf.len as i64, 0);
}

/// Reads from a file descriptor until EOF or buffer is full.
/// Returns the total number of bytes read, or a negative value on error.
export fn readToEnd(fd: i64, buf: *mut [u8]) -> i64 {
export fn readToEnd(fd: i64, buf: &mut [u8]) -> i64 {
    let mut total: u32 = 0;
    while total < buf.len {
        let chunk = &mut buf[total..];
        let n = read(fd, chunk);
        let n = read(fd, &mut buf[total..]);

        if n < 0 {
            return n;
        }
        if n == 0 {

    return total as i64;
}

/// Writes to a file descriptor from the provided buffer.
/// Returns the number of bytes written, or a negative value on error.
export fn write(fd: i64, buf: *[u8]) -> i64 {
export fn write(fd: i64, buf: &[u8]) -> i64 {
    return intrinsics::ecall(64, fd, buf.ptr as i64, buf.len as i64, 0);
}

/// Writes the entire contents of a buffer to a file descriptor.
/// Returns `false` when the descriptor cannot accept the full buffer.
export fn writeAll(fd: i64, data: *[u8]) -> bool {
export fn writeAll(fd: i64, data: &[u8]) -> bool {
    let mut written: u32 = 0;
    while written < data.len {
        let n = write(fd, &data[written..]);
        if n <= 0 {
            return false;

export fn close(fd: i64) -> i64 {
    return intrinsics::ecall(57, fd, 0, 0, 0);
}

/// Reads the entire contents of a file at the given path into the provided buffer.
/// Returns a slice containing the data read, or `nil` on error.
export fn readFile(path: *[u8], buf: *mut [u8]) -> ?*[u8] {
/// Return the number of bytes read, or `nil` on error.
export fn readFile(path: &[u8], buf: &mut [u8]) -> ?u32 {
    let fd = open(path, O_RDONLY);
    if fd < 0 {
        return nil;
    }
    let n = readToEnd(fd, buf);

        return nil;
    }
    if n < 0 {
        return nil;
    }
    return &buf[..n as u32];
    return n as u32;
}

/// Exit the current process with the given status code.
export fn exit(status: i64) {
    intrinsics::ecall(93, status, 0, 0, 0);
}

/// Writes the entire contents of a buffer to a file at the given path.
/// Creates the file if it doesn't exist, truncates if it does.
/// Returns `true` on success.
export fn writeFile(path: *[u8], data: *[u8]) -> bool {
    return writeFileParts(path, &[data]);
export fn writeFile(path: &[u8], data: &[u8]) -> bool {
    let flags = OpenFlags(*O_WRONLY | *O_CREAT | *O_TRUNC);
    let fd = openOpts(path, flags, 420);
    if fd < 0 { return false; }
    let written = writeAll(fd, data);
    let closed = close(fd) == 0;
    return written and closed;
}

/// Writes each buffer to a file at the given path.
/// Creates the file if it doesn't exist, truncates if it does.
/// Returns `true` only when every part and the final close succeed.
export fn writeFileParts(path: *[u8], parts: *[*[u8]]) -> bool {
export fn writeFileParts(path: &[u8], parts: &[*[u8]]) -> bool {
    let flags = OpenFlags(*O_WRONLY | *O_CREAT | *O_TRUNC);
    let fd = openOpts(path, flags, 420); // 0644 in octal.
    if fd < 0 {
        return false;
    }

lib/std/testing.rad +8 -8


/// Descriptor for a single test case, holding its module path, name, and entry point.
export record TestInfo: Copy {
    module: *[u8],
    name: *[u8],
    func: fn() throws (TestError),
    func: unsafe fn() throws (TestError),
}

/// Construct a [`TestInfo`]. Used by the compiler's synthetic test harness.
export fn test(module: *[u8], name: *[u8], func: fn() throws (TestError)) -> TestInfo {
export fn test(module: *[u8], name: *[u8], func: unsafe fn() throws (TestError)) -> TestInfo {
    return TestInfo { module, name, func };
}

/// Run all tests and return `0` on success or `1` if any test failed.
export fn runAllTests(tests: *[TestInfo]) -> i32 {
export unsafe fn runAllTests(tests: &[TestInfo]) -> i32 {
    let mut ctx: Ctx = Ctx { passed: 0, failed: 0 };

    io::print("Running ");
    io::printU32(tests.len);
    io::print(" test(s)...\n\n");

        return 1;
    }
    return 0;
}

fn runTest(
    ctx: *mut Ctx,
unsafe fn runTest(
    ctx: &mut Ctx,
    module: *[u8],
    name: *[u8],
    testFn: fn () throws (TestError)
    testFn: unsafe fn() throws (TestError)
) {
    io::print("test ");
    io::print(module);
    io::print("::");
    io::print(name);

        io::printLn("FAILED");
        set ctx.failed += 1;
    }
}

fn printTestSummary(ctx: *Ctx) {
fn printTestSummary(ctx: &Ctx) {
    if (ctx.failed > 0) {
        io::print("\ntest result: FAILED. ");
        io::printU32(ctx.passed);
        io::print(" passed; ");
        io::printU32(ctx.failed);

        io::printLn(" passed; 0 failed");
    }
}

/// Assert that two byte slices are equal.
export fn expectBytesEq(left: *[u8], right: *[u8])
export fn expectBytesEq(left: &[u8], right: &[u8])
    throws (TestError)
{
    try expect(mem::eq(left, right));
}


lib/std/tests.rad +53 -53


// fmt /////////////////////////////////////////////////////////////////////////

@test fn testFormatU32Zero() throws (testing::TestError) {
    let mut buffer: [u8; 11] = [0; 11];
    let result: *[u8] = fmt::formatU32(0, &mut buffer[..]);
    try testing::expect(result.len == 1);
    try testing::expectBytesEq(result, "0");
    let start = fmt::formatU32(0, &mut buffer[..]);
    try testing::expect(buffer.len - start == 1);
    try testing::expectBytesEq(&buffer[start..], "0");
}

@test fn testFormatU32Basic() throws (testing::TestError) {
    let mut buffer: [u8; 11] = [0; 11];
    let result: *[u8] = fmt::formatU32(123, &mut buffer[..]);
    try testing::expect(result.len == 3);
    try testing::expectBytesEq(result, "123");
    let start = fmt::formatU32(123, &mut buffer[..]);
    try testing::expect(buffer.len - start == 3);
    try testing::expectBytesEq(&buffer[start..], "123");
}

@test fn testFormatU32Large() throws (testing::TestError) {
    let mut buffer: [u8; 11] = [0; 11];
    let result: *[u8] = fmt::formatU32(90000, &mut buffer[..]);
    try testing::expect(result.len == 5);
    try testing::expectBytesEq(result, "90000");
    let start = fmt::formatU32(90000, &mut buffer[..]);
    try testing::expect(buffer.len - start == 5);
    try testing::expectBytesEq(&buffer[start..], "90000");
}

@test fn testFormatU32Max() throws (testing::TestError) {
    let mut buffer: [u8; 11] = [0; 11];
    let result: *[u8] = fmt::formatU32(4294967295, &mut buffer[..]);
    try testing::expect(result.len == 10);
    try testing::expectBytesEq(result, "4294967295");
    let start = fmt::formatU32(4294967295, &mut buffer[..]);
    try testing::expect(buffer.len - start == 10);
    try testing::expectBytesEq(&buffer[start..], "4294967295");
}

@test fn testFormatI32Positive() throws (testing::TestError) {
    let mut buffer: [u8; 11] = [0; 11];
    let result: *[u8] = fmt::formatI32(456, &mut buffer[..]);
    try testing::expect(result.len == 3);
    try testing::expectBytesEq(result, "456");
    let start = fmt::formatI32(456, &mut buffer[..]);
    try testing::expect(buffer.len - start == 3);
    try testing::expectBytesEq(&buffer[start..], "456");
}

@test fn testFormatI32Negative() throws (testing::TestError) {
    let mut buffer: [u8; 11] = [0; 11];
    let result: *[u8] = fmt::formatI32(-789, &mut buffer[..]);
    try testing::expect(result.len == 4);
    try testing::expectBytesEq(result, "-789");
    let start = fmt::formatI32(-789, &mut buffer[..]);
    try testing::expect(buffer.len - start == 4);
    try testing::expectBytesEq(&buffer[start..], "-789");
}

@test fn testFormatI32Zero() throws (testing::TestError) {
    let mut buffer: [u8; 11] = [0; 11];
    let result: *[u8] = fmt::formatI32(0, &mut buffer[..]);
    try testing::expect(result.len == 1);
    try testing::expectBytesEq(result, "0");
    let start = fmt::formatI32(0, &mut buffer[..]);
    try testing::expect(buffer.len - start == 1);
    try testing::expectBytesEq(&buffer[start..], "0");
}

@test fn testFormatI32Max() throws (testing::TestError) {
    let mut buffer: [u8; 11] = [0; 11];
    let result: *[u8] = fmt::formatI32(2147483647, &mut buffer[..]);
    try testing::expect(result.len == 10);
    try testing::expectBytesEq(result, "2147483647");
    let start = fmt::formatI32(2147483647, &mut buffer[..]);
    try testing::expect(buffer.len - start == 10);
    try testing::expectBytesEq(&buffer[start..], "2147483647");
}

@test fn testFormatI32Min() throws (testing::TestError) {
    let mut buffer: [u8; 11] = [0; 11];
    let result: *[u8] = fmt::formatI32(-2147483648, &mut buffer[..]);
    try testing::expect(result.len == 11);
    try testing::expectBytesEq(result, "-2147483648");
    let start = fmt::formatI32(-2147483648, &mut buffer[..]);
    try testing::expect(buffer.len - start == 11);
    try testing::expectBytesEq(&buffer[start..], "-2147483648");
}

@test fn testFormatU64Zero() throws (testing::TestError) {
    let mut buffer: [u8; 20] = [0; 20];
    let result: *[u8] = fmt::formatU64(0, &mut buffer[..]);
    try testing::expect(result.len == 1);
    try testing::expectBytesEq(result, "0");
    let start = fmt::formatU64(0, &mut buffer[..]);
    try testing::expect(buffer.len - start == 1);
    try testing::expectBytesEq(&buffer[start..], "0");
}

@test fn testFormatU64Max() throws (testing::TestError) {
    let mut buffer: [u8; 20] = [0; 20];
    let result: *[u8] = fmt::formatU64(18446744073709551615, &mut buffer[..]);
    try testing::expect(result.len == 20);
    try testing::expectBytesEq(result, "18446744073709551615");
    let start = fmt::formatU64(18446744073709551615, &mut buffer[..]);
    try testing::expect(buffer.len - start == 20);
    try testing::expectBytesEq(&buffer[start..], "18446744073709551615");
}

@test fn testFormatI64Negative() throws (testing::TestError) {
    let mut buffer: [u8; 20] = [0; 20];
    let result: *[u8] = fmt::formatI64(-9876543210, &mut buffer[..]);
    try testing::expect(result.len == 11);
    try testing::expectBytesEq(result, "-9876543210");
    let start = fmt::formatI64(-9876543210, &mut buffer[..]);
    try testing::expect(buffer.len - start == 11);
    try testing::expectBytesEq(&buffer[start..], "-9876543210");
}

@test fn testFormatI64Min() throws (testing::TestError) {
    let mut buffer: [u8; 20] = [0; 20];
    let result: *[u8] = fmt::formatI64(-9223372036854775808, &mut buffer[..]);
    try testing::expect(result.len == 20);
    try testing::expectBytesEq(result, "-9223372036854775808");
    let start = fmt::formatI64(-9223372036854775808, &mut buffer[..]);
    try testing::expect(buffer.len - start == 20);
    try testing::expectBytesEq(&buffer[start..], "-9223372036854775808");
}

@test fn testParseIntLiteralText() throws (testing::TestError) {
    let dec = try fmt::parseInt("123") catch {
        throw testing::TestError::Failed;

        throw testing::TestError::Failed;
    }
    let data = unix::readFile(path, &mut buffer[..]) else {
        throw testing::TestError::Failed;
    };
    try testing::expectBytesEq(data, "hello world");
    try testing::expectBytesEq(&buffer[..data], "hello world");
}

@test fn testStripPrefixMatch() throws (testing::TestError) {
    let input: *[u8] = "hello world";
    let prefix: *[u8] = "hello";

    try testing::expect(mem::cmp("abcd", "abc") > 0);
}

// vec /////////////////////////////////////////////////////////////////////////

@test fn testVecInitialState() throws (testing::TestError) {
@test unsafe fn testVecInitialState() throws (testing::TestError) {
    let mut arena: [u8; 16] align(4) = undefined;
    let mut v = vec::new(&mut arena[..], @sizeOf(i32), @alignOf(i32));

    try testing::expect(vec::len(&v) == 0);
    try testing::expect(vec::capacity(&v) == 4);
}

@test fn testVecPushAndGet() throws (testing::TestError) {
@test unsafe fn testVecPushAndGet() throws (testing::TestError) {
    let mut arena: [u8; 16] align(4) = undefined;
    let mut v = vec::new(&mut arena[..], @sizeOf(i32), @alignOf(i32));

    let val1: i32 = 42;
    try testing::expect(vec::push(&mut v, &val1));
    try testing::expect(vec::len(&v) == 1);

    let ptr = vec::get(&v, 0) else {
        throw testing::TestError::Failed;
    };
    let i32ptr: *i32 = ptr as *i32;
    let i32ptr: *unsafe i32 = ptr as *unsafe i32;
    let value: i32 = *i32ptr;
    try testing::expect(value == 42);
}

@test fn testVecPushPop() throws (testing::TestError) {
@test unsafe fn testVecPushPop() throws (testing::TestError) {
    let mut arena: [u8; 16] align(4) = undefined;
    let mut v = vec::new(&mut arena[..], @sizeOf(i32), @alignOf(i32));

    let val1: i32 = 42;
    let val2: i32 = 100;

    try testing::expect(vec::len(&v) == 0);

    try testing::expectNot(vec::pop(&mut v, &mut popped));
}

@test fn testVecGetSet() throws (testing::TestError) {
@test unsafe fn testVecGetSet() throws (testing::TestError) {
    let mut arena: [u8; 32] align(4) = undefined;
    let mut v = vec::new(&mut arena[..], @sizeOf(i32), @alignOf(i32));

    let val1: i32 = 10;
    let val2: i32 = 20;

    vec::push(&mut v, &val1);
    vec::push(&mut v, &val2);
    vec::push(&mut v, &val3);

    if let ptr = vec::get(&v, 0) {
        let value: i32 = *(ptr as *i32);
        let value: i32 = *(ptr as *unsafe i32);
        try testing::expect(value == 10);
    } else {
        throw testing::TestError::Failed;
    }

    if let ptr = vec::get(&v, 1) {
        let value: i32 = *(ptr as *i32);
        let value: i32 = *(ptr as *unsafe i32);
        try testing::expect(value == 20);
    } else {
        throw testing::TestError::Failed;
    }

    if let ptr = vec::get(&v, 2) {
        let value: i32 = *(ptr as *i32);
        let value: i32 = *(ptr as *unsafe i32);
        try testing::expect(value == 30);
    } else {
        throw testing::TestError::Failed;
    }
    try testing::expect(vec::get(&v, 3) == nil);

    let new: i32 = 999;
    try testing::expect(vec::put(&mut v, 1, &new));

    if let ptr = vec::get(&v, 1) {
        let value: i32 = *(ptr as *i32);
        let value: i32 = *(ptr as *unsafe i32);
        try testing::expect(value == 999);
    } else {
        throw testing::TestError::Failed;
    }
    try testing::expectNot(vec::put(&mut v, 5, &new));
}

@test fn testVecCapacity() throws (testing::TestError) {
@test unsafe fn testVecCapacity() throws (testing::TestError) {
    let mut arena: [u8; 16] align(4) = undefined;
    let mut v = vec::new(&mut arena[..], @sizeOf(i32), @alignOf(i32));

    let val: i32 = 7;
    try testing::expect(vec::push(&mut v, &val));


    try testing::expectNot(vec::push(&mut v, &val));
    try testing::expect(vec::len(&v) == 4);
}

@test fn testVecReset() throws (testing::TestError) {
@test unsafe fn testVecReset() throws (testing::TestError) {
    let mut arena: [u8; 16] align(4) = undefined;
    let mut v = vec::new(&mut arena[..], @sizeOf(i32), @alignOf(i32));

    let val: i32 = 123;
    vec::push(&mut v, &val);


    try testing::expect(vec::push(&mut v, &val));
    try testing::expect(vec::len(&v) == 1);
}

@test fn testVecStruct() throws (testing::TestError) {
@test unsafe fn testVecStruct() throws (testing::TestError) {
    let mut arena: [u8; 64] align(4) = undefined;
    let mut v = vec::new(&mut arena[..], @sizeOf(Point), @alignOf(Point));

    let p1: Point = Point { x: 1, y: 2 };
    let p2: Point = Point { x: 3, y: 4 };

    try testing::expect(vec::push(&mut v, &p1));
    try testing::expect(vec::push(&mut v, &p2));

    if let ptr = vec::get(&v, 0) {
        let p: *Point = ptr as *Point;
        let p: *unsafe Point = ptr as *unsafe Point;
        try testing::expect(p.x == 1);
        try testing::expect(p.y == 2);
    } else {
        throw testing::TestError::Failed;
    }

lib/std/vec.rad +22 -30

//! Raw vector: type-unsafe dynamic array backed by static storage.
//! Raw vector backed by caller-managed storage.
//!
//! Users provide their own arena (static array) and the vector manages
//! Users provide their own storage and the vector manages
//! element count within that arena. The arena should be aligned according
//! to the element type's requirements.

/// Raw vector metadata structure.
///
/// Does not own storage, points to user-provided arena.
export record RawVec: Copy {
    /// Pointer to user-provided byte arena.
    data: *mut [u8],
    data: *unsafe mut [u8],
    /// Current number of elements stored.
    len: u32,
    /// Size of each element in bytes (stride between elements).
    stride: u32,
    /// Alignment in bytes required by element type (>= 1).
    alignment: u32,
}

/// Create a new raw vector with external arena.
///
/// * `arena` is a pointer to static array backing storage.
/// * `arena` must outlive the vector and all returned element pointers.
/// * `stride` is the size of each element.
/// * `alignment` is the required alignment for elements.
export fn new(arena: *mut [u8], stride: u32, alignment: u32) -> RawVec {
export unsafe fn new(arena: &mut [u8], stride: u32, alignment: u32) -> RawVec {
    assert stride > 0;
    assert alignment > 0;
    assert (arena.ptr as u32) % alignment == 0;
    assert (arena.len % stride) == 0;

    return RawVec { data: arena, len: 0, stride, alignment };
    return RawVec { data: arena as *unsafe mut [u8], len: 0, stride, alignment };
}

/// Get the current number of elements in the vector.
export fn len(vec: *RawVec) -> u32 {
export fn len(vec: &RawVec) -> u32 {
    return vec.len;
}

/// Get the maximum capacity of the vector.
export fn capacity(vec: *RawVec) -> u32 {
export unsafe fn capacity(vec: &RawVec) -> u32 {
    return vec.data.len / vec.stride;
}

/// Reset the vector to empty (does not clear memory).
export fn reset(vec: *mut RawVec) {
export fn reset(vec: &mut RawVec) {
    set vec.len = 0;
}

/// Get a pointer to the element at the given index.
///
/// Returns nil if index is out of bounds.
export fn get(vec: *RawVec, index: u32) -> ?*opaque {
export unsafe fn get(vec: &RawVec, index: u32) -> ?*unsafe opaque {
    if index >= vec.len {
        return nil;
    }
    let offset: u32 = index * vec.stride;
    let ptr: *u8 = &vec.data[offset];
    let ptr: *unsafe u8 = &vec.data[offset];

    return ptr as *opaque;
    return ptr as *unsafe opaque;
}

/// Push an element onto the end of the vector.
///
/// Returns false if the vector is at capacity.
export fn push(vec: *mut RawVec, elem: *opaque) -> bool {
export unsafe fn push(vec: &mut RawVec, elem: &opaque) -> bool {
    if vec.len >= capacity(vec) {
        return false;
    }
    let off: u32 = vec.len * vec.stride;
    let dst: *mut u8 = &mut vec.data[off];
    let src: *u8 = elem as *u8;

    copyBytes(dst, src, vec.stride);
    copyBytes(&mut vec.data[off..off + vec.stride], @sliceOf(elem as &u8, vec.stride));
    set vec.len += 1;

    return true;
}

/// Pop an element from the end of the vector.
///
/// Copies the element into the provided output pointer.
/// Returns false if the vector is empty.
export fn pop(vec: *mut RawVec, out: *mut opaque) -> bool {
export fn pop(vec: &mut RawVec, out: &mut opaque) -> bool {
    if vec.len == 0 {
        return false;
    }
    set vec.len -= 1;

    let off: u32 = vec.len * vec.stride;
    let src: *u8 = &vec.data[off];
    let dst: *mut u8 = out as *mut u8;

    copyBytes(dst, src, vec.stride);
    copyBytes(@sliceOf(out as &mut u8, vec.stride), &vec.data[off..off + vec.stride]);

    return true;
}

/// Set the element at the given index.
///
/// Returns false if index is out of bounds.
export fn put(vec: *mut RawVec, index: u32, elem: *opaque) -> bool {
export fn put(vec: &mut RawVec, index: u32, elem: &opaque) -> bool {
    if index >= vec.len {
        return false;
    }
    let off: u32 = index * vec.stride;
    let dst: *mut u8 = &mut vec.data[off];
    let src: *u8 = elem as *u8;

    copyBytes(dst, src, vec.stride);
    copyBytes(&mut vec.data[off..off + vec.stride], @sliceOf(elem as &u8, vec.stride));

    return true;
}

/// Copy bytes from source to destination.
fn copyBytes(dst: *mut u8, src: *u8, count: u32) {
    for i in 0..count {
        set *(dst + i) = *(src + i);
fn copyBytes(dst: &mut [u8], src: &[u8]) {
    assert dst.len == src.len;
    for i in 0..src.len {
        set dst[i] = src[i];
    }
}

seed/radiance.rv64 +0 -0

Binary file changed.

seed/radiance.rv64.git +1 -1

1		-	1e2fdea952350036a4172f567442e608555094b9e18fa69f1fb615453d5352b6
	1	+	55e5d92edb60a10e44c67ba6bb5c2cc19f89ce22fd9c3c1c38c23fb2df718814

seed/update +1 -1

39	39		# ---------------------------------------------------------------------------
40	40		# Command line flags for Radiance compiler
41	41		# ---------------------------------------------------------------------------
42	42
43	43		STD_MODS="$(sed 's/^/-mod /' std.lib \| tr '\n' ' ')"
44		-	OPTS="-pkg std ${STD_MODS} -pkg radiance -mod compiler/radiance.rad -entry radiance"
	44	+	OPTS="-pkg std ${STD_MODS} -pkg radiance -mod compiler/radiance.rad -mod compiler/radiance/codegen.rad -entry radiance"
45	45
46	46		# ---------------------------------------------------------------------------
47	47		# Emulator settings
48	48		# ---------------------------------------------------------------------------
49	49

test/runner.rad +29 -16

    }
    return &line[..end];
}

/// Get next line from string at offset. Returns the line and updates offset past newline.
fn nextLine(s: *[u8], offset: *mut u32) -> *[u8] {
fn nextLine(s: *[u8], offset: &mut u32) -> *[u8] {
    let start = *offset;
    let mut i = start;

    while i < s.len and s[i] <> '\n' {
        set i += 1;

}

/// Derive the `.ril` path from a `.rad` source path. Returns nil if the path
/// does not end in `.rad` or the buffer is too small. The result is
/// null-terminated for use with syscalls.
fn deriveRilPath(sourcePath: *[u8], buf: *mut [u8]) -> ?*[u8] {
fn deriveRilPath(sourcePath: *[u8], buf: &mut [u8]) -> ?u32 {
    let len = sourcePath.len;
    if len < SOURCE_EXT.len {
        return nil;
    }
    let extStart = len - SOURCE_EXT.len;

    try mem::copy(&mut buf[extStart..len], SNAPSHOT_EXT) catch {
        return nil;
    };
    set buf[len] = 0;

    return &buf[..len];
    return len;
}

/// Write a self-contained RV64 image containing text and data sections.
fn writeImage(code: *[u32], roData: *[u8], rwData: *[u8], path: *[u8]) -> bool {
unsafe fn writeImage(
    code: *[u32],
    roData: *[u8],
    rwData: *[u8],
    path: *[u8]
) -> bool {
    let mut header = rv64::imageHeader(code.len * rv64::INSTR_SIZE as u32, roData.len, rwData.len);
    let headerWords = &header[..];
    let headerBytes = @sliceOf(headerWords.ptr as *u8, headerWords.len * rv64::WORD_SIZE as 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);

    return unix::writeFileParts(path, &[headerBytes, codeBytes, roData, rwData]);
    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)
        and unix::writeAll(fd, roData) and unix::writeAll(fd, rwData);
    let closed = unix::close(fd) == 0;
    return written and closed;
}

fn assembleBinary(sourcePath: *[u8], outputPath: *[u8]) -> bool {
    let source = unix::readFile(sourcePath, &mut SOURCE_BUF[..]) else {
unsafe fn assembleBinary(sourcePath: *[u8], outputPath: *[u8]) -> bool {
    let sourceLen = unix::readFile(sourcePath, &mut SOURCE_BUF[..]) else {
        io::printError("error: could not read source: ");
        io::printError(sourcePath);
        io::printError("\n");
        return false;
    };

    let source = &SOURCE_BUF[..sourceLen];
    let mut arena = alloc::new(&mut AST_ARENA_STORAGE[..]);
    let program = try asm::assemble(
        asm::scanner::SourceKind::File { path: sourcePath },
        source,
        &mut ASM_TEXT_STORAGE[..],

    }
    return true;
}

/// Run a single IL snapshot test case. Returns `true` on success.
fn runTest(sourcePath: *[u8]) -> bool {
unsafe fn runTest(sourcePath: *[u8]) -> bool {
    // Path buffer.
    let mut rilPathBuf: [u8; MAX_PATH_LEN] = undefined;
    let mut pkgScope: resolver::Scope = undefined;
    static pkgScope: resolver::Scope = undefined;

    // Derive .ril path from source path.
    let rilPath = deriveRilPath(sourcePath, &mut rilPathBuf[..]) else {
    let rilPathLen = deriveRilPath(sourcePath, &mut rilPathBuf[..]) else {
        io::print("error: invalid source path (must end in .rad): ");
        io::printLn(sourcePath);
        return false;
    };

    // Read expected IL.
    let expected = unix::readFile(rilPath, &mut EXPECTED_BUF[..]) else {
    let expectedLen = unix::readFile(&rilPathBuf[..rilPathLen], &mut EXPECTED_BUF[..]) else {
        io::print("error: could not read expected IL: ");
        io::printLn(rilPath);
        io::printLn(&rilPathBuf[..rilPathLen]);
        return false;
    };

    // Read source file.
    let source = unix::readFile(sourcePath, &mut SOURCE_BUF[..]) else {
    let sourceLen = unix::readFile(sourcePath, &mut SOURCE_BUF[..]) else {
        io::print("error: could not read source: ");
        io::printLn(sourcePath);
        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 {
        io::printLn("error: parsing failed");
        return false;


    return true;
}

/// Run a single test specified as an argument.
@default fn main(env: *sys::Env) -> i32 {
@default unsafe fn main(env: *sys::Env) -> i32 {
    let args = env.args;

    if args.len == 4 and mem::eq(args[1], "assemble") {
        if assembleBinary(args[2], args[3]) {
            return 0;

test/tests/array.aggregate.stride.rad +1 -1

fn arrayOfRecords(arr: [Point; 3], idx: u32) -> i32 {
    return arr[idx].x;
}

/// Take address of record in array.
fn addressOfRecord(arr: [Point; 3], idx: u32) -> *Point {
unsafe fn addressOfRecord(arr: [Point; 3], idx: u32) -> *unsafe Point {
    return &arr[idx];
}

/// Array of arrays (16 bytes per element).
fn arrayOfArrays(arr: [[i32; 4]; 3], idx: u32) -> i32 {

test/tests/array.slice.full.rad +1 -1

1	1		/// Creates a slice from an array with full range.
2		-	fn sliceFull(a: [i32; 4]) -> *[i32] {
	2	+	unsafe fn sliceFull(a: [i32; 4]) -> *unsafe [i32] {
3	3		return &a[..];
4	4		}

test/tests/array.slice.gen.end.rad +2 -2

//! returns: 0
@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut arr: [i32; 4] = [1, 2, 3, 4];
    let mut slice: *[i32] = &arr[..2];
    let mut slice: *unsafe [i32] = &arr[..2];

    return 0;
}

test/tests/array.slice.gen.index.rad +2 -2

//! returns: 0
@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut arr: [i32; 4] = [1, 2, 3, 4];
    let mut slice: *[i32] = &arr[1..];
    let mut slice: *unsafe [i32] = &arr[1..];

    return (slice[1]) - 3;
}

test/tests/array.slice.gen.open.rad +2 -2

//! returns: 0
@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut arr: [i32; 4] = [1, 2, 3, 4];
    let mut slice: *[i32] = &arr[..];
    let mut slice: *unsafe [i32] = &arr[..];

    return 0;
}

test/tests/array.slice.gen.start.end.rad +2 -2

//! returns: 0
@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut arr: [i32; 4] = [1, 2, 3, 4];
    let mut slice: *[i32] = &arr[1..3];
    let mut slice: *unsafe [i32] = &arr[1..3];

    return 0;
}

test/tests/array.slice.gen.start.rad +2 -2

//! returns: 0
@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut arr: [i32; 4] = [1, 2, 3, 4];
    let mut slice: *[i32] = &arr[2..];
    let mut slice: *unsafe [i32] = &arr[2..];

    return 0;
}

test/tests/array.slice.openend.rad +1 -1

1	1		/// Creates a slice from an array with open end bound.
2		-	fn sliceOpenEnd(a: [i32; 4], start: u32) -> *[i32] {
	2	+	unsafe fn sliceOpenEnd(a: [i32; 4], start: u32) -> *unsafe [i32] {
3	3		return &a[start..];
4	4		}

test/tests/array.slice.openstart.rad +1 -1

1	1		/// Creates a slice from an array with open start bound.
2		-	fn sliceOpenStart(a: [i32; 4], end: u32) -> *[i32] {
	2	+	unsafe fn sliceOpenStart(a: [i32; 4], end: u32) -> *unsafe [i32] {
3	3		return &a[..end];
4	4		}

test/tests/array.slice.rad +6 -6

//! returns: 0
//! Test array slicing with various ranges.

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let arr: [i32; 5] = [1, 2, 3, 4, 5];

    let slice1: *[i32] = &arr[..];
    let slice2: *[i32] = &arr[1..4];
    let slice3: *[i32] = &arr[..3];
    let slice4: *[i32] = &arr[2..];
    let slice1: *unsafe [i32] = &arr[..];
    let slice2: *unsafe [i32] = &arr[1..4];
    let slice3: *unsafe [i32] = &arr[..3];
    let slice4: *unsafe [i32] = &arr[2..];

    assert slice1.len == 5;
    assert slice2.len == 3;
    assert slice3.len == 3;
    assert slice4.len == 3;

    let slice5: *[i32] = slice3;
    let slice5: *unsafe [i32] = slice3;

    assert slice5.len == 3;
    assert slice5.ptr == slice3.ptr;

    let sum1: i32 = slice1[0] + slice1[4];  // 6

test/tests/bool.comparison.slice.rad +45 -45

1	1		//! returns: 0
2		-	fn memEq(a: [u8], b: [u8]) -> bool {
	2	+	fn memEq(a: &[u8], b: &[u8]) -> bool {
3	3		if a.len <> b.len {
4	4		return false;
5	5		}
6	6		for i in 0..a.len {
7	7		if a[i] <> b[i] {


fn sliceU8(input: *[u8]) -> *[u8] {
    return input;
}

fn sliceI32(input: *[i32]) -> *[i32] {
fn sliceI32(input: *unsafe [i32]) -> *unsafe [i32] {
    return input;
}

fn sliceEqualU32(a: *[u32], b: *[u32]) -> bool {
fn sliceEqualU32(a: &[u32], b: &[u32]) -> bool {
    if a.len <> b.len {
        return false;
    }
    for i in 0..a.len {
        if a[i] <> b[i] {

        }
    }
    return true;
}

fn sliceEqualI32(a: *[i32], b: *[i32]) -> bool {
fn sliceEqualI32(a: &[i32], b: &[i32]) -> bool {
    if a.len <> b.len {
        return false;
    }
    for i in 0..a.len {
        if a[i] <> b[i] {

        }
    }
    return true;
}

fn sliceEqual1() -> bool {
unsafe fn sliceEqual1() -> bool {
    let a1: [u32; 3] = [9, 42, 3];

    let s1: *[u32] = &a1[..];
    let s2: *[u32] = &a1[..];
    let s1: *unsafe [u32] = &a1[..];
    let s2: *unsafe [u32] = &a1[..];

    return s1 == s2 and sliceEqualU32(s1, s2);
    return s1 == s2 and sliceEqualU32(&s1[..], &s2[..]);
}

fn sliceEqual2() -> bool {
unsafe fn sliceEqual2() -> bool {
    let a1: [u32; 3] = [9, 42, 3];

    let s1: *[u32] = &a1[1..];
    let s2: *[u32] = &a1[1..];
    let s1: *unsafe [u32] = &a1[1..];
    let s2: *unsafe [u32] = &a1[1..];

    return s1 == s2 and sliceEqualU32(s1, s2);
    return s1 == s2 and sliceEqualU32(&s1[..], &s2[..]);
}

fn sliceEqual3() -> bool {
unsafe fn sliceEqual3() -> bool {
    let a1: [u32; 3] = [9, 42, 3];

    let s1: *[u32] = &a1[..1];
    let s2: *[u32] = &a1[..1];
    let s1: *unsafe [u32] = &a1[..1];
    let s2: *unsafe [u32] = &a1[..1];

    return s1 == s2 and sliceEqualU32(s1, s2);
    return s1 == s2 and sliceEqualU32(&s1[..], &s2[..]);
}

fn sliceEqual4() -> bool {
unsafe fn sliceEqual4() -> bool {
    let a1: [u32; 3] = [9, 42, 3];

    let s1: *[u32] = &a1[2..];
    let s2: *[u32] = &a1[2..];
    let s1: *unsafe [u32] = &a1[2..];
    let s2: *unsafe [u32] = &a1[2..];

    return s1 == s2 and sliceEqualU32(s1, s2);
    return s1 == s2 and sliceEqualU32(&s1[..], &s2[..]);
}

fn sliceNotEqualSameArray1() -> bool {
unsafe fn sliceNotEqualSameArray1() -> bool {
    let a1: [u32; 3] = [42, 8, 3];

    let s1: *[u32] = &a1[..2];
    let s2: *[u32] = &a1[1..3];
    let s1: *unsafe [u32] = &a1[..2];
    let s2: *unsafe [u32] = &a1[1..3];

    return s1 <> s2 and not sliceEqualU32(s1, s2);
    return s1 <> s2 and not sliceEqualU32(&s1[..], &s2[..]);
}

fn sliceNotEqualSameArray2() -> bool {
unsafe fn sliceNotEqualSameArray2() -> bool {
    let a1: [u32; 3] = [42, 8, 3];

    let s1: *[u32] = &a1[..2];
    let s2: *[u32] = &a1[..3];
    let s1: *unsafe [u32] = &a1[..2];
    let s2: *unsafe [u32] = &a1[..3];

    return s1 <> s2 and not sliceEqualU32(s1, s2);
    return s1 <> s2 and not sliceEqualU32(&s1[..], &s2[..]);
}

fn sliceEqualDifferentArray() -> bool {
unsafe fn sliceEqualDifferentArray() -> bool {
    let a1: [u32; 3] = [42, 8, 3];
    let a2: [u32; 3] = [42, 8, 3];

    let s1: *[u32] = &a1[..];
    let s2: *[u32] = &a2[..];
    let s1: *unsafe [u32] = &a1[..];
    let s2: *unsafe [u32] = &a2[..];

    return sliceEqualU32(s1, s2) and s1 <> s2;
    return sliceEqualU32(&s1[..], &s2[..]) and s1 <> s2;
}

fn sliceEqualString1() -> bool {
    let s1: *[u8] = "ABC";
    let s2: *[u8] = "ABC";

    return memEq(s1, s2);
    return memEq(&s1[..], s2);
}

fn sliceEqualString2() -> bool {
    let s1: *[u8] = "ABC";
    let s2: *[u8] = "DEF";

    return not memEq(s1, s2);
    return not memEq(&s1[..], s2);
}

fn sliceEqualString3() -> bool {
unsafe fn sliceEqualString3() -> bool {
    let a1: [u8; 3] = ['A', 'B', 'C'];
    let s1: *[u8] = &a1[..];
    let s1: *unsafe [u8] = &a1[..];
    let s2: *[u8] = "ABC";

    return memEq(s1, s2)
       and memEq(s1, "ABC")
    return memEq(&s1[..], s2)
       and memEq(&s1[..], "ABC")
       and memEq(&a1[..], "ABC");
}

fn sliceEqualString4() -> bool {
    let s1: *[u8] = "ABC";
    let s2: *[u8] = &['A', 'B', 'C'];

    return memEq(s1, s2);
    return memEq(&s1[..], s2);
}

fn sliceEqualString5() -> bool {
    let s1: *[u8] = "ABC";

    // Sub-slicing a slice currently trips a separate compiler bug.
    // Keep this check focused on slice equality behavior itself.
    return memEq(s1, "ABC");
    return memEq(&s1[..], "ABC");
}

fn sliceNotEqualU8() -> bool {
    let a: [u8; 3] = [1, 2, 3];
    let b: [u8; 3] = [1, 2, 4];

       and not memEq(&a[..], &a[1..])
       and not memEq(&a[..], &b[..])
       and not memEq(&a[..], &[1, 3, 3]);
}

fn sliceNotEqualU16() -> bool {
unsafe fn sliceNotEqualU16() -> bool {
    let a: [u16; 3] = [1, 2, 3];
    let b: [u16; 3] = [1, 2, 4];
    let s: *[u16] = &[1, 2, 3];
    let s: *unsafe [u16] = &[1, 2, 3];

    return s <> &[1, 2, 4]
       and s <> &[1, 0, 3]
       and &a[..] <> &a[1..]
       and &a[..] <> &b[..]
       and &a[..] <> &[1, 3, 3];
}

fn sliceReturnEqual() -> bool {
unsafe fn sliceReturnEqual() -> bool {
    return memEq(sliceU8("ABC"), "ABC")
       and sliceEqualI32(sliceI32(&[1, 2, 3]), &[1, 2, 3]);
       and sliceEqualI32(&sliceI32(&[1, 2, 3])[..], &[1, 2, 3]);
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    assert sliceEqual1();
    assert sliceEqual2();
    assert sliceEqual3();
    assert sliceEqual4();
    assert sliceEqualString1();

test/tests/bool.comparison.slice.record.gen.rad +10 -10

    x: i32,
    y: i32,
}

record Line: Copy {
    points: *[Point],
    points: *unsafe [Point],
}

fn pointsEqual(a: *[Point], b: *[Point]) -> bool {
fn pointsEqual(a: &[Point], b: &[Point]) -> bool {
    if a.len <> b.len {
        return false;
    }
    for i in 0..a.len {
        if a[i].x <> b[i].x or a[i].y <> b[i].y {

        }
    }
    return true;
}

fn lineEqual(a: Line, b: Line) -> bool {
    return pointsEqual(a.points, b.points);
unsafe fn lineEqual(a: Line, b: Line) -> bool {
    return pointsEqual(&a.points[..], &b.points[..]);
}

fn testSliceStructEqual() -> bool {
unsafe fn testSliceStructEqual() -> bool {
    let a: [Point; 2] = [Point { x: 1, y: 2 }, Point { x: 3, y: 4 }];
    let b: [Point; 2] = [Point { x: 1, y: 2 }, Point { x: 3, y: 4 }];

    return pointsEqual(&a[..], &b[..]);
}

fn testSliceStructNotEqualContent() -> bool {
unsafe fn testSliceStructNotEqualContent() -> bool {
    let a: [Point; 2] = [Point { x: 1, y: 2 }, Point { x: 3, y: 4 }];
    let b: [Point; 2] = [Point { x: 1, y: 2 }, Point { x: 3, y: 5 }];

    return not pointsEqual(&a[..], &b[..]);
}

fn testSliceStructNotEqualLength() -> bool {
unsafe fn testSliceStructNotEqualLength() -> bool {
    let a: [Point; 2] = [Point { x: 1, y: 2 }, Point { x: 3, y: 4 }];
    let b: [Point; 1] = [Point { x: 1, y: 2 }];

    return not pointsEqual(&a[..], &b[..]);
}

fn testStructWithSliceFieldEqual() -> bool {
unsafe fn testStructWithSliceFieldEqual() -> bool {
    let pts1: [Point; 2] = [Point { x: 1, y: 2 }, Point { x: 3, y: 4 }];
    let pts2: [Point; 2] = [Point { x: 1, y: 2 }, Point { x: 3, y: 4 }];

    let line1: Line = Line { points: &pts1[..] };
    let line2: Line = Line { points: &pts2[..] };

    return lineEqual(line1, line2);
}

fn testStructWithSliceFieldNotEqual() -> bool {
unsafe fn testStructWithSliceFieldNotEqual() -> bool {
    let pts1: [Point; 2] = [Point { x: 1, y: 2 }, Point { x: 3, y: 4 }];
    let pts2: [Point; 2] = [Point { x: 1, y: 2 }, Point { x: 3, y: 5 }];

    let line1: Line = Line { points: &pts1[..] };
    let line2: Line = Line { points: &pts2[..] };

    return not lineEqual(line1, line2);
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    assert testSliceStructEqual();
    assert testSliceStructNotEqualContent();
    assert testSliceStructNotEqualLength();
    assert testStructWithSliceFieldEqual();
    assert testStructWithSliceFieldNotEqual();

test/tests/bool.comparison.slice.union.gen.rad +12 -12

    width: u32,
    height: u32,
}

union Shape: Copy {
    points(*[Point]),
    sizes(*[Size]),
    points(*unsafe [Point]),
    sizes(*unsafe [Size]),
}

fn pointsEqual(a: *[Point], b: *[Point]) -> bool {
fn pointsEqual(a: &[Point], b: &[Point]) -> bool {
    if a.len <> b.len {
        return false;
    }
    for i in 0..a.len {
        if a[i].x <> b[i].x or a[i].y <> b[i].y {

        }
    }
    return true;
}

fn sizesEqual(a: *[Size], b: *[Size]) -> bool {
fn sizesEqual(a: &[Size], b: &[Size]) -> bool {
    if a.len <> b.len {
        return false;
    }
    for i in 0..a.len {
        if a[i].width <> b[i].width or a[i].height <> b[i].height {

        }
    }
    return true;
}

fn shapeEqual(a: Shape, b: Shape) -> bool {
unsafe fn shapeEqual(a: Shape, b: Shape) -> bool {
    if let case Shape::points(pointsA) = a {
        if let case Shape::points(pointsB) = b {
            return pointsEqual(pointsA, pointsB);
            return pointsEqual(&pointsA[..], &pointsB[..]);
        }
        return false;
    }
    if let case Shape::sizes(sizesA) = a {
        if let case Shape::sizes(sizesB) = b {
            return sizesEqual(sizesA, sizesB);
            return sizesEqual(&sizesA[..], &sizesB[..]);
        }
        return false;
    }
    return false;
}

fn testEnumSliceEqual() -> bool {
unsafe fn testEnumSliceEqual() -> bool {
    let pts1: [Point; 2] = [Point { x: 1, y: 2 }, Point { x: 3, y: 4 }];
    let pts2: [Point; 2] = [Point { x: 1, y: 2 }, Point { x: 3, y: 4 }];

    let s1: Shape = Shape::points(&pts1[..]);
    let s2: Shape = Shape::points(&pts2[..]);

    return shapeEqual(s1, s2);
}

fn testEnumSliceNotEqual() -> bool {
unsafe fn testEnumSliceNotEqual() -> bool {
    let pts1: [Point; 2] = [Point { x: 1, y: 2 }, Point { x: 3, y: 4 }];
    let pts2: [Point; 2] = [Point { x: 1, y: 2 }, Point { x: 3, y: 5 }];

    let s1: Shape = Shape::points(&pts1[..]);
    let s2: Shape = Shape::points(&pts2[..]);

    return not shapeEqual(s1, s2);
}

fn testEnumSizesSliceEqual() -> bool {
unsafe fn testEnumSizesSliceEqual() -> bool {
    let sizes1: [Size; 2] = [Size { width: 10, height: 20 }, Size { width: 30, height: 40 }];
    let sizes2: [Size; 2] = [Size { width: 10, height: 20 }, Size { width: 30, height: 40 }];

    let s1: Shape = Shape::sizes(&sizes1[..]);
    let s2: Shape = Shape::sizes(&sizes2[..]);

    return shapeEqual(s1, s2);
}

fn testEnumDifferentVariants() -> bool {
unsafe fn testEnumDifferentVariants() -> bool {
    let pts: [Point; 2] = [Point { x: 1, y: 2 }, Point { x: 3, y: 4 }];
    let sizes: [Size; 2] = [Size { width: 10, height: 20 }, Size { width: 30, height: 40 }];

    let s1: Shape = Shape::points(&pts[..]);
    let s2: Shape = Shape::sizes(&sizes[..]);

    return not shapeEqual(s1, s2);
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    assert testEnumSliceEqual();
    assert testEnumSliceNotEqual();
    assert testEnumSizesSliceEqual();
    assert testEnumDifferentVariants();
    return 0;

test/tests/bool.short.circuit.rad +1 -1

//! returns: 0
//! Test short-circuiting behavior of 'and' and 'or' operators.
fn modify(counter: *mut i32, ret: bool) -> bool {
fn modify(counter: &mut i32, ret: bool) -> bool {
    set *counter += 1;
    return ret;
}

@default fn main() -> i32 {

test/tests/builtin.sliceof.invalid.cap.rad +3 -3

//! returns: 133
//! Test @sliceOf runtime validation for len > cap.

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut arr: [i32; 4] = [10, 20, 30, 40];
    let ptr: *i32 = &arr[0];
    let slice: *[i32] = @sliceOf(ptr, 4, 3);
    let ptr: *unsafe i32 = &arr[0];
    let slice: *unsafe [i32] = @sliceOf(ptr, 4, 3);

    return slice.len as i32;
}

test/tests/builtin.sliceof.mut.rad +3 -3

//! returns: 0
// Test the @sliceOf builtin with mutable slice.

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut arr: [i32; 4] = [10, 20, 30, 40];

    // Get a mutable pointer to the first element
    let ptr: *mut i32 = &mut arr[0];
    let ptr: *unsafe mut i32 = &mut arr[0];

    // Create a mutable slice from the pointer and length
    let slice: *mut [i32] = @sliceOf(ptr, 4);
    let slice: *unsafe mut [i32] = @sliceOf(ptr, 4);

    // Double each element via the slice
    set slice[0] *= 2;
    set slice[1] *= 2;
    set slice[2] *= 2;

test/tests/builtin.sliceof.rad +3 -3

//! returns: 100
// Test @sliceOf builtin: create a slice from a pointer and length.

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut arr: [i32; 4] = [10, 20, 30, 40];

    // Get a pointer to the first element
    let ptr: *i32 = &arr[0];
    let ptr: *unsafe i32 = &arr[0];

    // Create a slice from the pointer and length
    let slice: *[i32] = @sliceOf(ptr, 4);
    let slice: *unsafe [i32] = @sliceOf(ptr, 4);

    // Access elements via the slice and sum them
    let mut sum: i32 = 0;
    set sum += slice[0];
    set sum += slice[1];

test/tests/call.aggregate.arg.snapshot.rad +1 -1

record Pair: Copy {
    x: i32,
    y: i32,
}

fn mutate(pair: *mut Pair) -> i32 {
fn mutate(pair: &mut Pair) -> i32 {
    set pair.x = 99;
    return 0;
}

fn first(pair: Pair, ignored: i32) -> i32 {

test/tests/call.clobber.rad +3 -3

//! returns: 0
//! Test that values live across function calls are not clobbered.
fn modify(counter: *mut i32, ret: bool) -> bool {
unsafe fn modify(counter: *unsafe mut i32, ret: bool) -> bool {
    set *counter += 1;
    return ret;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut x: i32 = 0;
    let r: bool = modify(&mut x, false);
    assert x == 1;
    assert not r;

    // Pointer live across call.
    let mut y: i32 = 42;
    let p: *mut i32 = &mut y;
    let p: *unsafe mut i32 = &mut y;
    let r2: bool = modify(p, true);
    assert *p == 43;
    assert r2;
    return 0;
}

test/tests/compound.assign.index.once.rad +1 -1

//! returns: 0
//! Compound assignment evaluates a side-effecting lvalue exactly once.

fn nextIndex(calls: *mut u32) -> u32 {
fn nextIndex(calls: &mut u32) -> u32 {
    let index = *calls;
    set *calls += 1;
    return index;
}


test/tests/compound.assign.rad +2 -2

//! returns: 0
/// Test compound assignment operators (+=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=).
@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut a: i32 = 10;

    // Test +=
    set a += 5;
    assert a == 15;

    set arr[1] += 5;
    assert arr[1] == 25;

    // Test compound assignment with pointer dereference.
    let mut val: i32 = 100;
    let p: *mut i32 = &mut val;
    let p: *unsafe mut i32 = &mut val;
    set *p += 50;
    assert val == 150;

    // Test chained compound assignments.
    let mut x: i32 = 1;

test/tests/cond.match.guard.regalloc.rad +3 -3

    span1: u32,
    span2: u32,
    kind: Kind,
}

fn getPath(node: *Node, buf: *mut [*[u8]]) -> *[*[u8]] {
    let mut out: *[*[u8]] = &[];
unsafe fn getPath(node: &Node, buf: &mut [*[u8]]) -> *unsafe [*[u8]] {
    let mut out: *unsafe [*[u8]] = &[];

    match node.kind {
        case Kind::Name(name) if name.len > 0 => {
            set buf[0] = name;
            set out = &buf[..1];

        else => {}
    }
    return out;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let n = Node {
        id: 0, span1: 0, span2: 5,
        kind: Kind::Name("Hello"),
    };
    let mut buffer: [*[u8]; 4] = undefined;

test/tests/edge.cases.2.rad +1 -1


export record Scanner: Copy {
    source: *[u8],
}

fn peek(s: *Scanner) -> ?u8 {
fn peek(s: &Scanner) -> ?u8 {
    if 0 + 0 >= s.source.len {
        return nil;
    }
    return 'a';
}

test/tests/edge.cases.3.rad +3 -3

export record Scanner: Copy {
    source: *[u8],
    cursor: u32,
}

fn isEof(s: *Scanner) -> bool {
fn isEof(s: &Scanner) -> bool {
    return s.cursor >= s.source.len;
}

export fn current(s: *Scanner) -> ?u8 {
export fn current(s: &Scanner) -> ?u8 {
    if isEof(s) {
        return nil;
    }
    return s.source[s.cursor];
}

fn peek(s: *Scanner) -> ?u8 {
fn peek(s: &Scanner) -> ?u8 {
    if s.cursor + 1 >= s.source.len {
        return nil;
    }
    return s.source[s.cursor + 1];
}

test/tests/edge.cases.4.rad +4 -4


record Node: Copy {
    value: NodeValue,
}

fn node(nodes: *mut Node, count: *mut u32, value: NodeValue) -> *Node {
unsafe fn node(nodes: *unsafe mut Node, count: *unsafe mut u32, value: NodeValue) -> *unsafe Node {
    let index = *count;
    let slot = nodes + index;
    set *slot = Node { value };
    set *count = index + 1;
    return slot;
}

fn nodeTypeInt(nodes: *mut Node, count: *mut u32, width: u8, sign: Signedness) -> *Node {
unsafe fn nodeTypeInt(nodes: *unsafe mut Node, count: *unsafe mut u32, width: u8, sign: Signedness) -> *unsafe Node {
    return node(nodes, count, NodeValue::TypeSig(
        TypeSig::Integer { width, sign }
    ));
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let direct = TypeSig::Integer {
        width: 4,
        sign: Signedness::Signed,
    };
    let case TypeSig::Integer { width: w1, .. } = direct
        else return 50;

    assert w1 == 4;
    let mut nodes: [Node; 2] = undefined;
    let nodesPtr: *mut Node = &mut nodes[0];
    let nodesPtr: *unsafe mut Node = &mut nodes[0];
    let mut count: u32 = 0;
    let typeNode = nodeTypeInt(nodesPtr, &mut count, 4, Signedness::Signed);
    let case NodeValue::TypeSig(sig) = typeNode.value
        else return 40;


test/tests/edge.cases.rad +1 -1


export record Scanner: Copy {
    source: *[u8],
}

fn peek(s: *Scanner)  -> i32 {
fn peek(s: &Scanner)  -> i32 {
    assert 0 + 0 <= s.source.len;
    return 0;
}

@default fn main() -> i32 {

test/tests/error.slice.bounds.rad +2 -2

//! returns: 133
//! Test slice bounds checking with runtime EBREAK.

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let arr: [i32; 3] = [1, 2, 3];
    let slice: *[i32] = &arr[..];
    let slice: *unsafe [i32] = &arr[..];
    let value: i32 = slice[3];

    return value;
}

test/tests/error.try.rad +3 -3

        throw TestError::Bust;
    }
    return 77;
}

fn catchReturn(flag: *mut u32, fail: bool) -> bool {
fn catchReturn(flag: &mut u32, fail: bool) -> bool {
    let value: u32 = try maybeReturn(fail) catch {
        return true;
    };
    set *flag = value;
    return false;

        set idx += 1;
    }
    return total;
}

fn structSuccess(state: *mut ResultSink) -> u32 throws (TestError) {
fn structSuccess(state: &mut ResultSink) -> u32 throws (TestError) {
    let value: u32 = try returnsOk();
    set state.last = value;
    set state.count += 1;
    return value;
}

fn structFailure(state: *mut ResultSink) -> u32 throws (TestError) {
fn structFailure(state: &mut ResultSink) -> u32 throws (TestError) {
    try returnsErr(1);
    set state.last = 999;
    return 999;
}


test/tests/field.aggregate.rad +2 -2

record Inner: Copy { x: i32, y: i32 }
union MaybeInt: Copy { None, Some(i32) }

record HasRecord: Copy { inner: Inner, z: i32 }
record HasUnion: Copy { maybe: MaybeInt, z: i32 }
record HasSlice: Copy { data: *[i32], z: i32 }
record HasSlice: Copy { data: *unsafe [i32], z: i32 }

/// Access a record field and read from it.
fn accessRecordField() -> i32 {
    let r = HasRecord { inner: Inner { x: 10, y: 20 }, z: 30 };
    return r.inner.y;

    let r = HasUnion { maybe: MaybeInt::Some(42), z: 99 };
    return r.maybe;
}

/// Access a slice field and get its length.
fn accessSliceField() -> u32 {
unsafe fn accessSliceField() -> u32 {
    let arr: [i32; 3] = [1, 2, 3];
    let r = HasSlice { data: &arr[..], z: 77 };
    return r.data.len;
}

test/tests/fn.callback.nested.rad +9 -5

        return n + 1;
    }
    return current;
}

fn maxRegCallback(reg: Reg, ctx: *mut opaque) {
    let max = ctx as *mut u32;
/// Update the maximum register count through a borrowed counter.
fn updateMax(reg: Reg, max: &mut u32) {
    set *max = maxRegNum(reg.n, *max);
}

fn withReg(val: Val, callback: fn(Reg, *mut opaque), ctx: *mut opaque) {
fn maxRegCallback(reg: Reg, ctx: &mut opaque) {
    updateMax(reg, ctx as &mut u32);
}

fn withReg(val: Val, callback: fn(Reg, &mut opaque), ctx: &mut opaque) {
    if let case Val::Reg(r) = val {
        callback(r, ctx);
    }
}

fn forEachVal(a: Val, b: Val, c: Val, callback: fn(Reg, *mut opaque), ctx: *mut opaque) {
fn forEachVal(a: Val, b: Val, c: Val, callback: fn(Reg, &mut opaque), ctx: &mut opaque) {
    withReg(a, callback, ctx);
    withReg(b, callback, ctx);
    withReg(c, callback, ctx);
}


    forEachVal(
        Val::Reg(Reg { n: 0 }),
        Val::Reg(Reg { n: 5 }),
        Val::Reg(Reg { n: 2 }),
        maxRegCallback,
        &mut maxReg as *mut opaque
        &mut maxReg as &mut opaque
    );

    // maxReg should be 6 (max register 5 + 1)
    if maxReg == 6 {
        return 0;

test/tests/fn.unsafe.callbacks.rad added +30 -0

1	+	//! returns: 0
2	+
3	+	mod operations;
4	+
5	+	record Callback: Copy {
6	+	/// Function called with a raw pointer to a live integer.
7	+	invoke: unsafe fn(*unsafe u32) -> u32,
8	+	}
9	+
10	+	/// Call a safe function from a module that also exports unsafe functions.
11	+	fn readBorrow(value: &u32) -> u32 {
12	+	return operations::readBorrow(value);
13	+	}
14	+
15	+	/// Return a constant without reading the pointer.
16	+	fn constantValue(value: *unsafe u32) -> u32 {
17	+	return 7;
18	+	}
19	+
20	+	@default unsafe fn main() -> i32 {
21	+	let value: u32 = 42;
22	+	assert readBorrow(&value) == 42;
23	+
24	+	let raw = Callback { invoke: operations::readRaw };
25	+	assert raw.invoke(&value) == 42;
26	+
27	+	let checked = Callback { invoke: constantValue };
28	+	assert checked.invoke(&value) == 7;
29	+	return 0;
30	+	}

test/tests/fn.unsafe.callbacks/operations.rad added +9 -0

1	+	/// Read an integer through a checked borrow.
2	+	export fn readBorrow(value: &u32) -> u32 {
3	+	return *value;
4	+	}
5	+
6	+	/// Read an integer through a raw pointer that must remain valid for the call.
7	+	export unsafe fn readRaw(value: *unsafe u32) -> u32 {
8	+	return *value;
9	+	}

test/tests/for.else.continue.rad +1 -1

record Field: Copy {
    name: ?*[u8],
    value: i32,
}

fn findField(fields: *[Field], target: *[u8]) -> ?i32 {
fn findField(fields: &[Field], target: &[u8]) -> ?i32 {
    for i in 0..fields.len {
        let name = fields[i].name
            else continue;
        if name.len == target.len {
            let mut eq = true;

test/tests/index.u8.rad +2 -2

//! returns: 0

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let arr: [i32; 4] = [10, 20, 42, 30];

    // u8 index.
    let idx8: u8 = 2;
    if arr[idx8] <> 42 {

    // Unsuffixed integer literal index.
    if arr[1] <> 20 {
        return 4;
    }
    // u8 index into slice.
    let s = &arr[..];
    let s: *unsafe [i32] = &arr[..];
    let si: u8 = 1;
    if s[si] <> 20 {
        return 5;
    }
    return 0;

test/tests/match.mutref.push.rad +4 -4

//! returns: 0
//! Test pushing items through a mutable reference obtained via match.

record U32List: Copy {
    data: *mut [u32],
    data: *unsafe mut [u32],
    len: u32,
}

union Sealed: Copy {
    No { items: U32List },
    Yes,
}

fn pushItem(list: *mut U32List, value: u32) {
unsafe fn pushItem(list: &mut U32List, value: u32) {
    set list.data[list.len] = value;
    set list.len += 1;
}

fn addToUnsealedBlock(state: *mut Sealed, value: u32) -> bool {
unsafe fn addToUnsealedBlock(state: &mut Sealed, value: u32) -> bool {
    match state {
        case Sealed::No { items } => {
            pushItem(items, value);
            return true;
        },

            return false;
        },
    }
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut buf: [u32; 8] = undefined;
    set buf[0] = 0;
    let mut state = Sealed::No { items: U32List { data: &mut buf[0..8], len: 0 } };

    assert addToUnsealedBlock(&mut state, 42);

test/tests/match.mutref.union.rad +1 -1

record Data: Copy {
    state: State,
    value: u32,
}

fn process(d: *mut Data) -> u32 {
fn process(d: &mut Data) -> u32 {
    match &mut d.state {
        case State::A { count } => {
            let c = *count;
            set *count = c + 1;
            return c;

test/tests/match.nested.deref.rad +12 -12

    A(i32),
    B,
}

union Outer: Copy {
    Some(*Inner),
    Some(*unsafe Inner),
    None,
}

/// Match nested union variant through pointer dereference in match/case.
fn matchDeref(o: Outer) -> i32 {
unsafe fn matchDeref(o: Outer) -> i32 {
    match o {
        case Outer::Some(Inner::A(x)) => {
            return x;
        }
        case Outer::Some(Inner::B) => {

        }
    }
}

/// If-let-case with auto-deref nested pattern.
fn ifLetDeref(o: Outer) -> i32 {
unsafe fn ifLetDeref(o: Outer) -> i32 {
    if let case Outer::Some(Inner::A(x)) = o {
        return x;
    }
    return 0;
}

/// Let-else with auto-deref nested pattern.
fn letElseDeref(o: Outer) -> i32 {
unsafe fn letElseDeref(o: Outer) -> i32 {
    let case Outer::Some(Inner::A(x)) = o
        else { return -1; };
    return x;
}

/// Record with pointer field and nested pattern through deref.
record Container: Copy {
    inner: *Inner,
    inner: *unsafe Inner,
    tag: i32,
}

union Boxed: Copy {
    Some { c: Container },
    None,
}

/// Nested record with auto-deref on a pointer field.
fn matchRecordDeref(b: Boxed) -> i32 {
unsafe fn matchRecordDeref(b: Boxed) -> i32 {
    match b {
        case Boxed::Some { c: Container { inner: Inner::A(val), tag } } => {
            return val + tag;
        }
        else => {

        }
    }
}

/// Auto-deref through pointer in if-let-case with record.
fn ifLetRecordDeref(b: Boxed) -> i32 {
unsafe fn ifLetRecordDeref(b: Boxed) -> i32 {
    if let case Boxed::Some { c: Container { inner: Inner::A(val), tag } } = b {
        return val + tag;
    }
    return 0;
}

/// Void variant through pointer deref.
fn matchDerefVoid(o: Outer) -> i32 {
unsafe fn matchDerefVoid(o: Outer) -> i32 {
    if let case Outer::Some(Inner::B) = o {
        return 1;
    }
    return 0;
}

/// Auto-deref with placeholder in nested pattern.
fn matchDerefPlaceholder(o: Outer) -> i32 {
unsafe fn matchDerefPlaceholder(o: Outer) -> i32 {
    if let case Outer::Some(Inner::A(_)) = o {
        return 1;
    }
    return 0;
}

    x: i32,
    y: i32,
}

union Holder: Copy {
    Ptr { p: *Point, z: i32 },
    Ptr { p: *unsafe Point, z: i32 },
    Empty,
}

fn derefRecordField(h: Holder) -> i32 {
unsafe fn derefRecordField(h: Holder) -> i32 {
    if let case Holder::Ptr { p: Point { x, y }, z } = h {
        return x + y + z;
    }
    return 0;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let innerA = Inner::A(42);
    let innerB = Inner::B;

    // matchDeref
    assert matchDeref(Outer::Some(&innerA)) == 42;

test/tests/method.basic.rad +4 -4

record Point: Copy {
    x: i32,
    y: i32,
}

fn (p: *Point) sum() -> i32 {
fn (p: &Point) sum() -> i32 {
    return p.x + p.y;
}

fn (p: *mut Point) translate(dx: i32, dy: i32) {
fn (p: &mut Point) translate(dx: i32, dy: i32) {
    set p.x = p.x + dx;
    set p.y = p.y + dy;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut pt = Point { x: 3, y: 4 };

    // Call immutable method.
    assert pt.sum() == 7;


    pt.translate(10, 20);
    assert pt.x == 13;
    assert pt.y == 24;

    // Call via pointer.
    let ptr = &pt;
    let ptr: *unsafe Point = &pt;
    assert ptr.sum() == 37;

    return 0;
}

test/tests/method.multiple.rad +5 -5

record Vec2: Copy {
    x: i32,
    y: i32,
}

fn (v: *Vec2) magnitudeSq() -> i32 {
fn (v: &Vec2) magnitudeSq() -> i32 {
    return v.x * v.x + v.y * v.y;
}

fn (v: *Vec2) dot(other: *Vec2) -> i32 {
unsafe fn (v: &Vec2) dot(other: *unsafe Vec2) -> i32 {
    return v.x * other.x + v.y * other.y;
}

fn (v: *mut Vec2) add(other: *Vec2) {
unsafe fn (v: &mut Vec2) add(other: *unsafe Vec2) {
    set v.x = v.x + other.x;
    set v.y = v.y + other.y;
}

fn (v: *mut Vec2) scale(factor: i32) {
fn (v: &mut Vec2) scale(factor: i32) {
    set v.x = v.x * factor;
    set v.y = v.y * factor;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut a = Vec2 { x: 3, y: 4 };
    let b = Vec2 { x: 1, y: 2 };

    // Immutable method.
    assert a.magnitudeSq() == 25;

test/tests/method.ptr.rad +5 -5


record Counter: Copy {
    value: i32,
}

fn (c: *Counter) get() -> i32 {
fn (c: &Counter) get() -> i32 {
    return c.value;
}

fn (c: *mut Counter) inc() {
fn (c: &mut Counter) inc() {
    set c.value = c.value + 1;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut c = Counter { value: 0 };

    // Direct call on value.
    assert c.get() == 0;

    // Mutable method on value.
    c.inc();
    assert c.get() == 1;

    // Call via immutable pointer.
    let p = &c;
    let p: *unsafe Counter = &c;
    assert p.get() == 1;

    // Call via mutable pointer.
    let mp = &mut c;
    let mp: *unsafe mut Counter = &mut c;
    mp.inc();
    assert mp.get() == 2;

    // Original value also updated.
    assert c.get() == 2;

test/tests/method.with.trait.rad +5 -5

    x: i32,
    y: i32,
}

// Standalone method.
fn (w: *Widget) area() -> i32 {
unsafe fn (w: *unsafe Widget) area() -> i32 {
    return w.x * w.y;
}

// Trait with its own method.
trait Printable {
    fn (*Printable) code() -> i32;
    unsafe fn (*unsafe Printable) code() -> i32;
}

instance Printable for Widget {
    fn (w: *Widget) code() -> i32 {
    unsafe fn (w: *unsafe Widget) code() -> i32 {
        return w.x + w.y;
    }
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let w = Widget { x: 3, y: 5 };

    // Standalone method call.
    assert w.area() == 15;

    // Trait method call via trait object.
    let p: *opaque Printable = &w;
    let p: *unsafe opaque Printable = &w;
    assert p.code() == 8;

    return 0;
}

test/tests/mutref.call.result.rad +3 -3


record Box: Copy {
    x: i32,
}

fn idBox(b: *mut Box) -> *mut Box {
fn idBox(b: *unsafe mut Box) -> *unsafe mut Box {
    return b;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut b = Box { x: 1 };

    let px: *mut i32 = &mut idBox(&mut b).x;
    let px: *unsafe mut i32 = &mut idBox(&mut b).x;
    set *px = 9;

    assert b.x == 9;
    return 0;
}

test/tests/mutref.loop.bug.rad +1 -1

//!
//! The critical case is when the loop executes zero iterations: the merge
//! block tries to `load` through the initial integer value (not a valid
//! pointer), crashing the program.

fn store(ptr: *mut u32, val: u32) {
fn store(ptr: &mut u32, val: u32) {
    set *ptr = val;
}

/// Zero-iteration loop with &mut inside the body.
/// Without the fix, `val` starts as integer 42 in SSA, but the post-loop

test/tests/mutref.loop.rad +4 -4

fn callback(val: u32, ctx: *mut opaque) {
    let max = ctx as *mut u32;
unsafe fn callback(val: u32, ctx: *unsafe mut opaque) {
    let max = ctx as *unsafe mut u32;
    set *max = val;
}

fn test() -> i32 {
unsafe fn test() -> i32 {
    let mut maxReg: u32 = 0;
    let mut i: u32 = 0;
    while i < 3 {
        callback(i, &mut maxReg as *mut opaque);
        callback(i, &mut maxReg as *unsafe mut opaque);
        set i += 1;
    }
    return maxReg as i32;
}

test/tests/mutref.scalar.rad +1 -1

fn modify(counter: *mut i32, ret: bool) -> bool {
fn modify(counter: &mut i32, ret: bool) -> bool {
    set *counter += 1;
    return ret;
}

fn test() -> i32 {

test/tests/opt.nil.check.rad +8 -8

//! Test nil check for optional pointers and slices.
//! Ensure that nil checks compare the full pointer width, not just the low byte.

/// Return a pointer whose low byte is zero but is non-null.
/// This tests that nil checks use W64, not W8.
fn makeAlignedPtr() -> *u8 {
unsafe fn makeAlignedPtr() -> *unsafe u8 {
    let arr: [u8; 512] = undefined;
    // Find an address within arr whose low byte is 0x00.
    let base: u64 = &arr[0] as u64;
    let offset: u64 = 256 - (base % 256);
    return &arr[offset as u32] as *u8;
    return &arr[offset as u32] as *unsafe u8;
}

/// Test: optional pointer nil check must use full 64-bit comparison.
fn testOptionalPtrNilCheck() -> i32 {
unsafe fn testOptionalPtrNilCheck() -> i32 {
    let p = makeAlignedPtr();
    let opt: ?*u8 = p;
    let opt: ?*unsafe u8 = p;

    // The pointer is not nil, but its low byte is 0x00.
    // A W8 comparison would wrongly say it's nil.
    assert opt <> nil;
    if let v = opt {

    }
    return 2;
}

/// Test: optional slice nil check must use full 64-bit comparison.
fn testOptionalSliceNilCheck() -> i32 {
unsafe fn testOptionalSliceNilCheck() -> i32 {
    let arr: [u8; 512] = undefined;
    let base: u64 = &arr[0] as u64;
    let offset: u64 = 256 - (base % 256);
    // Create a slice starting at an address whose low byte is 0.
    let s: *[u8] = &arr[offset as u32 ..];
    let s: *unsafe [u8] = &arr[offset as u32 ..];

    let opt: ?*[u8] = s;
    let opt: ?*unsafe [u8] = s;
    assert opt <> nil;
    if let v = opt {
        return 0;
    }
    return 2;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let r1 = testOptionalPtrNilCheck();
    if r1 <> 0 {
        return r1;
    }
    let r2 = testOptionalSliceNilCheck();

test/tests/opt.slice.npo.rad +31 -31

//! Optional slices should have the same size as slices (16 bytes),
//! using a null data pointer to represent `nil`.

fn checkSizes() -> u8 {
    // ?*[T] should be the same size as *[T] (16 bytes, not 24).
    assert @sizeOf(?*[u8]) == 16;
    assert @alignOf(?*[u8]) == 8;
    assert @sizeOf(?*[u16]) == 16;
    assert @sizeOf(?*mut [u8]) == 16;
    assert @sizeOf(?*unsafe [u8]) == 16;
    assert @alignOf(?*unsafe [u8]) == 8;
    assert @sizeOf(?*unsafe [u16]) == 16;
    assert @sizeOf(?*unsafe mut [u8]) == 16;
    return 0;
}

fn checkNil() -> u8 {
    let x: ?*[u8] = nil;
    let x: ?*unsafe [u8] = nil;
    assert x == nil;
    return 0;
}

fn checkWrap() -> u8 {
unsafe fn checkWrap() -> u8 {
    let arr: [u8; 3] = [1, 2, 3];
    let s = &arr[..];
    let opt: ?*[u8] = s;
    let s: *unsafe [u8] = &arr[..];
    let opt: ?*unsafe [u8] = s;

    assert opt <> nil;
    return 0;
}

fn checkIfLet() -> u8 {
unsafe fn checkIfLet() -> u8 {
    let arr: [u8; 3] = [10, 20, 30];
    let s = &arr[..];
    let opt: ?*[u8] = s;
    let s: *unsafe [u8] = &arr[..];
    let opt: ?*unsafe [u8] = s;

    if let val = opt {
        assert val.len == 3;
        assert val[0] == 10;
        assert val[1] == 20;
    } else {
        return 34;
    }

    let none: ?*[u8] = nil;
    let none: ?*unsafe [u8] = nil;
    if let _ = none {
        return 35;
    }
    return 0;
}

fn checkLetElse() -> u8 {
unsafe fn checkLetElse() -> u8 {
    let arr: [u8; 3] = [10, 20, 30];
    let s = &arr[..];
    let opt: ?*[u8] = s;
    let s: *unsafe [u8] = &arr[..];
    let opt: ?*unsafe [u8] = s;

    let val = opt else {
        return 40;
    };
    assert val.len == 3;
    return 0;
}

fn returnNil() -> ?*[u8] {
fn returnNil() -> ?*unsafe [u8] {
    return nil;
}

fn returnSome() -> ?*[u8] {
    let arr: [u8; 2] = [42, 99];
    return &arr[..];
unsafe fn returnSome() -> ?*unsafe [u8] {
    static arr: [u8; 2] = [42, 99];
    return &arr[..] as *unsafe [u8];
}

fn checkReturn() -> u8 {
unsafe fn checkReturn() -> u8 {
    let a = returnNil();
    assert a == nil;
    let b = returnSome();
    assert b <> nil;
    if let val = b {

        return 53;
    }
    return 0;
}

fn checkMatch() -> u8 {
unsafe fn checkMatch() -> u8 {
    let arr: [u8; 2] = [5, 6];
    let s = &arr[..];
    let opt: ?*[u8] = s;
    let s: *unsafe [u8] = &arr[..];
    let opt: ?*unsafe [u8] = s;

    match opt {
        case nil => {
            return 60;
        }
        else => {}
    }

    let none: ?*[u8] = nil;
    let none: ?*unsafe [u8] = nil;
    match none {
        case nil => {}
        else => {
            return 61;
        }
    }
    return 0;
}

fn checkEq() -> u8 {
    let a: ?*[u8] = nil;
    let b: ?*[u8] = nil;
unsafe fn checkEq() -> u8 {
    let a: ?*unsafe [u8] = nil;
    let b: ?*unsafe [u8] = nil;

    // nil == nil
    assert a == b;

    let arr: [u8; 2] = [1, 2];
    let s = &arr[..];
    let c: ?*[u8] = s;
    let s: *unsafe [u8] = &arr[..];
    let c: ?*unsafe [u8] = s;

    // some <> nil
    assert c <> a;

    // some == some (same pointer)
    let d: ?*[u8] = s;
    let d: ?*unsafe [u8] = s;
    assert c == d;

    return 0;
}

@default fn main() -> u8 {
@default unsafe fn main() -> u8 {
    let r1 = checkSizes();
    if r1 <> 0 {
        return r1;
    }
    let r2 = checkNil();

test/tests/opt.slice.npo.ril +6 -3

data mut $returnSome$nominal$arr align 1 {
    w8 42;
    w8 99;
}

fn w8 $checkSizes() {
  @entry0
    br.eq w32 16 16 @assert.ok2 @assert.fail1;
  @assert.fail1
    unreachable;

    ret %0;
}

fn w64 $returnSome(w64 %0) {
  @entry0
    reserve %1 2 1;
    store w8 42 %1 0;
    store w8 99 %1 1;
    copy %1 $returnSome$nominal$arr;
    reserve %2 16 8;
    store w64 %1 %2 0;
    store w32 2 %2 8;
    store w32 2 %2 12;
    blit %0 %2 16;

test/tests/pointer.copy.edge.case.rad +4 -4

record Parser: Copy {
    nodes: [Node; 1],
    count: u32,
}

fn makeNode(p: *mut Parser, kind: NodeKind) -> *mut Node {
unsafe fn makeNode(p: *unsafe mut Parser, kind: NodeKind) -> *unsafe mut Node {
    let idx: u32 = p.count;
    set p.nodes[idx] = Node {
        span: Span { length: 0 },
        kind,
    };
    set p.count = idx + 1;
    return &mut p.nodes[idx];
}

fn setLen(n: *mut Node, len: u32) {
unsafe fn setLen(n: *unsafe mut Node, len: u32) {
    set n.span.length = len;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut parser: Parser = Parser {
        nodes: [Node {
            span: Span { length: 0 },
            kind: NodeKind::Placeholder,
        }; 1],

    set parser.nodes[0] = Node {
        span: Span { length: 0 },
        kind: NodeKind::Placeholder,
    };

    let node: *mut Node = makeNode(&mut parser, NodeKind::Bool(true));
    let node: *unsafe mut Node = makeNode(&mut parser, NodeKind::Bool(true));
    setLen(node, 4);

    match parser.nodes[0].kind {
        case NodeKind::Bool(value) => {
            assert value;

test/tests/pointer.slice.index.rad +2 -2

//! returns: 0

record Holder: Copy {
    ptr: *[i32],
    ptr: *unsafe [i32],
    zero: u32,
}

// Test that pointer-to-slice indexing correctly dereferences the slice header.
@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let arr: [i32; 2] = [5, 7];
    let h = Holder { ptr: &arr[..], zero: 0 };

    return (h.ptr[1]) - 7;
}

test/tests/pointer.stack.borrow.rad added +38 -0

1	+	//! returns: 0
2	+
3	+	/// Permanent values used by stored pointers.
4	+	static VALUES: [u32; 3] = [3, 5, 7];
5	+
6	+	/// Add a value to a stack location during a call.
7	+	fn increment(value: &mut u32, amount: u32) {
8	+	set *value += amount;
9	+	}
10	+
11	+	/// Sum borrowed values during a call.
12	+	fn sum(values: &[u32]) -> u32 {
13	+	let mut result: u32 = 0;
14	+	for value in values {
15	+	set result += value;
16	+	}
17	+	return result;
18	+	}
19	+
20	+	/// Return a slice backed by permanent storage.
21	+	fn values() -> *[u32] {
22	+	return &VALUES[1..];
23	+	}
24	+
25	+	/// Exercise stack borrows and stored pointers to permanent data.
26	+	@default fn main() -> i32 {
27	+	let mut value: u32 = 4;
28	+	increment(&mut value, 6);
29	+	if value <> 10 { return 1; }
30	+
31	+	let local: [u32; 3] = [value, 2, 3];
32	+	if sum(&local[..]) <> 15 { return 2; }
33	+	if sum(values()) <> 12 { return 3; }
34	+
35	+	let pointer: *u32 = &VALUES[0];
36	+	if *pointer <> 3 { return 4; }
37	+	return 0;
38	+	}

test/tests/pointer.stack.unsafe.rad added +18 -0

1	+	//! returns: 0
2	+
3	+	/// Exercise raw pointers while their stack storage is alive.
4	+	@default unsafe fn main() -> i32 {
5	+	let mut value: u32 = 4;
6	+	let pointer: *unsafe mut u32 = &mut value;
7	+	set *pointer = 9;
8	+	if value <> 9 { return 1; }
9	+
10	+	let mut values: [u32; 2] = [value, 2];
11	+	let slice: *unsafe mut [u32] = &mut values[..];
12	+	set slice[1] = 7;
13	+	if values[1] <> 7 { return 2; }
14	+
15	+	let cast = &value as *unsafe u32;
16	+	if *cast <> 9 { return 3; }
17	+	return 0;
18	+	}

test/tests/prog.bignum.rad +9 -9


/// Number of limbs per big number (128 bits = 4 x 32-bit words).
constant LIMBS: u32 = 4;

/// Set a big number to a u32 value.
fn bnFromU32(dst: *mut [u32], val: u32) {
fn bnFromU32(dst: &mut [u32], val: u32) {
    set dst[0] = val;
    let mut i: u32 = 1;
    while i < LIMBS {
        set dst[i] = 0;
        set i += 1;
    }
}

/// Set a big number to zero.
fn bnZero(dst: *mut [u32]) {
fn bnZero(dst: &mut [u32]) {
    let mut i: u32 = 0;
    while i < LIMBS {
        set dst[i] = 0;
        set i += 1;
    }
}

/// Copy src to dst.
fn bnCopy(dst: *mut [u32], src: *[u32]) {
fn bnCopy(dst: &mut [u32], src: &[u32]) {
    let mut i: u32 = 0;
    while i < LIMBS {
        set dst[i] = src[i];
        set i += 1;
    }
}

/// Compare two big numbers. Returns 0 if equal, 1 if a > b, -1 if a < b.
fn bnCmp(a: *[u32], b: *[u32]) -> i32 {
fn bnCmp(a: &[u32], b: &[u32]) -> i32 {
    let mut i: i32 = LIMBS as i32 - 1;
    while i >= 0 {
        if a[i as u32] > b[i as u32] {
            return 1;
        }

    }
    return 0;
}

/// Add two big numbers: dst = a + b. Returns carry (0 or 1).
fn bnAdd(dst: *mut [u32], a: *[u32], b: *[u32]) -> u32 {
fn bnAdd(dst: &mut [u32], a: &[u32], b: &[u32]) -> u32 {
    let mut carry: u32 = 0;
    let mut i: u32 = 0;
    while i < LIMBS {
        let sumLo: u32 = a[i] + b[i];
        let mut carry1: u32 = 0;

    }
    return carry;
}

/// Subtract two big numbers: dst = a - b. Returns borrow (0 or 1).
fn bnSub(dst: *mut [u32], a: *[u32], b: *[u32]) -> u32 {
fn bnSub(dst: &mut [u32], a: &[u32], b: &[u32]) -> u32 {
    let mut borrow: u32 = 0;
    let mut i: u32 = 0;
    while i < LIMBS {
        let diff: u32 = a[i] - b[i];
        let mut borrow1: u32 = 0;

    }
    return borrow;
}

/// Multiply two LIMBS-word numbers, producing a 2*LIMBS-word result in wide.
fn bnMul(wide: *mut [u32], a: *[u32], b: *[u32]) {
fn bnMul(wide: &mut [u32], a: &[u32], b: &[u32]) {
    let mut i: u32 = 0;
    while i < LIMBS * 2 {
        set wide[i] = 0;
        set i += 1;
    }

        set i += 1;
    }
}

/// Left shift a big number by 1 bit.
fn bnShl1(dst: *mut [u32], src: *[u32]) {
fn bnShl1(dst: &mut [u32], src: &[u32]) {
    let mut carry: u32 = 0;
    let mut i: u32 = 0;
    while i < LIMBS {
        let newCarry: u32 = src[i] >> 31;
        set dst[i] = (src[i] << 1) | carry;

        set i += 1;
    }
}

/// Right shift a big number by 1 bit.
fn bnShr1(dst: *mut [u32], src: *[u32]) {
fn bnShr1(dst: &mut [u32], src: &[u32]) {
    let mut carry: u32 = 0;
    let mut i: u32 = LIMBS;
    while i > 0 {
        set i -= 1;
        let newCarry: u32 = src[i] & 1;

test/tests/prog.binsearch.rad +4 -4

//! returns: 0
//! Binary search.
//! Search a pre-sorted array for present and absent values.

/// Binary search for `target` in `data`. Returns the index if found, or nil.
fn binarySearch(data: *[i32], target: i32) -> ?u32 {
fn binarySearch(data: &[i32], target: i32) -> ?u32 {
    let mut lo: i32 = 0;
    let mut hi: i32 = data.len as i32 - 1;

    while lo <= hi {
        let mid: i32 = lo + (hi - lo) / 2;

    }
    return nil;
}

/// Test searching for elements that exist.
fn testPresent(data: *[i32]) -> i32 {
fn testPresent(data: &[i32]) -> i32 {
    // First element.
    let idx0 = binarySearch(data, 3) else {
        return 1;
    };
    assert idx0 == 0;

    assert idx16 == 16;
    return 0;
}

/// Test searching for elements that do not exist.
fn testAbsent(data: *[i32]) -> i32 {
fn testAbsent(data: &[i32]) -> i32 {
    // Below range.
    assert binarySearch(data, 1) == nil;
    // Above range.
    assert binarySearch(data, 200) == nil;
    // Between existing elements.

    assert binarySearch(data, 99) == nil;
    return 0;
}

/// Test searching for every element in the array.
fn testAllPresent(data: *[i32]) -> i32 {
fn testAllPresent(data: &[i32]) -> i32 {
    for value, index in data {
        let found = binarySearch(data, value) else {
            return index as i32 + 1;
        };
        if found <> index {

test/tests/prog.bubblesort.rad +4 -4

//! returns: 0
//! Bubble sort.
//! Sort an array of integers and verify the result.

/// Bubble sort the array in ascending order.
fn bubbleSort(data: *mut [i32]) {
fn bubbleSort(data: &mut [i32]) {
    let mut n: u32 = data.len;
    while n > 1 {
        let mut swapped: bool = false;
        let mut i: u32 = 0;
        while i < n - 1 {

        set n -= 1;
    }
}

/// Verify the array is sorted in ascending order.
fn isSorted(data: *[i32]) -> bool {
fn isSorted(data: &[i32]) -> bool {
    let mut prev: ?i32 = nil;
    for val in data {
        if let p = prev {
            if p > val {
                return false;

    }
    return true;
}

/// Compute the sum of all elements.
fn sum(data: *[i32]) -> i32 {
fn sum(data: &[i32]) -> i32 {
    let mut total: i32 = 0;
    for val in data {
        set total += val;
    }
    return total;
}

/// Verify specific positions in the sorted output.
fn verifyPositions(data: *[i32]) -> i32 {
fn verifyPositions(data: &[i32]) -> i32 {
    // Sorted: 3 5 7 12 17 19 28 31 42 50 55 66 71 80 88 93
    assert data[0] == 3;
    assert data[1] == 5;
    assert data[2] == 7;
    assert data[7] == 31;

test/tests/prog.cordic.rad +8 -8

    sin: i32,
}

/// CORDIC rotation mode: compute cos(angle) and sin(angle).
/// Input angle in Q16.16 radians, must be in [-pi/2, pi/2].
fn cordicRotate(angle: i32, atanTable: *[i32]) -> CosSin {
fn cordicRotate(angle: i32, atanTable: &[i32]) -> CosSin {
    let mut x: i32 = CORDIC_GAIN;
    let mut y: i32 = 0;
    let mut z: i32 = angle;

    let mut i: u32 = 0;


    return CosSin { cos: x, sin: y };
}

/// Compute cos and sin for any angle by reducing to [-pi/2, pi/2].
fn cosSin(angle: i32, atanTable: *[i32]) -> CosSin {
fn cosSin(angle: i32, atanTable: &[i32]) -> CosSin {
    let mut a: i32 = angle;

    // Reduce to [-pi, pi].
    while a > PI {
        set a -= 2 * PI;

    }
    return result as i32;
}

/// Test cos(0) = 1, sin(0) = 0.
fn testZero(atanTable: *[i32]) -> i32 {
fn testZero(atanTable: &[i32]) -> i32 {
    let r: CosSin = cosSin(0, atanTable);
    // cos(0) should be close to 65536 (1.0 in Q16.16).
    let cosErr: i32 = abs(r.cos - SCALE);
    let sinErr: i32 = abs(r.sin);


    assert sinErr <= 655;
    return 0;
}

/// Test cos(pi/2) = 0, sin(pi/2) = 1.
fn testHalfPi(atanTable: *[i32]) -> i32 {
fn testHalfPi(atanTable: &[i32]) -> i32 {
    let r: CosSin = cosSin(HALF_PI, atanTable);
    let cosErr: i32 = abs(r.cos);
    let sinErr: i32 = abs(r.sin - SCALE);

    assert cosErr <= 655;
    assert sinErr <= 655;
    return 0;
}

/// Test cos(pi) = -1, sin(pi) = 0.
fn testPi(atanTable: *[i32]) -> i32 {
fn testPi(atanTable: &[i32]) -> i32 {
    let r: CosSin = cosSin(PI, atanTable);
    let cosErr: i32 = abs(r.cos + SCALE);
    let sinErr: i32 = abs(r.sin);

    assert cosErr <= 655;
    assert sinErr <= 655;
    return 0;
}

/// Test Pythagorean identity: sin^2 + cos^2 = 1 for several angles.
fn testPythagorean(atanTable: *[i32]) -> i32 {
fn testPythagorean(atanTable: &[i32]) -> i32 {
    // Test at 16 evenly spaced angles from 0 to 2*pi.
    let step: i32 = PI / 8;
    let mut i: i32 = 0 - PI;

    while i <= PI {

    }
    return 0;
}

/// Test symmetry: sin(-x) = -sin(x), cos(-x) = cos(x).
fn testSymmetry(atanTable: *[i32]) -> i32 {
fn testSymmetry(atanTable: &[i32]) -> i32 {
    let angles: [i32; 5] = [16384, 32768, 51472, 65536, 81920];

    let mut i: u32 = 0;
    while i < 5 {
        let a: i32 = angles[i];

    }
    return 0;
}

/// Test specific known value: cos(pi/3) = 0.5, sin(pi/3) = 0.866.
fn testPiThird(atanTable: *[i32]) -> i32 {
fn testPiThird(atanTable: &[i32]) -> i32 {
    // pi/3 in Q16.16 = 68629.
    let piThird: i32 = 68629;
    let r: CosSin = cosSin(piThird, atanTable);

    // cos(pi/3) = 0.5 = 32768 in Q16.16.

test/tests/prog.crc32.rad +5 -5

//! CRC-32.
//! Compute CRC-32 of a byte buffer using a 256-entry lookup table.
//! The table is built at startup. Verify against known checksums.

/// Build the CRC-32 lookup table using the standard polynomial 0xEDB88320.
fn buildTable(table: *mut [u32]) {
fn buildTable(table: &mut [u32]) {
    let mut i: u32 = 0;
    while i < 256 {
        let mut crc: u32 = i;
        let mut j: u32 = 0;
        while j < 8 {

        set i += 1;
    }
}

/// Compute CRC-32 of a byte slice.
fn crc32(table: *[u32], data: *[u8]) -> u32 {
fn crc32(table: &[u32], data: &[u8]) -> u32 {
    let mut crc: u32 = 0xFFFFFFFF;
    let mut i: u32 = 0;
    while i < data.len {
        let byte: u8 = data[i];
        let index: u32 = (crc ^ byte as u32) & 0xFF;

    }
    return crc ^ 0xFFFFFFFF;
}

/// Test the lookup table has been built correctly.
fn testTable(table: *[u32]) -> i32 {
fn testTable(table: &[u32]) -> i32 {
    // TABLE[0] should be 0 (zero input, all shifts produce zero).
    assert table[0] == 0;
    // Known value: TABLE[1] = 0x77073096
    assert table[1] == 0x77073096;
    // TABLE[255] is a known value: 0x2D02EF8D
    assert table[255] == 0x2D02EF8D;
    return 0;
}

/// Test CRC-32 of known strings.
fn testKnownCRC(table: *[u32]) -> i32 {
fn testKnownCRC(table: &[u32]) -> i32 {
    // CRC-32 of empty data should be 0x00000000.
    assert crc32(table, &[]) == 0x00000000;

    // CRC-32 of "123456789" = 0xCBF43926 (the standard check value).
    let check: [u8; 9] = [0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39];

    assert crc32(table, &single[..]) == 0xD3D99E8B;
    return 0;
}

/// Test CRC-32 of incrementally built data.
fn testIncremental(table: *[u32]) -> i32 {
fn testIncremental(table: &[u32]) -> i32 {
    // Build a 32-byte buffer with values 0..31.
    let mut buf: [u8; 32] = [0; 32];
    let mut i: u32 = 0;
    while i < 32 {
        set buf[i] = i as u8;

test/tests/prog.dijkstra.rad +23 -23

    dist: u32,
    node: u32,
}

record Graph: Copy {
    adj: *mut [[u32; 16]],
    dist: *mut [u32],
    prev: *mut [i32],
    visited: *mut [bool],
    adj: *unsafe mut [[u32; 16]],
    dist: *unsafe mut [u32],
    prev: *unsafe mut [i32],
    visited: *unsafe mut [bool],
    numNodes: u32,
    heap: *mut [HeapEntry],
    heap: *unsafe mut [HeapEntry],
    heapSize: u32,
}

fn heapSwap(g: *mut Graph, i: u32, j: u32) {
unsafe fn heapSwap(g: &mut Graph, i: u32, j: u32) {
    let tmp: HeapEntry = g.heap[i];
    set g.heap[i] = g.heap[j];
    set g.heap[j] = tmp;
}

fn siftUp(g: *mut Graph, pos: u32) {
unsafe fn siftUp(g: &mut Graph, pos: u32) {
    let mut i: u32 = pos;
    while i > 0 {
        let parent: u32 = (i - 1) / 2;
        if g.heap[i].dist < g.heap[parent].dist {
            heapSwap(g, i, parent);

            return;
        }
    }
}

fn siftDown(g: *mut Graph, pos: u32) {
unsafe fn siftDown(g: &mut Graph, pos: u32) {
    let mut i: u32 = pos;
    while true {
        let left: u32 = 2 * i + 1;
        let right: u32 = 2 * i + 2;
        let mut smallest: u32 = i;

        heapSwap(g, i, smallest);
        set i = smallest;
    }
}

fn heapPush(g: *mut Graph, dist: u32, node: u32) {
unsafe fn heapPush(g: &mut Graph, dist: u32, node: u32) {
    set g.heap[g.heapSize] = HeapEntry { dist, node };
    set g.heapSize += 1;
    siftUp(g, g.heapSize - 1);
}

/// Pop from the heap. Returns nil if the heap is empty.
fn heapPop(g: *mut Graph) -> ?HeapEntry {
unsafe fn heapPop(g: &mut Graph) -> ?HeapEntry {
    if g.heapSize == 0 {
        return nil;
    }
    let result: HeapEntry = g.heap[0];
    set g.heapSize -= 1;

        siftDown(g, 0);
    }
    return result;
}

fn addEdge(g: *mut Graph, from: u32, to: u32, weight: u32) {
unsafe fn addEdge(g: &mut Graph, from: u32, to: u32, weight: u32) {
    set g.adj[from][to] = weight;
}

fn addBidiEdge(g: *mut Graph, from: u32, to: u32, weight: u32) {
unsafe fn addBidiEdge(g: &mut Graph, from: u32, to: u32, weight: u32) {
    set g.adj[from][to] = weight;
    set g.adj[to][from] = weight;
}

fn resetGraph(g: *mut Graph, n: u32) {
unsafe fn resetGraph(g: &mut Graph, n: u32) {
    set g.numNodes = n;
    let mut i: u32 = 0;
    while i < MAX_NODES {
        let mut j: u32 = 0;
        while j < MAX_NODES {

    }
    set g.heapSize = 0;
}

/// Get the predecessor as an optional; -1 means no predecessor.
fn getPrev(g: *Graph, node: u32) -> ?u32 {
unsafe fn getPrev(g: &Graph, node: u32) -> ?u32 {
    let p = g.prev[node];
    if p < 0 {
        return nil;
    }
    return p as u32;
}

fn dijkstra(g: *mut Graph, source: u32) {
unsafe fn dijkstra(g: &mut Graph, source: u32) {
    set g.dist[source] = 0;
    heapPush(g, 0, source);

    while let entry = heapPop(g) {
        let u: u32 = entry.node;

        }
    }
}

/// Reconstruct the shortest path from source to target.
fn reconstructPath(g: *Graph, target: u32, path: *mut [u32]) -> u32 {
unsafe fn reconstructPath(g: &Graph, target: u32, path: &mut [u32]) -> u32 {
    let mut len: u32 = 0;

    set path[len] = target;
    set len += 1;


        set b -= 1;
    }
    return len;
}

fn testLinear(g: *mut Graph) -> i32 {
unsafe fn testLinear(g: &mut Graph) -> i32 {
    resetGraph(g, 5);
    addEdge(g, 0, 1, 10);
    addEdge(g, 1, 2, 10);
    addEdge(g, 2, 3, 10);
    addEdge(g, 3, 4, 10);

    assert path[4] == 4;

    return 0;
}

fn testShortcut(g: *mut Graph) -> i32 {
unsafe fn testShortcut(g: &mut Graph) -> i32 {
    resetGraph(g, 4);
    addEdge(g, 0, 1, 10);
    addEdge(g, 1, 2, 10);
    addEdge(g, 0, 3, 5);
    addEdge(g, 3, 2, 3);

    assert prev2 == 3;

    return 0;
}

fn testBidirectional(g: *mut Graph) -> i32 {
unsafe fn testBidirectional(g: &mut Graph) -> i32 {
    resetGraph(g, 5);
    addBidiEdge(g, 0, 1, 1);
    addBidiEdge(g, 1, 2, 2);
    addBidiEdge(g, 2, 3, 3);
    addBidiEdge(g, 3, 0, 4);

    }

    return 0;
}

fn testComplete(g: *mut Graph) -> i32 {
unsafe fn testComplete(g: &mut Graph) -> i32 {
    resetGraph(g, 8);

    let mut i: u32 = 0;
    while i < 8 {
        let mut j: u32 = 0;

    }

    return 0;
}

fn testDisconnected(g: *mut Graph) -> i32 {
unsafe fn testDisconnected(g: &mut Graph) -> i32 {
    resetGraph(g, 6);
    addEdge(g, 0, 1, 5);
    addEdge(g, 1, 2, 3);
    addEdge(g, 3, 4, 2);
    addEdge(g, 4, 5, 1);

    assert getPrev(g, 3) == nil;

    return 0;
}

fn testDiamond(g: *mut Graph) -> i32 {
unsafe fn testDiamond(g: &mut Graph) -> i32 {
    resetGraph(g, 5);
    addEdge(g, 0, 1, 5);
    addEdge(g, 0, 2, 5);
    addEdge(g, 1, 3, 5);
    addEdge(g, 2, 3, 5);

    assert prev3 == 1 or prev3 == 2;

    return 0;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut adj: [[u32; 16]; 16] = [[0xFFFFFFFF; 16]; 16];
    let mut dist: [u32; 16] = [0xFFFFFFFF; 16];
    let mut prev: [i32; 16] = [-1; 16];
    let mut visited: [bool; 16] = [false; 16];
    let mut heap: [HeapEntry; 256] = [HeapEntry { dist: 0, node: 0 }; 256];

test/tests/prog.eval.rad +17 -17

union EvalError: Copy {
    DivByZero
}

/// Allocate a new node, returning its index.
fn newNode(pool: *mut Pool, expr: Expr) -> u32 {
fn newNode(pool: &mut Pool, expr: Expr) -> u32 {
    let idx = pool.count;
    set pool.nodes[idx] = expr;
    set pool.count += 1;
    return idx;
}

/// Convenience constructors.
fn num(pool: *mut Pool, n: i32) -> u32 {
fn num(pool: &mut Pool, n: i32) -> u32 {
    return newNode(pool, Expr::Num(n));
}

fn add(pool: *mut Pool, left: u32, right: u32) -> u32 {
fn add(pool: &mut Pool, left: u32, right: u32) -> u32 {
    return newNode(pool, Expr::Add(BinOp { left, right }));
}

fn sub(pool: *mut Pool, left: u32, right: u32) -> u32 {
fn sub(pool: &mut Pool, left: u32, right: u32) -> u32 {
    return newNode(pool, Expr::Sub(BinOp { left, right }));
}

fn mul(pool: *mut Pool, left: u32, right: u32) -> u32 {
fn mul(pool: &mut Pool, left: u32, right: u32) -> u32 {
    return newNode(pool, Expr::Mul(BinOp { left, right }));
}

fn div(pool: *mut Pool, left: u32, right: u32) -> u32 {
fn div(pool: &mut Pool, left: u32, right: u32) -> u32 {
    return newNode(pool, Expr::Div(BinOp { left, right }));
}

fn neg(pool: *mut Pool, child: u32) -> u32 {
fn neg(pool: &mut Pool, child: u32) -> u32 {
    return newNode(pool, Expr::Neg(child));
}

/// Recursively evaluate the expression tree rooted at nodes[idx].
fn eval(nodes: *[Expr], idx: u32) -> i32 throws (EvalError) {
fn eval(nodes: &[Expr], idx: u32) -> i32 throws (EvalError) {
    let node = nodes[idx];
    match node {
        case Expr::Num(n) => {
            return n;
        }

        }
    }
}

/// Count the total number of nodes in the tree rooted at idx.
fn countNodes(nodes: *[Expr], idx: u32) -> u32 {
fn countNodes(nodes: &[Expr], idx: u32) -> u32 {
    let node = nodes[idx];
    match node {
        case Expr::Num(_) => {
            return 1;
        }

        }
    }
}

/// Reset the node pool.
fn reset(pool: *mut Pool) {
fn reset(pool: &mut Pool) {
    set pool.count = 0;
}

/// Test 1: Simple addition: 3 + 4 = 7
fn testSimpleAdd(pool: *mut Pool) -> i32 {
fn testSimpleAdd(pool: &mut Pool) -> i32 {
    reset(pool);
    let root = add(pool, num(pool, 3), num(pool, 4));
    assert try! eval(&pool.nodes[..], root) == 7;
    return 0;
}

/// Test 2: Nested expression: (2 + 3) * (4 - 1) = 5 * 3 = 15
fn testNested(pool: *mut Pool) -> i32 {
fn testNested(pool: &mut Pool) -> i32 {
    reset(pool);
    let left = add(pool, num(pool, 2), num(pool, 3));
    let right = sub(pool, num(pool, 4), num(pool, 1));
    let root = mul(pool, left, right);
    assert try! eval(&pool.nodes[..], root) == 15;
    assert countNodes(&pool.nodes[..], root) == 7;
    return 0;
}

/// Test 3: Complex expression: ((10 + 5) * 2 - 6) / 4 = (30 - 6) / 4 = 24 / 4 = 6
fn testComplex(pool: *mut Pool) -> i32 {
fn testComplex(pool: &mut Pool) -> i32 {
    reset(pool);
    let a = add(pool, num(pool, 10), num(pool, 5));
    let b = mul(pool, a, num(pool, 2));
    let c = sub(pool, b, num(pool, 6));
    let root = div(pool, c, num(pool, 4));
    assert try! eval(&pool.nodes[..], root) == 6;
    return 0;
}

/// Test 4: Negation: -(3 + 4) = -7
fn testNeg(pool: *mut Pool) -> i32 {
fn testNeg(pool: &mut Pool) -> i32 {
    reset(pool);
    let root = neg(pool, add(pool, num(pool, 3), num(pool, 4)));
    assert try! eval(&pool.nodes[..], root) == -7;
    return 0;
}

/// Test 5: Deep tree: 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 = 36
fn testDeep(pool: *mut Pool) -> i32 {
fn testDeep(pool: &mut Pool) -> i32 {
    reset(pool);
    let mut root = num(pool, 1);
    let values: [i32; 7] = [2, 3, 4, 5, 6, 7, 8];
    for v in values {
        set root = add(pool, root, num(pool, v));

    assert countNodes(&pool.nodes[..], root) == 15;
    return 0;
}

/// Test 6: Mixed operations: (100 - 3 * (2 + 8)) / 7 = (100 - 30) / 7 = 70 / 7 = 10
fn testMixed(pool: *mut Pool) -> i32 {
fn testMixed(pool: &mut Pool) -> i32 {
    reset(pool);
    let inner = add(pool, num(pool, 2), num(pool, 8));
    let product = mul(pool, num(pool, 3), inner);
    let diff = sub(pool, num(pool, 100), product);
    let root = div(pool, diff, num(pool, 7));
    assert try! eval(&pool.nodes[..], root) == 10;
    return 0;
}

/// Test 7: Single number.
fn testSingleNum(pool: *mut Pool) -> i32 {
fn testSingleNum(pool: &mut Pool) -> i32 {
    reset(pool);
    let root = num(pool, 42);
    assert try! eval(&pool.nodes[..], root) == 42;
    assert countNodes(&pool.nodes[..], root) == 1;
    return 0;

test/tests/prog.hanoi.rad +7 -7

    moves: [Move; 63],
    count: u32,
}

/// Record a move.
fn recordMove(ml: *mut MoveLog, disk: u32, from: u32, to: u32) {
fn recordMove(ml: &mut MoveLog, disk: u32, from: u32, to: u32) {
    if ml.count < MAX_MOVES {
        set ml.moves[ml.count] = Move { disk, from, to };
        set ml.count += 1;
    }
}

/// Solve Tower of Hanoi recursively.
/// Move `n` disks from peg `from` to peg `to` using `aux` as auxiliary.
fn hanoi(ml: *mut MoveLog, n: u32, from: u32, to: u32, aux: u32) {
fn hanoi(ml: &mut MoveLog, n: u32, from: u32, to: u32, aux: u32) {
    if n == 0 {
        return;
    }
    hanoi(ml, n - 1, from, aux, to);
    recordMove(ml, n, from, to);
    hanoi(ml, n - 1, aux, to, from);
}

/// Verify total move count.
fn testMoveCount(ml: *MoveLog) -> i32 {
fn testMoveCount(ml: &MoveLog) -> i32 {
    // For N disks, there are 2^N - 1 moves.
    assert ml.count == MAX_MOVES;
    return 0;
}

/// Verify specific moves.
fn testSpecificMoves(ml: *MoveLog) -> i32 {
fn testSpecificMoves(ml: &MoveLog) -> i32 {
    // First move: smallest disk (1) from peg 0 to peg 2.
    assert ml.moves[0].disk == 1;
    assert ml.moves[0].from == 0;
    assert ml.moves[0].to == 2;


record Pegs: Copy {
    stacks: [[u32; 6]; 3],
    top: [u32; 3],
}

fn pegPush(pegs: *mut Pegs, peg: u32, disk: u32) -> bool {
fn pegPush(pegs: &mut Pegs, peg: u32, disk: u32) -> bool {
    let t = pegs.top[peg];
    if t > 0 {
        // Check that the top disk is larger than the one being placed.
        if pegs.stacks[peg][t - 1] < disk {
            return false;

    set pegs.stacks[peg][t] = disk;
    set pegs.top[peg] = t + 1;
    return true;
}

fn pegPop(pegs: *mut Pegs, peg: u32) -> u32 {
fn pegPop(pegs: &mut Pegs, peg: u32) -> u32 {
    let t = pegs.top[peg];
    if t == 0 {
        // Should not happen in a valid solution.
        return 0;
    }


/// Simulate the peg state to verify correctness.
/// Replay all moves and check:
/// 1. No larger disk is placed on a smaller disk.
/// 2. All disks end up on peg 1.
fn testSimulate(ml: *MoveLog) -> i32 {
fn testSimulate(ml: &MoveLog) -> i32 {
    let mut pegs = Pegs {
        stacks: [[0; 6]; 3],
        top: [0, 0, 0],
    };


test/tests/prog.huffman.rad +26 -26

}

constant NIL: u32 = 0xFFFFFFFF;

record HuffState: Copy {
    nodes: *mut [HNode],
    nodes: *unsafe mut [HNode],
    nodeCount: u32,
    heap: *mut [u32],
    heap: *unsafe mut [u32],
    heapSize: u32,
    codeBits: *mut [u32],
    codeLen: *mut [u32],
    bitstream: *mut [u8],
    codeBits: *unsafe mut [u32],
    codeLen: *unsafe mut [u32],
    bitstream: *unsafe mut [u8],
    bitCount: u32,
}

fn newLeaf(s: *mut HuffState, freq: u32, symbol: u32) -> u32 {
unsafe fn newLeaf(s: *unsafe mut HuffState, freq: u32, symbol: u32) -> u32 {
    let idx: u32 = s.nodeCount;
    set s.nodes[idx] = HNode { freq, kind: HNodeKind::Leaf(symbol), left: NIL, right: NIL };
    set s.nodeCount += 1;
    return idx;
}

fn newInterior(s: *mut HuffState, freq: u32, left: u32, right: u32) -> u32 {
unsafe fn newInterior(s: *unsafe mut HuffState, freq: u32, left: u32, right: u32) -> u32 {
    let idx: u32 = s.nodeCount;
    set s.nodes[idx] = HNode { freq, kind: HNodeKind::Interior, left, right };
    set s.nodeCount += 1;
    return idx;
}

/// Get the symbol from a node, or nil if it's an interior node.
fn nodeSymbol(node: *HNode) -> ?u32 {
unsafe fn nodeSymbol(node: *unsafe HNode) -> ?u32 {
    match node.kind {
        case HNodeKind::Leaf(sym) => {
            return sym;
        }
        case HNodeKind::Interior => {
            return nil;
        }
    }
}

fn heapSwap(s: *mut HuffState, i: u32, j: u32) {
unsafe fn heapSwap(s: *unsafe mut HuffState, i: u32, j: u32) {
    let tmp: u32 = s.heap[i];
    set s.heap[i] = s.heap[j];
    set s.heap[j] = tmp;
}

fn heapFreq(s: *HuffState, i: u32) -> u32 {
unsafe fn heapFreq(s: *unsafe HuffState, i: u32) -> u32 {
    return s.nodes[s.heap[i]].freq;
}

fn siftUp(s: *mut HuffState, pos: u32) {
unsafe fn siftUp(s: *unsafe mut HuffState, pos: u32) {
    let mut i: u32 = pos;
    while i > 0 {
        let parent: u32 = (i - 1) / 2;
        if heapFreq(s, i) < heapFreq(s, parent) {
            heapSwap(s, i, parent);

            return;
        }
    }
}

fn siftDown(s: *mut HuffState, pos: u32) {
unsafe fn siftDown(s: *unsafe mut HuffState, pos: u32) {
    let mut i: u32 = pos;
    while true {
        let left: u32 = 2 * i + 1;
        let right: u32 = 2 * i + 2;
        let mut smallest: u32 = i;

        heapSwap(s, i, smallest);
        set i = smallest;
    }
}

fn heapPush(s: *mut HuffState, nodeIdx: u32) {
unsafe fn heapPush(s: *unsafe mut HuffState, nodeIdx: u32) {
    set s.heap[s.heapSize] = nodeIdx;
    set s.heapSize += 1;
    siftUp(s, s.heapSize - 1);
}

fn heapPop(s: *mut HuffState) -> u32 {
unsafe fn heapPop(s: *unsafe mut HuffState) -> u32 {
    let result: u32 = s.heap[0];
    set s.heapSize -= 1;
    set s.heap[0] = s.heap[s.heapSize];
    if s.heapSize > 0 {
        siftDown(s, 0);
    }
    return result;
}

fn buildTree(s: *mut HuffState, freqs: *[u32]) -> u32 {
unsafe fn buildTree(s: *unsafe mut HuffState, freqs: *unsafe [u32]) -> u32 {
    set s.nodeCount = 0;
    set s.heapSize = 0;

    for freq, sym in freqs {
        if freq > 0 {

    }

    return heapPop(s);
}

fn generateCodes(s: *mut HuffState, nodeIdx: u32, code: u32, depth: u32) {
unsafe fn generateCodes(s: *unsafe mut HuffState, nodeIdx: u32, code: u32, depth: u32) {
    match s.nodes[nodeIdx].kind {
        case HNodeKind::Leaf(sym) => {
            set s.codeBits[sym] = code;
            set s.codeLen[sym] = depth;
        }

            }
        }
    }
}

fn writeBit(s: *mut HuffState, bit: u32) {
unsafe fn writeBit(s: *unsafe mut HuffState, bit: u32) {
    let byteIdx: u32 = s.bitCount / 8;
    let bitIdx: u32 = 7 - (s.bitCount % 8);
    if bit == 1 {
        set s.bitstream[byteIdx] |= (1 as u8 << bitIdx as u8);
    }
    set s.bitCount += 1;
}

fn readBit(s: *HuffState, pos: u32) -> u32 {
unsafe fn readBit(s: *unsafe HuffState, pos: u32) -> u32 {
    let byteIdx: u32 = pos / 8;
    let bitIdx: u32 = 7 - (pos % 8);
    return (s.bitstream[byteIdx] >> bitIdx as u8) as u32 & 1;
}

fn encode(s: *mut HuffState, msg: *[u32]) {
unsafe fn encode(s: *unsafe mut HuffState, msg: *unsafe [u32]) {
    set s.bitCount = 0;
    let mut i: u32 = 0;
    while i < MAX_BITS {
        set s.bitstream[i] = 0;
        set i += 1;

            set b += 1;
        }
    }
}

fn decode(s: *HuffState, root: u32, numSymbols: u32, out: *mut [u32]) -> u32 {
unsafe fn decode(s: *unsafe HuffState, root: u32, numSymbols: u32, out: *unsafe mut [u32]) -> u32 {
    let mut bitPos: u32 = 0;
    let mut decoded: u32 = 0;

    while decoded < numSymbols {
        let mut cur: u32 = root;

        set decoded += 1;
    }
    return decoded;
}

fn resetCodes(s: *mut HuffState) {
unsafe fn resetCodes(s: *unsafe mut HuffState) {
    let mut i: u32 = 0;
    while i < MAX_SYMBOLS {
        set s.codeBits[i] = 0;
        set s.codeLen[i] = 0;
        set i += 1;
    }
}

fn testBasic(s: *mut HuffState) -> i32 {
unsafe fn testBasic(s: *unsafe mut HuffState) -> i32 {
    let freqs: [u32; 5] = [5, 9, 12, 13, 16];
    let root: u32 = buildTree(s, &freqs[..]);

    assert s.nodes[root].freq == 55;


    }

    return 0;
}

fn testRoundTrip(s: *mut HuffState) -> i32 {
unsafe fn testRoundTrip(s: *unsafe mut HuffState) -> i32 {
    let freqs: [u32; 5] = [5, 9, 12, 13, 16];
    let root: u32 = buildTree(s, &freqs[..]);

    resetCodes(s);
    generateCodes(s, root, 0, 0);

    }

    return 0;
}

fn testSkewed(s: *mut HuffState) -> i32 {
unsafe fn testSkewed(s: *unsafe mut HuffState) -> i32 {
    let freqs: [u32; 6] = [100, 1, 1, 1, 1, 1];
    let root: u32 = buildTree(s, &freqs[..]);

    resetCodes(s);
    generateCodes(s, root, 0, 0);

    }

    return 0;
}

fn testUniform(s: *mut HuffState) -> i32 {
unsafe fn testUniform(s: *unsafe mut HuffState) -> i32 {
    let freqs: [u32; 8] = [10, 10, 10, 10, 10, 10, 10, 10];
    let root: u32 = buildTree(s, &freqs[..]);

    assert s.nodes[root].freq == 80;


    }

    return 0;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut nodes: [HNode; 63] = [HNode { freq: 0, kind: HNodeKind::Interior, left: 0xFFFFFFFF, right: 0xFFFFFFFF }; 63];
    let mut heap: [u32; 63] = [0; 63];
    let mut codeBits: [u32; 32] = [0; 32];
    let mut codeLen: [u32; 32] = [0; 32];
    let mut bitstream: [u8; 512] = [0; 512];

test/tests/prog.hybridsort.rad +7 -7

//! Insertion sort and selection sort.
//! Sort two copies of the same data with each algorithm, then verify
//! both produce identical sorted output.

/// Copy `src` into `dst`.
fn copy(dst: *mut [i32], src: *[i32]) {
fn copy(dst: &mut [i32], src: &[i32]) {
    for val, i in src {
        set dst[i] = val;
    }
}

/// Insertion sort on the given array.
fn insertionSort(data: *mut [i32]) {
fn insertionSort(data: &mut [i32]) {
    let mut i: u32 = 1;
    while i < data.len {
        let key = data[i];
        let mut j: i32 = i as i32 - 1;
        while j >= 0 and data[j as u32] > key {

        set i += 1;
    }
}

/// Selection sort on the given array.
fn selectionSort(data: *mut [i32]) {
fn selectionSort(data: &mut [i32]) {
    let mut i: u32 = 0;
    while i < data.len - 1 {
        let mut minIdx: u32 = i;
        let mut j: u32 = i + 1;
        while j < data.len {

        set i += 1;
    }
}

/// Check that an array is sorted in ascending order.
fn isSorted(data: *[i32]) -> bool {
fn isSorted(data: &[i32]) -> bool {
    let mut prev: ?i32 = nil;
    for val in data {
        if let p = prev {
            if p > val {
                return false;

    }
    return true;
}

/// Compute sum of all elements.
fn sum(data: *[i32]) -> i32 {
fn sum(data: &[i32]) -> i32 {
    let mut total: i32 = 0;
    for val in data {
        set total += val;
    }
    return total;
}

/// Compare two arrays element by element.
fn arraysEqual(a: *[i32], b: *[i32]) -> i32 {
fn arraysEqual(a: &[i32], b: &[i32]) -> i32 {
    for val, i in a {
        if val <> b[i] {
            return i as i32 + 1;
        }
    }
    return 0;
}

/// Verify specific positions in the sorted output.
fn verifyPositions(data: *[i32]) -> i32 {
fn verifyPositions(data: &[i32]) -> i32 {
    // Sorted: 2 3 6 8 10 14 19 25 27 33 39 41 45 48 53 56 62 67 72 74 81 88 91 97
    let expected: [i32; 6] = [2, 3, 6, 41, 91, 97];
    let indices: [u32; 6] = [0, 1, 2, 11, 22, 23];

    for exp, i in expected {

test/tests/prog.linkedlist.rad +14 -14

    free: u32,
    head: ?u32,
}

/// Allocate a node from the pool. Returns its index.
fn alloc(list: *mut List, value: i32) -> u32 {
fn alloc(list: &mut List, value: i32) -> u32 {
    let idx = list.free;
    set list.free += 1;
    set list.pool[idx] = Node { value, next: nil };
    return idx;
}

/// Push a value onto the front of the list.
fn push(list: *mut List, value: i32) {
fn push(list: &mut List, value: i32) {
    let idx = alloc(list, value);
    set list.pool[idx].next = list.head;
    set list.head = idx;
}

/// Pop a value from the front of the list. Returns nil if empty.
fn pop(list: *mut List) -> ?i32 {
fn pop(list: &mut List) -> ?i32 {
    let idx = list.head else {
        return nil;
    };
    let value = list.pool[idx].value;
    set list.head = list.pool[idx].next;
    return value;
}

/// Get the length of the list.
fn length(list: *List) -> u32 {
fn length(list: &List) -> u32 {
    let mut count: u32 = 0;
    let mut cur = list.head;
    while let idx = cur {
        set count += 1;
        set cur = list.pool[idx].next;
    }
    return count;
}

/// Find a value in the list. Returns the node index if found, or nil.
fn find(list: *List, value: i32) -> ?u32 {
fn find(list: &List, value: i32) -> ?u32 {
    let mut cur = list.head;
    while let idx = cur {
        if list.pool[idx].value == value {
            return idx;
        }

    }
    return nil;
}

/// Get the value at a given index (0-based from head).
fn valueAt(list: *List, index: u32) -> ?i32 {
fn valueAt(list: &List, index: u32) -> ?i32 {
    let mut cur = list.head;
    let mut i: u32 = 0;
    while let idx = cur {
        if i == index {
            return list.pool[idx].value;

    }
    return nil;
}

/// Reverse the linked list in-place.
fn reverse(list: *mut List) {
fn reverse(list: &mut List) {
    let mut prev: ?u32 = nil;
    let mut cur = list.head;
    while let idx = cur {
        let next = list.pool[idx].next;
        set list.pool[idx].next = prev;

    }
    set list.head = prev;
}

/// Compute the sum of all values in the list.
fn sum(list: *List) -> i32 {
fn sum(list: &List) -> i32 {
    let mut total: i32 = 0;
    let mut cur = list.head;
    while let idx = cur {
        set total += list.pool[idx].value;
        set cur = list.pool[idx].next;
    }
    return total;
}

/// Reset the list to empty.
fn reset(list: *mut List) {
fn reset(list: &mut List) {
    set list.head = nil;
    set list.free = 0;
}

/// Test basic push and length.
fn testPushLength(list: *mut List) -> i32 {
fn testPushLength(list: &mut List) -> i32 {
    push(list, 10);
    push(list, 20);
    push(list, 30);

    assert length(list) == 3;

    assert v2 == 10;
    return 0;
}

/// Test pop.
fn testPop(list: *mut List) -> i32 {
fn testPop(list: &mut List) -> i32 {
    let v = pop(list) else {
        return 1;
    };
    assert v == 30;
    assert length(list) == 2;

    assert v0 == 20;
    return 0;
}

/// Test find.
fn testFind(list: *mut List) -> i32 {
fn testFind(list: &mut List) -> i32 {
    // 20 should be found.
    assert find(list, 20) <> nil;
    // 10 should be found.
    assert find(list, 10) <> nil;
    // 30 was popped, should not be found.

    assert find(list, 99) == nil;
    return 0;
}

/// Test reverse.
fn testReverse(list: *mut List) -> i32 {
fn testReverse(list: &mut List) -> i32 {
    // Current list: 20 -> 10
    // Add more elements.
    push(list, 40);
    push(list, 50);
    // List: 50 -> 40 -> 20 -> 10

    assert sum(list) == sumBefore;
    return 0;
}

/// Test building a larger list.
fn testLargerList(list: *mut List) -> i32 {
fn testLargerList(list: &mut List) -> i32 {
    reset(list);

    // Push 32 elements.
    let mut i: u32 = 0;
    while i < 32 {

test/tests/prog.lzw.rad +23 -23

    prefix: u32,
    suffix: u8,
}

record LzwState: Copy {
    encDict: *mut [DictEntry],
    encDict: *unsafe mut [DictEntry],
    encDictSize: u32,
    decDict: *mut [DictEntry],
    decDict: *unsafe mut [DictEntry],
    decDictSize: u32,
    encoded: *mut [u32],
    encoded: *unsafe mut [u32],
    encLen: u32,
    decoded: *mut [u8],
    decoded: *unsafe mut [u8],
    decLen: u32,
    temp: *mut [u8],
    temp: *unsafe mut [u8],
}

fn initEncDict(s: *mut LzwState) {
unsafe fn initEncDict(s: *unsafe mut LzwState) {
    set s.encDictSize = INIT_DICT;
    let mut i: u32 = 0;
    while i < 256 {
        set s.encDict[i] = DictEntry { prefix: 0xFFFF, suffix: i as u8 };
        set i += 1;
    }
}

fn initDecDict(s: *mut LzwState) {
unsafe fn initDecDict(s: *unsafe mut LzwState) {
    set s.decDictSize = INIT_DICT;
    let mut i: u32 = 0;
    while i < 256 {
        set s.decDict[i] = DictEntry { prefix: 0xFFFF, suffix: i as u8 };
        set i += 1;
    }
}

fn dictLookup(s: *LzwState, prefix: u32, suffix: u8) -> u32 {
unsafe fn dictLookup(s: *unsafe LzwState, prefix: u32, suffix: u8) -> u32 {
    let mut i: u32 = 0;
    while i < s.encDictSize {
        if s.encDict[i].prefix == prefix and s.encDict[i].suffix == suffix {
            return i;
        }
        set i += 1;
    }
    return 0xFFFFFFFF;
}

fn dictAdd(s: *mut LzwState, prefix: u32, suffix: u8) {
unsafe fn dictAdd(s: *unsafe mut LzwState, prefix: u32, suffix: u8) {
    if s.encDictSize < MAX_DICT {
        set s.encDict[s.encDictSize] = DictEntry { prefix, suffix };
        set s.encDictSize += 1;
    }
}

fn emitCode(s: *mut LzwState, code: u32) {
unsafe fn emitCode(s: *unsafe mut LzwState, code: u32) {
    set s.encoded[s.encLen] = code;
    set s.encLen += 1;
}

fn encode(s: *mut LzwState, data: *[u8]) {
unsafe fn encode(s: *unsafe mut LzwState, data: &[u8]) {
    initEncDict(s);
    set s.encLen = 0;

    if data.len == 0 {
        emitCode(s, EOI_CODE);

    }
    emitCode(s, w);
    emitCode(s, EOI_CODE);
}

fn decodeString(s: *mut LzwState, code: u32) -> u32 {
unsafe fn decodeString(s: *unsafe mut LzwState, code: u32) -> u32 {
    let mut len: u32 = 0;
    let mut c: u32 = code;
    while c <> 0xFFFF and c < s.decDictSize {
        set s.temp[len] = s.decDict[c].suffix;
        set len += 1;

        set b -= 1;
    }
    return len;
}

fn firstByte(s: *LzwState, code: u32) -> u8 {
unsafe fn firstByte(s: *unsafe LzwState, code: u32) -> u8 {
    let mut c: u32 = code;
    while s.decDict[c].prefix <> 0xFFFF and s.decDict[c].prefix < s.decDictSize {
        set c = s.decDict[c].prefix;
    }
    return s.decDict[c].suffix;
}

fn decDictAdd(s: *mut LzwState, prefix: u32, suffix: u8) {
unsafe fn decDictAdd(s: *unsafe mut LzwState, prefix: u32, suffix: u8) {
    if s.decDictSize < MAX_DICT {
        set s.decDict[s.decDictSize] = DictEntry { prefix, suffix };
        set s.decDictSize += 1;
    }
}

fn outputByte(s: *mut LzwState, b: u8) {
unsafe fn outputByte(s: *unsafe mut LzwState, b: u8) {
    set s.decoded[s.decLen] = b;
    set s.decLen += 1;
}

fn decode(s: *mut LzwState) {
unsafe fn decode(s: *unsafe mut LzwState) {
    initDecDict(s);
    set s.decLen = 0;

    if s.encLen == 0 {
        return;

        }
        set prevCode = code;
    }
}

fn testSimple(s: *mut LzwState) -> i32 {
unsafe fn testSimple(s: *unsafe mut LzwState) -> i32 {
    let data: *[u8] = "ABABABABAB";
    encode(s, data);

    assert s.encoded[s.encLen - 1] == EOI_CODE;


        set i += 1;
    }
    return 0;
}

fn testDistinct(s: *mut LzwState) -> i32 {
unsafe fn testDistinct(s: *unsafe mut LzwState) -> i32 {
    let data: [u8; 16] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
    encode(s, &data[..]);

    decode(s);
    assert s.decLen == 16;

        set i += 1;
    }
    return 0;
}

fn testRepetitive(s: *mut LzwState) -> i32 {
unsafe fn testRepetitive(s: *unsafe mut LzwState) -> i32 {
    let mut data: [u8; 64] = [65; 64];
    encode(s, &data[..]);

    assert s.encLen < 32;


        set i += 1;
    }
    return 0;
}

fn testMixed(s: *mut LzwState) -> i32 {
unsafe fn testMixed(s: *unsafe mut LzwState) -> i32 {
    let data: *[u8] = "TOBEORNOTTOBEORTOBEORNOT";
    encode(s, data);

    decode(s);
    assert s.decLen == 24;

    assert s.encLen - 1 < 24;

    return 0;
}

fn testEmpty(s: *mut LzwState) -> i32 {
unsafe fn testEmpty(s: *unsafe mut LzwState) -> i32 {
    encode(s, &[]);
    assert s.encLen == 1;
    assert s.encoded[0] == EOI_CODE;

    decode(s);
    assert s.decLen == 0;
    return 0;
}

fn testSingle(s: *mut LzwState) -> i32 {
unsafe fn testSingle(s: *unsafe mut LzwState) -> i32 {
    let data: *[u8] = "*";
    encode(s, data);

    decode(s);
    assert s.decLen == 1;
    assert s.decoded[0] == 42;
    return 0;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut encDict: [DictEntry; 512] = [DictEntry { prefix: 0xFFFF, suffix: 0 }; 512];
    let mut decDict: [DictEntry; 512] = [DictEntry { prefix: 0xFFFF, suffix: 0 }; 512];
    let mut encoded: [u32; 512] = [0; 512];
    let mut decoded: [u8; 256] = [0; 256];
    let mut temp: [u8; 256] = [0; 256];

test/tests/prog.matmul.rad +5 -5

record Mat4: Copy {
    rows: [[i32; 4]; 4],
}

/// Perform matrix multiplication: c = a * b.
fn matmul(c: *mut Mat4, a: *Mat4, b: *Mat4) {
fn matmul(c: &mut Mat4, a: &Mat4, b: &Mat4) {
    let mut i: u32 = 0;
    while i < N {
        let mut j: u32 = 0;
        while j < N {
            let mut sum: i32 = 0;

        set i += 1;
    }
}

/// Verify c matches expected.
fn verifyResult(c: *Mat4, expected: *Mat4) -> i32 {
fn verifyResult(c: &Mat4, expected: &Mat4) -> i32 {
    let mut i: u32 = 0;
    while i < N {
        let mut j: u32 = 0;
        while j < N {
            if c.rows[i][j] <> expected.rows[i][j] {

    }
    return 0;
}

/// Compute the trace (sum of diagonal) of a matrix.
fn trace(m: *Mat4) -> i32 {
fn trace(m: &Mat4) -> i32 {
    let mut sum: i32 = 0;
    let mut i: u32 = 0;
    while i < N {
        set sum += m.rows[i][i];
        set i += 1;
    }
    return sum;
}

/// Zero out a matrix.
fn zero(m: *mut Mat4) {
fn zero(m: &mut Mat4) {
    let mut i: u32 = 0;
    while i < N {
        let mut j: u32 = 0;
        while j < N {
            set m.rows[i][j] = 0;

        set i += 1;
    }
}

/// Multiply matrices multiple times to test repeated computation.
fn testRepeatedMultiply(c: *mut Mat4, a: *Mat4, b: *Mat4) -> i32 {
fn testRepeatedMultiply(c: &mut Mat4, a: &Mat4, b: &Mat4) -> i32 {
    // First pass already done, trace = 13+43+43+85 = 184.
    assert trace(c) == 184;

    // Zero out c and re-multiply to ensure idempotent.
    zero(c);

test/tests/prog.mersenne.rad +11 -11

constant MATRIX_A: u32 = 0x9908B0DF;
constant UPPER_MASK: u32 = 0x80000000;
constant LOWER_MASK: u32 = 0x7FFFFFFF;

record MtState: Copy {
    mt: *mut [u32],
    mt: *unsafe mut [u32],
    mti: u32,
}

fn mtInit(s: *mut MtState, seed: u32) {
unsafe fn mtInit(s: &mut MtState, seed: u32) {
    set s.mt[0] = seed;
    let mut i: u32 = 1;
    while i < N {
        let prev: u32 = s.mt[i - 1];
        let xored: u32 = prev ^ (prev >> 30);

        set i += 1;
    }
    set s.mti = N;
}

fn generateNumbers(s: *mut MtState) {
unsafe fn generateNumbers(s: &mut MtState) {
    let mut i: u32 = 0;

    while i < N - M {
        let y: u32 = (s.mt[i] & UPPER_MASK) | (s.mt[i + 1] & LOWER_MASK);
        let mut mag: u32 = 0;

    set s.mt[N - 1] = s.mt[M - 1] ^ (y >> 1) ^ mag;

    set s.mti = 0;
}

fn mtNext(s: *mut MtState) -> u32 {
unsafe fn mtNext(s: &mut MtState) -> u32 {
    if s.mti >= N {
        generateNumbers(s);
    }

    let mut y: u32 = s.mt[s.mti];

    set y ^= (y >> 18);

    return y;
}

fn testKnownSequence(s: *mut MtState) -> i32 {
unsafe fn testKnownSequence(s: &mut MtState) -> i32 {
    mtInit(s, 1);

    let v0: u32 = mtNext(s);
    assert v0 == 1791095845;


    assert v4 == 491263;

    return 0;
}

fn testDeterminism(s: *mut MtState) -> i32 {
unsafe fn testDeterminism(s: &mut MtState) -> i32 {
    mtInit(s, 42);

    let mut first: [u32; 10] = [0; 10];
    let mut i: u32 = 0;
    while i < 10 {

    }

    return 0;
}

fn testDifferentSeeds(s: *mut MtState) -> i32 {
unsafe fn testDifferentSeeds(s: &mut MtState) -> i32 {
    mtInit(s, 1);
    let a: u32 = mtNext(s);

    mtInit(s, 2);
    let b: u32 = mtNext(s);

    assert a <> c;

    return 0;
}

fn testChiSquared(s: *mut MtState) -> i32 {
unsafe fn testChiSquared(s: &mut MtState) -> i32 {
    mtInit(s, 12345);

    constant NUM_BINS: u32 = 16;
    constant NUM_SAMPLES: u32 = 1600;
    constant EXPECTED: u32 = 100;

    }

    return 0;
}

fn testRegeneration(s: *mut MtState) -> i32 {
unsafe fn testRegeneration(s: &mut MtState) -> i32 {
    mtInit(s, 7);

    let mut last: u32 = 0;
    let mut i: u32 = 0;
    while i < 700 {

    assert more <> 0;

    return 0;
}

fn testBitCoverage(s: *mut MtState) -> i32 {
unsafe fn testBitCoverage(s: &mut MtState) -> i32 {
    mtInit(s, 999);

    let mut orAll: u32 = 0;
    let mut andAll: u32 = 0xFFFFFFFF;


    assert andAll == 0;

    return 0;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut mt: [u32; 624] = [0; 624];
    let mut s: MtState = MtState {
        mt: &mut mt[..],
        mti: 625,
    };

test/tests/prog.nqueens.rad +8 -8

//! for boards of size 1 through 8 and verify against known solution counts.

constant MAX_N: u32 = 8;

record Board: Copy {
    queens: *mut [i32],
    queens: *unsafe mut [i32],
    solutionCount: u32,
    boardSize: u32,
}

fn isSafe(b: *Board, row: u32, col: u32) -> bool {
unsafe fn isSafe(b: &Board, row: u32, col: u32) -> bool {
    let mut i: u32 = 0;
    while i < row {
        let qcol: i32 = b.queens[i];
        if qcol == col as i32 {
            return false;

        set i += 1;
    }
    return true;
}

fn solve(b: *mut Board, row: u32) {
unsafe fn solve(b: &mut Board, row: u32) {
    if row == b.boardSize {
        set b.solutionCount += 1;
        return;
    }
    let mut col: u32 = 0;

        }
        set col += 1;
    }
}

fn resetBoard(b: *mut Board) {
unsafe fn resetBoard(b: &mut Board) {
    let mut i: u32 = 0;
    while i < MAX_N {
        set b.queens[i] = -1;
        set i += 1;
    }
    set b.solutionCount = 0;
}

fn solveNQueens(b: *mut Board, n: u32) -> u32 {
unsafe fn solveNQueens(b: &mut Board, n: u32) -> u32 {
    resetBoard(b);
    set b.boardSize = n;
    solve(b, 0);
    return b.solutionCount;
}

fn testAllSizes(b: *mut Board) -> i32 {
unsafe fn testAllSizes(b: &mut Board) -> i32 {
    let expected: [u32; 9] = [0, 1, 0, 0, 2, 10, 4, 40, 92];
    let mut n: u32 = 1;
    while n <= 8 {
        let count: u32 = solveNQueens(b, n);
        if count <> expected[n] {

    }

    return 0;
}

fn testDeterminism(b: *mut Board) -> i32 {
unsafe fn testDeterminism(b: &mut Board) -> i32 {
    let count1: u32 = solveNQueens(b, 8);
    let count2: u32 = solveNQueens(b, 8);
    let count3: u32 = solveNQueens(b, 8);

    assert count1 == 92;

    assert expected[8] > expected[7];

    return 0;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut queens: [i32; 8] = [-1; 8];
    let mut b: Board = Board {
        queens: &mut queens[..],
        solutionCount: 0,
        boardSize: 0,

test/tests/prog.rbtree.rad +18 -18

    right: u32,
    parent: u32,
}

record RBTree: Copy {
    pool: *mut [RBNode],
    pool: *unsafe mut [RBNode],
    poolNext: u32,
    root: u32,
    inorder: *mut [i32],
    inorder: *unsafe mut [i32],
    inorderCount: u32,
}

fn allocNode(t: *mut RBTree, key: i32) -> u32 {
unsafe fn allocNode(t: *unsafe mut RBTree, key: i32) -> u32 {
    let idx: u32 = t.poolNext;
    set t.poolNext += 1;
    set t.pool[idx] = RBNode { key, color: RED, left: NIL, right: NIL, parent: NIL };
    return idx;
}

fn rotateLeft(t: *mut RBTree, x: u32) {
unsafe fn rotateLeft(t: *unsafe mut RBTree, x: u32) {
    let y: u32 = t.pool[x].right;
    set t.pool[x].right = t.pool[y].left;
    if t.pool[y].left <> NIL {
        set t.pool[t.pool[y].left].parent = x;
    }

    }
    set t.pool[y].left = x;
    set t.pool[x].parent = y;
}

fn rotateRight(t: *mut RBTree, x: u32) {
unsafe fn rotateRight(t: *unsafe mut RBTree, x: u32) {
    let y: u32 = t.pool[x].left;
    set t.pool[x].left = t.pool[y].right;
    if t.pool[y].right <> NIL {
        set t.pool[t.pool[y].right].parent = x;
    }

    }
    set t.pool[y].right = x;
    set t.pool[x].parent = y;
}

fn insertFixup(t: *mut RBTree, zArg: u32) {
unsafe fn insertFixup(t: *unsafe mut RBTree, zArg: u32) {
    let mut z: u32 = zArg;
    while t.pool[t.pool[z].parent].color == RED {
        if t.pool[z].parent == t.pool[t.pool[t.pool[z].parent].parent].left {
            let y: u32 = t.pool[t.pool[t.pool[z].parent].parent].right;
            if t.pool[y].color == RED {

        }
    }
    set t.pool[t.root].color = BLACK;
}

fn insert(t: *mut RBTree, key: i32) {
unsafe fn insert(t: *unsafe mut RBTree, key: i32) {
    let z: u32 = allocNode(t, key);
    let mut y: u32 = NIL;
    let mut x: u32 = t.root;

    while x <> NIL {

    }

    insertFixup(t, z);
}

fn search(t: *RBTree, key: i32) -> bool {
unsafe fn search(t: *unsafe RBTree, key: i32) -> bool {
    let mut x: u32 = t.root;
    while x <> NIL {
        if key == t.pool[x].key {
            return true;
        } else if key < t.pool[x].key {

        }
    }
    return false;
}

fn inorderWalk(t: *mut RBTree, x: u32) {
unsafe fn inorderWalk(t: *unsafe mut RBTree, x: u32) {
    if x == NIL {
        return;
    }
    inorderWalk(t, t.pool[x].left);
    set t.inorder[t.inorderCount] = t.pool[x].key;
    set t.inorderCount += 1;
    inorderWalk(t, t.pool[x].right);
}

fn countNodes(t: *RBTree, x: u32) -> u32 {
unsafe fn countNodes(t: *unsafe RBTree, x: u32) -> u32 {
    if x == NIL {
        return 0;
    }
    return 1 + countNodes(t, t.pool[x].left) + countNodes(t, t.pool[x].right);
}

fn blackHeight(t: *RBTree, x: u32) -> i32 {
unsafe fn blackHeight(t: *unsafe RBTree, x: u32) -> i32 {
    if x == NIL {
        return 1;
    }
    let leftBH: i32 = blackHeight(t, t.pool[x].left);
    let rightBH: i32 = blackHeight(t, t.pool[x].right);

        return leftBH + 1;
    }
    return leftBH;
}

fn noRedRed(t: *RBTree, x: u32) -> bool {
unsafe fn noRedRed(t: *unsafe RBTree, x: u32) -> bool {
    if x == NIL {
        return true;
    }
    if t.pool[x].color == RED {
        if t.pool[t.pool[x].left].color == RED {

        return false;
    }
    return noRedRed(t, t.pool[x].right);
}

fn resetTree(t: *mut RBTree) {
unsafe fn resetTree(t: *unsafe mut RBTree) {
    let mut i: u32 = 0;
    while i < POOL_SIZE {
        set t.pool[i] = RBNode { key: 0, color: BLACK, left: NIL, right: NIL, parent: NIL };
        set i += 1;
    }
    set t.poolNext = 1;
    set t.root = NIL;
    set t.inorderCount = 0;
}

fn testAscending(t: *mut RBTree) -> i32 {
unsafe fn testAscending(t: *unsafe mut RBTree) -> i32 {
    resetTree(t);

    let mut i: i32 = 0;
    while i < 32 {
        insert(t, i);

    }

    return 0;
}

fn testDescending(t: *mut RBTree) -> i32 {
unsafe fn testDescending(t: *unsafe mut RBTree) -> i32 {
    resetTree(t);

    let mut i: i32 = 31;
    while i >= 0 {
        insert(t, i);

    }

    return 0;
}

fn testRandom(t: *mut RBTree) -> i32 {
unsafe fn testRandom(t: *unsafe mut RBTree) -> i32 {
    resetTree(t);

    let mut inserted: [bool; 48] = [false; 48];
    let mut seed: u32 = 42;
    let mut count: u32 = 0;

    }

    return 0;
}

fn testHeight(t: *mut RBTree) -> i32 {
unsafe fn testHeight(t: *unsafe mut RBTree) -> i32 {
    resetTree(t);

    let mut i: i32 = 0;
    while i < 63 {
        insert(t, i);

    assert bh <= 7;

    return 0;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut pool: [RBNode; 128] = [RBNode { key: 0, color: 1, left: 0, right: 0, parent: 0 }; 128];
    let mut inorder: [i32; 128] = [0; 128];

    let mut t: RBTree = RBTree {
        pool: &mut pool[..],

test/tests/prog.regex.rad +28 -28

    start: u32,
    endState: u32,
}

record NfaState: Copy {
    trans: *mut [Trans],
    trans: *unsafe mut [Trans],
    transCount: u32,
    stateFirst: *mut [u32],
    transNext: *mut [u32],
    stateFirst: *unsafe mut [u32],
    transNext: *unsafe mut [u32],
    stateCount: u32,
    acceptState: u32,
    current: *mut [u32],
    nextSet: *mut [u32],
    closure: *mut [u32],
    fragStack: *mut [Frag],
    current: *unsafe mut [u32],
    nextSet: *unsafe mut [u32],
    closure: *unsafe mut [u32],
    fragStack: *unsafe mut [Frag],
    fragTop: u32,
}

fn newState(nfa: *mut NfaState) -> u32 {
unsafe fn newState(nfa: *unsafe mut NfaState) -> u32 {
    let s: u32 = nfa.stateCount;
    set nfa.stateFirst[s] = NIL;
    set nfa.stateCount += 1;
    return s;
}

fn addTrans(nfa: *mut NfaState, from: u32, kind: u32, ch: u8, to: u32) {
unsafe fn addTrans(nfa: *unsafe mut NfaState, from: u32, kind: u32, ch: u8, to: u32) {
    let idx: u32 = nfa.transCount;
    set nfa.trans[idx] = Trans { kind, ch, to };
    set nfa.transNext[idx] = nfa.stateFirst[from];
    set nfa.stateFirst[from] = idx;
    set nfa.transCount += 1;
}

fn pushFrag(nfa: *mut NfaState, f: Frag) {
unsafe fn pushFrag(nfa: *unsafe mut NfaState, f: Frag) {
    set nfa.fragStack[nfa.fragTop] = f;
    set nfa.fragTop += 1;
}

fn popFrag(nfa: *mut NfaState) -> Frag {
unsafe fn popFrag(nfa: *unsafe mut NfaState) -> Frag {
    set nfa.fragTop -= 1;
    return nfa.fragStack[nfa.fragTop];
}

fn setEmpty(s: *mut [u32]) {
unsafe fn setEmpty(s: *unsafe mut [u32]) {
    set s[0] = 0;
    set s[1] = 0;
    set s[2] = 0;
    set s[3] = 0;
}

fn setAdd(s: *mut [u32], bit: u32) {
unsafe fn setAdd(s: *unsafe mut [u32], bit: u32) {
    let word: u32 = bit / 32;
    let pos: u32 = bit % 32;
    set s[word] |= (1 << pos);
}

fn setHas(s: *[u32], bit: u32) -> bool {
unsafe fn setHas(s: *unsafe [u32], bit: u32) -> bool {
    let word: u32 = bit / 32;
    let pos: u32 = bit % 32;
    return (s[word] >> pos) & 1 == 1;
}

fn setIsEmpty(s: *[u32]) -> bool {
unsafe fn setIsEmpty(s: *unsafe [u32]) -> bool {
    return s[0] == 0 and s[1] == 0 and s[2] == 0 and s[3] == 0;
}

fn setCopy(dst: *mut [u32], src: *[u32]) {
unsafe fn setCopy(dst: *unsafe mut [u32], src: *unsafe [u32]) {
    set dst[0] = src[0];
    set dst[1] = src[1];
    set dst[2] = src[2];
    set dst[3] = src[3];
}

fn epsilonClosure(nfa: *mut NfaState, states: *mut [u32]) {
unsafe fn epsilonClosure(nfa: *unsafe mut NfaState, states: *unsafe mut [u32]) {
    setCopy(nfa.closure, states);

    let mut changed: bool = true;
    while changed {
        set changed = false;

    }

    setCopy(states, nfa.closure);
}

fn resetNFA(nfa: *mut NfaState) {
unsafe fn resetNFA(nfa: *unsafe mut NfaState) {
    set nfa.stateCount = 0;
    set nfa.transCount = 0;
    set nfa.fragTop = 0;
    let mut i: u32 = 0;
    while i < MAX_STATES {

        set nfa.transNext[i] = NIL;
        set i += 1;
    }
}

fn compile(nfa: *mut NfaState, pattern: *[u8]) -> u32 {
unsafe fn compile(nfa: *unsafe mut NfaState, pattern: &[u8]) -> u32 {
    resetNFA(nfa);

    let mut i: u32 = 0;
    while i < pattern.len {
        let ch: u8 = pattern[i];


    set nfa.acceptState = frags[numFrags - 1].endState;
    return frags[0].start;
}

fn nfaMatches(nfa: *mut NfaState, start: u32, input: *[u8]) -> bool {
unsafe fn nfaMatches(nfa: *unsafe mut NfaState, start: u32, input: &[u8]) -> bool {
    setEmpty(nfa.current);
    setAdd(nfa.current, start);
    epsilonClosure(nfa, nfa.current);

    let mut i: u32 = 0;

    }

    return setHas(nfa.current, nfa.acceptState);
}

fn testLiteral(nfa: *mut NfaState) -> i32 {
unsafe fn testLiteral(nfa: *unsafe mut NfaState) -> i32 {
    let start: u32 = compile(nfa, "abc");

    assert nfaMatches(nfa, start, "abc");
    if nfaMatches(nfa, start, "ab") { return 2; }
    if nfaMatches(nfa, start, "abcd") { return 3; }
    if nfaMatches(nfa, start, "abd") { return 4; }

    return 0;
}

fn testStar(nfa: *mut NfaState) -> i32 {
unsafe fn testStar(nfa: *unsafe mut NfaState) -> i32 {
    let start: u32 = compile(nfa, "a*");

    assert nfaMatches(nfa, start, "");
    assert nfaMatches(nfa, start, "a");
    assert nfaMatches(nfa, start, "aaa");
    if nfaMatches(nfa, start, "b") { return 4; }

    return 0;
}

fn testPlus(nfa: *mut NfaState) -> i32 {
unsafe fn testPlus(nfa: *unsafe mut NfaState) -> i32 {
    let start: u32 = compile(nfa, "a+");

    if nfaMatches(nfa, start, "") { return 1; }
    assert nfaMatches(nfa, start, "a");
    assert nfaMatches(nfa, start, "aaaaa");

    return 0;
}

fn testQuestion(nfa: *mut NfaState) -> i32 {
unsafe fn testQuestion(nfa: *unsafe mut NfaState) -> i32 {
    let start: u32 = compile(nfa, "a?");

    assert nfaMatches(nfa, start, "");
    assert nfaMatches(nfa, start, "a");
    if nfaMatches(nfa, start, "aa") { return 3; }

    return 0;
}

fn testDot(nfa: *mut NfaState) -> i32 {
unsafe fn testDot(nfa: *unsafe mut NfaState) -> i32 {
    let start: u32 = compile(nfa, "..");

    assert nfaMatches(nfa, start, "ab");
    assert nfaMatches(nfa, start, "zz");
    if nfaMatches(nfa, start, "a") { return 3; }
    if nfaMatches(nfa, start, "abc") { return 4; }

    return 0;
}

fn testComplex(nfa: *mut NfaState) -> i32 {
unsafe fn testComplex(nfa: *unsafe mut NfaState) -> i32 {
    let start: u32 = compile(nfa, "ab*c");

    assert nfaMatches(nfa, start, "ac");
    assert nfaMatches(nfa, start, "abc");
    assert nfaMatches(nfa, start, "abbc");

    if nfaMatches(nfa, start, "adc") { return 6; }

    return 0;
}

fn testDotStar(nfa: *mut NfaState) -> i32 {
unsafe fn testDotStar(nfa: *unsafe mut NfaState) -> i32 {
    let start: u32 = compile(nfa, ".*");

    assert nfaMatches(nfa, start, "");
    assert nfaMatches(nfa, start, "hello");
    assert nfaMatches(nfa, start, "x");

    return 0;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut trans: [Trans; 256] = [Trans { kind: 0, ch: 0, to: 0 }; 256];
    let mut stateFirst: [u32; 128] = [0xFFFFFFFF; 128];
    let mut transNext: [u32; 256] = [0xFFFFFFFF; 256];
    let mut current: [u32; 4] = [0; 4];
    let mut nextSet: [u32; 4] = [0; 4];

test/tests/prog.sha256.rad +6 -6

fn ssig1(x: u32) -> u32 {
    return rotr(x, 17) ^ rotr(x, 19) ^ (x >> 10);
}

/// Prepare the message schedule from a 16-word (512-bit) block.
fn prepareSchedule(s: *mut Sha256, block: *[u32]) {
fn prepareSchedule(s: &mut Sha256, block: &[u32]) {
    // Copy the first 16 words directly.
    let mut i: u32 = 0;
    while i < 16 {
        set s.w[i] = block[i];
        set i += 1;

        set i += 1;
    }
}

/// Run the 64-round compression function.
fn compress(s: *mut Sha256, k: *[u32]) {
fn compress(s: &mut Sha256, k: &[u32]) {
    let mut a: u32 = s.h[0];
    let mut b: u32 = s.h[1];
    let mut c: u32 = s.h[2];
    let mut d: u32 = s.h[3];
    let mut e: u32 = s.h[4];

    set s.h[6] += g;
    set s.h[7] += hh;
}

/// Reset hash state to initial values.
fn resetHash(s: *mut Sha256) {
fn resetHash(s: &mut Sha256) {
    let mut i: u32 = 0;
    while i < 8 {
        set s.h[i] = INIT_H[i];
        set i += 1;
    }
}

/// Pad and hash a short message (up to 55 bytes, fits in one 512-bit block).
fn hashMessage(s: *mut Sha256, k: *[u32], msg: *[u8]) -> i32 {
fn hashMessage(s: &mut Sha256, k: &[u32], msg: &[u8]) -> i32 {
    // The message must fit in a single block (max 55 bytes for 1-block padding).
    if msg.len > 55 {
        return -1;
    }


    return 0;
}

/// Test SHA-256 of the empty string "".
/// Expected: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
fn testEmpty(s: *mut Sha256, k: *[u32]) -> i32 {
fn testEmpty(s: &mut Sha256, k: &[u32]) -> i32 {
    assert hashMessage(s, k, &[]) == 0;

    assert s.h[0] == 0xE3B0C442;
    assert s.h[1] == 0x98FC1C14;
    assert s.h[2] == 0x9AFBF4C8;

    return 0;
}

/// Test SHA-256 of "abc".
/// Expected: ba7816bf 8f01cfea 414140de 5dae2223 b00361a3 96177a9c b410ff61 f20015ad
fn testAbc(s: *mut Sha256, k: *[u32]) -> i32 {
fn testAbc(s: &mut Sha256, k: &[u32]) -> i32 {
    let msg: [u8; 3] = [0x61, 0x62, 0x63];
    assert hashMessage(s, k, &msg[..]) == 0;

    assert s.h[0] == 0xBA7816BF;
    assert s.h[1] == 0x8F01CFEA;

test/tests/prog.sieve.rad +8 -8

//! Sieve of Eratosthenes.
//! Find all primes up to 256 using a boolean array.
//! Verify the count of primes matches the known value (54 primes <= 256).

/// Mark all multiples of p as composite.
fn markMultiples(sieve: *mut [bool], p: u32) {
fn markMultiples(sieve: &mut [bool], p: u32) {
    let mut i: u32 = p * p;
    while i < sieve.len {
        set sieve[i] = true;
        set i += p;
    }
}

/// Run the sieve algorithm.
fn runSieve(sieve: *mut [bool]) {
fn runSieve(sieve: &mut [bool]) {
    // 0 and 1 are not prime.
    set sieve[0] = true;
    set sieve[1] = true;

    let mut p: u32 = 2;

        set p += 1;
    }
}

/// Count the number of primes found.
fn countPrimes(sieve: *[bool]) -> u32 {
fn countPrimes(sieve: &[bool]) -> u32 {
    let mut count: u32 = 0;
    for composite in sieve {
        if not composite {
            set count += 1;
        }
    }
    return count;
}

/// Collect primes into a slice, return count.
fn collectPrimes(sieve: *[bool], primes: *mut [u32]) -> u32 {
fn collectPrimes(sieve: &[bool], primes: &mut [u32]) -> u32 {
    let mut count: u32 = 0;
    for composite, idx in sieve {
        if not composite {
            if count < primes.len {
                set primes[count] = idx;

    }
    return count;
}

/// Check that specific known primes are marked correctly.
fn verifyKnownPrimes(sieve: *[bool]) -> i32 {
fn verifyKnownPrimes(sieve: &[bool]) -> i32 {
    // Known small primes.
    let primes: [u32; 6] = [2, 3, 5, 7, 11, 13];
    for p in primes {
        if sieve[p] {
            return 1;

    assert sieve[250];
    return 0;
}

/// Verify that collected primes are in ascending order and all valid.
fn verifyCollected(sieve: *[bool]) -> i32 {
unsafe fn verifyCollected(sieve: &[bool]) -> i32 {
    let mut primesBuf: [u32; 64] = [0; 64];
    let count = collectPrimes(sieve, &mut primesBuf[..]);

    assert count == 54;


    assert primesBuf[0] == 2;
    // Last prime should be 251.
    assert primesBuf[count - 1] == 251;

    // Verify ascending order.
    let collected = &primesBuf[0..count];
    let collected: *unsafe [u32] = &primesBuf[0..count];
    let mut prev: ?u32 = nil;
    for p in collected {
        if let prevVal = prev {
            assert prevVal < p;
        }
        set prev = p;
    }
    return 0;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut sieve: [bool; 256] = [false; 256];
    runSieve(&mut sieve[..]);

    let r1 = verifyKnownPrimes(&sieve[..]);
    if r1 <> 0 {

test/tests/prog.symtab.rad +18 -18

    symbolCount: u32,
}

/// The symbol table.
record SymTab: Copy {
    symbols: *mut [Symbol],
    symbols: *unsafe mut [Symbol],
    symbolCount: u32,
    scopes: *mut [ScopeMarker],
    scopes: *unsafe mut [ScopeMarker],
    scopeDepth: u32,
    buckets: *mut [u32],
    buckets: *unsafe mut [u32],
}

/// Simple string hash function.
fn hashName(name: *[u8]) -> u32 {
fn hashName(name: &[u8]) -> u32 {
    let mut h: u32 = 5381;
    for ch in name {
        set h = ((h << 5) + h) + ch as u32;
    }
    return h;
}

/// Initialize the symbol table.
fn init(tab: *mut SymTab) {
unsafe fn init(tab: &mut SymTab) {
    set tab.symbolCount = 0;
    set tab.scopeDepth = 0;

    for i in 0..HASH_SIZE {
        set tab.buckets[i] = NIL;
    }
}

/// Push a new scope.
fn pushScope(tab: *mut SymTab) {
unsafe fn pushScope(tab: &mut SymTab) {
    set tab.scopes[tab.scopeDepth] = ScopeMarker { symbolCount: tab.symbolCount };
    set tab.scopeDepth += 1;
}

/// Pop the current scope, removing all symbols defined in it.
fn popScope(tab: *mut SymTab) {
unsafe fn popScope(tab: &mut SymTab) {
    if tab.scopeDepth == 0 {
        return;
    }
    set tab.scopeDepth -= 1;
    let marker = tab.scopes[tab.scopeDepth];

        }
    }
}

/// Define a symbol in the current scope.
fn define(tab: *mut SymTab, name: *[u8], value: i32) -> u32 {
unsafe fn define(tab: &mut SymTab, name: &[u8], value: i32) -> u32 {
    let h = hashName(name);
    let bucket = h % HASH_SIZE;

    // Check for shadowed symbol with same name.
    let mut shadowIdx: u32 = NIL;

    set tab.symbolCount += 1;
    return idx;
}

/// Look up a symbol by name. Returns the value if found.
fn lookup(tab: *SymTab, name: *[u8]) -> ?i32 {
unsafe fn lookup(tab: &SymTab, name: &[u8]) -> ?i32 {
    let h = hashName(name);
    let bucket = h % HASH_SIZE;
    let mut cur = tab.buckets[bucket];

    while cur <> NIL {

    }
    return nil;
}

/// Update a symbol's value. Returns true if the symbol was found.
fn update(tab: *mut SymTab, name: *[u8], newValue: i32) -> bool {
unsafe fn update(tab: &mut SymTab, name: &[u8], newValue: i32) -> bool {
    let h = hashName(name);
    let bucket = h % HASH_SIZE;
    let mut cur = tab.buckets[bucket];

    while cur <> NIL {

    }
    return false;
}

/// Test basic define and lookup.
fn testBasic(tab: *mut SymTab) -> i32 {
unsafe fn testBasic(tab: &mut SymTab) -> i32 {
    init(tab);
    pushScope(tab);

    define(tab, "x", 10);
    define(tab, "y", 20);

    popScope(tab);
    return 0;
}

/// Test scope shadowing.
fn testShadowing(tab: *mut SymTab) -> i32 {
unsafe fn testShadowing(tab: &mut SymTab) -> i32 {
    init(tab);
    pushScope(tab);
    define(tab, "x", 1);

    // Verify outer x.

    popScope(tab);
    return 0;
}

/// Test deep nesting with shadowing.
fn testDeepNesting(tab: *mut SymTab) -> i32 {
unsafe fn testDeepNesting(tab: &mut SymTab) -> i32 {
    init(tab);

    // Define x at each of 8 scope levels.
    let mut i: u32 = 0;
    while i < 8 {

    popScope(tab);
    return 0;
}

/// Test multiple symbols per scope.
fn testMultipleSymbols(tab: *mut SymTab) -> i32 {
unsafe fn testMultipleSymbols(tab: &mut SymTab) -> i32 {
    init(tab);
    pushScope(tab);

    // Define a bunch of symbols.
    let names: [*[u8]; 8] = ["a", "bb", "ccc", "dddd", "eeeee", "ff", "ggg", "h"];

    popScope(tab);
    return 0;
}

/// Test update functionality.
fn testUpdate(tab: *mut SymTab) -> i32 {
unsafe fn testUpdate(tab: &mut SymTab) -> i32 {
    init(tab);
    pushScope(tab);

    define(tab, "counter", 0);


    popScope(tab);
    return 0;
}

/// Test scope isolation: symbols in popped scopes are gone.
fn testScopeIsolation(tab: *mut SymTab) -> i32 {
unsafe fn testScopeIsolation(tab: &mut SymTab) -> i32 {
    init(tab);

    pushScope(tab);
    define(tab, "outer", 1);


    popScope(tab);
    return 0;
}

/// Test interleaved defines and lookups across scopes using while-let.
fn testInterleaved(tab: *mut SymTab) -> i32 {
unsafe fn testInterleaved(tab: &mut SymTab) -> i32 {
    init(tab);
    pushScope(tab);

    define(tab, "a", 100);
    define(tab, "b", 200);

    popScope(tab);
    popScope(tab);
    return 0;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut symbols: [Symbol; 256] = [Symbol { nameHash: 0, value: 0, depth: 0, next: NIL, shadow: NIL }; 256];
    let mut scopes: [ScopeMarker; 16] = [ScopeMarker { symbolCount: 0 }; 16];
    let mut buckets: [u32; 64] = [NIL; 64];

    let mut tab = SymTab {

test/tests/prog.tokenizer.rad +34 -34

    pos: u32,
}

/// A list of tokens with a fixed-size backing store.
record TokenList: Copy {
    tokens: *mut [Token],
    tokens: *unsafe mut [Token],
    count: u32,
}

/// AST node for parsed expressions.
union Expr: Copy {

    right: u32,
}

/// Pool of AST nodes.
record ExprPool: Copy {
    nodes: *mut [Expr],
    nodes: *unsafe mut [Expr],
    count: u32,
}

/// Parser state.
record Parser: Copy {
    tokens: *[Token],
    tokens: *unsafe [Token],
    tokenCount: u32,
    pos: u32,
    pool: *mut ExprPool,
    pool: *unsafe mut ExprPool,
}

/// Check if a byte is a digit.
fn isDigit(c: u8) -> bool {
    return c >= 48 and c <= 57;

fn isSpace(c: u8) -> bool {
    return c == 32 or c == 9 or c == 10 or c == 13;
}

/// Peek at the current character, returning nil at end.
fn peek(lex: *Lexer) -> ?u8 {
unsafe fn peek(lex: *unsafe Lexer) -> ?u8 {
    if lex.pos < lex.source.len {
        return lex.source[lex.pos];
    }
    return nil;
}

/// Advance the lexer by one character.
fn advance(lex: *mut Lexer) {
unsafe fn advance(lex: *unsafe mut Lexer) {
    if lex.pos < lex.source.len {
        set lex.pos += 1;
    }
}

/// Skip whitespace characters.
fn skipWhitespace(lex: *mut Lexer) {
unsafe fn skipWhitespace(lex: *unsafe mut Lexer) {
    while let ch = peek(lex); isSpace(ch) {
        advance(lex);
    }
}

/// Scan a number literal.
fn scanNumber(lex: *mut Lexer) -> i32 {
unsafe fn scanNumber(lex: *unsafe mut Lexer) -> i32 {
    let mut value: i32 = 0;
    while let ch = peek(lex); isDigit(ch) {
        set value = value * 10 + (ch - 48) as i32;
        advance(lex);
    }
    return value;
}

/// Get the next token from the lexer.
fn nextToken(lex: *mut Lexer) -> Token {
unsafe fn nextToken(lex: *unsafe mut Lexer) -> Token {
    skipWhitespace(lex);

    if let ch = peek(lex) {
        if isDigit(ch) {
            return Token::Number(scanNumber(lex));

    }
    return Token::Eof;
}

/// Tokenize the entire source into a token list.
fn tokenize(lex: *mut Lexer, list: *mut TokenList) -> bool {
unsafe fn tokenize(lex: *unsafe mut Lexer, list: *unsafe mut TokenList) -> bool {
    let mut done: bool = false;
    while not done {
        let tok = nextToken(lex);
        match tok {
            case Token::Invalid(_) => {

    }
    return true;
}

/// Allocate a new expression node.
fn newExpr(pool: *mut ExprPool, expr: Expr) -> u32 {
unsafe fn newExpr(pool: *unsafe mut ExprPool, expr: Expr) -> u32 {
    let idx = pool.count;
    set pool.nodes[idx] = expr;
    set pool.count += 1;
    return idx;
}

/// Get the current token in the parser.
fn currentToken(p: *Parser) -> Token {
unsafe fn currentToken(p: *unsafe Parser) -> Token {
    if p.pos < p.tokenCount {
        return p.tokens[p.pos];
    }
    return Token::Eof;
}

/// Advance the parser to the next token.
fn advanceParser(p: *mut Parser) {
unsafe fn advanceParser(p: *unsafe mut Parser) {
    if p.pos < p.tokenCount {
        set p.pos += 1;
    }
}

/// Parse a primary expression (number, parenthesized expression, or unary minus).
fn parsePrimary(p: *mut Parser) -> ?u32 {
unsafe fn parsePrimary(p: *unsafe mut Parser) -> ?u32 {
    let tok = currentToken(p);

    match tok {
        case Token::Number(n) => {
            advanceParser(p);

        }
    }
}

/// Parse multiplication and division (higher precedence).
fn parseMulDiv(p: *mut Parser, left: u32) -> u32 {
unsafe fn parseMulDiv(p: *unsafe mut Parser, left: u32) -> u32 {
    let mut result: u32 = left;
    let mut cont: bool = true;

    while cont {
        let tok = currentToken(p);

    }
    return result;
}

/// Parse addition and subtraction (lower precedence).
fn parseAddSub(p: *mut Parser, left: u32) -> u32 {
unsafe fn parseAddSub(p: *unsafe mut Parser, left: u32) -> u32 {
    let mut result: u32 = parseMulDiv(p, left);
    let mut cont: bool = true;

    while cont {
        let tok = currentToken(p);

    }
    return result;
}

/// Parse a full expression.
fn parseExpr(p: *mut Parser) -> ?u32 {
unsafe fn parseExpr(p: *unsafe mut Parser) -> ?u32 {
    let left = parsePrimary(p) else {
        return nil;
    };
    return parseAddSub(p, left);
}

/// Evaluate an expression tree.
fn eval(nodes: *[Expr], idx: u32) -> i32 {
unsafe fn eval(nodes: *unsafe [Expr], idx: u32) -> i32 {
    let node = nodes[idx];
    match node {
        case Expr::Num(n) => {
            return n;
        }

        }
    }
}

/// Count nodes in an expression tree.
fn countNodes(nodes: *[Expr], idx: u32) -> u32 {
unsafe fn countNodes(nodes: *unsafe [Expr], idx: u32) -> u32 {
    let node = nodes[idx];
    match node {
        case Expr::Num(_) => { return 1; }
        case Expr::BinOp(data) => {
            return 1 + countNodes(nodes, data.left) + countNodes(nodes, data.right);

        }
    }
}

/// Helper: tokenize, parse, and evaluate a string expression.
fn evaluate(
unsafe fn evaluate(
    source: *[u8],
    tokenBuf: *mut [Token],
    exprBuf: *mut [Expr]
    tokenBuf: *unsafe mut [Token],
    exprBuf: *unsafe mut [Expr]
) -> ?i32 {
    let mut lex = Lexer { source, pos: 0 };
    let mut list = TokenList { tokens: tokenBuf, count: 0 };

    if not tokenize(&mut lex, &mut list) {

    };
    return eval(exprBuf, root);
}

/// Test simple number.
fn testNumber(tokenBuf: *mut [Token], exprBuf: *mut [Expr]) -> i32 {
unsafe fn testNumber(tokenBuf: *unsafe mut [Token], exprBuf: *unsafe mut [Expr]) -> i32 {
    let result = evaluate("42", tokenBuf, exprBuf) else {
        return 1;
    };
    assert result == 42;
    return 0;
}

/// Test addition.
fn testAdd(tokenBuf: *mut [Token], exprBuf: *mut [Expr]) -> i32 {
unsafe fn testAdd(tokenBuf: *unsafe mut [Token], exprBuf: *unsafe mut [Expr]) -> i32 {
    let result = evaluate("3 + 4", tokenBuf, exprBuf) else {
        return 1;
    };
    assert result == 7;
    return 0;
}

/// Test precedence: multiplication before addition.
fn testPrecedence(tokenBuf: *mut [Token], exprBuf: *mut [Expr]) -> i32 {
unsafe fn testPrecedence(tokenBuf: *unsafe mut [Token], exprBuf: *unsafe mut [Expr]) -> i32 {
    let result = evaluate("2 + 3 * 4", tokenBuf, exprBuf) else {
        return 1;
    };
    assert result == 14;
    return 0;
}

/// Test parenthesized expression.
fn testParens(tokenBuf: *mut [Token], exprBuf: *mut [Expr]) -> i32 {
unsafe fn testParens(tokenBuf: *unsafe mut [Token], exprBuf: *unsafe mut [Expr]) -> i32 {
    let result = evaluate("(2 + 3) * 4", tokenBuf, exprBuf) else {
        return 1;
    };
    assert result == 20;
    return 0;
}

/// Test negation.
fn testNeg(tokenBuf: *mut [Token], exprBuf: *mut [Expr]) -> i32 {
unsafe fn testNeg(tokenBuf: *unsafe mut [Token], exprBuf: *unsafe mut [Expr]) -> i32 {
    let result = evaluate("-5 + 8", tokenBuf, exprBuf) else {
        return 1;
    };
    assert result == 3;
    return 0;
}

/// Test complex expression.
fn testComplex(tokenBuf: *mut [Token], exprBuf: *mut [Expr]) -> i32 {
unsafe fn testComplex(tokenBuf: *unsafe mut [Token], exprBuf: *unsafe mut [Expr]) -> i32 {
    // (10 - 3) * (2 + 1) = 7 * 3 = 21
    let result = evaluate("(10 - 3) * (2 + 1)", tokenBuf, exprBuf) else {
        return 1;
    };
    assert result == 21;
    return 0;
}

/// Test chained operations.
fn testChained(tokenBuf: *mut [Token], exprBuf: *mut [Expr]) -> i32 {
unsafe fn testChained(tokenBuf: *unsafe mut [Token], exprBuf: *unsafe mut [Expr]) -> i32 {
    // 100 - 20 - 30 - 10 = 40
    let result = evaluate("100 - 20 - 30 - 10", tokenBuf, exprBuf) else {
        return 1;
    };
    assert result == 40;
    return 0;
}

/// Test token counting via for-in.
fn testTokenCount(tokenBuf: *mut [Token], exprBuf: *mut [Expr]) -> i32 {
unsafe fn testTokenCount(tokenBuf: *unsafe mut [Token], exprBuf: *unsafe mut [Expr]) -> i32 {
    let mut lex = Lexer { source: "1 + 2 * 3", pos: 0 };
    let mut list = TokenList { tokens: tokenBuf, count: 0 };
    assert tokenize(&mut lex, &mut list);

    // Should be: 1, +, 2, *, 3, Eof = 6 tokens


    return 0;
}

/// Test division and mixed operations.
fn testDivision(tokenBuf: *mut [Token], exprBuf: *mut [Expr]) -> i32 {
unsafe fn testDivision(tokenBuf: *unsafe mut [Token], exprBuf: *unsafe mut [Expr]) -> i32 {
    // 20 / 4 + 3 = 5 + 3 = 8
    let result = evaluate("20 / 4 + 3", tokenBuf, exprBuf) else {
        return 1;
    };
    assert result == 8;
    return 0;
}

/// Test deeply nested parentheses.
fn testDeepNesting(tokenBuf: *mut [Token], exprBuf: *mut [Expr]) -> i32 {
unsafe fn testDeepNesting(tokenBuf: *unsafe mut [Token], exprBuf: *unsafe mut [Expr]) -> i32 {
    // ((((5)))) = 5
    let result = evaluate("((((5))))", tokenBuf, exprBuf) else {
        return 1;
    };
    assert result == 5;
    return 0;
}

/// Test node count of complex expression.
fn testNodeCount(tokenBuf: *mut [Token], exprBuf: *mut [Expr]) -> i32 {
unsafe fn testNodeCount(tokenBuf: *unsafe mut [Token], exprBuf: *unsafe mut [Expr]) -> i32 {
    let mut lex = Lexer { source: "1 + 2 * 3", pos: 0 };
    let mut list = TokenList { tokens: tokenBuf, count: 0 };
    assert tokenize(&mut lex, &mut list);

    let mut pool = ExprPool { nodes: exprBuf, count: 0 };

    let count = countNodes(exprBuf, root);
    assert count == 5;
    return 0;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut tokenBuf: [Token; 128] = [Token::Eof; 128];
    let mut exprBuf: [Expr; 128] = [Expr::Num(0); 128];

    let r1 = testNumber(&mut tokenBuf[..], &mut exprBuf[..]);
    if r1 <> 0 {

test/tests/prog.vm.rad +27 -27

    localBase: u32,
}

/// The VM state.
record VM: Copy {
    code: *[Op],
    code: *unsafe [Op],
    codeLen: u32,
    stack: *mut [i32],
    stack: *unsafe mut [i32],
    sp: u32,
    locals: *mut [i32],
    frames: *mut [Frame],
    locals: *unsafe mut [i32],
    frames: *unsafe mut [Frame],
    frameCount: u32,
    pc: u32,
}

/// VM error types.

    /// Too many nested calls.
    CallOverflow,
}

/// Push a value onto the stack.
fn push(vm: *mut VM, value: i32) throws (VmError) {
unsafe fn push(vm: *unsafe mut VM, value: i32) throws (VmError) {
    if vm.sp >= MAX_STACK {
        throw VmError::StackOverflow;
    }
    set vm.stack[vm.sp] = value;
    set vm.sp += 1;
}

/// Pop a value from the stack.
fn pop(vm: *mut VM) -> i32 throws (VmError) {
unsafe fn pop(vm: *unsafe mut VM) -> i32 throws (VmError) {
    if vm.sp == 0 {
        throw VmError::StackUnderflow;
    }
    set vm.sp -= 1;
    return vm.stack[vm.sp];
}

/// Peek at the top of the stack without removing.
fn peek(vm: *VM) -> i32 throws (VmError) {
unsafe fn peek(vm: *unsafe VM) -> i32 throws (VmError) {
    if vm.sp == 0 {
        throw VmError::StackUnderflow;
    }
    return vm.stack[vm.sp - 1];
}

/// Execute the bytecode program.
fn execute(vm: *mut VM) -> i32 throws (VmError) {
unsafe fn execute(vm: *unsafe mut VM) -> i32 throws (VmError) {
    while vm.pc < vm.codeLen {
        let instr = vm.code[vm.pc];
        set vm.pc += 1;

        match instr {

    }
    throw VmError::InvalidPC;
}

/// Helper to initialize VM and run a program.
fn runProgram(
    code: *[Op],
unsafe fn runProgram(
    code: *unsafe [Op],
    codeLen: u32,
    stackBuf: *mut [i32],
    localsBuf: *mut [i32],
    framesBuf: *mut [Frame]
    stackBuf: *unsafe mut [i32],
    localsBuf: *unsafe mut [i32],
    framesBuf: *unsafe mut [Frame]
) -> i32 throws (VmError) {
    let mut vm = VM {
        code,
        codeLen,
        stack: stackBuf,

    };
    return try execute(&mut vm);
}

/// Test basic arithmetic: 3 + 4 * 2 = 11
fn testArith(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {
unsafe fn testArith(stackBuf: *unsafe mut [i32], localsBuf: *unsafe mut [i32], framesBuf: *unsafe mut [Frame]) -> i32 {
    let mut code: [Op; 8] = [Op::Halt; 8];
    set code[0] = Op::Push(3);
    set code[1] = Op::Push(4);
    set code[2] = Op::Push(2);
    set code[3] = Op::Mul;

    assert result == 11;
    return 0;
}

/// Test local variables: x = 5, y = 7, push x + y.
fn testLocals(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {
unsafe fn testLocals(stackBuf: *unsafe mut [i32], localsBuf: *unsafe mut [i32], framesBuf: *unsafe mut [Frame]) -> i32 {
    let mut code: [Op; 16] = [Op::Halt; 16];
    set code[0] = Op::Push(5);
    set code[1] = Op::Store(0);   // x = 5
    set code[2] = Op::Push(7);
    set code[3] = Op::Store(1);   // y = 7

    assert result == 12;
    return 0;
}

/// Test conditional jump: if 3 > 2 then push 42 else push 99.
fn testConditional(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {
unsafe fn testConditional(stackBuf: *unsafe mut [i32], localsBuf: *unsafe mut [i32], framesBuf: *unsafe mut [Frame]) -> i32 {
    let mut code: [Op; 16] = [Op::Halt; 16];
    set code[0] = Op::Push(3);
    set code[1] = Op::Push(2);
    set code[2] = Op::Gt;            // 3 > 2 => 1
    set code[3] = Op::JumpIfZero(6); // if false, jump to 6

    return 0;
}

/// Test loop: sum 1..5 using jumps.
/// local[0] = counter (starts at 1), local[1] = sum (starts at 0).
fn testLoop(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {
unsafe fn testLoop(stackBuf: *unsafe mut [i32], localsBuf: *unsafe mut [i32], framesBuf: *unsafe mut [Frame]) -> i32 {
    let mut code: [Op; 32] = [Op::Halt; 32];
    set code[0] = Op::Push(1);
    set code[1] = Op::Store(0);      // counter = 1
    set code[2] = Op::Push(0);
    set code[3] = Op::Store(1);      // sum = 0

    assert result == 15;
    return 0;
}

/// Test function call: call a function that computes n*2+1 for n=10.
fn testCall(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {
unsafe fn testCall(stackBuf: *unsafe mut [i32], localsBuf: *unsafe mut [i32], framesBuf: *unsafe mut [Frame]) -> i32 {
    let mut code: [Op; 32] = [Op::Halt; 32];

    // Main: push argument on stack, call function, halt.
    set code[0] = Op::Push(10);      // push argument
    set code[1] = Op::Call(5);       // call function at 5

    assert result == 21;
    return 0;
}

/// Test division by zero detection using try...catch with error binding.
fn testDivByZero(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {
unsafe fn testDivByZero(stackBuf: *unsafe mut [i32], localsBuf: *unsafe mut [i32], framesBuf: *unsafe mut [Frame]) -> i32 {
    let mut code: [Op; 8] = [Op::Halt; 8];
    set code[0] = Op::Push(42);
    set code[1] = Op::Push(0);
    set code[2] = Op::Div;
    set code[3] = Op::Halt;

    assert caught == 1;
    return 0;
}

/// Test negation and equality.
fn testNegAndEq(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {
unsafe fn testNegAndEq(stackBuf: *unsafe mut [i32], localsBuf: *unsafe mut [i32], framesBuf: *unsafe mut [Frame]) -> i32 {
    let mut code: [Op; 16] = [Op::Halt; 16];
    set code[0] = Op::Push(5);
    set code[1] = Op::Neg;           // -5
    set code[2] = Op::Push(-5);
    set code[3] = Op::Eq;            // -5 == -5 => 1

    assert result == 1;
    return 0;
}

/// Test factorial using recursive calls: fact(6) = 720.
fn testFactorial(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {
unsafe fn testFactorial(stackBuf: *unsafe mut [i32], localsBuf: *unsafe mut [i32], framesBuf: *unsafe mut [Frame]) -> i32 {
    let mut code: [Op; 32] = [Op::Halt; 32];

    // Main: push 6, call fact, halt.
    set code[0] = Op::Push(6);
    set code[1] = Op::Call(4);       // call fact at 4

    assert result == 720;
    return 0;
}

/// Test dup instruction.
fn testDup(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {
unsafe fn testDup(stackBuf: *unsafe mut [i32], localsBuf: *unsafe mut [i32], framesBuf: *unsafe mut [Frame]) -> i32 {
    let mut code: [Op; 8] = [Op::Halt; 8];
    set code[0] = Op::Push(7);
    set code[1] = Op::Dup;
    set code[2] = Op::Add;           // 7 + 7 = 14
    set code[3] = Op::Halt;

    assert result == 14;
    return 0;
}

/// Test stack underflow detection using try...catch with error binding.
fn testStackUnderflow(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {
unsafe fn testStackUnderflow(stackBuf: *unsafe mut [i32], localsBuf: *unsafe mut [i32], framesBuf: *unsafe mut [Frame]) -> i32 {
    let mut code: [Op; 4] = [Op::Halt; 4];
    set code[0] = Op::Add;  // nothing on stack
    set code[1] = Op::Halt;

    let mut caught: i32 = 0;

    assert caught == 1;
    return 0;
}

/// Test that try...catch on success path does not execute catch block.
fn testSuccessNoCatch(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {
unsafe fn testSuccessNoCatch(stackBuf: *unsafe mut [i32], localsBuf: *unsafe mut [i32], framesBuf: *unsafe mut [Frame]) -> i32 {
    let mut code: [Op; 4] = [Op::Halt; 4];
    set code[0] = Op::Push(99);
    set code[1] = Op::Halt;

    let mut caught: i32 = 0;

    assert result == 99;
    return 0;
}

/// Test call overflow detection by exhausting frames.
fn testCallOverflow(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {
unsafe fn testCallOverflow(stackBuf: *unsafe mut [i32], localsBuf: *unsafe mut [i32], framesBuf: *unsafe mut [Frame]) -> i32 {
    let mut code: [Op; 4] = [Op::Halt; 4];
    // Infinite recursion: function calls itself.
    set code[0] = Op::Call(0);
    set code[1] = Op::Halt;


    assert caught == 1;
    return 0;
}

/// Test that catch with no binding works (discard the error).
fn testCatchNoBinding(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {
unsafe fn testCatchNoBinding(stackBuf: *unsafe mut [i32], localsBuf: *unsafe mut [i32], framesBuf: *unsafe mut [Frame]) -> i32 {
    let mut code: [Op; 4] = [Op::Halt; 4];
    set code[0] = Op::Pop;  // underflow
    set code[1] = Op::Halt;

    // Catch without binding - just swallow the error.
    try runProgram(&code[..], 2, stackBuf, localsBuf, framesBuf) catch {};
    return 0;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut stackBuf: [i32; 64] = [0; 64];
    let mut localsBuf: [i32; 128] = [0; 128];
    let mut framesBuf: [Frame; 8] = [Frame { returnAddr: 0, localBase: 0 }; 8];

    let r1 = testArith(&mut stackBuf[..], &mut localsBuf[..], &mut framesBuf[..]);

test/tests/ptr.addressof.local.rad +3 -3

record Point: Copy { x: i32, y: i32 }

/// Address of a record local (aggregate) - value is already a pointer.
fn addressOfRecordLocal() -> *Point {
unsafe fn addressOfRecordLocal() -> *unsafe Point {
    let p = Point { x: 1, y: 2 };
    return &p;
}

/// Address of a scalar local - requires stack allocation.
fn addressOfScalarLocal() -> *i32 {
unsafe fn addressOfScalarLocal() -> *unsafe i32 {
    let x: i32 = 42;
    return &x;
}

/// Address of dereference - should return the original pointer.
fn addressOfDeref(ptr: *i32) -> *i32 {
unsafe fn addressOfDeref(ptr: &i32) -> *unsafe i32 {
    return &(*ptr);
}

test/tests/ptr.addressof.rad +1 -1

1	1		/// Takes the address of an array element.
2		-	fn addressOfElem(arr: [i32; 4], idx: u32) -> *i32 {
	2	+	unsafe fn addressOfElem(arr: [i32; 4], idx: u32) -> *unsafe i32 {
3	3		return &arr[idx];
4	4		}

test/tests/ptr.assign.rad +2 -2

//! returns: 42
@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut x: i32 = 1;
    let mut ptr: *mut i32 = &mut x;
    let mut ptr: *unsafe mut i32 = &mut x;

    set *ptr = 42;

    return x;
}

test/tests/ptr.deref.rad +9 -9

//! returns: 65
//! Test pointer dereference in various contexts.

fn derefArrayIndex(ary: [i32; 3]) -> i32 {
    let x: *i32 = &ary[1];
unsafe fn derefArrayIndex(ary: [i32; 3]) -> i32 {
    let x: *unsafe i32 = &ary[1];
    return *x;
}

fn derefSliceIndex(slc: *[i32]) -> i32 {
    let x: *i32 = &slc[2];
unsafe fn derefSliceIndex(slc: &[i32]) -> i32 {
    let x: *unsafe i32 = &slc[2];
    return *x;
}

fn derefBinop(x: i32, y: i32) -> i32 {
    let px: *i32 = &x;
    let py: *i32 = &y;
unsafe fn derefBinop(x: i32, y: i32) -> i32 {
    let px: *unsafe i32 = &x;
    let py: *unsafe i32 = &y;

    return *px + *py;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let x: i32  = 42;
    let y: *i32 = &x;
    let y: *unsafe i32 = &x;
    let z: i32  = *y; // 42
    let r: i32 = derefBinop(3, 6); // 9
    let a: i32 = derefArrayIndex([7, 8, 9]); // 8
    let s: i32 = derefSliceIndex(&[2, 4, 6]); // 6


test/tests/ptr.eq.rad +10 -10

    x: i32,
    y: i32,
}

// Test that pointer equality uses address comparison, not value comparison.
fn testPtrSameAddress() -> bool {
unsafe fn testPtrSameAddress() -> bool {
    let p1 = Point { x: 1, y: 2 };
    let a = &p1;
    let b = &p1;
    let a: *unsafe Point = &p1;
    let b: *unsafe Point = &p1;

    return a == b;  // Same address, should be equal.
}

fn testPtrDifferentAddressSameValues() -> bool {
unsafe fn testPtrDifferentAddressSameValues() -> bool {
    let p1 = Point { x: 1, y: 2 };
    let p2 = Point { x: 1, y: 2 };  // Same values as p1, but different address.
    let a = &p1;
    let b = &p2;
    let a: *unsafe Point = &p1;
    let b: *unsafe Point = &p2;

    return not (a == b);  // Different addresses, should NOT be equal.
}

fn testPtrDifferentAddressDifferentValues() -> bool {
unsafe fn testPtrDifferentAddressDifferentValues() -> bool {
    let p1 = Point { x: 1, y: 2 };
    let p2 = Point { x: 3, y: 4 };
    let a = &p1;
    let b = &p2;
    let a: *unsafe Point = &p1;
    let b: *unsafe Point = &p2;

    return not (a == b);  // Different addresses, should NOT be equal.
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    assert testPtrSameAddress();
    assert testPtrDifferentAddressSameValues();
    assert testPtrDifferentAddressDifferentValues();
    return 0;
}

test/tests/ptr.mutate.rad +2 -2

//! returns: 42

fn mutate1(ptr: *mut i32) {
fn mutate1(ptr: &mut i32) {
    set *ptr = 39;
}

fn mutate2(ptr: *mut i32) {
fn mutate2(ptr: &mut i32) {
    set *ptr += 2;
    set *ptr += 1;
}

@default fn main() -> i32 {

test/tests/ptr.opaque.rad +18 -18

//! returns: 0
//! Test basic opaque pointer usage (automatic coercion).
fn testOpaqueCasting() -> bool {
unsafe fn testOpaqueCasting() -> bool {
    let x: u32 = 42;
    let ptr: *u8 = &x as *u8;
    let opq: *opaque = ptr;  // Automatic coercion from *u8 to *opaque.
    let back: *u8 = opq as *u8;
    let ptr: *unsafe u8 = &x as *unsafe u8;
    let opq: *unsafe opaque = ptr;  // Automatic coercion from *u8 to *opaque.
    let back: *unsafe u8 = opq as *unsafe u8;

    return back == ptr;
}

/// Test that opaque can be used in function parameters.
fn takesOpaque(ptr: *opaque, orig: *u8) -> bool {
    let back: *u8 = ptr as *u8;
unsafe fn takesOpaque(ptr: *unsafe opaque, orig: *unsafe u8) -> bool {
    let back: *unsafe u8 = ptr as *unsafe u8;
    return back == orig;
}

fn testOpaqueParams() -> bool {
unsafe fn testOpaqueParams() -> bool {
    let x: u32 = 42;
    let ptr: *u8 = &x as *u8;
    let ptr: *unsafe u8 = &x as *unsafe u8;
    return takesOpaque(ptr, ptr);  // Automatic coercion in function call.
}

/// Test that opaque can be used in return types.
fn returnsOpaque(ptr: *u8) -> *opaque {
fn returnsOpaque(ptr: *unsafe u8) -> *unsafe opaque {
    return ptr;  // Automatic coercion in return.
}

fn testOpaqueReturn() -> bool {
unsafe fn testOpaqueReturn() -> bool {
    let x: u32 = 42;
    let ptr: *u8 = &x as *u8;
    let opq: *opaque = returnsOpaque(ptr);
    return opq as *u8 == ptr;
    let ptr: *unsafe u8 = &x as *unsafe u8;
    let opq: *unsafe opaque = returnsOpaque(ptr);
    return opq as *unsafe u8 == ptr;
}

/// Test nullable opaque pointers.
fn testNullableOpaque() -> bool {
    let mut opt: ?*opaque = nil;
unsafe fn testNullableOpaque() -> bool {
    let mut opt: ?*unsafe opaque = nil;
    if opt == nil {
        let x: u32 = 42;
        let ptr: *u8 = &x as *u8;
        let ptr: *unsafe u8 = &x as *unsafe u8;
        set opt = ptr;  // Automatic coercion in assignment.

        if let p = opt {
            return p as *u8 == ptr;
            return p as *unsafe u8 == ptr;
        }
    }
    return false;
}

@default fn main() -> u32 {
@default unsafe fn main() -> u32 {
    assert testOpaqueCasting();
    assert testOpaqueParams();
    assert testOpaqueReturn();
    assert testNullableOpaque();
    return 0;

test/tests/range.arithmetic.rad +4 -4

//! returns: 0

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let arr: [i32; 6] = [10, 20, 30, 40, 50, 60];
    let len: u32 = 6;

    // Arithmetic in range start (no parens needed).
    let s = &arr[len - 3..len];
    let s: *unsafe [i32] = &arr[len - 3..len];
    if s.len <> 3 { return 1; }
    if s[0] <> 40 { return 2; }
    if s[2] <> 60 { return 3; }

    // Arithmetic in range end.
    let s2 = &arr[0..len - 2];
    let s2: *unsafe [i32] = &arr[0..len - 2];
    if s2.len <> 4 { return 4; }
    if s2[3] <> 40 { return 5; }

    // Arithmetic in both.
    let s3 = &arr[len - 4..len - 1];
    let s3: *unsafe [i32] = &arr[len - 4..len - 1];
    if s3.len <> 3 { return 6; }
    if s3[0] <> 30 { return 7; }
    if s3[2] <> 50 { return 8; }

    // Arithmetic in subscript.

test/tests/record.ptr.access.rad +2 -2

record Point: Copy {
    x: i32,
    y: i32,
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut p: Point = Point { x: 11, y: 31 };
    let mut r: *Point = &p;
    let mut r: *unsafe Point = &p;

    let mut x: i32 = r.x;
    let mut y: i32 = r.y;

    return (x + y) - 42;

test/tests/record.ptr.mutate.rad +1 -1

record Point: Copy {
    x: i32,
    y: i32,
}

fn mutate(p: *mut Point) {
fn mutate(p: &mut Point) {
    set p.x = 4;
    set p.y = 38;
}

@default fn main() -> i32 {

test/tests/ref.if.bug.rad +1 -1

//! Regression test: address-of inside an if branch.
//!
//! When `&mut var` appears in only one branch of an if/else, the merge
//! block's phi merges the original integer value with a stack pointer.

fn store(ptr: *mut u32, val: u32) {
fn store(ptr: &mut u32, val: u32) {
    set *ptr = val;
}

fn testIfBranch(cond: bool) -> u32 {
    let mut val: u32 = 42;

test/tests/ref.immut.loop.bug.rad +1 -1

//! Even though the variable is not `mut`, taking its address inside a
//! loop can produce the same SSA/pointer phi conflict as with mutable
//! variables: the loop header merges the original integer with a pointer
//! from the stack slot created by `&x`.

fn read(ptr: *u32) -> u32 {
fn read(ptr: &u32) -> u32 {
    return *ptr;
}

fn testZeroIter(n: u32) -> u32 {
    let val: u32 = 42;

test/tests/ref.mut.ptr.rad +3 -3

//! returns: 84
//! Test mutable pointer references.

fn store(ptr: *mut i32) {
unsafe fn store(ptr: *unsafe mut i32) {
    set *ptr = 42;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut a: i32 = 0;
    let p: *mut i32 = &mut a;
    let p: *unsafe mut i32 = &mut a;
    store(p);

    let mut b: i32 = 0;
    store(&mut b);


test/tests/slice.alloc.loop.rad +3 -3

//! returns: 0
//! Test returning a slice from a function and iterating over it.
//! Exercises the same code path as createBlock's vars initialization.
//! The slice is returned through a return buffer (> 8 bytes).

fn makeSlice(buf: *mut [u8], count: u32) -> *mut [u8] {
unsafe fn makeSlice(buf: *unsafe mut [u8], count: u32) -> *unsafe mut [u8] {
    if count == 0 {
        return &mut [];
    }
    return @sliceOf(&mut buf[0], count);
}

fn initSlice(buf: *mut [u8], count: u32) -> i32 {
unsafe fn initSlice(buf: *unsafe mut [u8], count: u32) -> i32 {
    let s = makeSlice(buf, count);

    // This loop pattern matches createBlock's vars initialization.
    for i in 0..s.len {
        set s[i] = 0;
    }

    return s.len as i32;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut buf: [u8; 64] = undefined;

    let n = initSlice(&mut buf[..], 5);
    assert n == 5;


test/tests/slice.append.rad +3 -2


fn newArena(data: *mut [u8]) -> Arena {
    return Arena { data, offset: 0 };
}

fn arenaAlloc(arena: *mut Arena, size: u32, al: u32) -> *mut opaque {
fn arenaAlloc(arena: &mut Arena, size: u32, al: u32) -> *mut opaque {
    let aligned = (arena.offset + al - 1) / al * al;
    let newOffset = aligned + size;

    assert newOffset <= arena.data.len as u32;


}

static BUF: [u8; 4096] = undefined;

@default fn main() -> i32 {
    let mut arena = newArena(&mut BUF[..]);
    static arena: Arena = undefined;
    set arena = newArena(&mut BUF[..]);
    let a = arenaAllocator(&mut arena);

    // Allocate initial capacity of 4.
    let ptr = arenaAlloc(&mut arena, @sizeOf(i32) * 4, @alignOf(i32));
    let mut nums = @sliceOf(ptr as *mut i32, 0, 4);

test/tests/slice.append.ril +494 -485

data mut $BUF align 1 {
    undef * 4096;
}

data mut $main$nominal$arena align 8 {
    undef * 24;
}

fn w64 $newArena(w64 %0, w64 %1) {
  @entry0
    reserve %2 24 8;
    blit %2 %1 16;
    store w32 0 %2 16;

    store w64 %0 %1 0;
    store w32 4096 %1 8;
    store w32 4096 %1 12;
    reserve %2 24 8;
    call w64 %3 $newArena(%2, %1);
    reserve %4 16 8;
    call w64 %5 $arenaAllocator(%4, %3);
    mul w32 %6 4 4;
    call w64 %7 $arenaAlloc(%3, %6, 4);
    reserve %8 16 8;
    store w64 %7 %8 0;
    store w32 0 %8 8;
    store w32 4 %8 12;
    load w32 %9 %8 8;
    load w32 %10 %8 12;
    br.ult w32 %9 %10 @append.store1 @append.grow2;
    copy %4 $main$nominal$arena;
    blit %4 %3 24;
    copy %5 $main$nominal$arena;
    reserve %6 16 8;
    call w64 %7 $arenaAllocator(%6, %5);
    copy %8 $main$nominal$arena;
    mul w32 %9 4 4;
    call w64 %10 $arenaAlloc(%8, %9, 4);
    reserve %11 16 8;
    store w64 %10 %11 0;
    store w32 0 %11 8;
    store w32 4 %11 12;
    load w32 %12 %11 8;
    load w32 %13 %11 12;
    br.ult w32 %12 %13 @append.store1 @append.grow2;
  @append.store1
    load w64 %24 %8 0;
    mul w64 %25 %9 4;
    add w64 %26 %24 %25;
    store w32 10 %26 0;
    add w32 %27 %9 1;
    store w32 %27 %8 8;
    load w32 %32 %8 8;
    load w32 %33 %8 12;
    br.ult w32 %32 %33 @append.store6 @append.grow7;
    load w64 %27 %11 0;
    mul w64 %28 %12 4;
    add w64 %29 %27 %28;
    store w32 10 %29 0;
    add w32 %30 %12 1;
    store w32 %30 %11 8;
    load w32 %35 %11 8;
    load w32 %36 %11 12;
    br.ult w32 %35 %36 @append.store6 @append.grow7;
  @append.grow2
    shl w32 %11 %10 1;
    or w32 %12 %11 1;
    load w64 %13 %5 0;
    load w64 %14 %5 8;
    mul w32 %15 %12 4;
    call w64 %16 %13(%14, %15, 4);
    load w64 %17 %8 0;
    mul w32 %18 %9 4;
    shl w32 %14 %13 1;
    or w32 %15 %14 1;
    load w64 %16 %7 0;
    load w64 %17 %7 8;
    mul w32 %18 %15 4;
    call w64 %19 %16(%17, %18, 4);
    load w64 %20 %11 0;
    mul w32 %21 %12 4;
    jmp @append3(0);
  @append3(w32 %19)
    br.ult w32 %19 %18 @append4 @append5;
  @append3(w32 %22)
    br.ult w32 %22 %21 @append4 @append5;
  @append4
    add w64 %20 %17 %19;
    load w8 %21 %20 0;
    add w64 %22 %16 %19;
    store w8 %21 %22 0;
    add w32 %23 %19 1;
    jmp @append3(%23);
    add w64 %23 %20 %22;
    load w8 %24 %23 0;
    add w64 %25 %19 %22;
    store w8 %24 %25 0;
    add w32 %26 %22 1;
    jmp @append3(%26);
  @append5
    store w64 %16 %8 0;
    store w32 %12 %8 12;
    store w64 %19 %11 0;
    store w32 %15 %11 12;
    jmp @append.store1;
  @append.store6
    load w64 %47 %8 0;
    mul w64 %48 %32 4;
    add w64 %49 %47 %48;
    store w32 20 %49 0;
    add w32 %50 %32 1;
    store w32 %50 %8 8;
    load w32 %55 %8 8;
    load w32 %56 %8 12;
    br.ult w32 %55 %56 @append.store11 @append.grow12;
    load w64 %50 %11 0;
    mul w64 %51 %35 4;
    add w64 %52 %50 %51;
    store w32 20 %52 0;
    add w32 %53 %35 1;
    store w32 %53 %11 8;
    load w32 %58 %11 8;
    load w32 %59 %11 12;
    br.ult w32 %58 %59 @append.store11 @append.grow12;
  @append.grow7
    shl w32 %34 %33 1;
    or w32 %35 %34 1;
    load w64 %36 %5 0;
    load w64 %37 %5 8;
    mul w32 %38 %35 4;
    call w64 %39 %36(%37, %38, 4);
    load w64 %40 %8 0;
    mul w32 %41 %32 4;
    shl w32 %37 %36 1;
    or w32 %38 %37 1;
    load w64 %39 %7 0;
    load w64 %40 %7 8;
    mul w32 %41 %38 4;
    call w64 %42 %39(%40, %41, 4);
    load w64 %43 %11 0;
    mul w32 %44 %35 4;
    jmp @append8(0);
  @append8(w32 %42)
    br.ult w32 %42 %41 @append9 @append10;
  @append8(w32 %45)
    br.ult w32 %45 %44 @append9 @append10;
  @append9
    add w64 %43 %40 %42;
    load w8 %44 %43 0;
    add w64 %45 %39 %42;
    store w8 %44 %45 0;
    add w32 %46 %42 1;
    jmp @append8(%46);
    add w64 %46 %43 %45;
    load w8 %47 %46 0;
    add w64 %48 %42 %45;
    store w8 %47 %48 0;
    add w32 %49 %45 1;
    jmp @append8(%49);
  @append10
    store w64 %39 %8 0;
    store w32 %35 %8 12;
    store w64 %42 %11 0;
    store w32 %38 %11 12;
    jmp @append.store6;
  @append.store11
    load w64 %70 %8 0;
    mul w64 %71 %55 4;
    add w64 %72 %70 %71;
    store w32 30 %72 0;
    add w32 %73 %55 1;
    store w32 %73 %8 8;
    load w32 %76 %8 8;
    br.ne w32 %76 3 @then16 @merge17;
    load w64 %73 %11 0;
    mul w64 %74 %58 4;
    add w64 %75 %73 %74;
    store w32 30 %75 0;
    add w32 %76 %58 1;
    store w32 %76 %11 8;
    load w32 %79 %11 8;
    br.ne w32 %79 3 @then16 @merge17;
  @append.grow12
    shl w32 %57 %56 1;
    or w32 %58 %57 1;
    load w64 %59 %5 0;
    load w64 %60 %5 8;
    mul w32 %61 %58 4;
    call w64 %62 %59(%60, %61, 4);
    load w64 %63 %8 0;
    mul w32 %64 %55 4;
    shl w32 %60 %59 1;
    or w32 %61 %60 1;
    load w64 %62 %7 0;
    load w64 %63 %7 8;
    mul w32 %64 %61 4;
    call w64 %65 %62(%63, %64, 4);
    load w64 %66 %11 0;
    mul w32 %67 %58 4;
    jmp @append13(0);
  @append13(w32 %65)
    br.ult w32 %65 %64 @append14 @append15;
  @append13(w32 %68)
    br.ult w32 %68 %67 @append14 @append15;
  @append14
    add w64 %66 %63 %65;
    load w8 %67 %66 0;
    add w64 %68 %62 %65;
    store w8 %67 %68 0;
    add w32 %69 %65 1;
    jmp @append13(%69);
    add w64 %69 %66 %68;
    load w8 %70 %69 0;
    add w64 %71 %65 %68;
    store w8 %70 %71 0;
    add w32 %72 %68 1;
    jmp @append13(%72);
  @append15
    store w64 %62 %8 0;
    store w32 %58 %8 12;
    store w64 %65 %11 0;
    store w32 %61 %11 12;
    jmp @append.store11;
  @then16
    ret 1;
  @merge17
    load w32 %77 %8 12;
    br.ne w32 %77 4 @then18 @merge19;
    load w32 %80 %11 12;
    br.ne w32 %80 4 @then18 @merge19;
  @then18
    ret 2;
  @merge19
    load w32 %78 %8 8;
    br.ult w32 0 %78 @guard#pass22 @guard#trap23;
    load w32 %81 %11 8;
    br.ult w32 0 %81 @guard#pass22 @guard#trap23;
  @then20
    ret 3;
  @merge21
    load w32 %81 %8 8;
    br.ult w32 1 %81 @guard#pass26 @guard#trap27;
    load w32 %84 %11 8;
    br.ult w32 1 %84 @guard#pass26 @guard#trap27;
  @guard#pass22
    load w64 %79 %8 0;
    sload w32 %80 %79 0;
    br.ne w32 %80 10 @then20 @merge21;
    load w64 %82 %11 0;
    sload w32 %83 %82 0;
    br.ne w32 %83 10 @then20 @merge21;
  @guard#trap23
    ebreak;
    unreachable;
  @then24
    ret 4;
  @merge25
    load w32 %86 %8 8;
    br.ult w32 2 %86 @guard#pass30 @guard#trap31;
    load w32 %89 %11 8;
    br.ult w32 2 %89 @guard#pass30 @guard#trap31;
  @guard#pass26
    load w64 %82 %8 0;
    mul w64 %83 1 4;
    add w64 %84 %82 %83;
    sload w32 %85 %84 0;
    br.ne w32 %85 20 @then24 @merge25;
    load w64 %85 %11 0;
    mul w64 %86 1 4;
    add w64 %87 %85 %86;
    sload w32 %88 %87 0;
    br.ne w32 %88 20 @then24 @merge25;
  @guard#trap27
    ebreak;
    unreachable;
  @then28
    ret 5;
  @merge29
    load w32 %93 %8 8;
    load w32 %94 %8 12;
    br.ult w32 %93 %94 @append.store32 @append.grow33;
    load w32 %96 %11 8;
    load w32 %97 %11 12;
    br.ult w32 %96 %97 @append.store32 @append.grow33;
  @guard#pass30
    load w64 %87 %8 0;
    mul w64 %88 2 4;
    add w64 %89 %87 %88;
    sload w32 %90 %89 0;
    br.ne w32 %90 30 @then28 @merge29;
    load w64 %90 %11 0;
    mul w64 %91 2 4;
    add w64 %92 %90 %91;
    sload w32 %93 %92 0;
    br.ne w32 %93 30 @then28 @merge29;
  @guard#trap31
    ebreak;
    unreachable;
  @append.store32
    load w64 %108 %8 0;
    mul w64 %109 %93 4;
    add w64 %110 %108 %109;
    store w32 40 %110 0;
    add w32 %111 %93 1;
    store w32 %111 %8 8;
    load w32 %114 %8 8;
    br.ne w32 %114 4 @then37 @merge38;
    load w64 %111 %11 0;
    mul w64 %112 %96 4;
    add w64 %113 %111 %112;
    store w32 40 %113 0;
    add w32 %114 %96 1;
    store w32 %114 %11 8;
    load w32 %117 %11 8;
    br.ne w32 %117 4 @then37 @merge38;
  @append.grow33
    shl w32 %95 %94 1;
    or w32 %96 %95 1;
    load w64 %97 %5 0;
    load w64 %98 %5 8;
    mul w32 %99 %96 4;
    call w64 %100 %97(%98, %99, 4);
    load w64 %101 %8 0;
    mul w32 %102 %93 4;
    shl w32 %98 %97 1;
    or w32 %99 %98 1;
    load w64 %100 %7 0;
    load w64 %101 %7 8;
    mul w32 %102 %99 4;
    call w64 %103 %100(%101, %102, 4);
    load w64 %104 %11 0;
    mul w32 %105 %96 4;
    jmp @append34(0);
  @append34(w32 %103)
    br.ult w32 %103 %102 @append35 @append36;
  @append34(w32 %106)
    br.ult w32 %106 %105 @append35 @append36;
  @append35
    add w64 %104 %101 %103;
    load w8 %105 %104 0;
    add w64 %106 %100 %103;
    store w8 %105 %106 0;
    add w32 %107 %103 1;
    jmp @append34(%107);
    add w64 %107 %104 %106;
    load w8 %108 %107 0;
    add w64 %109 %103 %106;
    store w8 %108 %109 0;
    add w32 %110 %106 1;
    jmp @append34(%110);
  @append36
    store w64 %100 %8 0;
    store w32 %96 %8 12;
    store w64 %103 %11 0;
    store w32 %99 %11 12;
    jmp @append.store32;
  @then37
    ret 6;
  @merge38
    load w32 %115 %8 12;
    br.ne w32 %115 4 @then39 @merge40;
    load w32 %118 %11 12;
    br.ne w32 %118 4 @then39 @merge40;
  @then39
    ret 7;
  @merge40
    load w32 %118 %8 8;
    load w32 %119 %8 12;
    br.ult w32 %118 %119 @append.store41 @append.grow42;
    load w32 %121 %11 8;
    load w32 %122 %11 12;
    br.ult w32 %121 %122 @append.store41 @append.grow42;
  @append.store41
    load w64 %133 %8 0;
    mul w64 %134 %118 4;
    add w64 %135 %133 %134;
    store w32 50 %135 0;
    add w32 %136 %118 1;
    store w32 %136 %8 8;
    load w32 %139 %8 8;
    br.ne w32 %139 5 @then46 @merge47;
    load w64 %136 %11 0;
    mul w64 %137 %121 4;
    add w64 %138 %136 %137;
    store w32 50 %138 0;
    add w32 %139 %121 1;
    store w32 %139 %11 8;
    load w32 %142 %11 8;
    br.ne w32 %142 5 @then46 @merge47;
  @append.grow42
    shl w32 %120 %119 1;
    or w32 %121 %120 1;
    load w64 %122 %5 0;
    load w64 %123 %5 8;
    mul w32 %124 %121 4;
    call w64 %125 %122(%123, %124, 4);
    load w64 %126 %8 0;
    mul w32 %127 %118 4;
    shl w32 %123 %122 1;
    or w32 %124 %123 1;
    load w64 %125 %7 0;
    load w64 %126 %7 8;
    mul w32 %127 %124 4;
    call w64 %128 %125(%126, %127, 4);
    load w64 %129 %11 0;
    mul w32 %130 %121 4;
    jmp @append43(0);
  @append43(w32 %128)
    br.ult w32 %128 %127 @append44 @append45;
  @append43(w32 %131)
    br.ult w32 %131 %130 @append44 @append45;
  @append44
    add w64 %129 %126 %128;
    load w8 %130 %129 0;
    add w64 %131 %125 %128;
    store w8 %130 %131 0;
    add w32 %132 %128 1;
    jmp @append43(%132);
    add w64 %132 %129 %131;
    load w8 %133 %132 0;
    add w64 %134 %128 %131;
    store w8 %133 %134 0;
    add w32 %135 %131 1;
    jmp @append43(%135);
  @append45
    store w64 %125 %8 0;
    store w32 %121 %8 12;
    store w64 %128 %11 0;
    store w32 %124 %11 12;
    jmp @append.store41;
  @then46
    ret 8;
  @merge47
    load w32 %140 %8 12;
    br.ne w32 %140 9 @then48 @merge49;
    load w32 %143 %11 12;
    br.ne w32 %143 9 @then48 @merge49;
  @then48
    ret 9;
  @merge49
    load w32 %141 %8 8;
    br.ult w32 4 %141 @guard#pass52 @guard#trap53;
    load w32 %144 %11 8;
    br.ult w32 4 %144 @guard#pass52 @guard#trap53;
  @then50
    ret 10;
  @merge51
    load w32 %146 %8 8;
    br.ult w32 0 %146 @guard#pass56 @guard#trap57;
    load w32 %149 %11 8;
    br.ult w32 0 %149 @guard#pass56 @guard#trap57;
  @guard#pass52
    load w64 %142 %8 0;
    mul w64 %143 4 4;
    add w64 %144 %142 %143;
    sload w32 %145 %144 0;
    br.ne w32 %145 50 @then50 @merge51;
    load w64 %145 %11 0;
    mul w64 %146 4 4;
    add w64 %147 %145 %146;
    sload w32 %148 %147 0;
    br.ne w32 %148 50 @then50 @merge51;
  @guard#trap53
    ebreak;
    unreachable;
  @then54
    ret 11;
  @merge55
    load w32 %149 %8 8;
    br.ult w32 3 %149 @guard#pass60 @guard#trap61;
    load w32 %152 %11 8;
    br.ult w32 3 %152 @guard#pass60 @guard#trap61;
  @guard#pass56
    load w64 %147 %8 0;
    sload w32 %148 %147 0;
    br.ne w32 %148 10 @then54 @merge55;
    load w64 %150 %11 0;
    sload w32 %151 %150 0;
    br.ne w32 %151 10 @then54 @merge55;
  @guard#trap57
    ebreak;
    unreachable;
  @then58
    ret 12;
  @merge59
    reserve %164 16 8;
    store w64 %7 %164 0;
    store w32 0 %164 8;
    store w32 0 %164 12;
    load w32 %167 %164 8;
    load w32 %168 %164 12;
    br.ult w32 %167 %168 @append.store62 @append.grow63;
    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;
  @guard#pass60
    load w64 %150 %8 0;
    mul w64 %151 3 4;
    add w64 %152 %150 %151;
    sload w32 %153 %152 0;
    br.ne w32 %153 40 @then58 @merge59;
    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 %182 %164 0;
    mul w64 %183 %167 4;
    add w64 %184 %182 %183;
    store w32 99 %184 0;
    add w32 %185 %167 1;
    store w32 %185 %164 8;
    load w32 %188 %164 8;
    br.ne w32 %188 1 @then67 @merge68;
    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;
  @append.grow63
    shl w32 %169 %168 1;
    or w32 %170 %169 1;
    load w64 %171 %5 0;
    load w64 %172 %5 8;
    mul w32 %173 %170 4;
    call w64 %174 %171(%172, %173, 4);
    load w64 %175 %164 0;
    mul w32 %176 %167 4;
    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;
    jmp @append64(0);
  @append64(w32 %177)
    br.ult w32 %177 %176 @append65 @append66;
  @append64(w32 %180)
    br.ult w32 %180 %179 @append65 @append66;
  @append65
    add w64 %178 %175 %177;
    load w8 %179 %178 0;
    add w64 %180 %174 %177;
    store w8 %179 %180 0;
    add w32 %181 %177 1;
    jmp @append64(%181);
    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);
  @append66
    store w64 %174 %164 0;
    store w32 %170 %164 12;
    store w64 %177 %167 0;
    store w32 %173 %167 12;
    jmp @append.store62;
  @then67
    ret 13;
  @merge68
    load w32 %189 %164 12;
    br.ne w32 %189 1 @then69 @merge70;
    load w32 %192 %167 12;
    br.ne w32 %192 1 @then69 @merge70;
  @then69
    ret 14;
  @merge70
    load w32 %190 %164 8;
    br.ult w32 0 %190 @guard#pass73 @guard#trap74;
    load w32 %193 %167 8;
    br.ult w32 0 %193 @guard#pass73 @guard#trap74;
  @then71
    ret 15;
  @merge72
    load w32 %195 %8 8;
    load w64 %196 %8 0;
    load w32 %198 %11 8;
    load w64 %199 %11 0;
    jmp @loop75(0, 0);
  @guard#pass73
    load w64 %191 %164 0;
    sload w32 %192 %191 0;
    br.ne w32 %192 99 @then71 @merge72;
    load w64 %194 %167 0;
    sload w32 %195 %194 0;
    br.ne w32 %195 99 @then71 @merge72;
  @guard#trap74
    ebreak;
    unreachable;
  @loop75(w32 %197, w32 %201)
    br.slt w32 %197 %195 @body76 @merge77;
  @loop75(w32 %200, w32 %204)
    br.slt w32 %200 %198 @body76 @merge77;
  @body76
    mul w64 %198 %197 4;
    add w64 %199 %196 %198;
    sload w32 %200 %199 0;
    add w32 %202 %201 %200;
    add w32 %203 %197 1;
    jmp @loop75(%203, %202);
    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);
  @merge77
    br.ne w32 %201 150 @then78 @merge79;
    br.ne w32 %204 150 @then78 @merge79;
  @then78
    ret 16;
  @merge79
    call w64 %217 $arenaAlloc(%3, 2, 1);
    reserve %218 16 8;
    store w64 %217 %218 0;
    store w32 0 %218 8;
    store w32 2 %218 12;
    load w32 %222 %218 8;
    load w32 %223 %218 12;
    br.ult w32 %222 %223 @append.store80 @append.grow81;
    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;
  @append.store80
    load w64 %237 %218 0;
    add w64 %238 %237 %222;
    store w8 171 %238 0;
    add w32 %239 %222 1;
    store w32 %239 %218 8;
    load w32 %244 %218 8;
    load w32 %245 %218 12;
    br.ult w32 %244 %245 @append.store85 @append.grow86;
    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;
  @append.grow81
    shl w32 %224 %223 1;
    or w32 %225 %224 1;
    load w64 %226 %5 0;
    load w64 %227 %5 8;
    mul w32 %228 %225 1;
    call w64 %229 %226(%227, %228, 1);
    load w64 %230 %218 0;
    mul w32 %231 %222 1;
    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;
    jmp @append82(0);
  @append82(w32 %232)
    br.ult w32 %232 %231 @append83 @append84;
  @append82(w32 %223)
    br.ult w32 %223 %222 @append83 @append84;
  @append83
    add w64 %233 %230 %232;
    load w8 %234 %233 0;
    add w64 %235 %229 %232;
    store w8 %234 %235 0;
    add w32 %236 %232 1;
    jmp @append82(%236);
    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);
  @append84
    store w64 %229 %218 0;
    store w32 %225 %218 12;
    store w64 %220 %209 0;
    store w32 %216 %209 12;
    jmp @append.store80;
  @append.store85
    load w64 %259 %218 0;
    add w64 %260 %259 %244;
    store w8 205 %260 0;
    add w32 %261 %244 1;
    store w32 %261 %218 8;
    load w32 %264 %218 8;
    br.ne w32 %264 2 @then90 @merge91;
    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;
  @append.grow86
    shl w32 %246 %245 1;
    or w32 %247 %246 1;
    load w64 %248 %5 0;
    load w64 %249 %5 8;
    mul w32 %250 %247 1;
    call w64 %251 %248(%249, %250, 1);
    load w64 %252 %218 0;
    mul w32 %253 %244 1;
    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;
    jmp @append87(0);
  @append87(w32 %254)
    br.ult w32 %254 %253 @append88 @append89;
  @append87(w32 %245)
    br.ult w32 %245 %244 @append88 @append89;
  @append88
    add w64 %255 %252 %254;
    load w8 %256 %255 0;
    add w64 %257 %251 %254;
    store w8 %256 %257 0;
    add w32 %258 %254 1;
    jmp @append87(%258);
    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);
  @append89
    store w64 %251 %218 0;
    store w32 %247 %218 12;
    store w64 %242 %209 0;
    store w32 %238 %209 12;
    jmp @append.store85;
  @then90
    ret 17;
  @merge91
    load w32 %265 %218 8;
    br.ult w32 0 %265 @guard#pass94 @guard#trap95;
    load w32 %256 %209 8;
    br.ult w32 0 %256 @guard#pass94 @guard#trap95;
  @then92
    ret 18;
  @merge93
    load w32 %268 %218 8;
    br.ult w32 1 %268 @guard#pass98 @guard#trap99;
    load w32 %259 %209 8;
    br.ult w32 1 %259 @guard#pass98 @guard#trap99;
  @guard#pass94
    load w64 %266 %218 0;
    load w8 %267 %266 0;
    br.ne w8 %267 171 @then92 @merge93;
    load w64 %257 %209 0;
    load w8 %258 %257 0;
    br.ne w8 %258 171 @then92 @merge93;
  @guard#trap95
    ebreak;
    unreachable;
  @then96
    ret 19;
  @merge97
    load w32 %274 %218 8;
    load w32 %275 %218 12;
    br.ult w32 %274 %275 @append.store100 @append.grow101;
    load w32 %265 %209 8;
    load w32 %266 %209 12;
    br.ult w32 %265 %266 @append.store100 @append.grow101;
  @guard#pass98
    load w64 %269 %218 0;
    add w64 %270 %269 1;
    load w8 %271 %270 0;
    br.ne w8 %271 205 @then96 @merge97;
    load w64 %260 %209 0;
    add w64 %261 %260 1;
    load w8 %262 %261 0;
    br.ne w8 %262 205 @then96 @merge97;
  @guard#trap99
    ebreak;
    unreachable;
  @append.store100
    load w64 %289 %218 0;
    add w64 %290 %289 %274;
    store w8 239 %290 0;
    add w32 %291 %274 1;
    store w32 %291 %218 8;
    load w32 %294 %218 8;
    br.ne w32 %294 3 @then105 @merge106;
    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;
  @append.grow101
    shl w32 %276 %275 1;
    or w32 %277 %276 1;
    load w64 %278 %5 0;
    load w64 %279 %5 8;
    mul w32 %280 %277 1;
    call w64 %281 %278(%279, %280, 1);
    load w64 %282 %218 0;
    mul w32 %283 %274 1;
    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;
    jmp @append102(0);
  @append102(w32 %284)
    br.ult w32 %284 %283 @append103 @append104;
  @append102(w32 %275)
    br.ult w32 %275 %274 @append103 @append104;
  @append103
    add w64 %285 %282 %284;
    load w8 %286 %285 0;
    add w64 %287 %281 %284;
    store w8 %286 %287 0;
    add w32 %288 %284 1;
    jmp @append102(%288);
    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);
  @append104
    store w64 %281 %218 0;
    store w32 %277 %218 12;
    store w64 %272 %209 0;
    store w32 %268 %209 12;
    jmp @append.store100;
  @then105
    ret 20;
  @merge106
    load w32 %295 %218 12;
    br.ne w32 %295 5 @then107 @merge108;
    load w32 %286 %209 12;
    br.ne w32 %286 5 @then107 @merge108;
  @then107
    ret 21;
  @merge108
    load w32 %296 %218 8;
    br.ult w32 2 %296 @guard#pass111 @guard#trap112;
    load w32 %287 %209 8;
    br.ult w32 2 %287 @guard#pass111 @guard#trap112;
  @then109
    ret 22;
  @merge110
    load w32 %300 %218 8;
    br.ult w32 0 %300 @guard#pass115 @guard#trap116;
    load w32 %291 %209 8;
    br.ult w32 0 %291 @guard#pass115 @guard#trap116;
  @guard#pass111
    load w64 %297 %218 0;
    add w64 %298 %297 2;
    load w8 %299 %298 0;
    br.ne w8 %299 239 @then109 @merge110;
    load w64 %288 %209 0;
    add w64 %289 %288 2;
    load w8 %290 %289 0;
    br.ne w8 %290 239 @then109 @merge110;
  @guard#trap112
    ebreak;
    unreachable;
  @then113
    ret 23;
  @merge114
    mul w32 %309 4 2;
    call w64 %310 $arenaAlloc(%3, %309, 4);
    reserve %311 16 8;
    store w64 %310 %311 0;
    store w32 0 %311 8;
    store w32 2 %311 12;
    load w32 %314 %311 8;
    load w32 %315 %311 12;
    br.ult w32 %314 %315 @append.store117 @append.grow118;
    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;
  @guard#pass115
    load w64 %301 %218 0;
    load w8 %302 %301 0;
    br.ne w8 %302 171 @then113 @merge114;
    load w64 %292 %209 0;
    load w8 %293 %292 0;
    br.ne w8 %293 171 @then113 @merge114;
  @guard#trap116
    ebreak;
    unreachable;
  @append.store117
    load w64 %329 %311 0;
    mul w64 %330 %314 4;
    add w64 %331 %329 %330;
    store w32 42 %331 0;
    add w32 %332 %314 1;
    store w32 %332 %311 8;
    blit %311 %311 16;
    load w32 %335 %311 8;
    br.eq w32 %335 1 @assert.ok123 @assert.fail122;
    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;
  @append.grow118
    shl w32 %316 %315 1;
    or w32 %317 %316 1;
    load w64 %318 %5 0;
    load w64 %319 %5 8;
    mul w32 %320 %317 4;
    call w64 %321 %318(%319, %320, 4);
    load w64 %322 %311 0;
    mul w32 %323 %314 4;
    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;
    jmp @append119(0);
  @append119(w32 %324)
    br.ult w32 %324 %323 @append120 @append121;
  @append119(w32 %310)
    br.ult w32 %310 %309 @append120 @append121;
  @append120
    add w64 %325 %322 %324;
    load w8 %326 %325 0;
    add w64 %327 %321 %324;
    store w8 %326 %327 0;
    add w32 %328 %324 1;
    jmp @append119(%328);
    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);
  @append121
    store w64 %321 %311 0;
    store w32 %317 %311 12;
    store w64 %307 %297 0;
    store w32 %303 %297 12;
    jmp @append.store117;
  @assert.fail122
    unreachable;
  @assert.ok123
    load w32 %336 %311 8;
    br.ult w32 0 %336 @guard#pass126 @guard#trap127;
    load w32 %322 %297 8;
    br.ult w32 0 %322 @guard#pass126 @guard#trap127;
  @assert.fail124
    unreachable;
  @assert.ok125
    load w32 %341 %311 8;
    load w32 %342 %311 12;
    br.ult w32 %341 %342 @append.store128 @append.grow129;
    load w32 %327 %297 8;
    load w32 %328 %297 12;
    br.ult w32 %327 %328 @append.store128 @append.grow129;
  @guard#pass126
    load w64 %337 %311 0;
    sload w32 %338 %337 0;
    br.eq w32 %338 42 @assert.ok125 @assert.fail124;
    load w64 %323 %297 0;
    sload w32 %324 %323 0;
    br.eq w32 %324 42 @assert.ok125 @assert.fail124;
  @guard#trap127
    ebreak;
    unreachable;
  @append.store128
    load w64 %356 %311 0;
    mul w64 %357 %341 4;
    add w64 %358 %356 %357;
    store w32 43 %358 0;
    add w32 %359 %341 1;
    store w32 %359 %311 8;
    blit %311 %311 16;
    load w32 %362 %311 8;
    br.eq w32 %362 2 @assert.ok134 @assert.fail133;
    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;
  @append.grow129
    shl w32 %343 %342 1;
    or w32 %344 %343 1;
    load w64 %345 %5 0;
    load w64 %346 %5 8;
    mul w32 %347 %344 4;
    call w64 %348 %345(%346, %347, 4);
    load w64 %349 %311 0;
    mul w32 %350 %341 4;
    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;
    jmp @append130(0);
  @append130(w32 %351)
    br.ult w32 %351 %350 @append131 @append132;
  @append130(w32 %337)
    br.ult w32 %337 %336 @append131 @append132;
  @append131
    add w64 %352 %349 %351;
    load w8 %353 %352 0;
    add w64 %354 %348 %351;
    store w8 %353 %354 0;
    add w32 %355 %351 1;
    jmp @append130(%355);
    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);
  @append132
    store w64 %348 %311 0;
    store w32 %344 %311 12;
    store w64 %334 %297 0;
    store w32 %330 %297 12;
    jmp @append.store128;
  @assert.fail133
    unreachable;
  @assert.ok134
    load w32 %363 %311 8;
    br.ult w32 0 %363 @guard#pass135 @guard#trap136;
    load w32 %349 %297 8;
    br.ult w32 0 %349 @guard#pass135 @guard#trap136;
  @guard#pass135
    load w64 %364 %311 0;
    load w32 %367 %311 8;
    load w32 %368 %311 12;
    br.ult w32 %367 %368 @append.store137 @append.grow138;
    load w64 %350 %297 0;
    load w32 %353 %297 8;
    load w32 %354 %297 12;
    br.ult w32 %353 %354 @append.store137 @append.grow138;
  @guard#trap136
    ebreak;
    unreachable;
  @append.store137
    load w64 %382 %311 0;
    mul w64 %383 %367 4;
    add w64 %384 %382 %383;
    store w32 44 %384 0;
    add w32 %385 %367 1;
    store w32 %385 %311 8;
    blit %311 %311 16;
    load w32 %388 %311 8;
    br.eq w32 %388 3 @assert.ok143 @assert.fail142;
    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;
  @append.grow138
    shl w32 %369 %368 1;
    or w32 %370 %369 1;
    load w64 %371 %5 0;
    load w64 %372 %5 8;
    mul w32 %373 %370 4;
    call w64 %374 %371(%372, %373, 4);
    load w64 %375 %311 0;
    mul w32 %376 %367 4;
    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;
    jmp @append139(0);
  @append139(w32 %377)
    br.ult w32 %377 %376 @append140 @append141;
  @append139(w32 %363)
    br.ult w32 %363 %362 @append140 @append141;
  @append140
    add w64 %378 %375 %377;
    load w8 %379 %378 0;
    add w64 %380 %374 %377;
    store w8 %379 %380 0;
    add w32 %381 %377 1;
    jmp @append139(%381);
    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);
  @append141
    store w64 %374 %311 0;
    store w32 %370 %311 12;
    store w64 %360 %297 0;
    store w32 %356 %297 12;
    jmp @append.store137;
  @assert.fail142
    unreachable;
  @assert.ok143
    load w32 %389 %311 12;
    br.eq w32 %389 5 @assert.ok145 @assert.fail144;
    load w32 %375 %297 12;
    br.eq w32 %375 5 @assert.ok145 @assert.fail144;
  @assert.fail144
    unreachable;
  @assert.ok145
    load w32 %390 %311 8;
    br.ult w32 0 %390 @guard#pass146 @guard#trap147;
    load w32 %376 %297 8;
    br.ult w32 0 %376 @guard#pass146 @guard#trap147;
  @guard#pass146
    load w64 %391 %311 0;
    br.ne w64 %364 %391 @assert.ok149 @assert.fail148;
    load w64 %377 %297 0;
    br.ne w64 %350 %377 @assert.ok149 @assert.fail148;
  @guard#trap147
    ebreak;
    unreachable;
  @assert.fail148
    unreachable;
  @assert.ok149
    load w32 %394 %311 8;
    br.ult w32 0 %394 @guard#pass152 @guard#trap153;
    load w32 %380 %297 8;
    br.ult w32 0 %380 @guard#pass152 @guard#trap153;
  @assert.fail150
    unreachable;
  @assert.ok151
    load w32 %397 %311 8;
    br.ult w32 1 %397 @guard#pass156 @guard#trap157;
    load w32 %383 %297 8;
    br.ult w32 1 %383 @guard#pass156 @guard#trap157;
  @guard#pass152
    load w64 %395 %311 0;
    sload w32 %396 %395 0;
    br.eq w32 %396 42 @assert.ok151 @assert.fail150;
    load w64 %381 %297 0;
    sload w32 %382 %381 0;
    br.eq w32 %382 42 @assert.ok151 @assert.fail150;
  @guard#trap153
    ebreak;
    unreachable;
  @assert.fail154
    unreachable;
  @assert.ok155
    load w32 %402 %311 8;
    br.ult w32 2 %402 @guard#pass160 @guard#trap161;
    load w32 %388 %297 8;
    br.ult w32 2 %388 @guard#pass160 @guard#trap161;
  @guard#pass156
    load w64 %398 %311 0;
    mul w64 %399 1 4;
    add w64 %400 %398 %399;
    sload w32 %401 %400 0;
    br.eq w32 %401 43 @assert.ok155 @assert.fail154;
    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;
  @guard#trap157
    ebreak;
    unreachable;
  @assert.fail158
    unreachable;
  @assert.ok159
    ret 0;
  @guard#pass160
    load w64 %403 %311 0;
    mul w64 %404 2 4;
    add w64 %405 %403 %404;
    sload w32 %406 %405 0;
    br.eq w32 %406 44 @assert.ok159 @assert.fail158;
    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;
  @guard#trap161
    ebreak;
    unreachable;
}


test/tests/slice.assign.rad +4 -4

//! returns: 0

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    // Fill entire array.
    let mut a: [i32; 4] = [1, 2, 3, 4];
    set a[..] = 0;
    assert a == [0, 0, 0, 0];


11	11		set b[1..3] = 99;
12	12		assert b == [1, 99, 99, 4];
13	13
14	14		// Fill mutable slice.
15	15		let mut c: [i32; 4] = [10, 20, 30, 40];
16		-	let cs: *mut [i32] = &mut c[..];
	16	+	let cs: *unsafe mut [i32] = &mut c[..];
17	17		set cs[..] = 7;
18	18		assert c == [7, 7, 7, 7];
19	19
20	20		// Fill sub-range of mutable slice.
21	21		let mut d: [i32; 5] = [1, 2, 3, 4, 5];
22		-	let ds: *mut [i32] = &mut d[..];
	22	+	let ds: *unsafe mut [i32] = &mut d[..];
23	23		set ds[1..4] = 0;
24	24		assert d == [1, 0, 0, 0, 5];
25	25
26	26		// Copy slice into array.
27	27		let mut e: [i32; 3] = [0, 0, 0];

40	40		set g[1..1] = 99;
41	41		assert g == [1, 2, 3];
42	42
43	43		// Copy between sub-ranges.
44	44		let mut i: [i32; 10] = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100];
45		-	let s: *mut [i32] = &mut i[..];
	45	+	let s: *unsafe mut [i32] = &mut i[..];
46	46		set s[1..4] = &s[7..10];
47	47		assert i[1] == 80 and i[2] == 90 and i[3] == 100;
48	48
49	49		// Fill u8 array.
50	50		let mut h: [u8; 4] = [65, 66, 67, 68];

test/tests/slice.cap.rad +3 -3

//! returns: 0
//! Test slice capacity field and @sliceOf builtin.

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    // Test that regular slices have cap == len.
    let mut arr: [i32; 4] = [10, 20, 30, 40];
    let s = &mut arr[..];
    let s: *unsafe mut [i32] = &mut arr[..];

    if s.cap <> 4 {
        return 1;
    }
    if s.len <> s.cap {
        return 2;
    }

    // Test @sliceOf with explicit capacity.
    let ptr = &mut arr[0];
    let ptr: *unsafe mut i32 = &mut arr[0];
    let s2 = @sliceOf(ptr, 2, 4);

    if s2.len <> 2 {
        return 3;
    }

test/tests/slice.delete.rad +2 -2

//! returns: 0
//! Test slice .delete() method.

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut arr: [i32; 5] = [10, 20, 30, 40, 50];
    let mut s = &mut arr[..];
    let mut s: *unsafe mut [i32] = &mut arr[..];

    // Delete middle element (index 2: value 30).
    s.delete(2);

    if s.len <> 4 {

test/tests/slice.empty.suffix.rad +5 -5

//! returns: 0

fn checkArraySuffix() {
unsafe fn checkArraySuffix() {
    let xs: [u8; 3] = [10, 20, 30];
    let empty = &xs[xs.len..xs.len];
    let empty: *unsafe [u8] = &xs[xs.len..xs.len];

    assert empty.len == 0;
}

fn checkSliceSuffix() {
unsafe fn checkSliceSuffix() {
    let xs: [u8; 3] = [10, 20, 30];
    let slice: *[u8] = &xs[..];
    let slice: *unsafe [u8] = &xs[..];
    let empty = &slice[slice.len..slice.len];

    assert empty.len == 0;
}


    let empty = &text[text.len..text.len];

    assert empty.len == 0;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    checkArraySuffix();
    checkSliceSuffix();
    checkStringSuffix();
    return 0;
}

test/tests/slice.of.rad +2 -2

//! returns: 0
//! Test that @sliceOf produces a fat pointer with the correct length.

fn makeSlice(ptr: *mut i32, count: u32) -> *mut [i32] {
fn makeSlice(ptr: *unsafe mut i32, count: u32) -> *unsafe mut [i32] {
    return @sliceOf(ptr, count);
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut arr: [i32; 4] = [10, 20, 30, 40];
    let s = makeSlice(&mut arr[0], 4);

    assert s.len == 4;
    assert s[0] == 10;

test/tests/slice.range.bounds.check.rad +2 -2


fn id(n: u32) -> u32 {
    return n;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let xs: [i32; 3] = [1, 2, 3];
    let slice: *[i32] = &xs[..];
    let slice: *unsafe [i32] = &xs[..];
    let bad = &slice[id(4)..id(4)];

    return bad.len as i32;
}

test/tests/slice.range.dynamic.rad +2 -2

2	2
3	3		fn id(n: u32) -> u32 {
4	4		return n;
5	5		}
6	6
7		-	@default fn main() -> i32 {
	7	+	@default unsafe fn main() -> i32 {
8	8		let xs: [u8; 5] = [10, 20, 30, 40, 50];
9		-	let slice: *[u8] = &xs[..];
	9	+	let slice: *unsafe [u8] = &xs[..];
10	10
11	11		let start = id(1);
12	12		let end = id(4);
13	13		let mid = &slice[start..end];
14	14

test/tests/slice.range.order.check.rad +2 -2


fn id(n: u32) -> u32 {
    return n;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let xs: [i32; 3] = [1, 2, 3];
    let slice: *[i32] = &xs[..];
    let slice: *unsafe [i32] = &xs[..];
    let bad = &slice[id(2)..id(1)];

    return bad.len as i32;
}

test/tests/slice.range.rad +5 -5

/// Returns a subslice with explicit bounds.
fn sliceRange(s: *[i32], start: u32, end: u32) -> *[i32] {
unsafe fn sliceRange(s: &[i32], start: u32, end: u32) -> *unsafe [i32] {
    return &s[start..end];
}

/// Returns a subslice with an open end bound.
fn sliceRangeOpenEnd(s: *[i32], start: u32) -> *[i32] {
unsafe fn sliceRangeOpenEnd(s: &[i32], start: u32) -> *unsafe [i32] {
    return &s[start..];
}

/// Returns a subslice with an open start bound.
fn sliceRangeOpenStart(s: *[i32], end: u32) -> *[i32] {
unsafe fn sliceRangeOpenStart(s: &[i32], end: u32) -> *unsafe [i32] {
    return &s[..end];
}

/// Returns a full reslice of a slice.
fn sliceRangeFull(s: *[i32]) -> *[i32] {
unsafe fn sliceRangeFull(s: &[i32]) -> *unsafe [i32] {
    return &s[..];
}

/// Returns a subslice from an array parameter.
fn sliceArray(a: [i32; 4]) -> *[i32] {
unsafe fn sliceArray(a: [i32; 4]) -> *unsafe [i32] {
    return &a[1..3];
}

test/tests/slice.runtime.i32.rad +3 -3

// Test runtime slice literal with i32 elements

fn sliceWithVar(c: i32) -> *[i32] {
unsafe fn sliceWithVar(c: i32) -> *unsafe [i32] {
    return &[c];
}

fn sliceWithVars(a: i32, b: i32) -> *[i32] {
unsafe fn sliceWithVars(a: i32, b: i32) -> *unsafe [i32] {
    return &[a, b];
}

fn sliceWithMixed(a: i32) -> *[i32] {
unsafe fn sliceWithMixed(a: i32) -> *unsafe [i32] {
    return &[a, 42, a];
}

test/tests/slice.runtime.literal.rad +2 -2

/// Create a slice literal with a runtime (non-constant) element.
fn sliceWithVar(c: u8) -> *[u8] {
unsafe fn sliceWithVar(c: u8) -> *unsafe [u8] {
    return &[c];
}

/// Create a slice literal with multiple runtime elements.
fn sliceWithVars(a: u8, b: u8) -> *[u8] {
unsafe fn sliceWithVars(a: u8, b: u8) -> *unsafe [u8] {
    return &[a, b];
}

test/tests/slice.subslice.rad +15 -15

//! returns: 42

fn testBasicSubslice() -> bool {
unsafe fn testBasicSubslice() -> bool {
    let arr: [i32; 5] = [10, 20, 30, 40, 50];
    let slice: *[i32] = &arr[..];        // Full slice [10, 20, 30, 40, 50]
    let subslice: *[i32] = &slice[1..4]; // Sub-slice [20, 30, 40]
    let slice: *unsafe [i32] = &arr[..];        // Full slice [10, 20, 30, 40, 50]
    let subslice: *unsafe [i32] = &slice[1..4]; // Sub-slice [20, 30, 40]

    return subslice[0] == 20 and subslice[1] == 30 and subslice[2] == 40;
}

fn testNestedSubslice() -> bool {
unsafe fn testNestedSubslice() -> bool {
    let arr: [i32; 6] = [100, 200, 300, 400, 500, 600];
    let slice1: *[i32] = &arr[1..5];     // [200, 300, 400, 500]
    let slice2: *[i32] = &slice1[1..3];  // [300, 400]
    let slice3: *[i32] = &slice2[0..1];  // [300]
    let slice1: *unsafe [i32] = &arr[1..5];     // [200, 300, 400, 500]
    let slice2: *unsafe [i32] = &slice1[1..3];  // [300, 400]
    let slice3: *unsafe [i32] = &slice2[0..1];  // [300]

    return slice3[0] == 300;
}

fn testSubsliceLength() -> bool {
unsafe fn testSubsliceLength() -> bool {
    let arr: [i32; 4] = [1, 2, 3, 4];
    let slice: *[i32] = &arr[..];
    let subslice: *[i32] = &slice[1..3];
    let slice: *unsafe [i32] = &arr[..];
    let subslice: *unsafe [i32] = &slice[1..3];

    return subslice.len == 2;
}

fn testEdgeCases() -> bool {
unsafe fn testEdgeCases() -> bool {
    let arr: [i32; 3] = [7, 8, 9];
    let slice: *[i32] = &arr[..];
    let slice: *unsafe [i32] = &arr[..];

    // Test single element subslice
    let single: *[i32] = &slice[1..2];
    let single: *unsafe [i32] = &slice[1..2];
    if (single[0] <> 8 or single.len <> 1) {
        return false;
    }

    // Test empty subslice
    let empty: *[i32] = &slice[2..2];
    let empty: *unsafe [i32] = &slice[2..2];
    if (empty.len <> 0) {
        return false;
    }
    return true;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    if (
        testBasicSubslice() and
        testNestedSubslice() and
        testSubsliceLength() and
        testEdgeCases()

test/tests/spill.blockarg.clobber.rad +2 -2

record State: Copy {
    h: [u32; 8],
    w: [u32; 64],
}

fn prepareSchedule(s: *mut State, block: *[u32]) {
fn prepareSchedule(s: &mut State, block: &[u32]) {
    let mut i: u32 = 0;
    while i < 16 {
        set s.w[i] = block[i];
        set i += 1;
    }

    }
}

/// SHA-256 compression: 64 rounds with 8 rotating working variables.
/// Exercises heavy register pressure and spilled block-argument shuffles.
fn compress(s: *mut State, k: *[u32]) {
fn compress(s: &mut State, k: &[u32]) {
    let mut a: u32 = s.h[0];
    let mut b: u32 = s.h[1];
    let mut c: u32 = s.h[2];
    let mut d: u32 = s.h[3];
    let mut e: u32 = s.h[4];

test/tests/spill.loop.rad +1 -1

        return n;
    }
    return (n + a - 1) & (0 - a);
}

fn computeRecordLayout(tags: *[u8]) -> Layout {
fn computeRecordLayout(tags: &[u8]) -> Layout {
    let mut currentOffset: u32 = 0;
    let mut maxAlignment: u32 = 1;
    for i in 0..tags.len {
        let layout = getLayout(tags[i]);
        set currentOffset = alignUp(currentOffset, layout.alignment);

test/tests/trait.aggregate.ret.rad +9 -9

    y: i32,
    z: i32,
}

trait Geometry {
    fn (*Geometry) origin() -> Point;
    fn (*Geometry) center() -> Vec3;
    fn (*Geometry) maybe() -> ?i32;
    unsafe fn (*unsafe Geometry) origin() -> Point;
    unsafe fn (*unsafe Geometry) center() -> Vec3;
    unsafe fn (*unsafe Geometry) maybe() -> ?i32;
}

record Circle: Copy {
    cx: i32,
    cy: i32,
    radius: i32,
}

instance Geometry for Circle {
    fn (c: *Circle) origin() -> Point {
    unsafe fn (c: *unsafe Circle) origin() -> Point {
        return Point { x: c.cx, y: c.cy };
    }

    fn (c: *Circle) center() -> Vec3 {
    unsafe fn (c: *unsafe Circle) center() -> Vec3 {
        return Vec3 { x: c.cx, y: c.cy, z: 0 };
    }

    fn (c: *Circle) maybe() -> ?i32 {
    unsafe fn (c: *unsafe Circle) maybe() -> ?i32 {
        if c.radius > 0 {
            return c.radius;
        }
        return nil;
    }
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let c = Circle { cx: 10, cy: 20, radius: 5 };
    let g: *opaque Geometry = &c;
    let g: *unsafe opaque Geometry = &c;

    // Small struct return (Point, 8 bytes = pointer size).
    let p = g.origin();
    assert p.x == 10;
    assert p.y == 20;

        return 7;
    }

    // Optional return - None case.
    let c2 = Circle { cx: 0, cy: 0, radius: 0 };
    let g2: *opaque Geometry = &c2;
    let g2: *unsafe opaque Geometry = &c2;
    let m2 = g2.maybe();
    if let _ = m2 {
        return 8;
    }


test/tests/trait.array.optional.rad +12 -12

record Multiplier: Copy {
    n: i32,
}

trait Transform {
    fn (*Transform) apply(x: i32) -> i32;
    unsafe fn (*unsafe Transform) apply(x: i32) -> i32;
}

instance Transform for Adder {
    fn (a: *Adder) apply(x: i32) -> i32 {
    unsafe fn (a: *unsafe Adder) apply(x: i32) -> i32 {
        return x + a.n;
    }
}

instance Transform for Multiplier {
    fn (m: *Multiplier) apply(x: i32) -> i32 {
    unsafe fn (m: *unsafe Multiplier) apply(x: i32) -> i32 {
        return x * m.n;
    }
}

/// Apply a chain of transforms to a value.
fn applyAll(transforms: *[*opaque Transform], value: i32) -> i32 {
unsafe fn applyAll(transforms: *unsafe [*unsafe opaque Transform], value: i32) -> i32 {
    let mut result = value;
    for i in 0..transforms.len {
        set result = transforms[i].apply(result);
    }
    return result;
}

/// Apply an optional transform, returning the original value if nil.
fn applyMaybe(t: ?*opaque Transform, value: i32) -> i32 {
unsafe fn applyMaybe(t: ?*unsafe opaque Transform, value: i32) -> i32 {
    if let tr = t {
        return tr.apply(value);
    }
    return value;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let a1 = Adder { n: 10 };
    let m1 = Multiplier { n: 3 };
    let a2 = Adder { n: 5 };

    let t1: *opaque Transform = &a1;
    let t2: *opaque Transform = &m1;
    let t3: *opaque Transform = &a2;
    let t1: *unsafe opaque Transform = &a1;
    let t2: *unsafe opaque Transform = &m1;
    let t3: *unsafe opaque Transform = &a2;

    // Array of trait objects.
    let transforms: [*opaque Transform; 3] = [t1, t2, t3];
    let transforms: [*unsafe opaque Transform; 3] = [t1, t2, t3];
    // Chain: (1 + 10) * 3 + 5 = 38
    let result = applyAll(&transforms[..], 1);
    assert result == 38;

    // Optional trait object - Some case.
    let opt: ?*opaque Transform = t1;
    let opt: ?*unsafe opaque Transform = t1;
    let r2 = applyMaybe(opt, 5);
    assert r2 == 15;

    // Optional trait object - None case.
    let none: ?*opaque Transform = nil;
    let none: ?*unsafe opaque Transform = nil;
    let r3 = applyMaybe(none, 5);
    assert r3 == 5;

    return 0;
}

test/tests/trait.basic.rad +4 -4

record Counter: Copy {
    value: i32,
}

trait Adder {
    fn (*mut Adder) add(n: i32) -> i32;
    unsafe fn (*unsafe mut Adder) add(n: i32) -> i32;
}

instance Adder for Counter {
    fn (c: *mut Counter) add(n: i32) -> i32 {
    unsafe fn (c: *unsafe mut Counter) add(n: i32) -> i32 {
        set c.value = c.value + n;
        return c.value;
    }
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut c = Counter { value: 10 };
    let a: *mut opaque Adder = &mut c;
    let a: *unsafe mut opaque Adder = &mut c;

    let result = a.add(5);
    // c.value should be 15 now.
    assert result == 15;
    let result2 = a.add(3);

test/tests/trait.control.flow.rad +6 -6

record Counter: Copy {
    value: i32,
}

trait Stepper {
    fn (*mut Stepper) step() -> i32;
    fn (*Stepper) current() -> i32;
    unsafe fn (*unsafe mut Stepper) step() -> i32;
    unsafe fn (*unsafe Stepper) current() -> i32;
}

instance Stepper for Counter {
    fn (c: *mut Counter) step() -> i32 {
    unsafe fn (c: *unsafe mut Counter) step() -> i32 {
        set c.value = c.value + 1;
        return c.value;
    }

    fn (c: *Counter) current() -> i32 {
    unsafe fn (c: *unsafe Counter) current() -> i32 {
        return c.value;
    }
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut c = Counter { value: 0 };
    let s: *mut opaque Stepper = &mut c;
    let s: *unsafe mut opaque Stepper = &mut c;

    // Dispatch in a while loop.
    let mut i: i32 = 0;
    while i < 5 {
        s.step();

test/tests/trait.fn.param.rad +12 -12

record Square: Copy {
    side: i32,
}

trait Shape {
    fn (*Shape) area() -> i32;
    unsafe fn (*unsafe Shape) area() -> i32;
}

trait Scalable {
    fn (*mut Scalable) scale(factor: i32);
    unsafe fn (*unsafe mut Scalable) scale(factor: i32);
}

instance Shape for Circle {
    fn (c: *Circle) area() -> i32 {
    unsafe fn (c: *unsafe Circle) area() -> i32 {
        return c.radius * c.radius * 3;
    }
}

instance Shape for Square {
    fn (s: *Square) area() -> i32 {
    unsafe fn (s: *unsafe Square) area() -> i32 {
        return s.side * s.side;
    }
}

instance Scalable for Circle {
    fn (c: *mut Circle) scale(factor: i32) {
    unsafe fn (c: *unsafe mut Circle) scale(factor: i32) {
        set c.radius = c.radius * factor;
    }
}

/// Accept an immutable trait object parameter.
fn getArea(s: *opaque Shape) -> i32 {
unsafe fn getArea(s: *unsafe opaque Shape) -> i32 {
    return s.area();
}

/// Accept a mutable trait object parameter.
fn doubleSize(s: *mut opaque Scalable) {
unsafe fn doubleSize(s: *unsafe mut opaque Scalable) {
    s.scale(2);
}

/// Accept two trait object parameters.
fn totalArea(a: *opaque Shape, b: *opaque Shape) -> i32 {
unsafe fn totalArea(a: *unsafe opaque Shape, b: *unsafe opaque Shape) -> i32 {
    return a.area() + b.area();
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let c = Circle { radius: 5 };
    let s = Square { side: 4 };

    // Pass immutable trait objects to function.
    let cs: *opaque Shape = &c;
    let cs: *unsafe opaque Shape = &c;
    let ca = getArea(cs);
    assert ca == 75;

    let ss: *opaque Shape = &s;
    let ss: *unsafe opaque Shape = &s;
    let sa = getArea(ss);
    assert sa == 16;

    // Pass two different trait objects to same function.
    let total = totalArea(cs, ss);
    assert total == 91;

    // Pass mutable trait object to function.
    let mut c2 = Circle { radius: 3 };
    let sc: *mut opaque Scalable = &mut c2;
    let sc: *unsafe mut opaque Scalable = &mut c2;
    doubleSize(sc);
    assert c2.radius == 6;
    return 0;
}

test/tests/trait.multiple.methods.rad +8 -8

record Accumulator: Copy {
    total: i32,
}

trait Collector {
    fn (*mut Collector) add(n: i32) -> i32;
    fn (*mut Collector) clear();
    fn (*mut Collector) isEmpty() -> bool;
    unsafe fn (*unsafe mut Collector) add(n: i32) -> i32;
    unsafe fn (*unsafe mut Collector) clear();
    unsafe fn (*unsafe mut Collector) isEmpty() -> bool;
}

instance Collector for Accumulator {
    fn (a: *mut Accumulator) add(n: i32) -> i32 {
    unsafe fn (a: *unsafe mut Accumulator) add(n: i32) -> i32 {
        set a.total = a.total + n;
        return a.total;
    }

    fn (a: *mut Accumulator) clear() {
    unsafe fn (a: *unsafe mut Accumulator) clear() {
        set a.total = 0;
    }

    fn (a: *mut Accumulator) isEmpty() -> bool {
    unsafe fn (a: *unsafe mut Accumulator) isEmpty() -> bool {
        return a.total == 0;
    }
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut acc = Accumulator { total: 0 };
    let c: *mut opaque Collector = &mut acc;
    let c: *unsafe mut opaque Collector = &mut acc;

    // Initially empty.
    assert c.isEmpty();

    // Add returns running total.

test/tests/trait.multiple.traits.rad +9 -9

record Counter: Copy {
    value: i32,
}

trait Incrementable {
    fn (*mut Incrementable) inc() -> i32;
    unsafe fn (*unsafe mut Incrementable) inc() -> i32;
}

trait Resettable {
    fn (*mut Resettable) reset();
    fn (*mut Resettable) isZero() -> bool;
    unsafe fn (*unsafe mut Resettable) reset();
    unsafe fn (*unsafe mut Resettable) isZero() -> bool;
}

instance Incrementable for Counter {
    fn (c: *mut Counter) inc() -> i32 {
    unsafe fn (c: *unsafe mut Counter) inc() -> i32 {
        set c.value = c.value + 1;
        return c.value;
    }
}

instance Resettable for Counter {
    fn (c: *mut Counter) reset() {
    unsafe fn (c: *unsafe mut Counter) reset() {
        set c.value = 0;
    }

    fn (c: *mut Counter) isZero() -> bool {
    unsafe fn (c: *unsafe mut Counter) isZero() -> bool {
        return c.value == 0;
    }
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut c = Counter { value: 10 };

    // Dispatch through Incrementable.
    let i: *mut opaque Incrementable = &mut c;
    let i: *unsafe mut opaque Incrementable = &mut c;
    let v1 = i.inc();
    assert v1 == 11;

    // Dispatch through Resettable.
    let r: *mut opaque Resettable = &mut c;
    let r: *unsafe mut opaque Resettable = &mut c;
    if r.isZero() {
        return 2;
    }
    r.reset();
    assert r.isZero();

test/tests/trait.multiple.types.rad +10 -10

record Cat: Copy {
    lives: i32,
}

trait Speaker {
    fn (*Speaker) speak() -> i32;
    fn (*Speaker) isOld() -> bool;
    unsafe fn (*unsafe Speaker) speak() -> i32;
    unsafe fn (*unsafe Speaker) isOld() -> bool;
}

instance Speaker for Dog {
    fn (d: *Dog) speak() -> i32 {
    unsafe fn (d: *unsafe Dog) speak() -> i32 {
        return d.age;
    }

    fn (d: *Dog) isOld() -> bool {
    unsafe fn (d: *unsafe Dog) isOld() -> bool {
        return d.age > 10;
    }
}

instance Speaker for Cat {
    fn (c: *Cat) speak() -> i32 {
    unsafe fn (c: *unsafe Cat) speak() -> i32 {
        return c.lives * 10;
    }

    fn (c: *Cat) isOld() -> bool {
    unsafe fn (c: *unsafe Cat) isOld() -> bool {
        return c.lives < 5;
    }
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let d = Dog { age: 5 };
    let c = Cat { lives: 9 };

    // Immutable trait object from Dog.
    let sd: *opaque Speaker = &d;
    let sd: *unsafe opaque Speaker = &d;
    let v1 = sd.speak();
    assert v1 == 5;
    if sd.isOld() {
        return 2;
    }

    // Immutable trait object from Cat.
    let sc: *opaque Speaker = &c;
    let sc: *unsafe opaque Speaker = &c;
    let v2 = sc.speak();
    assert v2 == 90;
    if sc.isOld() {
        return 4;
    }

    // Old dog.
    let oldDog = Dog { age: 15 };
    let so: *opaque Speaker = &oldDog;
    let so: *unsafe opaque Speaker = &oldDog;
    assert so.isOld();
    return 0;
}

test/tests/trait.object.rad +4 -4

record Counter: Copy {
    value: i32,
}

trait Adder {
    fn (*mut Adder) add(n: i32) -> i32;
    unsafe fn (*unsafe mut Adder) add(n: i32) -> i32;
}

instance Adder for Counter {
    fn (c: *mut Counter) add(n: i32) -> i32 {
    unsafe fn (c: *unsafe mut Counter) add(n: i32) -> i32 {
        set c.value = c.value + n;
        return c.value;
    }
}

fn use_adder() -> i32 {
unsafe fn use_adder() -> i32 {
    let mut c = Counter { value: 0 };
    let a: *mut opaque Adder = &mut c;
    let a: *unsafe mut opaque Adder = &mut c;
    return a.add(1);
}

test/tests/trait.supertrait.forward.rad +6 -6

//! returns: 0
//! A supertrait declared later must contribute methods to its child trait.

trait Child: Parent {
    fn (*Child) child() -> i32;
    unsafe fn (*unsafe Child) child() -> i32;
}

trait Parent {
    fn (*Parent) parent() -> i32;
    unsafe fn (*unsafe Parent) parent() -> i32;
}

record Value: Copy {
    n: i32,
}

instance Parent for Value {
    fn (self: *Value) parent() -> i32 {
    unsafe fn (self: *unsafe Value) parent() -> i32 {
        return self.n;
    }
}

instance Child for Value {
    fn (self: *Value) child() -> i32 {
    unsafe fn (self: *unsafe Value) child() -> i32 {
        return self.n + 1;
    }
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let value = Value { n: 41 };
    let object: *opaque Child = &value;
    let object: *unsafe opaque Child = &value;
    assert object.parent() == 41;
    assert object.child() == 42;
    return 0;
}

test/tests/trait.supertrait.rad +8 -8

//! A Socket type implements all three. Coercing a `*opaque ReadWriter` to
//! `*opaque Reader` or `*opaque Writer` should work, and dispatching through
//! any of the three trait objects should call the correct methods.

trait Reader {
    fn (*mut Reader) read(buf: *mut [u8]) -> i32;
    unsafe fn (*unsafe mut Reader) read(buf: *unsafe mut [u8]) -> i32;
}

trait Writer {
    fn (*mut Writer) write(data: *[u8]) -> i32;
    unsafe fn (*unsafe mut Writer) write(data: *[u8]) -> i32;
}

trait ReadWriter: Reader + Writer {
    fn (*mut ReadWriter) flush() -> i32;
    unsafe fn (*unsafe mut ReadWriter) flush() -> i32;
}

record Socket: Copy {
    rbuf: [u8; 32],
    rpos: i32,

    wbuf: [u8; 32],
    wpos: i32,
}

instance Reader for Socket {
    fn (s: *mut Socket) read(buf: *mut [u8]) -> i32 {
    unsafe fn (s: *unsafe mut Socket) read(buf: *unsafe mut [u8]) -> i32 {
        let mut i: u32 = 0;
        while i < buf.len and s.rpos < s.rlen {
            set buf[i] = s.rbuf[s.rpos as u32];
            set s.rpos = s.rpos + 1;
            set i = i + 1;

        return i as i32;
    }
}

instance Writer for Socket {
    fn (s: *mut Socket) write(data: *[u8]) -> i32 {
    unsafe fn (s: *unsafe mut Socket) write(data: *[u8]) -> i32 {
        let mut i: u32 = 0;
        while i < data.len {
            if s.wpos >= 32 {
                return s.wpos;
            }

        return s.wpos;
    }
}

instance ReadWriter for Socket {
    fn (s: *mut Socket) flush() -> i32 {
    unsafe fn (s: *unsafe mut Socket) flush() -> i32 {
        let pos = s.wpos;
        set s.wpos = 0;
        return pos;
    }
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut sock = Socket {
        rbuf: undefined,
        rpos: 0,
        rlen: 5,
        wbuf: undefined,

    set sock.rbuf[2] = 'l' as u8;
    set sock.rbuf[3] = 'l' as u8;
    set sock.rbuf[4] = 'o' as u8;

    // Test 1: Use as ReadWriter trait object.
    let rw: *mut opaque ReadWriter = &mut sock;
    let rw: *unsafe mut opaque ReadWriter = &mut sock;

    // Test 2: Write through the ReadWriter (dispatches via Writer supertrait).
    let wn = rw.write("abc");
    assert wn == 3;
    assert sock.wpos == 3;

test/tests/trait.throws.rad +4 -4

record StrictParser: Copy {
    limit: i32,
}

trait Parser {
    fn (*Parser) parse(n: i32) -> i32 throws (ParseError);
    unsafe fn (*unsafe Parser) parse(n: i32) -> i32 throws (ParseError);
}

instance Parser for StrictParser {
    fn (p: *StrictParser) parse(n: i32) -> i32 throws (ParseError) {
    unsafe fn (p: *unsafe StrictParser) parse(n: i32) -> i32 throws (ParseError) {
        if n < 0 {
            throw ParseError::InvalidInput;
        }
        if n > p.limit {
            throw ParseError::Overflow;
        }
        return n * 2;
    }
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let sp = StrictParser { limit: 100 };
    let p: *opaque Parser = &sp;
    let p: *unsafe opaque Parser = &sp;

    // Success path.
    let r1 = try p.parse(5) catch {
        return 1;
    };

test/tests/trait.writer.rad +12 -12

//! A BufferWriter writes to an in-memory buffer; a CountingWriter wraps any
//! Writer and tracks how many bytes flow through it. This tests trait objects
//! as struct fields, dispatch chains, and a real-world composition pattern.

trait Writer {
    fn (*mut Writer) write(data: *[u8]) -> i32;
    fn (*Writer) total() -> i32;
    unsafe fn (*unsafe mut Writer) write(data: *[u8]) -> i32;
    unsafe fn (*unsafe Writer) total() -> i32;
}

/// Writes bytes into a fixed-size buffer.
record BufferWriter: Copy {
    buf: [u8; 64],
    pos: i32,
}

instance Writer for BufferWriter {
    fn (w: *mut BufferWriter) write(data: *[u8]) -> i32 {
    unsafe fn (w: *unsafe mut BufferWriter) write(data: *[u8]) -> i32 {
        let mut i: u32 = 0;
        while i < data.len {
            if w.pos >= 64 {
                return w.pos;
            }

            set i = i + 1;
        }
        return w.pos;
    }

    fn (w: *BufferWriter) total() -> i32 {
    unsafe fn (w: *unsafe BufferWriter) total() -> i32 {
        return w.pos;
    }
}

/// Counts bytes written through it, forwarding to an inner writer.
record CountingWriter: Copy {
    inner: *mut opaque Writer,
    inner: *unsafe mut opaque Writer,
    count: i32,
}

instance Writer for CountingWriter {
    fn (w: *mut CountingWriter) write(data: *[u8]) -> i32 {
    unsafe fn (w: *unsafe mut CountingWriter) write(data: *[u8]) -> i32 {
        set w.count = w.count + data.len as i32;
        return w.inner.write(data);
    }

    fn (w: *CountingWriter) total() -> i32 {
    unsafe fn (w: *unsafe CountingWriter) total() -> i32 {
        return w.count;
    }
}

/// Write a slice through any Writer.
fn emit(w: *mut opaque Writer, data: *[u8]) -> i32 {
unsafe fn emit(w: *unsafe mut opaque Writer, data: *[u8]) -> i32 {
    return w.write(data);
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    // Direct BufferWriter usage through trait.
    let mut buf = BufferWriter { buf: undefined, pos: 0 };
    let w: *mut opaque Writer = &mut buf;
    let w: *unsafe mut opaque Writer = &mut buf;
    emit(w, "hello");
    assert w.total() == 5;
    emit(w, " world");
    assert w.total() == 11;


    assert buf.buf[5] == ' ' as u8;
    assert buf.buf[10] == 'd' as u8;

    // Counting writer wrapping a buffer writer.
    let mut buf2 = BufferWriter { buf: undefined, pos: 0 };
    let bw2: *mut opaque Writer = &mut buf2;
    let bw2: *unsafe mut opaque Writer = &mut buf2;
    let mut cw = CountingWriter { inner: bw2, count: 0 };
    let w2: *mut opaque Writer = &mut cw;
    let w2: *unsafe mut opaque Writer = &mut cw;

    emit(w2, "abc");
    assert cw.count == 3;
    // Underlying buffer also received the bytes.
    assert buf2.pos == 3;

test/tests/type.unify.rad +18 -18


    return true;
}

/// Verifies assignment compatibility for pointers with identical target types.
fn testPointerUnification() -> bool {
unsafe fn testPointerUnification() -> bool {
    let x: i32 = 42;
    let y: i32 = 24;
    let ptr1: *i32 = &x;
    let ptr2: *i32 = &y;
    let mut ptrResult: *i32 = ptr1;
    let ptr1: *unsafe i32 = &x;
    let ptr2: *unsafe i32 = &y;
    let mut ptrResult: *unsafe i32 = ptr1;
    set ptrResult = ptr2;

    return true;
}

/// Verifies conversion from array references to slices.
fn testArrayToSlice() -> bool {
unsafe fn testArrayToSlice() -> bool {
    let arr: [i32; 3] = [1, 2, 3];
    let slice: *[i32] = &arr[..];
    let slice: *unsafe [i32] = &arr[..];

    return true;
}

/// Verifies mixed signed and unsigned arithmetic using an explicit cast.


    return true;
}

/// Verifies coercion from pointer values to optional pointer values.
fn testPointerToOptional() -> bool {
unsafe fn testPointerToOptional() -> bool {
    let value: i32 = 42;
    let ptr: *i32 = &value;
    let optPtr: ?*i32 = ptr;
    let ptr: *unsafe i32 = &value;
    let optPtr: ?*unsafe i32 = ptr;

    return true;
}

/// Verifies creation of slices for different, but internally consistent, element types.
fn testSliceElementUnification() -> bool {
unsafe fn testSliceElementUnification() -> bool {
    let arrSmall: [i8; 3] = [1, 2, 3];
    let sliceSmall: *[i8] = &arrSmall[..];
    let sliceSmall: *unsafe [i8] = &arrSmall[..];

    let arrLarge: [i32; 3] = [10, 20, 30];
    let sliceLarge: *[i32] = &arrLarge[..];
    let sliceLarge: *unsafe [i32] = &arrLarge[..];

    return true;
}

/// Verifies optional assignments involving `nil` and concrete values.


    return true;
}

/// Verifies repeated pointer assignments across multiple values of the same type.
fn testMultiplePointerAssignments() -> bool {
unsafe fn testMultiplePointerAssignments() -> bool {
    let value1: i32 = 42;
    let value2: i32 = 24;
    let value3: i32 = 100;

    let ptr1: *i32 = &value1;
    let ptr2: *i32 = &value2;
    let ptr3: *i32 = &value3;
    let ptr1: *unsafe i32 = &value1;
    let ptr2: *unsafe i32 = &value2;
    let ptr3: *unsafe i32 = &value3;

    let mut result: *i32 = ptr1;
    let mut result: *unsafe i32 = ptr1;
    set result = ptr2;
    set result = ptr3;

    return true;
}

    set result = b2;

    return true;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let testResult: bool =
        testNumericUnification() and
        testOptionalUnification() and
        testArrayUnification() and
        testPointerUnification() and

test/tests/union-tag.rad +3 -3

    V18,
    V19,
    V20,
}

fn tag(u: *BigUnion) -> u8 {
    let p = u as *opaque as *u8;
unsafe fn tag(u: *unsafe BigUnion) -> u8 {
    let p = u as *unsafe opaque as *unsafe u8;
    return *p;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let v0 = BigUnion::V0;
    assert tag(&v0) == 0;
    let v7 = BigUnion::V7;
    assert tag(&v7) == 7;
    let v13 = BigUnion::V13;

test/tests/union.edge.case.3.rad +3 -3


record Parser: Copy {
    root: Node,
}

fn node(p: *mut Parser, value: Node) -> *Node {
unsafe fn node(p: &mut Parser, value: Node) -> *unsafe Node {
    set p.root = value;
    return &p.root;
}

fn nodeBool(p: *mut Parser, value: bool) -> *Node {
unsafe fn nodeBool(p: &mut Parser, value: bool) -> *unsafe Node {
    return node(p, Node::Bool(value));
}

@default fn main() -> u32 {
@default unsafe fn main() -> u32 {
    let mut parser = Parser { root: undefined };

    match *nodeBool(&mut parser, true) {
        case Node::Bool(v) => {
            assert v == true;

test/tests/union.mixed.assign.rad +2 -2


record Holder: Copy {
    value: Mixed,
}

fn storePayload(holder: *mut Holder, value: i32) {
fn storePayload(holder: &mut Holder, value: i32) {
    set holder.value = Mixed::Payload(value);
}

fn storeFinal(holder: *mut Holder) {
fn storeFinal(holder: &mut Holder) {
    set holder.value = Mixed::Final;
}

fn checkIfLet(value: Mixed) -> i32 {
    if let case Mixed::Payload(v) = value {

test/tests/union.payload.mutref.rad +3 -3

//! Test accessing and modifying union payload through mutable reference.
//! This mirrors the pattern in createBlockParam where we match on
//! &mut blk.sealState and push to incompleteVars.

record U32List: Copy {
    data: *mut [u32],
    data: *unsafe mut [u32],
    len: u32,
}

union Sealed: Copy {
    No { items: U32List },

    padding1: i32,
    padding2: i32,
    state: Sealed,
}

fn addItemViaMatchRef(blk: *mut Block, val: u32) -> bool {
unsafe fn addItemViaMatchRef(blk: &mut Block, val: u32) -> bool {
    match &mut blk.state {
        case Sealed::No { items } => {
            set items.data[items.len] = val;
            set items.len += 1;
            return true;

            return false;
        },
    }
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut buf: [u32; 8] = undefined;
    let mut blk = Block {
        padding1: 0,
        padding2: 0,
        state: Sealed::No { items: U32List { data: &mut buf[0..8], len: 0 } },

test/tests/wildcard.import.owner.rad +1 -0

//! A wildcard import keeps the defining module for imported functions.
//! returns: 42

mod wildcard_import_owner;

use wildcard_import_owner::*;

@default fn main() -> i32 {
    return answer();
}

600	596		}
601	597		return result;
602	598		}
603	599
604	600		/// Check if a function declaration has the `@test` attribute and return its name if so.
605		-	fn getTestFnName(decl: ast::FnDecl) -> ?[u8] {
	601	+	fn getTestFnName(decl: &ast::FnDecl) -> ?*[u8] {
606	602		let attrs = decl.attrs else { return nil; };
607	603		if not ast::attributesContains(&attrs, ast::Attribute::Test) {
608	604		return nil;
609	605		}
610	606		let case ast::NodeValue::Ident(name) = decl.name.value

640	636		}
641	637		}
642	638		}
643	639
644	640		/// Synthesize a `testing::test("mod", "name", mod::fn)` call for one test.
645		-	fn synthTestCall(arena: mut ast::NodeArena, desc: TestDesc) -> *ast::Node {
	641	+	unsafe fn synthTestCall(arena: &mut ast::NodeArena, desc: &TestDesc) -> *ast::Node {
646	642		let callee = synthScopeAccess(arena, &["testing", "test"]);
647	643		let modStr = il::formatQualifiedName(
648	644		&mut arena.arena,
649	645		&desc.modPath[..desc.modPath.len - 1],
650	646		desc.modPath[desc.modPath.len - 1]

682	678		/// ]);
683	679		/// }
684	680		/// ```
685	681		///
686	682		/// Uses `#`-prefixed names to avoid conflicts with user code.
687		-	fn generateTestRunner(
688		-	ctx: *mut CompileContext,
689		-	arena: *mut ast::NodeArena
	683	+	unsafe fn generateTestRunner(
	684	+	ctx: *unsafe mut CompileContext,
	685	+	arena: &mut ast::NodeArena
690	686		) throws (Error) {
691	687		let entryPkg = try getEntryPackage(ctx);
692		-	let root = try getRootModule(entryPkg, &ctx.graph);
	688	+	let root = try getRootModule(&*entryPkg, &ctx.graph);
693	689
694	690		// Collect all test functions across all modules.
695	691		let mut tests: [TestDesc; MAX_TESTS] = undefined;
696	692		let mut testCount: u32 = 0;
697	693

702	698		}
703	699		if testCount == 0 {
704	700		throw error(&["fatal:", "no test functions found"]);
705	701		}
706	702		let mut countBuf: [u8; 10] = undefined;
707		-	let countStr = fmt::formatU32(testCount, &mut countBuf[..]);
708		-	pkgLog(entryPkg, &["found", countStr, "test(s)"]);
	703	+	let start = fmt::formatU32(testCount, &mut countBuf[..]);
	704	+	io::printError("radiance: ");
	705	+	io::printError(entryPkg.name);
	706	+	io::printError(": found ");
	707	+	io::printError(&countBuf[start..]);
	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	713		injectIntoBlock(root.ast, arena, fnDecl);
714	714		}
715	715
716	716		/// Synthesize the test entry point.
717		-	fn synthTestMainFn(arena: mut ast::NodeArena, tests: [TestDesc]) -> *ast::Node {
	717	+	unsafe fn synthTestMainFn(arena: &mut ast::NodeArena, tests: &[TestDesc]) -> *ast::Node {
718	718		// Build array literal: `[testing::test(...), ...]`.
719	719		let a = alloc::arenaAllocator(&mut arena.arena);
720	720		let mut elements = ast::nodeSlice(arena, tests.len as u32);
721	721		for i in 0..tests.len {
722	722		elements.append(synthTestCall(arena, &tests[i]), a);

738	738		// Build: `return testing::runAllTests(&[...]);`
739	739		let retStmt = ast::synthNode(arena, ast::NodeValue::Return { value: callExpr });
740	740		let bodyStmts = ast::nodeSlice(arena, 1).append(retStmt, a);
741	741		let fnBody = ast::synthNode(arena, ast::NodeValue::Block(ast::Block { statements: bodyStmts }));
742	742
743		-	// Build: `fn #testMain() -> i32`
	743	+	// Build: `unsafe fn #testMain() -> i32`
744	744		let fnName = ast::synthNode(arena, ast::NodeValue::Ident(strings::intern(&mut STRING_POOL, "#testMain")));
745	745		let returnType = ast::synthNode(arena, ast::NodeValue::TypeSig(ast::TypeSig::Integer {
746	746		width: 4, sign: ast::Signedness::Signed,
747	747		}));
748	748		let fnSig = ast::FnSig {
749	749		params: ast::nodeSlice(arena, 0),
750	750		returnType,
751	751		throwList: ast::nodeSlice(arena, 0),
752	752		};
753	753
754		-	// `@default` attribute.
	754	+	// Entry and function safety attributes.
755	755		let attrNode = ast::synthNode(arena, ast::NodeValue::Attribute(ast::Attribute::Default));
756		-	let attrList = ast::nodeSlice(arena, 1).append(attrNode, a);
	756	+	let unsafeAttr = ast::synthNode(arena, ast::NodeValue::Attribute(ast::Attribute::Unsafe));
	757	+	let attrList = ast::nodeSlice(arena, 2).append(attrNode, a).append(unsafeAttr, a);
757	758		let fnAttrs = ast::Attributes { list: attrList };
758	759
759	760		return ast::synthNode(arena, ast::NodeValue::FnDecl(ast::FnDecl {
760	761		name: fnName, sig: fnSig, body: fnBody, attrs: fnAttrs,
761	762		}));
762	763		}
763	764
764	765		/// Append a declaration to a block node's statement list.
765		-	fn injectIntoBlock(
	766	+	unsafe fn injectIntoBlock(
766	767		blockNode: *mut ast::Node,
767		-	arena: *mut ast::NodeArena,
	768	+	arena: &mut ast::NodeArena,
768	769		decl: *ast::Node
769	770		) {
770	771		let case ast::NodeValue::Block(block) = blockNode.value else {
771	772		panic "injectIntoBlock: expected Block node";
772	773		};
773	774		let stmts = block.statements.append(decl, alloc::arenaAllocator(&mut arena.arena));
774	775		set blockNode.value = ast::NodeValue::Block(ast::Block { statements: stmts });
775	776		}
776	777
777	778		/// Write a self-contained RV64 image containing text and data sections.
778		-	fn writeImage(
	779	+	unsafe fn writeImage(
779	780		code: *[u32],
780	781		roData: *[u8],
781	782		rwData: *[u8],
782	783		path: *[u8]
783	784		) -> bool {
784	785		let mut header = rv64::imageHeader(code.len * rv64::INSTR_SIZE as u32, roData.len, rwData.len);
785		-	let headerWords = &header[..];
786		-	let headerBytes = @sliceOf(headerWords.ptr as u8, headerWords.len rv64::WORD_SIZE as u32);
	786	+	let headerBytes: unsafe [u8] = @sliceOf(&header[0] as unsafe u8, header.len * rv64::WORD_SIZE as u32);
787	787		let codeBytes = @sliceOf(code.ptr as u8, code.len rv64::INSTR_SIZE as u32);
788	788
789		-	return unix::writeFileParts(path, &[headerBytes, codeBytes, roData, rwData]);
	789	+	let fd = unix::openOpts(path, unix::OpenFlags(unix::O_WRONLY \| unix::O_CREAT \| *unix::O_TRUNC), 420);
	790	+	if fd < 0 { return false; }
	791	+	let written = unix::writeAll(fd, &headerBytes[..]) and unix::writeAll(fd, codeBytes)
	792	+	and unix::writeAll(fd, roData) and unix::writeAll(fd, rwData);
	793	+	let closed = unix::close(fd) == 0;
	794	+	return written and closed;
790	795		}
791	796
792	797		/// Write a data section to a file at `basePath` + `ext`.
793	798		/// Empty data truncates any stale sidecar left by an earlier build.
794	799		fn writeDataWithExt(

36	36		endif
37	37
38	38		# Compiler build
39	39
40	40		SEED := seed/radiance.rv64
41		-	SEED_OPTS := $(STD) -pkg radiance -mod compiler/radiance.rad -entry radiance
	41	+	COMPILER_SRC := compiler/radiance.rad compiler/radiance/codegen.rad
	42	+	SEED_OPTS := $(STD) -pkg radiance $(patsubst %,-mod %,$(COMPILER_SRC)) -entry radiance
42	43
43		-	$(RAD_BIN): $(STD_LIB) compiler/radiance.rad \| $(BIN_DIR)
	44	+	$(RAD_BIN): $(STD_LIB) $(COMPILER_SRC) \| $(BIN_DIR)
44	45		@echo "radiance $(SEED) => $@"
45	46		@$(EMU) $(EMU_FLAGS) -run $(SEED) $(SEED_OPTS) -o $@
46	47
47	48		$(BIN_DIR):
48	49		@mkdir -p $@

1	1		//! Radiance compiler front-end.
	2	+	mod codegen;
	3	+
2	4		use std::mem;
3	5		use std::fmt;
4	6		use std::io;
5	7		use std::lang::alloc;
6	8		use std::lang::ast;

90	92		static ASM_RO_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = undefined;
91	93
92	94		/// Assembly source file extension.
93	95		constant ASM_SOURCE_EXT: *[u8] = ".ras";
94	96		/// Symbol name exported for startup code to call the semantic entry function.
95		-	constant DEFAULT_ENTRY_SYMBOL: *[u8] = "::default";
	97	+	export constant DEFAULT_ENTRY_SYMBOL: *[u8] = "::default";
96	98
97	99		/// Usage string.
98	100		constant USAGE: *[u8] =
99	101		"usage: radiance -pkg <name> [-start <input.ras>] -mod <input>.. [-pkg <name> -mod <input>..] -entry <pkg> -o <output>\n";
100	102

167	169		record RootModule: Copy {
168	170		entry: *module::ModuleEntry,
169	171		ast: *mut ast::Node,
170	172		}
171	173
172		-	/// State carried by the streaming lowerer/codegen callback.
173		-	record CodegenSinkContext: Copy {
174		-	/// RV64 generator receiving lowered functions.
175		-	generator: *mut rv64::Generator,
176		-	/// Arena holding the current function's lowered IL.
177		-	fnArena: *mut alloc::Arena,
178		-	}
179		-
180	174		/// Entry handling for streamed code generation.
181	175		union CodegenEntryMode: Copy {
182	176		/// Do not reserve an entry jump.
183	177		None,
184	178		/// Reserve and patch an entry jump to the `@default` function.

194	188		/// How the generated program should handle entry.
195	189		entryMode: CodegenEntryMode,
196	190		}
197	191
198	192		/// Print a driver error line.
199		-	fn error(msg: [[u8]]) -> Error {
	193	+	fn error(msg: &[*[u8]]) -> Error {
200	194		io::printError("radiance: ");
201	195
202	196		for part, i in msg {
203	197		io::printError(part);
204	198		if i < msg.len - 1 {

208	202		io::printError("\n");
209	203		return Error::Other;
210	204		}
211	205
212	206		/// Print a log line for the given package.
213		-	fn pkgLog(pkg: package::Package, msg: [*[u8]]) {
	207	+	fn pkgLog(pkg: &package::Package, msg: &[*[u8]]) {
214	208		io::printError("radiance: ");
215	209		io::printError(pkg.name);
216	210		io::printError(": ");
217	211
218	212		for part, i in msg {

244	238		asmPathCount: 0,
245	239		};
246	240		}
247	241
248	242		/// Register, load, and parse `path` within `pkg`.
249		-	fn processModule(
250		-	pkg: *mut package::Package,
251		-	graph: *mut module::ModuleGraph,
	243	+	unsafe fn processModule(
	244	+	pkg: *unsafe mut package::Package,
	245	+	graph: &mut module::ModuleGraph,
252	246		path: *[u8],
253		-	nodeArena: *mut ast::NodeArena,
254		-	sourceArena: *mut alloc::Arena
	247	+	nodeArena: &mut ast::NodeArena,
	248	+	sourceArena: &mut alloc::Arena
255	249		) throws (Error) {
256		-	pkgLog(pkg, &["parsing", "(", path, ")", ".."]);
	250	+	pkgLog(&*pkg, &["parsing", "(", path, ")", ".."]);
257	251
258		-	let moduleId = try package::registerModule(pkg, graph, path) catch {
	252	+	let moduleId = try package::registerModule(&mut *pkg, graph, path) catch {
259	253		throw error(&["error registering module"]);
260	254		};
261	255		// Read file into remaining arena space.
262	256		let buffer = alloc::remainingBuf(sourceArena);
263	257		if buffer.len == 0 {
264	258		throw error(&["fatal:", "source arena exhausted"]);
265	259		}
266		-	let source = unix::readFile(path, buffer) else {
	260	+	let sourceLen = unix::readFile(path, buffer) else {
267	261		throw error(&["error reading file"]);
268	262		};
	263	+	let source = &buffer[..sourceLen];
269	264		if source.len == buffer.len {
270	265		throw error(&["fatal:", "source arena too small, file truncated:", path]);
271	266		}
272	267		// Commit only what was read.
273	268		alloc::commit(sourceArena, source.len);

282	277		throw error(&["error setting source"]);
283	278		};
284	279		}
285	280
286	281		/// Consume the next argument, or print an error and throw.
287		-	fn nextArg(args: [[u8]], idx: mut u32, msg: [[u8]]) -> [u8] throws (Error) {
	282	+	fn nextArg(args: [[u8]], idx: &mut u32, msg: &[[u8]]) -> [u8] throws (Error) {
288	283		set *idx += 1;
289	284		if *idx >= args.len {
290	285		throw error(msg);
291	286		}
292	287		return args[*idx];
293	288		}
294	289
295	290		/// Parse CLI arguments and return compilation context.
296		-	fn processCommand(
	291	+	unsafe fn processCommand(
297	292		args: [[u8]],
298		-	arena: *mut ast::NodeArena
	293	+	arena: &mut ast::NodeArena
299	294		) -> CompileContext throws (Error) {
300	295		let mut buildTest = false;
301	296		let mut debugEnabled = false;
302	297		let mut outputPath: ?*[u8] = nil;
303	298		let mut dump = Dump::None;

327	322		} else if mem::eq(arg, "-mod") {
328	323		try nextArg(args, &mut idx, &["`-mod` requires a module path"]);
329	324		let pkgIdx = currentPkgIdx else {
330	325		throw error(&["`-mod` must follow a `-pkg` argument"]);
331	326		};
332		-	let input = &mut inputs[pkgIdx];
	327	+	let input: *unsafe mut PackageInput = &mut inputs[pkgIdx];
333	328		if hasExtension(args[idx], ASM_SOURCE_EXT) {
334	329		if input.asmPathCount >= MAX_ASM_MODULES {
335	330		throw error(&["too many assembly modules specified"]);
336	331		}
337	332		set input.asmPaths[input.asmPathCount] = args[idx];

346	341		} else if mem::eq(arg, "-start") {
347	342		try nextArg(args, &mut idx, &["`-start` requires an assembly path"]);
348	343		let pkgIdx = currentPkgIdx else {
349	344		throw error(&["`-start` must follow a `-pkg` argument"]);
350	345		};
351		-	let input = &mut inputs[pkgIdx];
	346	+	let input: *unsafe mut PackageInput = &mut inputs[pkgIdx];
352	347		if input.startupPath <> nil {
353	348		throw error(&["package", input.name, "has more than one startup file"]);
354	349		}
355	350		if not hasExtension(args[idx], ASM_SOURCE_EXT) {
356	351		throw error(&["`-start` requires a `.ras` assembly file"]);

435	430		debug: debugEnabled,
436	431		};
437	432		// Initialize and parse all packages.
438	433		let mut sourceArena = alloc::new(&mut MODULE_SOURCES[..]);
439	434		for i in 0..pkgCount {
440		-	package::init(&mut ctx.packages[i], i as u16, ctx.inputs[i].name, &mut STRING_POOL);
	435	+	let name = ctx.inputs[i].name;
	436	+	package::init(&mut ctx.packages[i], i as u16, name, &mut STRING_POOL);
441	437
442	438		for j in 0..ctx.inputs[i].radPathCount {
443	439		let path = ctx.inputs[i].radPaths[j];
444	440		try processModule(&mut ctx.packages[i], &mut ctx.graph, path, arena, &mut sourceArena);
445	441		}
446	442		}
447	443		return ctx;
448	444		}
449	445
450	446		/// Get the entry package from the context.
451		-	fn getEntryPackage(ctx: CompileContext) -> package::Package throws (Error) {
	447	+	unsafe fn getEntryPackage(ctx: unsafe CompileContext) -> unsafe package::Package throws (Error) {
452	448		let entryIdx = ctx.entryPkgIdx else {
453	449		throw error(&["no entry package specified"]);
454	450		};
455	451		return &ctx.packages[entryIdx];
456	452		}
457	453
458	454		/// Return the startup assembly path for the entry package, if one was supplied.
459		-	fn getEntryStartupPath(ctx: CompileContext) -> ?[u8] {
	455	+	fn getEntryStartupPath(ctx: &CompileContext) -> ?*[u8] {
460	456		let entryIdx = ctx.entryPkgIdx else {
461	457		panic "getEntryStartupPath: no entry package";
462	458		};
463	459		return ctx.inputs[entryIdx].startupPath;
464	460		}
465	461
466	462		/// Get root module info from a package.
467		-	fn getRootModule(pkg: package::Package, graph: module::ModuleGraph) -> RootModule throws (Error) {
	463	+	fn getRootModule(pkg: &package::Package, graph: &module::ModuleGraph) -> RootModule throws (Error) {
468	464		let rootId = pkg.rootModuleId else {
469	465		throw error(&["no root module found"]);
470	466		};
471	467		let rootEntry = module::get(graph, rootId) else {
472	468		throw error(&["root module entry not found"]);

476	472		};
477	473		return RootModule { entry: rootEntry, ast: rootAst };
478	474		}
479	475
480	476		/// Dump the module graph.
481		-	fn dumpGraph(ctx: *CompileContext) {
	477	+	unsafe fn dumpGraph(ctx: &CompileContext) {
482	478		let mut arena = alloc::new(&mut MAIN_ARENA[..]);
483	479		module::printer::printGraph(&ctx.graph, &mut arena);
484	480		}
485	481
486	482		/// Dump the parsed AST.
487		-	fn dumpAst(ctx: *CompileContext) throws (Error) {
	483	+	unsafe fn dumpAst(ctx: *unsafe CompileContext) throws (Error) {
488	484		let pkg = try getEntryPackage(ctx);
489		-	let root = try getRootModule(pkg, &ctx.graph);
	485	+	let root = try getRootModule(&*pkg, &ctx.graph);
490	486		let mut arena = alloc::new(&mut MAIN_ARENA[..]);
491	487
492	488		ast::printer::printTree(root.ast, &mut arena);
493	489		}
494	490
495	491		/// Lower all packages into a single IL program.
496	492		/// Dependencies are lowered first, then the entry package.
497		-	fn lowerAllPackages(
498		-	ctx: *mut CompileContext,
499		-	res: *mut resolver::Resolver
	493	+	unsafe fn lowerAllPackages(
	494	+	ctx: *unsafe mut CompileContext,
	495	+	res: *unsafe mut resolver::Resolver
500	496		) -> il::Program throws (Error) {
501	497		let entryIdx = ctx.entryPkgIdx else {
502	498		panic "lowerAllPackages: no entry package";
503	499		};
504	500		let entryPkg = &ctx.packages[entryIdx];

513	509		// Finalize and return the unified program.
514	510		return lower::finalize(&low);
515	511		}
516	512
517	513		/// Lower all packages into an existing lowerer.
518		-	fn lowerAllPackagesInto(
519		-	ctx: *mut CompileContext,
520		-	res: *mut resolver::Resolver,
521		-	low: *mut lower::Lowerer
	514	+	unsafe fn lowerAllPackagesInto(
	515	+	ctx: *unsafe mut CompileContext,
	516	+	res: *unsafe mut resolver::Resolver,
	517	+	low: &mut lower::Lowerer
522	518		) throws (Error) {
523	519		let entryIdx = ctx.entryPkgIdx else {
524	520		panic "lowerAllPackagesInto: no entry package";
525	521		};
526	522		// Lower all packages except entry.
527	523		for i in 0..ctx.packageCount {
528	524		if i <> entryIdx {
529		-	try lowerPackage(ctx, res, low, &mut ctx.packages[i], false);
	525	+	try lowerPackage(ctx, res, &mut *low, &mut ctx.packages[i], false);
530	526		}
531	527		}
532	528		// Lower entry package.
533		-	try lowerPackage(ctx, res, low, &mut ctx.packages[entryIdx], true);
	529	+	try lowerPackage(ctx, res, &mut *low, &mut ctx.packages[entryIdx], true);
534	530		}
535	531
536	532		/// Lower all modules in a package into the lowerer accumulator.
537		-	fn lowerPackage(
538		-	ctx: *CompileContext,
539		-	res: *mut resolver::Resolver,
540		-	low: *mut lower::Lowerer,
541		-	pkg: *mut package::Package,
	533	+	unsafe fn lowerPackage(
	534	+	ctx: *unsafe CompileContext,
	535	+	res: *unsafe mut resolver::Resolver,
	536	+	low: &mut lower::Lowerer,
	537	+	pkg: &mut package::Package,
542	538		isEntry: bool
543	539		) throws (Error) {
544	540		let rootId = pkg.rootModuleId else {
545	541		throw error(&["no root module found"]);
546	542		};
547	543		// Set lowerer's package context for qualified name generation.
548	544		// TODO: We shouldn't have to call this manually.
549		-	lower::setPackage(low, &ctx.graph, pkg.name);
	545	+	lower::setPackage(&mut *low, &ctx.graph, pkg.name);
550	546
551		-	try lowerModuleTreeInto(ctx, low, &ctx.graph, rootId, isEntry, pkg);
	547	+	try lowerModuleTreeInto(ctx, &mut *low, &ctx.graph, rootId, isEntry, pkg);
552	548		}
553	549
554	550		/// Recursively lower a module and all its children into the accumulator.
555		-	fn lowerModuleTreeInto(
556		-	ctx: *CompileContext,
557		-	low: *mut lower::Lowerer,
558		-	graph: *module::ModuleGraph,
	551	+	unsafe fn lowerModuleTreeInto(
	552	+	ctx: *unsafe CompileContext,
	553	+	low: &mut lower::Lowerer,
	554	+	graph: &module::ModuleGraph,
559	555		modId: u16,
560	556		isRoot: bool,
561		-	pkg: *package::Package
	557	+	pkg: &package::Package
562	558		) throws (Error) {
563	559		let entry = module::get(graph, modId) else {
564	560		throw error(&["module entry not found"]);
565	561		};
566	562		let modAst = entry.ast else {
567	563		throw error(&["module has no AST"]);
568	564		};
569		-	pkgLog(pkg, &["lowering", "(", entry.filePath, ")", ".."]);
	565	+	pkgLog(&*pkg, &["lowering", "(", entry.filePath, ")", ".."]);
570	566
571		-	try lower::lowerModule(low, modId, modAst, isRoot) catch err {
	567	+	try lower::lowerModule(&mut *low, modId, modAst, isRoot) catch err {
572	568		io::printError("radiance: ");
573	569		io::printError("internal error during lowering: ");
574	570		lower::printError(err);
575	571		io::printError("\n");
576	572
577	573		throw Error::Other;
578	574		};
579	575		// Recurse into children.
580	576		for i in 0..entry.childrenLen {
581	577		let childId = module::childAt(entry, i);
582		-	try lowerModuleTreeInto(ctx, low, graph, childId, false, pkg);
	578	+	try lowerModuleTreeInto(ctx, &mut *low, graph, childId, false, pkg);
583	579		}
584	580		}
585	581
586	582		/// Build a scope access chain: a::b::c from a slice of identifiers.
587		-	fn synthScopeAccess(arena: mut ast::NodeArena, path: [[u8]]) -> ast::Node {
	583	+	fn synthScopeAccess(arena: &mut ast::NodeArena, path: &[[u8]]) -> ast::Node {
588	584		let mut result = ast::synthNode(
589	585		arena,
590	586		ast::NodeValue::Ident(strings::intern(&mut STRING_POOL, path[0]))
591	587		);
592	588		for i in 1..path.len {

614	610		}
615	611
616	612		/// Scan a single module's AST for `@test` functions and append them to `tests`.
617	613		fn collectModuleTests(
618	614		entry: *module::ModuleEntry,
619		-	tests: *mut [TestDesc],
620		-	testCount: *mut u32
	615	+	tests: &mut [TestDesc],
	616	+	testCount: &mut u32
621	617		) {
622	618		let modAst = entry.ast else {
623	619		return;
624	620		};
625	621		let case ast::NodeValue::Block(block) = modAst.value else {

811	816		/// Serialize debug entries and write the `.debug` file.
812	817		/// Resolves module IDs to file paths via the module graph.
813	818		/// Format per entry is `{pc: u32, offset: u32, filePath: [u8], NULL}`.
814	819		fn writeDebugInfo(
815	820		entries: *[types::DebugEntry],
816		-	graph: *module::ModuleGraph,
	821	+	graph: &module::ModuleGraph,
817	822		basePath: *[u8],
818		-	arena: *mut alloc::Arena
	823	+	arena: &mut alloc::Arena
819	824		) throws (Error) {
820	825		if entries.len == 0 {
821	826		return;
822	827		}
823	828		// Use remaining arena space as serialization buffer.

838	843		}
839	844		try writeDataWithExt(&buf[..pos], basePath, DEBUG_EXT);
840	845		}
841	846
842	847		/// Run the resolver on the parsed modules.
843		-	fn runResolver(ctx: *mut CompileContext, nodeCount: u32) -> resolver::Resolver throws (Error) {
	848	+	unsafe fn runResolver(ctx: *unsafe mut CompileContext, nodeCount: u32) -> resolver::Resolver throws (Error) {
844	849		let mut mainArena = alloc::new(&mut MAIN_ARENA[..]);
845	850		let entryPkg = try getEntryPackage(ctx);
846	851
847		-	pkgLog(entryPkg, &["resolving", ".."]);
	852	+	pkgLog(&*entryPkg, &["resolving", ".."]);
848	853
849	854		let nodeDataSize = nodeCount * @sizeOf(resolver::NodeData);
850	855		let nodeDataPtr = try! alloc::alloc(&mut mainArena, nodeDataSize, @alignOf(resolver::NodeData));
851	856		let nodeData = @sliceOf(nodeDataPtr as *mut resolver::NodeData, nodeCount);
852	857		let storage = resolver::ResolverStorage {

860	865		// Build the semantic package list consumed by the resolver.
861	866		let mut resolverPkgs: [resolver::Pkg; MAX_PACKAGES] = undefined;
862	867		let mut resolverPackageCount: u32 = 0;
863	868		for i in 0..ctx.packageCount {
864	869		let pkg = &ctx.packages[i];
865		-	let root = try getRootModule(pkg, &ctx.graph);
	870	+	let root = try getRootModule(&*pkg, &ctx.graph);
866	871
867	872		set resolverPkgs[resolverPackageCount] = resolver::Pkg {
868	873		rootEntry: root.entry,
869	874		rootAst: root.ast,
870	875		};

879	884		throw Error::Other;
880	885		};
881	886		if not resolver::success(&diags) {
882	887		resolver::printer::printDiagnostics(&diags, &res);
883	888		let mut countBuf: [u8; 10] = undefined;
884		-	let countStr = fmt::formatU32(diags.errors.len, &mut countBuf[..]);
885		-	throw error(&["failed:", countStr, "errors"]);
	889	+	let start = fmt::formatU32(diags.errors.len, &mut countBuf[..]);
	890	+	io::printError("radiance: failed: ");
	891	+	io::printError(&countBuf[start..]);
	892	+	io::printError(" errors\n");
	893	+	throw Error::Other;
886	894		}
887	895		return res;
888	896		}
889	897
890		-	/// Emit one lowered function to machine code and reclaim its IL arena.
891		-	fn generateLoweredFn(ctxPtr: mut opaque, func: il::Fn, role: lower::FnRole) {
892		-	let ctx = ctxPtr as *mut CodegenSinkContext;
893		-
894		-	match role {
895		-	case lower::FnRole::Default => {
896		-	rv64::recordFunctionAlias(ctx.generator, DEFAULT_ENTRY_SYMBOL);
897		-	match ctx.generator.entryPatch {
898		-	case rv64::EntryPatch::Reserved(_) => {
899		-	set ctx.generator.entryPatch = rv64::EntryPatch::Reserved(func.name);
900		-	}
901		-	// No entry jump was reserved: startup assembly calls the
902		-	// default function through `DEFAULT_ENTRY_SYMBOL` instead.
903		-	case rv64::EntryPatch::None => {}
904		-	}
905		-	}
906		-	else => {}
907		-	}
908		-	rv64::generateFunction(ctx.generator, func, ctx.fnArena);
909		-	alloc::reset(ctx.fnArena);
910		-	}
911		-
912	898		/// Assemble one `.ras` input and merge it into the active code generator.
913	899		///
914	900		/// Text symbols are appended to `generator`. Data emitted by the assembler is
915	901		/// copied into `ASM_RO_DATA_BUF` at `asmDataLen`, and `asmDataLen` is advanced
916	902		/// so the next assembly module receives the correct rodata base address.
917		-	fn assembleAsmModule(
918		-	generator: *mut rv64::Generator,
919		-	pkg: *package::Package,
	903	+	unsafe fn assembleAsmModule(
	904	+	generator: &mut rv64::Generator,
	905	+	pkg: &package::Package,
920	906		path: *[u8],
921		-	asmDataLen: *mut u32,
922		-	arena: *mut alloc::Arena
	907	+	asmDataLen: &mut u32,
	908	+	arena: &mut alloc::Arena
923	909		) throws (Error) {
924		-	pkgLog(pkg, &["asm:", "parsing", "(", path, ")", ".."]);
	910	+	pkgLog(&*pkg, &["asm:", "parsing", "(", path, ")", ".."]);
925	911
926		-	let source = unix::readFile(path, &mut ASM_SOURCE_BUF[..]) else {
	912	+	let sourceLen = unix::readFile(path, &mut ASM_SOURCE_BUF[..]) else {
927	913		throw error(&["error reading assembly file"]);
928	914		};
	915	+	let source = &ASM_SOURCE_BUF[..sourceLen];
929	916		if source.len == ASM_SOURCE_BUF.len {
930	917		throw error(&["fatal:", "assembly source too large:", path]);
931	918		}
932	919		let program = try asm::assemble(
933	920		asm::scanner::SourceKind::File { path },

948	935
949	936		rv64::addAssembly(generator, program);
950	937		}
951	938
952	939		/// Assemble all inputs collected in the package inputs.
953		-	fn assembleAsmInputs(
954		-	ctx: *CompileContext,
955		-	generator: *mut rv64::Generator,
956		-	asmDataLen: *mut u32,
957		-	arena: *mut alloc::Arena
	940	+	unsafe fn assembleAsmInputs(
	941	+	ctx: &CompileContext,
	942	+	generator: &mut rv64::Generator,
	943	+	asmDataLen: &mut u32,
	944	+	arena: &mut alloc::Arena
958	945		) -> *[u8] throws (Error) {
959	946		for i in 0..ctx.packageCount {
960		-	let input = &ctx.inputs[i];
961		-	for j in 0..input.asmPathCount {
	947	+	for j in 0..ctx.inputs[i].asmPathCount {
962	948		try assembleAsmModule(
963	949		generator,
964	950		&ctx.packages[i],
965		-	input.asmPaths[j],
	951	+	ctx.inputs[i].asmPaths[j],
966	952		asmDataLen,
967	953		arena
968	954		);
969	955		}
970	956		}
971	957		return &ASM_RO_DATA_BUF[..*asmDataLen];
972	958		}
973	959
974	960		/// Lower all packages while streaming each lowered function into RV64 codegen.
975		-	fn lowerAndGenerateAllPackages(
976		-	ctx: *mut CompileContext,
977		-	res: *mut resolver::Resolver,
978		-	fnArena: *mut alloc::Arena,
	961	+	unsafe fn lowerAndGenerateAllPackages(
	962	+	ctx: *unsafe mut CompileContext,
	963	+	res: *unsafe mut resolver::Resolver,
	964	+	fnArena: &mut alloc::Arena,
979	965		codegenOptions: CodegenOptions
980	966		) -> rv64::Program throws (Error) {
981	967		let entryIdx = ctx.entryPkgIdx else {
982	968		panic "lowerAndGenerateAllPackages: no entry package";
983	969		};
984	970		let entryPkg = &ctx.packages[entryIdx];
985		-	let startupPath = getEntryStartupPath(ctx);
	971	+	let startupPath = getEntryStartupPath(&*ctx);
986	972		let options = lower::LowerOptions { debug: ctx.debug, buildTest: ctx.config.buildTest };
987	973		let storage = rv64::Storage {
988	974		dataSyms: &mut CODEGEN_DATA_SYMS[..],
989	975		dataSymEntries: &mut CODEGEN_DATA_SYM_ENTRIES[..],
990	976		};

997	983		}
998	984		let mut generator = rv64::beginProgram(
999	985		rv64::ProgramOptions { entryPatch, debug: codegenOptions.debug },
1000	986		&mut res.arena
1001	987		);
1002		-	let mut codegenCtx = CodegenSinkContext {
	988	+	let mut codegenCtx = codegen::Context {
1003	989		generator: &mut generator,
1004		-	fnArena,
	990	+	fnArena: fnArena as *unsafe mut alloc::Arena,
1005	991		};
1006	992		let mut low = lower::lowerer(
1007		-	res, &ctx.graph, entryPkg.name, &mut res.arena, fnArena, options
	993	+	res, &ctx.graph, entryPkg.name, &mut res.arena, fnArena as *unsafe mut alloc::Arena, options
1008	994		);
1009	995		set low.output = lower::FnOutput::Stream(lower::FnSink {
1010		-	ctx: &mut codegenCtx as *mut opaque,
1011		-	emitFn: generateLoweredFn,
	996	+	ctx: &mut codegenCtx as *unsafe mut opaque,
	997	+	emitFn: codegen::emit,
1012	998		});
1013	999		let mut asmDataLen: u32 = 0;
1014	1000		if let path = startupPath {
1015		-	try assembleAsmModule(&mut generator, entryPkg, path, &mut asmDataLen, &mut res.arena);
	1001	+	try assembleAsmModule(&mut generator, &*entryPkg, path, &mut asmDataLen, &mut res.arena);
1016	1002		}
1017	1003		try lowerAllPackagesInto(ctx, res, &mut low);
1018		-	let asmData = try assembleAsmInputs(ctx, &mut generator, &mut asmDataLen, &mut res.arena);
	1004	+	let asmData = try assembleAsmInputs(&*ctx, &mut generator, &mut asmDataLen, &mut res.arena);
1019	1005
1020	1006		match generator.entryPatch {
1021	1007		case rv64::EntryPatch::Reserved(targetName) => {
1022	1008		if targetName == nil {
1023	1009		throw error(&["fatal:", "no default function found"]);
1024	1010		}
1025	1011		}
1026	1012		else => {}
1027	1013		}
1028	1014		if let path = codegenOptions.logPath {
1029		-	pkgLog(entryPkg, &["generating code", "(", path, ")", ".."]);
	1015	+	pkgLog(&*entryPkg, &["generating code", "(", path, ")", ".."]);
1030	1016		}
1031	1017		return rv64::finishProgram(&mut generator, &low.data[..], storage, asmData, &mut RO_DATA_BUF[..], &mut RW_DATA_BUF[..]);
1032	1018		}
1033	1019
1034	1020		/// Lower, optionally dump, and optionally generate binary output.
1035		-	fn compile(
1036		-	ctx: *mut CompileContext,
1037		-	res: *mut resolver::Resolver,
1038		-	fnArena: *mut alloc::Arena
	1021	+	unsafe fn compile(
	1022	+	ctx: *unsafe mut CompileContext,
	1023	+	res: *unsafe mut resolver::Resolver,
	1024	+	fnArena: &mut alloc::Arena
1039	1025		) throws (Error) {
1040	1026		let entryPkg = try getEntryPackage(ctx);
1041	1027		let mut out = sexpr::Output::Stdout;
1042	1028
1043	1029		if ctx.dump == Dump::Il {

1061	1047		// Generate binary output if path specified.
1062	1048		let outPath = ctx.outputPath else {
1063	1049		try lowerAllPackages(ctx, res);
1064	1050		return;
1065	1051		};
1066		-	let startupPath = getEntryStartupPath(ctx);
	1052	+	let startupPath = getEntryStartupPath(&*ctx);
1067	1053		let result = try lowerAndGenerateAllPackages(ctx, res, fnArena, CodegenOptions {
1068	1054		logPath: outPath,
1069	1055		debug: ctx.debug,
1070	1056		entryMode: CodegenEntryMode::None
1071	1057		if startupPath <> nil

1083	1069
1084	1070		// Write debug info file if enabled.
1085	1071		if ctx.debug {
1086	1072		try writeDebugInfo(result.debugEntries, &ctx.graph, outPath, &mut res.arena);
1087	1073		}
1088		-	pkgLog(entryPkg, &["ok", "(", outPath, ")"]);
	1074	+	pkgLog(&*entryPkg, &["ok", "(", outPath, ")"]);
1089	1075		}
1090	1076
1091		-	@default fn main(env: *sys::Env) -> i32 {
	1077	+	@default unsafe fn main(env: *sys::Env) -> i32 {
1092	1078		let mut arena = ast::nodeArena(&mut TEMP_ARENA[..]);
1093	1079		let mut ctx = try processCommand(env.args, &mut arena) catch {
1094	1080		return 1;
1095	1081		};
1096	1082		match ctx.dump {

209	209		/// Entry jump patching state.
210	210		entryPatch: EntryPatch,
211	211		}
212	212
213	213		/// Begin RV64 code generation for a program's global state.
214		-	export fn beginProgram(
	214	+	export unsafe fn beginProgram(
215	215		options: ProgramOptions,
216		-	arena: *mut alloc::Arena
	216	+	arena: &mut alloc::Arena
217	217		) -> Generator {
218	218		let mut e = try! emit::emitter(arena, options.debug);
219	219
220	220		// Emit placeholder entry jump when requested.
221	221		// We'll patch this at the end once we know where the function is.

232	232		entryPatch: options.entryPatch,
233	233		};
234	234		}
235	235
236	236		/// Generate code for one IL function.
237		-	export fn generateFunction(
238		-	generator: *mut Generator,
	237	+	export unsafe fn generateFunction(
	238	+	generator: &mut Generator,
239	239		func: *il::Fn,
240		-	arena: *mut alloc::Arena
	240	+	arena: &mut alloc::Arena
241	241		) {
242	242		if func.isExtern {
243	243		return;
244	244		}
245	245		let checkpoint = alloc::save(arena);

251	251		// Reclaim unused memory after instruction selection.
252	252		alloc::restore(arena, checkpoint);
253	253		}
254	254
255	255		/// Record an alternate name for the next function emitted.
256		-	export fn recordFunctionAlias(generator: mut Generator, name: [u8]) {
257		-	emit::recordFuncOffsetAt(&mut generator.e, name, generator.e.codeLen);
	256	+	export fn recordFunctionAlias(generator: &mut Generator, name: *[u8]) {
	257	+	let codeLen = generator.e.codeLen;
	258	+	emit::recordFuncOffsetAt(&mut generator.e, name, codeLen);
258	259		}
259	260
260	261		/// Add the text section of an assembled program to the generator.
261	262		///
262	263		/// This function snapshots the generator's current code length as the base

267	268		/// separate assembly inputs may reuse the same local names.
268	269		///
269	270		/// Non-text symbols are ignored here because assembled data is not appended to
270	271		/// the generator's text stream. The driver merges assembled data into the RO data
271	272		/// prefix separately and passes that data to [`finishProgram`].
272		-	export fn addAssembly(generator: *mut Generator, program: asm::Program) {
	273	+	export fn addAssembly(generator: &mut Generator, program: asm::Program) {
273	274		let baseIndex = generator.e.codeLen;
274	275
275	276		for symbol in program.symbols {
276	277		if symbol.section == asm::Section::Text {
277	278		let index = baseIndex + ((symbol.offset as u32) / INSTR_SIZE as u32);

297	298		}
298	299		}
299	300
300	301		/// Finish RV64 code generation and return the emitted program.
301	302		export fn finishProgram(
302		-	generator: *mut Generator,
	303	+	generator: &mut Generator,
303	304		globalData: *[il::Data],
304	305		storage: Storage,
305	306		roDataPrefix: *[u8],
306	307		roDataBuf: *mut [u8],
307	308		rwDataBuf: *mut [u8]

452	452		}
453	453
454	454		/// Parser and emission state.
455	455		export record Assembler: Copy {
456	456		/// Allocation arena for temporary assembler state.
457		-	arena: *mut alloc::Arena,
	457	+	arena: *unsafe mut alloc::Arena,
458	458		/// Assembler lexical scanner.
459	459		scan: scanner::Scanner,
460	460		/// Output text buffer.
461	461		text: *mut [u32],
462	462		/// Output data buffer.

478	478		/// Absolute runtime address of data-section offset zero.
479	479		dataBase: u32,
480	480		}
481	481
482	482		/// Assemble source using `dataBase` as the runtime address of the data-section.
483		-	export fn assemble(
	483	+	export unsafe fn assemble(
484	484		sourceKind: scanner::SourceKind,
485	485		source: *[u8],
486	486		textBuf: *mut [u32],
487	487		dataBuf: *mut [u8],
488		-	arena: *mut alloc::Arena,
	488	+	arena: &mut alloc::Arena,
489	489		pool: *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);

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	502		let mut a = Assembler {
503		-	arena,
	503	+	arena: arena as *unsafe mut alloc::Arena,
504	504		scan: scanner::scanner(sourceKind, source, pool),
505	505		text: @sliceOf(textBuf.ptr, 0, textBuf.len),
506	506		data: @sliceOf(dataBuf.ptr, 0, dataBuf.len),
507	507		section: Section::Text,
508	508		symbols: @sliceOf((symbols as mut [Symbol]).ptr, 0, (symbols as mut [Symbol]).len),