radiance · commit

Makefile +2 -2

endif

# Compiler build

SEED      := seed/radiance.rv64
SEED_OPTS := $(STD) -pkg radiance -mod compiler/radiance.rad -entry radiance
SEED_OPTS := $(STD) -pkg radiance -mod compiler/radiance.rad -mod compiler/radiance/codegenSink.rad -entry radiance

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

$(BIN_DIR):
	@mkdir -p $@

compiler/radiance.rad +57 -83

/// Main arena size (96 MB) - lives throughout compilation.
/// Used for: resolver data, types, symbols, global IL data, and codegen output.
constant MAIN_ARENA_SIZE: u32 = 100663296;

/// AST storage arena.
static TEMP_ARENA: [u8; TEMP_ARENA_SIZE] = undefined;
unsafe static TEMP_ARENA: [u8; TEMP_ARENA_SIZE] = undefined;
/// Scratch storage reclaimed after each generated function.
static FN_ARENA: [u8; FN_ARENA_SIZE] = undefined;
unsafe static FN_ARENA: [u8; FN_ARENA_SIZE] = undefined;
/// Main storage arena - persists throughout compilation.
static MAIN_ARENA: [u8; MAIN_ARENA_SIZE] = undefined;
unsafe static MAIN_ARENA: [u8; MAIN_ARENA_SIZE] = undefined;

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

/// Package scope.
static RESOLVER_PKG_SCOPE: resolver::Scope = undefined;
unsafe static RESOLVER_PKG_SCOPE: resolver::Scope = undefined;
/// Errors emitted by resolver.
static RESOLVER_ERRORS: [resolver::Error; resolver::MAX_ERRORS] = undefined;
unsafe static RESOLVER_ERRORS: [resolver::Error; resolver::MAX_ERRORS] = undefined;

/// Code generation storage.
static CODEGEN_DATA_SYMS: [data::DataSym; data::MAX_DATA_SYMS] = undefined;
unsafe static CODEGEN_DATA_SYMS: [data::DataSym; data::MAX_DATA_SYMS] = undefined;
/// Hash table entries for data symbol lookup.
static CODEGEN_DATA_SYM_ENTRIES: [dict::Entry; data::DATA_SYM_TABLE_SIZE] = undefined;
unsafe static CODEGEN_DATA_SYM_ENTRIES: [dict::Entry; data::DATA_SYM_TABLE_SIZE] = undefined;

/// Debug info file extension.
constant DEBUG_EXT: *[u8] = ".debug";
unsafe constant DEBUG_EXT: *[u8] = ".debug";

/// Maximum rodata size (4MB).
constant MAX_RO_DATA_SIZE: u32 = 4194304;
/// Maximum rwdata size (4MB).
constant MAX_RW_DATA_SIZE: u32 = 4194304;
/// Maximum path length.
constant MAX_PATH_LEN: u32 = 256;
/// Read-only data buffer.
static RO_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = undefined;
unsafe static RO_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = undefined;
/// Read-write data buffer.
static RW_DATA_BUF: [u8; MAX_RW_DATA_SIZE] = undefined;
unsafe static RW_DATA_BUF: [u8; MAX_RW_DATA_SIZE] = undefined;
/// Assembly module source buffer.
static ASM_SOURCE_BUF: [u8; MAX_SOURCES_SIZE] = undefined;
unsafe static ASM_SOURCE_BUF: [u8; MAX_SOURCES_SIZE] = undefined;
/// Temporary assembly text buffer.
static ASM_TEXT_BUF: [u32; 262144] = undefined;
unsafe static ASM_TEXT_BUF: [u32; 262144] = undefined;
/// Temporary assembly data buffer.
static ASM_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = undefined;
unsafe static ASM_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = undefined;
/// Accumulated assembly read-only data.
static ASM_RO_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = undefined;
unsafe static ASM_RO_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = undefined;

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

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

/// Compiler error.
union Error {
    Other,

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

/// State carried by the streaming lowerer/codegen callback.
record CodegenSinkContext {
    /// RV64 generator receiving lowered functions.
    generator: *mut rv64::Generator,
    /// Arena holding the current function's lowered IL.
    fnArena: *mut alloc::Arena,
}
/// Trusted implementation for streamed code generation.
unsafe mod codegenSink;

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

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

/// Print a driver error line.
fn error(msg: *[*[u8]]) -> Error {
unsafe 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]]) {
unsafe fn pkgLog(pkg: *package::Package, msg: *[*[u8]]) {
    io::printError("radiance: ");
    io::printError(pkg.name);
    io::printError(": ");

    for part, i in msg {

    }
    io::printError("\n");
}

/// Return `true` when `path` ends with `ext`.
fn hasExtension(path: *[u8], ext: *[u8]) -> bool {
unsafe fn hasExtension(path: *[u8], ext: *[u8]) -> bool {
    if path.len < ext.len {
        return false;
    }
    let start = path.len - ext.len;
    return mem::eq(&path[start..], ext);
}

/// Create an empty source input set for one package.
fn packageInput(name: *[u8]) -> PackageInput {
unsafe fn packageInput(name: *[u8]) -> PackageInput {
    return PackageInput {
        name,
        startupPath: nil,
        radPaths: undefined,
        radPathCount: 0,

        asmPathCount: 0,
    };
}

/// Register, load, and parse `path` within `pkg`.
fn processModule(
unsafe fn processModule(
    pkg: *mut package::Package,
    graph: *mut module::ModuleGraph,
    path: *[u8],
    nodeArena: *mut ast::NodeArena,
    sourceArena: *mut alloc::Arena

        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) {
unsafe 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
) -> CompileContext throws (Error) {
    let mut buildTest = false;
    let mut debugEnabled = false;

    }
    return ctx;
}

/// Get the entry package from the context.
fn getEntryPackage(ctx: *CompileContext) -> *package::Package throws (Error) {
unsafe fn getEntryPackage(ctx: *CompileContext) -> *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] {
unsafe 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) {
unsafe 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: *CompileContext) throws (Error) {
    let pkg = try getEntryPackage(ctx);
    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(
unsafe fn lowerAllPackages(
    ctx: *mut CompileContext,
    res: *mut resolver::Resolver
) -> il::Program throws (Error) {
    let entryIdx = ctx.entryPkgIdx else {
        panic "lowerAllPackages: no entry package";

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

/// Lower all packages into an existing lowerer.
fn lowerAllPackagesInto(
unsafe fn lowerAllPackagesInto(
    ctx: *mut CompileContext,
    res: *mut resolver::Resolver,
    low: *mut lower::Lowerer
) throws (Error) {
    let entryIdx = ctx.entryPkgIdx else {

    // Lower entry package.
    try lowerPackage(ctx, res, low, &mut ctx.packages[entryIdx], true);
}

/// Lower all modules in a package into the lowerer accumulator.
fn lowerPackage(
unsafe fn lowerPackage(
    ctx: *CompileContext,
    res: *mut resolver::Resolver,
    low: *mut lower::Lowerer,
    pkg: *mut package::Package,
    isEntry: bool


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

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

        try lowerModuleTreeInto(ctx, 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 {
unsafe 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] {
unsafe 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


    return name;
}

/// Scan a single module's AST for `@test` functions and append them to `tests`.
fn collectModuleTests(
unsafe fn collectModuleTests(
    entry: *module::ModuleEntry,
    tests: *mut [TestDesc],
    testCount: *mut u32
) {
    let modAst = entry.ast 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(
unsafe fn generateTestRunner(
    ctx: *mut CompileContext,
    arena: *mut ast::NodeArena
) throws (Error) {
    let entryPkg = try getEntryPackage(ctx);
    let root = try getRootModule(entryPkg, &ctx.graph);


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

        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,
    decl: *ast::Node
) {
    let case ast::NodeValue::Block(block) = blockNode.value else {

    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 {

    return unix::writeFileParts(path, &[headerBytes, codeBytes, roData, rwData]);
}

/// Write a data section to a file at `basePath` + `ext`.
/// Empty data truncates any stale sidecar left by an earlier build.
fn writeDataWithExt(
unsafe fn writeDataWithExt(
    data: *[u8],
    basePath: *[u8],
    ext: *[u8]
) throws (Error) {
    let mut path: [u8; MAX_PATH_LEN] = undefined;

}

/// 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(
unsafe fn writeDebugInfo(
    entries: *[types::DebugEntry],
    graph: *module::ModuleGraph,
    basePath: *[u8],
    arena: *mut alloc::Arena
) throws (Error) {

    }
    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: *mut CompileContext, nodeCount: u32) -> resolver::Resolver throws (Error) {
    let mut mainArena = alloc::new(&mut MAIN_ARENA[..]);
    let entryPkg = try getEntryPackage(ctx);

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


        throw error(&["failed:", countStr, "errors"]);
    }
    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(
unsafe fn assembleAsmModule(
    generator: *mut rv64::Generator,
    pkg: *package::Package,
    path: *[u8],
    asmDataLen: *mut u32,
    arena: *mut alloc::Arena


    rv64::addAssembly(generator, program);
}

/// Assemble all inputs collected in the package inputs.
fn assembleAsmInputs(
unsafe fn assembleAsmInputs(
    ctx: *CompileContext,
    generator: *mut rv64::Generator,
    asmDataLen: *mut u32,
    arena: *mut alloc::Arena
) -> *[u8] throws (Error) {

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

/// Lower all packages while streaming each lowered function into RV64 codegen.
fn lowerAndGenerateAllPackages(
unsafe fn lowerAndGenerateAllPackages(
    ctx: *mut CompileContext,
    res: *mut resolver::Resolver,
    fnArena: *mut alloc::Arena,
    codegenOptions: CodegenOptions
) -> rv64::Program throws (Error) {

    }
    let mut generator = rv64::beginProgram(
        rv64::ProgramOptions { entryPatch, debug: codegenOptions.debug },
        &mut res.arena
    );
    let mut codegenCtx = CodegenSinkContext {
    let mut codegenCtx = codegenSink::Context {
        generator: &mut generator,
        fnArena,
    };
    let mut low = lower::lowerer(
        res, &ctx.graph, entryPkg.name, &mut res.arena, fnArena, options
    );
    set low.output = lower::FnOutput::Stream(lower::FnSink {
        ctx: &mut codegenCtx as *mut opaque,
        emitFn: generateLoweredFn,
        ctx: codegenSink::eraseContext(&mut codegenCtx),
        emitFn: codegenSink::generate,
    });
    let mut asmDataLen: u32 = 0;
    if let path = startupPath {
        try assembleAsmModule(&mut generator, entryPkg, path, &mut asmDataLen, &mut res.arena);
    }

    }
    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(
unsafe fn compile(
    ctx: *mut CompileContext,
    res: *mut resolver::Resolver,
    fnArena: *mut alloc::Arena
) throws (Error) {
    let entryPkg = try getEntryPackage(ctx);

        try writeDebugInfo(result.debugEntries, &ctx.graph, outPath, &mut res.arena);
    }
    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/codegenSink.rad added +49 -0

1	+	//! Trusted streamed code generation implementation.
2	+	use std::lang::alloc;
3	+	use std::lang::il;
4	+	use std::lang::lower;
5	+	use std::arch::rv64;
6	+
7	+	/// Symbol name exported for startup code to call the semantic entry function.
8	+	unsafe constant DEFAULT_ENTRY_SYMBOL: *[u8] = "::default";
9	+
10	+	/// State carried by the streaming lowerer/codegen callback.
11	+	export record Context {
12	+	/// RV64 generator receiving lowered functions.
13	+	generator: *mut rv64::Generator,
14	+	/// Arena holding the current function's lowered IL.
15	+	fnArena: *mut alloc::Arena,
16	+	}
17	+
18	+	/// Erase a streamed code generation context for storage in a function sink.
19	+	///
20	+	/// The caller must keep `ctx` alive and exclusively accessible until the sink
21	+	/// stops invoking its callback.
22	+	export unsafe fn eraseContext(ctx: &mut Context) -> *unsafe mut u8 {
23	+	return ((ctx as &mut opaque) as &mut u8) as *unsafe mut u8;
24	+	}
25	+
26	+	/// Generate machine code for a lowered function and reclaim its IL arena.
27	+	export fn generate(ctx: &mut opaque, func: *il::Fn, role: lower::FnRole) {
28	+	generateWithContext(ctx as &mut Context, func, role);
29	+	}
30	+
31	+	/// Generate machine code with the typed streamed-lowering context.
32	+	fn generateWithContext(ctx: &mut Context, func: *il::Fn, role: lower::FnRole) {
33	+	match role {
34	+	case lower::FnRole::Default => {
35	+	rv64::recordFunctionAlias(ctx.generator, DEFAULT_ENTRY_SYMBOL);
36	+	match ctx.generator.entryPatch {
37	+	case rv64::EntryPatch::Reserved(_) => {
38	+	set ctx.generator.entryPatch = rv64::EntryPatch::Reserved(func.name);
39	+	}
40	+	// No entry jump was reserved: startup assembly calls the
41	+	// default function through `DEFAULT_ENTRY_SYMBOL` instead.
42	+	case rv64::EntryPatch::None => {}
43	+	}
44	+	}
45	+	else => {}
46	+	}
47	+	rv64::generateFunction(ctx.generator, func, ctx.fnArena);
48	+	alloc::reset(ctx.fnArena);
49	+	}

lib/std.rad +11 -11

//! The Radiance Standard Library.

export mod io;
export mod collections;
export unsafe mod io;
export unsafe mod collections;
export mod char;
export mod lang;
export mod sys;
export mod arch;
export mod fmt;
export mod mem;
export mod vec;
export mod intrinsics;
export unsafe mod lang;
export unsafe mod sys;
export unsafe mod arch;
export unsafe mod fmt;
export unsafe mod mem;
export unsafe mod vec;
export unsafe mod intrinsics;

// Test modules.
@test export mod testing;
@test export mod tests;
@test export unsafe mod testing;
@test export unsafe mod tests;

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

export constant SHIFT_LIMIT: i32 = 64;
/// Largest `lui` or `auipc` immediate.
export constant UPPER_IMM_MAX_VALUE: i64 = 0xFFFFF;

/// Sorted instruction descriptor table used by the assembler parser.
export constant INSTRUCTIONS: [InstructionEntry; 88] = [
export unsafe constant INSTRUCTIONS: [InstructionEntry; 88] = [
    { name: "add",    encoder: InstructionEncoder::RRR { enc: encode::add } },
    { name: "addi",   encoder: InstructionEncoder::RRI { enc: encode::addi } },
    { name: "addiw",  encoder: InstructionEncoder::RRI { enc: encode::addiw } },
    { name: "addw",   encoder: InstructionEncoder::RRR { enc: encode::addw } },
    { name: "and",    encoder: InstructionEncoder::RRR { enc: encode::and_ } },

    { name: "xor",    encoder: InstructionEncoder::RRR { enc: encode::xor } },
    { name: "xori",   encoder: InstructionEncoder::RRI { enc: encode::xori } },
];

/// Sorted directive lookup table used by the assembler parser.
export constant DIRECTIVES: [DirectiveEntry; 10] = [
export unsafe constant DIRECTIVES: [DirectiveEntry; 10] = [
    { name: "align",    kind: DirectiveKind::Align },
    { name: "ascii",    kind: DirectiveKind::Ascii },
    { name: "byte",     kind: DirectiveKind::Byte },
    { name: "constant", kind: DirectiveKind::Constant },
    { name: "data",     kind: DirectiveKind::Data },

    { name: "text",     kind: DirectiveKind::Text },
    { name: "word",     kind: DirectiveKind::Word },
];

/// Sorted register-name lookup table used by the assembler parser.
export constant REGISTERS: [RegisterEntry; 33] = [
export unsafe constant REGISTERS: [RegisterEntry; 33] = [
    { name: "a0",   reg: rv64::A0 },
    { name: "a1",   reg: rv64::A1 },
    { name: "a2",   reg: rv64::A2 },
    { name: "a3",   reg: rv64::A3 },
    { name: "a4",   reg: rv64::A4 },

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

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

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

use std::mem;
use std::testing;
use std::lang::strings;

/// String pool used by assembler scanner tests.
static TEST_STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
unsafe static TEST_STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };

/// Create a scanner for test input.
fn testScanner(source: *[u8]) -> super::Scanner {
    return super::scanner(super::SourceKind::String, source, &mut TEST_STRING_POOL);
}

lib/std/arch/rv64/asm/tests.rad +6 -6

use std::arch::rv64::encode;
use std::arch::rv64::printer;

use super::scanner;

static ASM_ARENA_STORAGE: [u8; 65536] = undefined;
static ASM_TEXT_STORAGE: [u32; 256] = undefined;
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;
unsafe static ASM_ARENA_STORAGE: [u8; 65536] = undefined;
unsafe static ASM_TEXT_STORAGE: [u32; 256] = undefined;
unsafe static ASM_DATA_STORAGE: [u8; 1024] = undefined;
unsafe static ASM_STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
unsafe static PRINT_ARENA_STORAGE: [u8; 1024] = undefined;
unsafe static PRINT_BUFFER: [u8; 128] = undefined;

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,

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

15	15		/////////////////////
16	16		// Register Names //
17	17		/////////////////////
18	18
19	19		/// ABI register names.
20		-	constant REG_NAMES: [*[u8]; 32] = [
	20	+	unsafe constant REG_NAMES: [*[u8]; 32] = [
21	21		"%zero", "%ra", "%sp", "%gp", "%tp", "%t0", "%t1", "%t2",
22	22		"%fp", "%s1", "%a0", "%a1", "%a2", "%a3", "%a4", "%a5",
23	23		"%a6", "%a7", "%s2", "%s3", "%s4", "%s5", "%s6", "%s7",
24	24		"%s8", "%s9", "%s10", "%s11", "%t3", "%t4", "%t5", "%t6"
25	25		];

lib/std/intrinsics.rad +6 -3

//! Compiler intrinsics.

/// Environment call.
/// Issue a system call with the given number and arguments.
///
/// Issues a system call with the given number and arguments.
/// Arguments and the return value are `i64` to support both 32-bit
/// emulator addresses and 64-bit native (AMD64) pointers.
@intrinsic export fn ecall(number: u32, arg1: i64, arg2: i64, arg3: i64, arg4: i64) -> i64;
///
/// The caller must satisfy the target system call's ABI. Every argument that
/// the kernel interprets as an address must remain valid and readable or
/// writable for the full extent and duration required by that system call.
@intrinsic export unsafe fn ecall(number: u32, arg1: i64, arg2: i64, arg3: i64, arg4: i64) -> i64;

/// Break out of program.
@intrinsic export fn ebreak();

/// Full acquire/release memory fence.

lib/std/io.rad +5 -3

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

export fn print(str: *[u8]) {
    intrinsics::ecall(64, 1, str.ptr as i64, str.len as i64, 0);
    unsafe { intrinsics::ecall(64, 1, str.ptr as i64, str.len as i64, 0); }
}

export fn printError(str: *[u8]) {
    intrinsics::ecall(64, 2, str.ptr as i64, str.len as i64, 0);
    unsafe { intrinsics::ecall(64, 2, str.ptr as i64, str.len as i64, 0); }
}

export fn printLn(str: *[u8]) {
    print(str);
    print("\n");

    let result: *[u8] = fmt::formatBool(val, &mut buffer[..]);
    print(result);
}

export fn read(buf: *mut [u8]) -> u32 {
    return intrinsics::ecall(63, 0, buf.ptr as i64, buf.len as i64, 0) as u32;
    let mut result: i64 = 0;
    unsafe { set result = intrinsics::ecall(63, 0, buf.ptr as i64, buf.len as i64, 0); }
    return result as u32;
}

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


lib/std/lang.rad +12 -12

//! Radiance language implementation.
export mod alloc;
export mod sexpr;
export unsafe mod alloc;
export unsafe mod sexpr;
export mod types;
export mod strings;
export mod scanner;
export mod ast;
export mod parser;
export mod module;
export mod resolver;
export mod package;
export mod il;
export mod lower;
export mod gen;
export unsafe mod strings;
export unsafe mod scanner;
export unsafe mod ast;
export unsafe mod parser;
export unsafe mod module;
export unsafe mod resolver;
export unsafe mod package;
export unsafe mod il;
export unsafe mod lower;
export unsafe mod gen;

lib/std/lang/alloc.rad +40 -15

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

use std::mem;
/// Largest byte extent representable by allocator APIs.
constant MAX_EXTENT: u32 = 0xFFFFFFFF;

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

    return Arena { data, offset: 0 };
}

/// Allocate `size` bytes with the given alignment.
///
/// `size` must be nonzero and `alignment` must be a nonzero power of two.
/// 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.
/// the arena is exhausted or its offset lies beyond the backing storage. 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) {
    assert alignment > 0;
    assert (alignment & (alignment - 1)) == 0;
    assert size > 0;

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

    if newOffset > arena.data.len as u32 {
    let capacity = arena.data.len as u32;
    if arena.offset > capacity {
        throw AllocError::OutOfMemory;
    }
    let available = capacity - arena.offset;
    let padding = (0 - arena.offset) & (alignment - 1);
    if padding > available {
        throw AllocError::OutOfMemory;
    }
    let alignedAvailable = available - padding;
    if size > alignedAvailable {
        throw AllocError::OutOfMemory;
    }
    let aligned = arena.offset + padding;
    let newOffset = aligned + size;
    let base: *mut u8 = &mut arena.data[aligned];
    set arena.offset = newOffset;

    return base as *mut opaque;
}

/// Reset the arena, allowing all memory to be reused.
///
/// The caller must not use any allocation from this arena after the reset.
/// Does not zero the memory.
export fn reset(arena: *mut Arena) {
export unsafe fn reset(arena: *mut Arena) {
    set arena.offset = 0;
}

/// Save the current arena state for later restoration.
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) {
///
/// The caller must not use an allocation reclaimed by this operation.
export unsafe fn restore(arena: *mut Arena, savedOffset: u32) {
    set arena.offset = savedOffset;
}

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

/// Returns the number of bytes remaining in the arena.
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] {
/// Return an exclusive view of the remaining buffer.
///
/// The caller must end access through the view before another arena operation.
export unsafe 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) {
/// Commit `size` bytes of allocation and advance the offset.
///
/// The caller must provide a size within the view returned by [`remainingBuf`]
/// and must end access through that view before another arena operation.
export unsafe fn commit(arena: *mut Arena, size: u32) {
    assert size <= remaining(arena), "alloc::commit: size exceeds remaining capacity";
    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.
/// Throws `AllocError` if the arena is exhausted or the total byte extent
/// cannot be represented by `u32`.
export fn allocSlice(arena: *mut Arena, size: u32, alignment: u32, count: u32) -> *mut [opaque] throws (AllocError) {
    if count == 0 {
        return &mut [];
    }
    if size > MAX_EXTENT / count {
        throw AllocError::OutOfMemory;
    }
    let ptr = try alloc(arena, size * count, alignment);

    return @sliceOf(ptr, count);
}


lib/std/lang/alloc/tests.rad +29 -0

        set failed = true;
    };
    try testing::expect(failed);
}

/// Test that a forged arena offset cannot wrap allocation arithmetic.
@test fn testAllocRejectsInvalidOffset() throws (testing::TestError) {
    static STORAGE: [u8; 16] = undefined;
    let mut arena = super::Arena { data: &mut STORAGE[..], offset: 0xFFFFFFFF };
    let mut failed = false;

    try super::alloc(&mut arena, 1, 1) catch {
        set failed = true;
    };

    try testing::expect(failed);
    try testing::expect(super::used(&arena) == 0xFFFFFFFF);
}

/// Test that slice byte extents cannot overflow u32.
@test fn testAllocSliceExtentOverflow() throws (testing::TestError) {
    static STORAGE: [u8; 16] = undefined;
    let mut arena = super::new(&mut STORAGE[..]);
    let count: u32 = 0xFFFFFFFF / 3 + 1;
    let mut failed = false;

    try super::allocSlice(&mut arena, 3, 1, count) catch {
        set failed = true;
    };

    try testing::expect(failed);
    try testing::expect(super::used(&arena) == 0);
}

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

lib/std/lang/ast.rad +2 -0

        /// Argument list.
        args: *mut [*Node],
    },
    /// Block expression or statement body.
    Block(Block),
    /// Scoped unsafe block (`unsafe { ... }`).
    Unsafe(*Node),
    /// Call expression, eg. `f(x)`.
    Call(Call),
    /// Field access expression (e.g. `foo.bar`).
    FieldAccess(Access),
    /// Scope access expression (e.g. `foo::bar`).

lib/std/lang/ast/printer.rad +2 -0

        }
        case super::NodeValue::Block(blk) => {
            let children = nodeListToExprs(a, &blk.statements[..]);
            return sexpr::block(a, "block", &[], children);
        }
        case super::NodeValue::Unsafe(body) =>
            return sexpr::list(a, "unsafe", &[toExpr(a, body)]),
        case super::NodeValue::Let(decl) => {
            let mut head = "let";
            if decl.mutable { set head = "let-mut"; }
            return sexpr::list(a, head, &[
                toExpr(a, decl.ident),

lib/std/lang/gen/regalloc/assign.rad +22 -12

                allocatable,
                calleeSaved: config.calleeSaved,
                assignments,
                spillInfo,
            };
            il::forEachReg(instr, processInstrRegCb, &mut ctx as *mut opaque);
            il::forEachReg(instr, processInstrRegCb, &mut ctx);

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

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

/// Callback for [`il::forEachReg`]: free last uses and allocate missing uses.
fn processInstrRegCb(reg: il::Reg, ctxPtr: *mut opaque) {
    let ctx = ctxPtr as *mut InstrCtx;
    if not liveness::hasLaterUse(ctx.live, ctx.func, ctx.blockIdx, ctx.instrIdx, reg) {
        if let phys = rmapRemove(ctx.current, reg.n) {
            bitset::clear(ctx.usedRegs, *phys as u32);
fn processInstrRegCb(reg: il::Reg, ctx: &mut opaque) {
    if not liveness::hasLaterUse(
        (ctx as &mut InstrCtx).live,
        (ctx as &mut InstrCtx).func,
        (ctx as &mut InstrCtx).blockIdx,
        (ctx as &mut InstrCtx).instrIdx,
        reg
    ) {
        if let phys = rmapRemove((ctx as &mut InstrCtx).current, reg.n) {
            bitset::clear((ctx as &mut InstrCtx).usedRegs, *phys as u32);
        }
    }
    assert reg.n < ctx.assignments.len, "processInstrRegCb: register out of bounds";
    if spill::isSpilled(ctx.spillInfo, reg) {
    assert reg.n < (ctx as &mut InstrCtx).assignments.len,
        "processInstrRegCb: register out of bounds";
    if spill::isSpilled((ctx as &mut InstrCtx).spillInfo, reg) {
        return; // Spilled values don't get physical registers.
    }
    if ctx.assignments[reg.n] == nil {
        set ctx.assignments[reg.n] = rallocReg(
            ctx.current, ctx.usedRegs, reg.n, ctx.allocatable,
            ctx.calleeSaved, ctx.spillInfo
    if (ctx as &mut InstrCtx).assignments[reg.n] == nil {
        set (ctx as &mut InstrCtx).assignments[reg.n] = rallocReg(
            (ctx as &mut InstrCtx).current,
            (ctx as &mut InstrCtx).usedRegs,
            reg.n,
            (ctx as &mut InstrCtx).allocatable,
            (ctx as &mut InstrCtx).calleeSaved,
            (ctx as &mut InstrCtx).spillInfo
        );
    }
}

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

        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);
            if let dst = il::instrDst(block.instrs[i]) {
                set maxReg = maxRegNum(dst.n, maxReg);
            }
        }
    }

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

        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;
    if not bitset::contains(c.defs, reg.n) {
        bitset::put(c.uses, reg.n);
fn addUseCallback(reg: il::Reg, ctx: &mut opaque) {
    if not bitset::contains((ctx as &mut DefsUses).defs, reg.n) {
        bitset::put((ctx as &mut DefsUses).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;
    set *max = maxRegNum(reg.n, *max);
fn maxRegCallback(reg: il::Reg, ctx: &mut opaque) {
    set *(ctx as &mut u32) = maxRegNum(reg.n, *(ctx as &mut u32));
}

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

}

/// Check if an instruction uses a specific register.
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);
    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;
    if reg.n == c.target {
        set c.found = true;
fn findRegCallback(reg: il::Reg, ctx: &mut opaque) {
    if reg.n == (ctx as &mut FindCtx).target {
        markFound(ctx as &mut FindCtx);
    }
}

/// Mark a register search context as found.
fn markFound(ctx: &mut FindCtx) {
    set ctx.found = true;
}

lib/std/lang/gen/regalloc/spill.rad +14 -8

            // 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);
        }
        // Also limit pressure at block entry.
        limitPressure(&mut scratch, &mut spilled, costs, numRegs);
    }


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

/// Sort candidates by cost (ascending) using insertion sort, then spill

        }
    }
}

/// Callback for [`il::forEachReg`]: increments use count for register.
fn countRegUseCallback(reg: il::Reg, ctxPtr: *mut opaque) {
    let ctx = ctxPtr as *mut CountCtx;
    assert reg.n < ctx.costs.len, "countRegUseCallback: register out of bounds";
    set ctx.costs[reg.n].uses = ctx.costs[reg.n].uses + ctx.weight;
fn countRegUseCallback(reg: il::Reg, ctx: &mut opaque) {
    assert reg.n < (ctx as &mut CountCtx).costs.len,
        "countRegUseCallback: register out of bounds";
    set (ctx as &mut CountCtx).costs[reg.n].uses =
        (ctx as &mut CountCtx).costs[reg.n].uses + (ctx as &mut CountCtx).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);
fn addRegToSetCallback(reg: il::Reg, ctx: &mut opaque) {
    if reg.n >= (ctx as &mut bitset::Bitset).len {
        return;
    }
    let word = reg.n / 32;
    let bit = reg.n % 32;
    set (ctx as &mut bitset::Bitset).bits[word] |= (1 << bit);
}

/// Check if a register is spilled.
export fn isSpilled(info: *SpillInfo, reg: il::Reg) -> bool {
    if reg.n >= info.maxReg {

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

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

export mod printer;

/// Unit tests for intermediate language traversal.
@test mod tests;

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

/// Source location for debug info.
///

///////////////////////
// Name Formatting   //
///////////////////////

/// Separator for qualified symbol names.
export constant PATH_SEPARATOR: *[u8] = "::";
export unsafe 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] {
    let mut totalLen: u32 = name.len;
    for segment in path {

    }
}

/// 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 fn forEachReg(instr: Instr, f: 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) {
fn withReg(val: Val, callback: fn(Reg, &mut opaque), ctx: &mut opaque) {
    if let case Val::Reg(r) = val {
        callback(r, ctx);
    }
}

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

1	+	//! Intermediate language tests.
2	+
3	+	use std::testing;
4	+
5	+	/// Add one register number through a call-scoped context loan.
6	+	fn observeReg(reg: super::Reg, ctx: &mut opaque) {
7	+	unsafe { set *(ctx as &mut u32) += reg.n; }
8	+	}
9	+
10	+	/// Register traversal may reuse one mutable callback context loan.
11	+	@test fn testForEachRegCallbackLoan() throws (testing::TestError) {
12	+	let mut context: u32 = 0;
13	+	let instr = super::Instr::Store {
14	+	typ: super::Type::W32,
15	+	src: super::Val::Reg(super::Reg { n: 1 }),
16	+	dst: super::Reg { n: 2 },
17	+	offset: 0,
18	+	};
19	+	super::forEachReg(instr, observeReg, &mut context);
20	+	assert context == 3;
21	+	}

lib/std/lang/lower.rad +11 -5

    Default,
}

/// Function sink used by lowerers that consume functions as they are produced.
export record FnSink {
    /// Opaque context passed to the sink callback.
    ctx: *mut opaque,
    /// Raw storage address reborrowed only for the duration of each callback.
    ctx: *unsafe mut u8,
    /// Callback invoked for each lowered function.
    emitFn: fn(*mut opaque, *il::Fn, FnRole),
    emitFn: fn(&mut opaque, *il::Fn, FnRole),
}

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

            let mut fns = accumulated;
            fns.append(func, self.allocator);
            set self.output = FnOutput::Accumulate(fns);
        }
        case FnOutput::Stream(sink) => {
            sink.emitFn(sink.ctx, func, role);
            sink.emitFn(&mut *sink.ctx as &mut opaque, func, role);
        }
    }
}

/// Get the function role for a top-level function declaration.

    }
    match node.value {
        case ast::NodeValue::Block(_) => {
            try lowerBlock(self, node);
        }
        case ast::NodeValue::Unsafe(body) => {
            try lowerNode(self, body);
        }
        case ast::NodeValue::Return { value } => {
            try lowerReturnStmt(self, node, value);
        }
        case ast::NodeValue::Throw { expr } => {
            try lowerThrowStmt(self, expr);

    } else {
        throw LowerError::UnknownIntrinsic;
    }
}

/// Lower an ecall intrinsic: `ecall(num, a0, a1, a2, a3) -> i32`.
/// Lower an ecall intrinsic: `ecall(num, a0, a1, a2, a3) -> i64`.
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]);

        }
        case ast::NodeValue::Block(_) => {
            try lowerBlock(self, node);
            set val = il::Val::Undef;
        }
        case ast::NodeValue::Unsafe(body) => {
            set val = try lowerExpr(self, body);
        }
        case ast::NodeValue::ExprStmt(expr) => {
            let _ = expr;
            set val = il::Val::Undef;
        }
        // Lower these as statements.

lib/std/lang/module.rad +1 -1

/// Maximum number of components that make up a logical module path.
constant MAX_MODULE_PATH_DEPTH: u32 = 16;
/// Filesystem separator used when constructing child paths.
constant PATH_SEP: u8 = '/';
/// Source file extension handled by the loader.
constant SOURCE_EXT: *[u8] = ".rad";
unsafe constant SOURCE_EXT: *[u8] = ".rad";

/// Lifecycle state for modules in the dependency graph.
export union ModuleState {
    /// Slot unused or yet to be initialized.
    Vacant,

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

use std::lang::strings;

/// Test arena backing storage.
static TEST_ARENA: [u8; 4096] = undefined;
/// Interned string pool.
static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
unsafe static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };

fn expectSliceEq(actual: *[u8], expected: *[u8])
    throws (testing::TestError)
{
    if not mem::eq(actual, expected) {

lib/std/lang/parser.rad +31 -1

             ast::NodeValue::WhileLet(_),
             ast::NodeValue::For(_),
             ast::NodeValue::Loop { .. },
             ast::NodeValue::Match(_),
             ast::NodeValue::Block(_),
             ast::NodeValue::Unsafe(_),
             ast::NodeValue::FnDecl(_),
             ast::NodeValue::RecordDecl(_),
             ast::NodeValue::UnionDecl(_),
             ast::NodeValue::TraitDecl { .. },
             ast::NodeValue::InstanceDecl { .. },
             ast::NodeValue::MethodDecl { .. } => return false,
        else => return true,
    }
}

/// Speculatively parse a scoped unsafe block.
///
/// Restores the parser when `unsafe` starts a declaration instead.
fn tryParseUnsafeBlock(p: *mut Parser) -> ?*ast::Node
    throws (ParseError)
{
    let saved = saveState(p);
    if not consume(p, scanner::TokenKind::Unsafe) {
        return nil;
    }
    if not check(p, scanner::TokenKind::LBrace) {
        restoreState(p, &saved);
        return nil;
    }
    let body = try parseBlock(p);
    return node(p, ast::NodeValue::Unsafe(body));
}

/// Parse a primary leaf expression without postfix operators.
fn parseLeaf(p: *mut Parser) -> *ast::Node
    throws (ParseError)
{
    match p.current.kind {

        }
        case scanner::TokenKind::False => {
            advance(p);
            return nodeBool(p, false);
        }
        case scanner::TokenKind::Unsafe => {
            let unsafeBlock = try tryParseUnsafeBlock(p)
                else throw failParsing(p, "expected `{` after `unsafe`");
            return unsafeBlock;
        }
        case scanner::TokenKind::Ident => {
            advance(p);
            return node(p, ast::NodeValue::Ident(p.previous.source));
        }
        case scanner::TokenKind::Super => {

///
/// Dispatches to the appropriate statement parser based on the current token.
export fn parseStmt(p: *mut Parser) -> *ast::Node
    throws (ParseError)
{
    if let unsafeBlock = try tryParseUnsafeBlock(p) {
        return unsafeBlock;
    }

    // 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
            and p.current.kind <> scanner::TokenKind::Static
            and p.current.kind <> scanner::TokenKind::Constant
        {
            throw failParsing(p, "`unsafe` is only allowed on functions and modules");
            throw failParsing(p, "`unsafe` is only allowed on functions, modules, statics, and constants");
        }
        let allowed: bool =
            p.current.kind == scanner::TokenKind::Fn or
            p.current.kind == scanner::TokenKind::Union or
            p.current.kind == scanner::TokenKind::Record or

lib/std/lang/parser/tests.rad +63 -4

/// Unified arena size.
constant ARENA_SIZE: u32 = 2097152;
/// Unified arena storage for all AST allocations.
static ARENA_STORAGE: [u8; ARENA_SIZE] = undefined;
/// String pool.
static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
unsafe static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };

/// Assert that a node is an identifier with the given name.
fn expectIdent(node: *ast::Node, name: *[u8])
    throws (testing::TestError)
{


    return root;
}

/// Parse a single expression from a string.
export fn parseExprStr(input: *[u8]) -> *ast::Node
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);

    let r2 = try! parseExprStr("false");
    let case ast::NodeValue::Bool(v2) = r2.value if not v2
        else throw testing::TestError::Failed;
}

/// Verify why the static-arena expression parser stays module-private.
@test fn testParseExprStrResetsSharedArena() throws (testing::TestError) {
    let first = try! parseExprStr("first");
    let second = try! parseExprStr("second");

    try testing::expect(first == second);
    try expectIdent(first, "second");
}

/// Test parsing number literals.
@test fn testParseNumber() throws (testing::TestError) {
    let r1 = try! parseExprStr("4519");
    try expectNumber(r1, "4519");
}

    let case ast::NodeValue::ExprStmt(thirdExpr) = thirdStmt.value
        else throw testing::TestError::Failed;
    try expectIdent(thirdExpr, "third");
}

/// Test parsing an unsafe block and its child block AST.
@test fn testParseUnsafeBlock() throws (testing::TestError) {
    let root = try! parseStmtStr("unsafe { operation }");
    let case ast::NodeValue::Unsafe(body) = root.value
        else throw testing::TestError::Failed;

    try expectBlockExprStmt(body, ast::NodeValue::Ident("operation"));
}

/// Test parsing an unsafe block as one statement in an enclosing block.
@test fn testParseUnsafeBlockStatement() throws (testing::TestError) {
    let root = try! parseStmtStr("{ before; unsafe { operation; } after; }");
    let case ast::NodeValue::Block(block) = root.value
        else throw testing::TestError::Failed;
    try testing::expect(block.statements.len == 3);

    let firstStmt = block.statements[0];
    let case ast::NodeValue::ExprStmt(firstExpr) = firstStmt.value
        else throw testing::TestError::Failed;
    try expectIdent(firstExpr, "before");

    let unsafeStmt = block.statements[1];
    let case ast::NodeValue::Unsafe(body) = unsafeStmt.value
        else throw testing::TestError::Failed;
    try expectBlockExprStmt(body, ast::NodeValue::Ident("operation"));

    let lastStmt = block.statements[2];
    let case ast::NodeValue::ExprStmt(lastExpr) = lastStmt.value
        else throw testing::TestError::Failed;
    try expectIdent(lastExpr, "after");
}

/// Test parsing a block that keeps a trailing `;` delimiter.
@test fn testParseBlockTrailingSemicolon() throws (testing::TestError) {
    let root = try! parseStmtStr("if cond { only; }") catch {
        throw testing::TestError::Failed;
    };


    try testing::expect(attrs.list.len == 1);
    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Unsafe));
}

/// Test parsing an unsafe static initializer.
@test fn testParseUnsafeStaticDecl() throws (testing::TestError) {
    let node = try! parseStmtStr("unsafe static BUFFER: [u8; 4] = undefined;");
    let case ast::NodeValue::StaticDecl(decl) = node.value
        else throw testing::TestError::Failed;
    let attrs = decl.attrs
        else throw testing::TestError::Failed;
    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Unsafe));
}

/// Test parsing an unsafe constant declaration.
@test fn testParseUnsafeConstDecl() throws (testing::TestError) {
    let node = try! parseStmtStr("unsafe constant TEXT: *[u8] = \"text\";");
    let case ast::NodeValue::ConstDecl(decl) = node.value
        else throw testing::TestError::Failed;
    let attrs = decl.attrs
        else throw testing::TestError::Failed;
    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) {
    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;");

lib/std/lang/resolver.rad +469 -105


/// Maximum number of diagnostics recorded.
export constant MAX_ERRORS: u32 = 64;

/// Synthetic function name used when wrapping a bare expression for analysis.
export constant ANALYZE_EXPR_FN_NAME: *[u8] = "__expr__";
export unsafe constant ANALYZE_EXPR_FN_NAME: *[u8] = "__expr__";
/// Synthetic function name used when wrapping a block for analysis.
export constant ANALYZE_BLOCK_FN_NAME: *[u8] = "__block__";
export unsafe constant ANALYZE_BLOCK_FN_NAME: *[u8] = "__block__";

/// Maximum number of symbols stored within a module scope.
export constant MAX_MODULE_SYMBOLS: u32 = 512;
/// Maximum number of symbols stored within a local scope.
export constant MAX_LOCAL_SYMBOLS: u32 = 32;

    /// Symbol for the method.
    symbol: *mut Symbol,
}

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

/// Maximum `u16` value.
constant U16_MAX: u16 = 0xFFFF;
/// Maximum `u8` value.
constant U8_MAX: u16 = 0xFF;

    FnMissingBody,
    /// Function body is not expected.
    FnUnexpectedBody,
    /// Intrinsic function must not have a body.
    IntrinsicUnexpectedBody,
    /// Ecall intrinsic declaration does not match the canonical unsafe ABI.
    InvalidEcallIntrinsicSignature,
    /// Encountered loop control outside of a loop construct.
    InvalidLoopControl,
    /// `try` used when the enclosing function does not declare throws.
    TryRequiresThrows,
    /// `try` used to propagate an error not declared by the enclosing function.

    constValue: ?ConstValue,
    /// Lexical scope owned by this node.
    scope: ?*mut Scope,
    /// Node-specific extra data.
    extra: NodeExtra,
    /// Whether the declaration body belongs to a trusted unsafe module.
    trustedBody: bool,
}

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

    len: u32,
    /// Whether this control-flow path has terminated.
    terminated: bool,
}

/// Loans kept alive while later call arguments are evaluated.
record LinearLoans {
    /// Enclosing call's active loans.
    parent: ?*LinearLoans,
    /// Root symbol for each active loan.
    roots: [?*mut Symbol; MAX_FN_PARAMS + 1],
    /// Whether each loan excludes every other access.
    exclusive: [bool; MAX_FN_PARAMS + 1],
    /// Number of active entries.
    len: u32,
}

/// Function-local exact-use checker state.
record LinearChecker {
    /// Resolver that owns the symbols and diagnostics.
    resolver: *mut Resolver,
    /// Active loans from enclosing and earlier call arguments.
    loans: ?*LinearLoans,
    /// 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.

            coercion: Coercion::Identity,
            sym: nil,
            constValue: nil,
            scope: nil,
            extra: NodeExtra::None,
            trustedBody: false,
        };
    }

    let mut moduleScopes: [?*mut Scope; module::MAX_MODULES] = undefined;
    // TODO: Simplify.

/// Return whether pointer classes are compatible.
fn pointerClassesAssignable(
    to: types::PointerClass,
    from: types::PointerClass,
) -> bool {
    return to == from or (
        to == types::PointerClass::Owned
        and from == types::PointerClass::Ref
    );
    return to == from;
}

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

    if self.unsafeDepth == 0 {
        throw emitError(self, node, ErrorKind::UnsafeOperation);
    }
}

/// Require unsafe context when reading an unsafe binding that is not a function declaration.
fn checkUnsafeBindingAccess(
    self: *mut Resolver,
    node: *ast::Node,
    sym: *mut Symbol,
) throws (ResolveError) {
    if not ast::hasAttribute(sym.attrs, ast::Attribute::Unsafe) {
        return;
    }
    if let case ast::NodeValue::FnDecl(_) = sym.node.value {
        return;
    }
    match sym.data {
        case SymbolData::Value { .. },
             SymbolData::Constant { .. } => try requireUnsafe(self, node),
        else => {}
    }
}

/// Reject calls from safe code through unsafe function types.
fn checkUnsafeCall(self: *mut Resolver, node: *ast::Node, info: *FnType)
    throws (ResolveError)
{
    if info.isUnsafe and self.unsafeDepth == 0 {

    }
    match node.value {
        case ast::NodeValue::Ident(name) => {
            let sym = findAnySymbol(self.scope, name)
                else throw emitError(self, node, ErrorKind::UnresolvedSymbol(name));
            try checkUnsafeBindingAccess(self, node, sym);
            setNodeSymbol(self, node, sym);
            match sym.data {
                case SymbolData::Value { type, .. } =>
                    return setNodeType(self, node, type),
                case SymbolData::Constant { type, value } => {

        },
        case ast::NodeValue::Call(call) => return try resolveCall(self, node, call, CallCtx::Normal),
        case ast::NodeValue::FieldAccess(access) => return try resolveFieldAccess(self, node, access),
        case ast::NodeValue::BinOp(binop) => return try resolveBinOp(self, node, binop),
        case ast::NodeValue::Block(block) => return try resolveBlock(self, node, block),
        case ast::NodeValue::Unsafe(body) => {
            set self.unsafeDepth += 1;
            let bodyTy = try visit(self, body, hint) catch e {
                set self.unsafeDepth -= 1;
                throw e;
            };
            set self.unsafeDepth -= 1;
            return setNodeType(self, node, bodyTy);
        },
        case ast::NodeValue::Let(decl) => return try resolveLet(self, node, decl),
        case ast::NodeValue::ConstDecl(decl) => return try resolveConstOrStatic(
            self, node, decl.ident, decl.type, decl.value, decl.attrs, true
        ),
        case ast::NodeValue::StaticDecl(decl) => return try resolveConstOrStatic(

                return setNodeType(self, node, hint);
            }
            return setNodeType(self, node, Type::Nil);
        },
        case ast::NodeValue::Undef => {
            try requireUnsafe(self, node);
            return setNodeType(self, node, Type::Undefined);
        },
        case ast::NodeValue::Bool(value) => {
            setNodeConstValue(self, node, ConstValue::Bool(value));
            return setNodeType(self, node, Type::Bool);

        },
        case ast::NodeValue::As(expr) => {
            // Cast expressions are constant if the source value is constant.
            return isConstExpr(self, expr.value);
        },
        case ast::NodeValue::Unsafe(body) => {
            return isConstExpr(self, body);
        },
        else => {
            return false;
        }
    }
}

    isConst: bool
) -> Type throws (ResolveError) {
    let attrs = resolveAttributes(self, attrList);
    let bindingTy = try infer(self, typeNode);
    try ensureStorableType(self, typeNode, bindingTy);
    let valueTy = try checkAssignable(self, valueNode, bindingTy);
    try ensureTypeResolved(self, bindingTy, typeNode);
    let unsafeGlobal = ast::hasAttribute(attrs, ast::Attribute::Unsafe);
    if isLinear(bindingTy) and not unsafeGlobal {
        throw emitError(self, typeNode, ErrorKind::LinearDiscard);
    }
    let unsafeInitializer = unsafeGlobal;
    if unsafeInitializer {
        set self.unsafeDepth += 1;
    }
    let valueTy = try checkAssignable(self, valueNode, bindingTy) catch e {
        if unsafeInitializer {
            set self.unsafeDepth -= 1;
        }
        throw e;
    };
    if unsafeInitializer {
        set self.unsafeDepth -= 1;
    }

    if isConst {
        let mut constVal = constValueEntry(self, valueNode);
        if constVal == nil and not isConstExpr(self, valueNode) {
            throw emitError(self, valueNode, ErrorKind::ConstExprRequired);

    setNodeType(self, valueNode, bindingTy);

    return Type::Void;
}

/// Return whether a function type matches the compiler's ecall ABI.
fn isCanonicalEcallType(info: *FnType) -> bool {
    if not info.isUnsafe
        or info.paramTypes.len <> 5
        or info.throwList.len <> 0
        or *info.returnType <> Type::I64
    {
        return false;
    }
    return *info.paramTypes[0] == Type::U32
        and *info.paramTypes[1] == Type::I64
        and *info.paramTypes[2] == Type::I64
        and *info.paramTypes[3] == Type::I64
        and *info.paramTypes[4] == Type::I64;
}

/// Analyze a function declaration signature and bind the function name.
fn resolveFnDecl(self: *mut Resolver, node: *ast::Node, decl: ast::FnDecl) -> Type
    throws (ResolveError)
{
    set self.nodeData.entries[node.id].trustedBody = self.unsafeDepth > 0;
    let attrMask = resolveAttributes(self, decl.attrs);
    let mut retTy = Type::Void;
    if let retNode = decl.sig.returnType {
        set retTy = try infer(self, retNode);
        try ensureStorableType(self, retNode, retTy);

        try ensureStorableType(self, throwNode, throwTy);
    }
    exitFn(self);
    set fnType.paramTypes = &paramTypes[..];
    set fnType.throwList = &throwList[..];
    if ast::hasAttribute(attrMask, ast::Attribute::Intrinsic) {
        let name = try nodeName(self, decl.name);
        if mem::eq(name, "ecall") and not isCanonicalEcallType(&fnType) {
            throw emitError(
                self,
                node,
                ErrorKind::InvalidEcallIntrinsicSignature,
            );
        }
    }

    // Bind the function name.
    let ty = Type::Fn(allocFnType(self, fnType));
    let sym = try bindValueIdent(self, decl.name, node, ty, false, 0, attrMask)
        else throw emitError(self, node, ErrorKind::ExpectedIdentifier);

    };
    let retTy = *fnType.returnType;
    let isExtern = ast::hasAttribute(sym.attrs, ast::Attribute::Extern);
    let isIntrinsic = ast::hasAttribute(sym.attrs, ast::Attribute::Intrinsic);
    let isUnsafe = fnType.isUnsafe;
    let trustedBody = nodeData(self, node).trustedBody;

    if let body = decl.body {
        if isIntrinsic {
            throw emitError(self, node, ErrorKind::IntrinsicUnexpectedBody);
        }
        if isExtern {
            throw emitError(self, node, ErrorKind::FnUnexpectedBody);
        }
        if isUnsafe {
        if isUnsafe or trustedBody {
            set self.unsafeDepth += 1;
        }
        enterFn(self, node, fnType); // Enter function scope for body analysis.

        let bodyTy = try checkAssignable(self, body, Type::Void) catch e {
            exitFn(self);
            if isUnsafe { set self.unsafeDepth -= 1; }
            if isUnsafe or trustedBody { set self.unsafeDepth -= 1; }
            throw e;
        };
        if retTy <> Type::Void and bodyTy <> Type::Never {
            exitFn(self);
            if isUnsafe { set self.unsafeDepth -= 1; }
            if isUnsafe or trustedBody { set self.unsafeDepth -= 1; }
            throw emitError(self, body, ErrorKind::FnMissingReturn);
        }
        if self.unsafeDepth == 0 {
            try checkLinearFn(self, nil, decl.sig.params, body) catch e {
                exitFn(self);
                throw e;
            };
        }
        exitFn(self);
        if isUnsafe {
        if isUnsafe or trustedBody {
            set self.unsafeDepth -= 1;
        }
    } else if not isExtern {
        throw emitError(self, node, ErrorKind::FnMissingBody);
    }

    // Match each instance method to a trait method.
    for methodNode in methods {
        let case ast::NodeValue::MethodDecl {
            name, receiverName, receiverType, sig, body, attrs,
        } = methodNode.value else continue;
        set self.nodeData.entries[methodNode.id].trustedBody = self.unsafeDepth > 0;

        let methodName = try nodeName(self, name);
        let attrMask = resolveAttributes(self, attrs);

        // Find the matching trait method.

    let sym = symbolFor(self, node)
        else throw emitError(self, node, ErrorKind::Internal);
    let case SymbolData::Value { type: Type::Fn(fnType), .. } = sym.data
        else panic "resolveMethodBody: expected value symbol";
    let isUnsafe = fnType.isUnsafe;
    if isUnsafe {
    let trustedBody = nodeData(self, node).trustedBody;
    if isUnsafe or trustedBody {
        set self.unsafeDepth += 1;
    }

    // Enter function scope.
    enterFn(self, node, fnType);

    // Bind the receiver parameter.
    let receiverTy = *fnType.paramTypes[0];
    try bindValueIdent(self, receiverName, receiverName, receiverTy, false, 0, 0) catch e {
        exitFn(self);
        if isUnsafe { set self.unsafeDepth -= 1; }
        if isUnsafe or trustedBody { set self.unsafeDepth -= 1; }
        throw e;
    };
    // Bind the remaining parameters from the signature.
    for paramNode in sig.params {
        let paramTy = try infer(self, paramNode) catch e {
            exitFn(self);
            if isUnsafe { set self.unsafeDepth -= 1; }
            if isUnsafe or trustedBody { set self.unsafeDepth -= 1; }
            throw e;
        };
    }

    // Resolve the body.
    let retTy = *fnType.returnType;
    let bodyTy = try checkAssignable(self, body, Type::Void) catch e {
        exitFn(self);
        if isUnsafe { set self.unsafeDepth -= 1; }
        if isUnsafe or trustedBody { set self.unsafeDepth -= 1; }
        throw e;
    };
    if retTy <> Type::Void and bodyTy <> Type::Never {
        exitFn(self);
        if isUnsafe { set self.unsafeDepth -= 1; }
        if isUnsafe or trustedBody { set self.unsafeDepth -= 1; }
        throw emitError(self, body, ErrorKind::FnMissingReturn);
    }
    if self.unsafeDepth == 0 {
        try checkLinearFn(self, receiverName, sig.params, body) catch e {
            exitFn(self);
            throw e;
        };
    }
    exitFn(self);
    if isUnsafe {
    if isUnsafe or trustedBody {
        set self.unsafeDepth -= 1;
    }
}

/// Resolve a standalone method declaration (signature only).

    receiverName: *ast::Node,
    receiverType: *ast::Node,
    sig: ast::FnSig,
    attrs: ?ast::Attributes,
) throws (ResolveError) {
    set self.nodeData.entries[node.id].trustedBody = self.unsafeDepth > 0;
    // Resolve the receiver type: must be `*Type` or `*mut Type` pointing to a
    // nominal type.
    let fullReceiverTy = try infer(self, receiverType);
    let case Type::Pointer {
        class: receiverClass, target: receiverTarget, mutable: receiverMut,

    // Find module under the current module.
    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 "resolveModDecl: expected block for module root";
    try resolveModuleDecls(self, &block);

    let mut isUnsafe = false;
    if let attrs = decl.attrs {
        set isUnsafe = ast::attributesContains(&attrs, ast::Attribute::Unsafe);
    }
    if isUnsafe {
        set self.unsafeDepth += 1;
    }
    try resolveModuleDecls(self, &block) catch e {
        if isUnsafe { set self.unsafeDepth -= 1; }
        exitModuleScope(self, submod);
        throw e;
    };
    if isUnsafe {
        set self.unsafeDepth -= 1;
    }
    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

            throw emitError(self, node, ErrorKind::BuiltinArgCountMismatch(CountMismatch {
                expected: 2,
                actual: args.len as u32,
            }));
        }
        try requireUnsafe(self, node);
        let ptrType = try visit(self, args[0], Type::Unknown);
        let case Type::Pointer { class, target, mutable } = ptrType else {
            throw emitError(self, node, ErrorKind::ExpectedPointer);
        };
        let _ = try checkAssignable(self, args[1], Type::U32);


    // Associate return type to call.
    return setNodeType(self, node, *info.returnType);
}

/// Return whether a type has the exact allocator representation used by slice append lowering.
fn isSliceAllocatorType(ty: Type) -> bool {
    let case Type::Nominal(NominalType::Record(recInfo)) = ty
        else return false;
    if recInfo.fields.len <> 2
        or recInfo.layout.size <> PTR_SIZE * 2
        or recInfo.layout.alignment <> PTR_SIZE
        or recInfo.fields[0].offset <> 0
        or recInfo.fields[1].offset <> PTR_SIZE as i32
    {
        return false;
    }

    let case Type::Fn(callback) = recInfo.fields[0].fieldType
        else return false;
    if callback.isUnsafe
        or callback.paramTypes.len <> 3
        or callback.throwList.len <> 0
        or *callback.paramTypes[1] <> Type::U32
        or *callback.paramTypes[2] <> Type::U32
    {
        return false;
    }
    let case Type::Pointer {
        class: types::PointerClass::Owned,
        target: callbackCtx,
        mutable: true,
    } = *callback.paramTypes[0] else return false;
    if *callbackCtx <> Type::Opaque {
        return false;
    }
    let case Type::Pointer {
        class: types::PointerClass::Owned,
        target: result,
        mutable: true,
    } = *callback.returnType else return false;
    if *result <> Type::Opaque {
        return false;
    }

    return typesEqual(recInfo.fields[1].fieldType, *callback.paramTypes[0]);
}

/// Resolve `slice.append(val, allocator)`.
fn resolveSliceAppend(
    self: *mut Resolver,
    node: *ast::Node,
    parent: *ast::Node,

        throw emitError(self, node, ErrorKind::FnArgCountMismatch(CountMismatch {
            expected: 2,
            actual: args.len as u32,
        }));
    }
    try requireUnsafe(self, node);
    // First argument must be assignable to the element type.
    try checkAssignable(self, args[0], *elemType);
    // Second argument: the allocator. We accept any type -- the lowerer
    // reads `.func` and `.ctx` at fixed offsets.
    try visit(self, args[1], Type::Unknown);
    // The lowerer loads the allocator callback and context from fixed offsets.
    let allocatorType = try visit(self, args[1], Type::Unknown);
    try ensureTypeResolved(self, allocatorType, args[1]);
    if not isSliceAllocatorType(allocatorType) {
        throw emitTypeMismatch(self, args[1], TypeMismatch {
            expected: Type::Unknown,
            actual: allocatorType,
        });
    }
    set self.nodeData.entries[node.id].extra = NodeExtra::SliceAppend { elemType };

    // Return the parent's type so the caller can rebind:
    return setNodeType(self, node, parentType);
}

/// Analyze a scope access expression.
fn resolveScopeAccess(self: *mut Resolver, node: *ast::Node, access: ast::Access) -> Type
    throws (ResolveError)
{
    let sym = try resolveAccess(self, node, access, self.scope);
    try checkUnsafeBindingAccess(self, node, sym);
    let mut ty: Type = undefined;

    match sym.data {
        case SymbolData::Value { type, .. } => {
            setNodeSymbol(self, node, sym);


/// Analyze an address-of expression.
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;
    // Safe address-of expressions always create call-scoped loans. Trusted
    // implementations may create owners when no loan or raw type is required.
    let class = types::PointerClass::Owned
        if self.unsafeDepth > 0 and not isRefType(hint) and not isUnsafePointerType(hint)
        else types::PointerClass::Ref;
    if addr.mutable {
        if not try canBorrowMutFrom(self, addr.target) {
            throw emitError(self, addr.target, ErrorKind::ImmutableBinding);
        }
    }

    assert sourceTy <> Type::Unknown;
    assert targetTy <> Type::Unknown;

    let mut valid = isValidCast(sourceTy, targetTy);
    if let case Type::Pointer {
        class: sourceClass, target: sourceTarget, mutable: sourceMutable,
        class: sourceClass, mutable: sourceMutable, ..
    } = sourceTy {
        if let case Type::Pointer {
            class: targetClass, target: targetTarget, mutable: targetMutable,
            class: targetClass, mutable: targetMutable, ..
        } = targetTy {
            if sourceClass == types::PointerClass::Ref and
               targetClass == types::PointerClass::Unsafe and
               (not targetMutable or sourceMutable) and
               isValidCast(*sourceTarget, *targetTarget)
            {
            let compatibleClass = sourceClass == targetClass or (
                sourceClass == types::PointerClass::Ref and
                targetClass == types::PointerClass::Unsafe
            );
            if compatibleClass and (not targetMutable or sourceMutable) {
                set valid = true;
            }
        }
    }
    if let case Type::Slice {
        class: sourceClass, item: sourceItem, mutable: sourceMutable,
        class: sourceClass, mutable: sourceMutable, ..
    } = sourceTy {
        if let case Type::Slice {
            class: targetClass, item: targetItem, mutable: targetMutable,
            class: targetClass, mutable: targetMutable, ..
        } = targetTy {
            if sourceClass == types::PointerClass::Ref and
               targetClass == types::PointerClass::Unsafe and
               (not targetMutable or sourceMutable) and
               isValidCast(*sourceItem, *targetItem)
            {
            let compatibleClass = sourceClass == targetClass or (
                sourceClass == types::PointerClass::Ref and
                targetClass == types::PointerClass::Unsafe
            );
            if compatibleClass and (not targetMutable or sourceMutable) {
                set valid = true;
            }
        }
    }
    if valid {
        let mut changesRepresentation = false;
        match sourceTy {
            case Type::Pointer { target: sourceTarget, .. } => {
                if let case Type::Pointer { target: targetTarget, .. } = targetTy {
                    set changesRepresentation = not typesEqual(*sourceTarget, *targetTarget);
                }
            }
            case Type::Slice { item: sourceItem, .. } => {
                if let case Type::Slice { item: targetItem, .. } = targetTy {
                    set changesRepresentation = not typesEqual(*sourceItem, *targetItem);
                }
            }
            else => {}
        }
        if changesRepresentation {
            try requireUnsafe(self, node);
        }
        // Propagate the constant value after applying the cast's target-width
        // truncation and signed interpretation.
        if let value = constValueEntry(self, expr.value) {
            if let case ConstValue::Int(i) = value {
                setNodeConstValue(self, node, castConstInt(i, targetTy));

                        throw emitError(self, node, ErrorKind::OpaquePointerArithmetic);
                    }
                    if leftClass <> types::PointerClass::Ref
                        and isNumericType(rightTy)
                    {
                        if leftClass == types::PointerClass::Unsafe {
                            try requireUnsafe(self, node);
                        }
                        try requireUnsafe(self, node);
                        return setNodeType(self, node, leftTy);
                    }
                }
                if let case Type::Pointer { class: rightClass, target: rightTarget, .. } = rightTy {
                    if *rightTarget == Type::Opaque {

                    }
                    if binop.op == ast::BinaryOp::Add
                        and rightClass <> types::PointerClass::Ref
                        and isNumericType(leftTy)
                    {
                        if rightClass == types::PointerClass::Unsafe {
                            try requireUnsafe(self, node);
                        }
                        try requireUnsafe(self, node);
                        return setNodeType(self, node, rightTy);
                    }
                }
            }
            let leftTy = try checkNumeric(self, binop.left);

        }
    }
    set env.len = start;
}

/// Consume a tracked identifier exactly once.
fn consumeLinearIdent(
/// Mark a tracked identifier as consumed.
fn consumeLinearIdent(env: *mut LinearEnv, index: u32) {
    set env.available &= ~((1 as u64) << (index as u64));
}

/// Check that a tracked identifier is available for its requested use.
fn checkLinearIdent(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
    node: *ast::Node,
    usage: LinearUse,
) throws (ResolveError) {
    if usage == LinearUse::Place {
        return;
    }
    let sym = symbolFor(checker.resolver, node) else return;
    let index = findLinearBinding(env, sym) else return;
    if not linearBindingAvailable(env, index) {
        throw emitError(
            checker.resolver,
            node,
            ErrorKind::LinearUseAfterConsume(sym.name),
        );
    }
    set env.available &= ~((1 as u64) << (index as u64));
    if usage == LinearUse::Consume {
        consumeLinearIdent(env, index);
    }
}

/// Verify that two live branches agree on every outer binding.
fn joinLinearBranches(
    checker: *mut LinearChecker,

        }
    }
    set env.terminated = true;
}

/// Find the local root borrowed or consumed by an argument expression.
/// Find the root borrowed or consumed by an argument expression.
fn linearRootSymbol(self: *mut Resolver, node: *ast::Node) -> ?*mut Symbol {
    match node.value {
        case ast::NodeValue::Ident(_) => return symbolFor(self, node),
        case ast::NodeValue::Ident(_),
             ast::NodeValue::ScopeAccess(_) => return symbolFor(self, node),
        case ast::NodeValue::AddressOf(addr) => return linearRootSymbol(self, addr.target),
        case ast::NodeValue::FieldAccess(access) =>
            return linearRootSymbol(self, access.parent),
        case ast::NodeValue::Subscript { container, .. } =>
            return linearRootSymbol(self, container),
        case ast::NodeValue::Deref(target) => return linearRootSymbol(self, target),
        case ast::NodeValue::As(expr) => return linearRootSymbol(self, expr.value),
        case ast::NodeValue::Unsafe(body) => return linearRootSymbol(self, body),
        else => return nil,
    }
}

/// Reject an access that overlaps a loan active in an enclosing call.
fn checkCallLoanConflicts(
    checker: *mut LinearChecker,
    node: *ast::Node,
    exclusive: bool,
) throws (ResolveError) {
    let root = linearRootSymbol(checker.resolver, node) else return;
    let mut cursor = checker.loans;
    while let loans = cursor {
        for i in 0..loans.len {
            if let previous = loans.roots[i];
                previous == root and (loans.exclusive[i] or exclusive)
            {
                throw emitError(
                    checker.resolver,
                    node,
                    ErrorKind::BorrowConflict(root.name),
                );
            }
        }
        set cursor = loans.parent;
    }
}

/// Add the value identifiers introduced by a pattern.
fn addLinearPatternBindings(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
    pattern: *ast::Node,

    if haveResult {
        set *env = result;
    }
}

/// Check one call argument and retain its loan through all later arguments.
fn checkLinearCallArg(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
    loans: *mut LinearLoans,
    arg: *ast::Node,
    expected: Type,
) throws (ResolveError) {
    let mut exclusive = isLinear(expected);
    if let case Type::Pointer {
        class: types::PointerClass::Ref,
        mutable,
        ..
    } = expected {
        set exclusive = mutable;
    } else if let case Type::Slice {
        class: types::PointerClass::Ref,
        mutable,
        ..
    } = expected {
        set exclusive = mutable;
    } else if let case Type::TraitObject {
        class: types::PointerClass::Ref,
        mutable,
        ..
    } = expected {
        set exclusive = mutable;
    }
    if not isUnsafePointerType(expected) {
        try checkCallLoanConflicts(checker, arg, exclusive);
    }
    if isRefType(expected) {
        try checkLinearNode(checker, env, arg, LinearUse::Borrow);
    } else {
        try checkLinearNode(checker, env, arg, LinearUse::Consume);
    }
    if (isRefType(expected) or isLinear(expected)) and not isUnsafePointerType(expected) {
        if let root = linearRootSymbol(checker.resolver, arg) {
            set loans.roots[loans.len] = root;
            set loans.exclusive[loans.len] = exclusive;
            set loans.len += 1;
        }
    }
}

/// Check a syntactic slice append or delete call without a callee function type.
fn checkLinearSliceCall(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
    node: *ast::Node,
    call: ast::Call,
    elemType: ?*Type,
) throws (ResolveError) {
    let case ast::NodeValue::FieldAccess(access) = call.callee.value else {
        throw emitError(checker.resolver, call.callee, ErrorKind::Internal);
    };
    let receiverTy = typeFor(checker.resolver, access.parent) else {
        throw emitError(checker.resolver, access.parent, ErrorKind::Internal);
    };
    let case Type::Slice { class: receiverClass, .. } = autoDeref(receiverTy) else {
        throw emitError(checker.resolver, access.parent, ErrorKind::Internal);
    };
    let mut loans = LinearLoans {
        parent: checker.loans,
        roots: [nil; MAX_FN_PARAMS + 1],
        exclusive: [false; MAX_FN_PARAMS + 1],
        len: 0,
    };
    set checker.loans = &loans;

    if receiverClass <> types::PointerClass::Unsafe {
        try checkCallLoanConflicts(checker, access.parent, true);
    }
    if receiverClass == types::PointerClass::Owned and elemType <> nil {
        try checkLinearNode(checker, env, access.parent, LinearUse::Consume);
    } else if receiverClass <> types::PointerClass::Unsafe {
        try checkLinearNode(checker, env, access.parent, LinearUse::Borrow);
    } else {
        try checkLinearNode(checker, env, access.parent, LinearUse::Observe);
    }
    if receiverClass <> types::PointerClass::Unsafe {
        if let root = linearRootSymbol(checker.resolver, access.parent) {
            set loans.roots[loans.len] = root;
            set loans.exclusive[loans.len] = true;
            set loans.len += 1;
        }
    }

    if let item = elemType {
        if call.args.len <> 2 {
            throw emitError(checker.resolver, node, ErrorKind::Internal);
        }
        try checkLinearCallArg(checker, env, &mut loans, call.args[0], *item);
        let allocatorTy = typeFor(checker.resolver, call.args[1]) else {
            throw emitError(checker.resolver, call.args[1], ErrorKind::Internal);
        };
        try checkLinearCallArg(
            checker,
            env,
            &mut loans,
            call.args[1],
            allocatorTy,
        );
    } else {
        if call.args.len <> 1 {
            throw emitError(checker.resolver, node, ErrorKind::Internal);
        }
        try checkLinearCallArg(
            checker,
            env,
            &mut loans,
            call.args[0],
            Type::U32,
        );
    }
    set checker.loans = loans.parent;
}

/// Check call-scoped loans and argument ownership transfers.
fn checkLinearCall(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
    node: *ast::Node,
    call: ast::Call,
) throws (ResolveError) {
    match checker.resolver.nodeData.entries[node.id].extra {
        case NodeExtra::SliceAppend { elemType } => {
            try checkLinearSliceCall(checker, env, node, call, elemType);
            return;
        }
        case NodeExtra::SliceDelete { .. } => {
            try checkLinearSliceCall(checker, env, node, call, nil);
            return;
        }
        else => {}
    }
    try checkLinearNode(checker, env, call.callee, LinearUse::Observe);
    let calleeTy = typeFor(checker.resolver, call.callee) else {
        throw emitError(checker.resolver, call.callee, ErrorKind::Internal);
    };
    let case Type::Fn(info) = calleeTy else {
        for arg in call.args {
            try checkLinearNode(checker, env, arg, LinearUse::Consume);
        }
        return;
    };
    let mut roots: [?*mut Symbol; MAX_FN_PARAMS + 1] = undefined;
    let mut exclusive: [bool; MAX_FN_PARAMS + 1] = undefined;
    let mut rootsLen: u32 = 0;
    let mut loans = LinearLoans {
        parent: checker.loans,
        roots: [nil; MAX_FN_PARAMS + 1],
        exclusive: [false; MAX_FN_PARAMS + 1],
        len: 0,
    };
    set checker.loans = &loans;

    // Method function types exclude their implicit receiver. Account for it
    // explicitly so owning receivers are consumed and reference receivers
    // participate in call-scoped loan conflict checks.
    if let case ast::NodeValue::FieldAccess(access) = call.callee.value {

                set haveReceiver = true;
            }
            else => {}
        }
        if haveReceiver {
            let receiverExclusive =
                receiverClass == types::PointerClass::Owned or receiverMutable;
            if receiverClass <> types::PointerClass::Unsafe {
                let root = linearRootSymbol(checker.resolver, access.parent);
                if let rootSym = root {
                    set roots[rootsLen] = rootSym;
                    set exclusive[rootsLen] =
                        receiverClass == types::PointerClass::Owned or receiverMutable;
                    set rootsLen += 1;
                }
                try checkCallLoanConflicts(checker, access.parent, receiverExclusive);
            }
            if receiverClass == types::PointerClass::Ref {
                try checkLinearNode(checker, env, access.parent, LinearUse::Borrow);
            } else if receiverClass == types::PointerClass::Owned {
                try checkLinearNode(checker, env, access.parent, LinearUse::Consume);
            }
            if receiverClass <> types::PointerClass::Unsafe {
                if let root = linearRootSymbol(checker.resolver, access.parent) {
                    set loans.roots[loans.len] = root;
                    set loans.exclusive[loans.len] = receiverExclusive;
                    set loans.len += 1;
                }
            }
        }
    }

    for arg, i in call.args {
        let expected = *info.paramTypes[i];
        let root = linearRootSymbol(checker.resolver, arg);
        let mut argExclusive = isLinear(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;
        } else if let case Type::TraitObject {
            class: types::PointerClass::Ref, mutable, ..
        } = expected {
            set argExclusive = mutable;
        }
        if not isUnsafePointerType(expected) {
            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,
                                arg,
                                ErrorKind::BorrowConflict(rootSym.name),
                            );
                        }
                    }
                }
                set roots[rootsLen] = rootSym;
                set exclusive[rootsLen] = argExclusive;
                set rootsLen += 1;
            }
        }
        if isRefType(expected) {
            try checkLinearNode(checker, env, arg, LinearUse::Borrow);
        } else {
            try checkLinearNode(checker, env, arg, LinearUse::Consume);
        }
        try checkLinearCallArg(
            checker,
            env,
            &mut loans,
            arg,
            *info.paramTypes[i],
        );
    }
    set checker.loans = loans.parent;
}

/// Check a pattern conditional. Linear scrutinees require an exhaustive match.
fn checkLinearIfLet(
    checker: *mut LinearChecker,

    usage: LinearUse,
) throws (ResolveError) {
    if env.terminated {
        return;
    }
    match node.value {
        case ast::NodeValue::Ident(_) => {
            if usage == LinearUse::Consume {
                try consumeLinearIdent(checker, env, node);
            }
    let mut exclusive = usage == LinearUse::Place;
    if usage == LinearUse::Consume {
        if let ty = typeFor(checker.resolver, node) {
            set exclusive = isLinear(ty);
        }
    }
    if let case ast::NodeValue::AddressOf(addr) = node.value; addr.mutable {
        set exclusive = true;
    }
    try checkCallLoanConflicts(checker, node, exclusive);
    match node.value {
        case ast::NodeValue::Ident(_) =>
            try checkLinearIdent(checker, env, node, usage),
        case ast::NodeValue::ExprStmt(expr) => {
            if let exprTy = typeFor(checker.resolver, expr) {
                if isLinear(exprTy) {
                    throw emitError(checker.resolver, expr, ErrorKind::LinearDiscard);
                }
            }
            try checkLinearNode(checker, env, expr, LinearUse::Consume);
        }
        case ast::NodeValue::Block(_) => try checkLinearBlock(checker, env, node),
        case ast::NodeValue::Unsafe(body) =>
            try checkLinearNode(checker, env, body, usage),
        case ast::NodeValue::Let(binding) => {
            if let case ast::NodeValue::Undef = binding.value.value {
                if let bindingTy = typeFor(checker.resolver, binding.ident);
                    isLinear(bindingTy)
                {

            try checkLinearNode(checker, env, repeat.item, LinearUse::Consume);
            try checkLinearNode(checker, env, repeat.count, LinearUse::Consume);
        }
        case ast::NodeValue::BinOp(op) => {
            try checkLinearNode(checker, env, op.left, LinearUse::Consume);
            try checkLinearNode(checker, env, op.right, LinearUse::Consume);
            if op.op == ast::BinaryOp::And or op.op == ast::BinaryOp::Or {
                let skipped = *env;
                let mut evaluated = skipped;
                try checkLinearNode(
                    checker,
                    &mut evaluated,
                    op.right,
                    LinearUse::Consume,
                );
                try joinLinearBranches(checker, env, skipped, evaluated, node);
            } else {
                try checkLinearNode(checker, env, op.right, LinearUse::Consume);
            }
        }
        case ast::NodeValue::UnOp(op) => {
            try checkLinearNode(checker, env, op.value, LinearUse::Consume);
        }
        case ast::NodeValue::As(expr) => {

            try checkLinearMatch(checker, env, node, matchExpr);
        }
        case ast::NodeValue::Try(tryExpr) => {
            try checkLinearNode(checker, env, tryExpr.expr, usage);
            let success = *env;
            if tryExpr.catches.len == 0
                and not tryExpr.shouldPanic
                and not tryExpr.returnsOptional
            {
                let mut errorExit = success;
                try finishLinearExit(checker, &mut errorExit);
            }
            for catchNode in tryExpr.catches {
                let case ast::NodeValue::CatchClause(catchClause) = catchNode.value
                    else panic "checkLinearNode: expected catch";
                let mut branch = success;
                let start = branch.len;

    params: *mut [*ast::Node],
    body: *ast::Node,
) throws (ResolveError) {
    let mut checker = LinearChecker {
        resolver: self,
        loans: nil,
        loopMarks: [0; MAX_LINEAR_LOOP_DEPTH],
        loopAvailable: [0; MAX_LINEAR_LOOP_DEPTH],
        loopExitAvailable: [0; MAX_LINEAR_LOOP_DEPTH],
        loopHasNaturalExit: [false; MAX_LINEAR_LOOP_DEPTH],
        loopBreakSeen: [false; MAX_LINEAR_LOOP_DEPTH],

lib/std/lang/resolver/printer.rad +3 -0

            io::print("function body is not expected");
        }
        case super::ErrorKind::IntrinsicUnexpectedBody => {
            io::print("intrinsic function must not have a body");
        }
        case super::ErrorKind::InvalidEcallIntrinsicSignature => {
            io::print("ecall intrinsic must be unsafe and use signature (u32, i64, i64, i64, i64) -> i64");
        }
        case super::ErrorKind::InvalidLoopControl => {
            io::print("loop control outside of a loop construct");
        }
        case super::ErrorKind::TryRequiresThrows => {
            io::print("try used when function does not declare throws");

lib/std/lang/resolver/tests.rad +726 -149

use std::lang::scanner;
use std::lang::module;
use std::lang::strings;

/// Synthetic file path used for resolver tests.
constant MODULE_PATH: *[u8] = "/dev/test.rad";
unsafe constant MODULE_PATH: *[u8] = "/dev/test.rad";

/// AST arena storage used by resolver tests.
static AST_ARENA: [u8; 2097152] = undefined;
unsafe static AST_ARENA: [u8; 2097152] = undefined;

/// Resolver arena storage used by resolver tests.
static ARENA_STORAGE: [u8; 2097152] = undefined;
unsafe static ARENA_STORAGE: [u8; 2097152] = undefined;

/// Node metadata storage used by resolver tests.
static NODE_DATA_STORAGE: [super::NodeData; 256] = undefined;
unsafe static NODE_DATA_STORAGE: [super::NodeData; 256] = undefined;

/// Diagnostic storage used by resolver tests.
static ERROR_STORAGE: [super::Error; 16] = undefined;
unsafe static ERROR_STORAGE: [super::Error; 16] = undefined;

/// Package scope used by resolver tests.
static PKG_SCOPE: super::Scope = undefined;
unsafe static PKG_SCOPE: super::Scope = undefined;

/// Module entries used by resolver tests.
static MODULE_ENTRIES: [module::ModuleEntry; 8] = undefined;
unsafe static MODULE_ENTRIES: [module::ModuleEntry; 8] = undefined;

/// Module graph used by resolver tests.
static MODULE_GRAPH: module::ModuleGraph = undefined;
unsafe static MODULE_GRAPH: module::ModuleGraph = undefined;

/// Module AST arena storage used by resolver tests.
static MODULE_ARENA_STORAGE: [u8; 4096] = undefined;
unsafe static MODULE_ARENA_STORAGE: [u8; 4096] = undefined;

/// Module AST arena used by resolver tests.
static MODULE_ARENA: ast::NodeArena = undefined;
unsafe static MODULE_ARENA: ast::NodeArena = undefined;

/// Interned string pool used by resolver tests.
static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
unsafe static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };

/// String literals used in tests.
constant LITERALS: [*[u8]; 15] = [
unsafe constant LITERALS: [*[u8]; 15] = [
    "Ok", "Error", "R", "S",
    "f", "Status", "Pending",
    "Some", "None", "First",
    "Second", "Opt", "x",
    "value", "idx"

    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Require a linear use-after-consume error at the later identifier use.
fn expectLinearUseAfterConsume(
    program: *[u8],
    name: *[u8],
    offset: u32,
) throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectErrorKind(
        &result,
        super::ErrorKind::LinearUseAfterConsume(name),
    );
    let node = err.node else throw testing::TestError::Failed;
    try testing::expect(node.span.offset == offset);
}

/// Require an inferred integer type mismatch.
fn expectIntMismatch(program: *[u8], expected: super::Type)
    throws (testing::TestError)
{
    let mut a = testResolver();

        throw testing::TestError::Failed;
    }
    return body.statements[index];
}

/// Retrieve a declared function body by its statement index.
fn getFnDeclBody(root: *ast::Node, index: u32) -> ast::Block
    throws (testing::TestError)
{
    let stmt = try getBlockStmt(root, index);
    let case ast::NodeValue::FnDecl(decl) = stmt.value
        else throw testing::TestError::Failed;
    let body = decl.body
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Block(block) = body.value
        else throw testing::TestError::Failed;
    return block;
}

/// Retrieve a function body block by function name from the program scope.
fn getFnBody(a: *super::Resolver, root: *ast::Node, name: *[u8]) -> ast::Block
    throws (testing::TestError)
{
    let scope = super::scopeFor(a, root)

    try expectType(&a, result.root, super::Type::Bool);
}

@test fn testResolveStringLiteralType() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveExprStr(&mut a, "\"hello\"");
    let result = try resolveBlockStr(&mut a, "panic \"hello\";");

    try expectNoErrors(&result);
    let ty = try typeOf(&a, result.root);
    let stmt = try getBlockStmt(result.root, 0);
    let case ast::NodeValue::Panic { message } = stmt.value
        else throw testing::TestError::Failed;
    let literal = message
        else throw testing::TestError::Failed;
    let ty = try typeOf(&a, literal);
    let elemTy = try expectSliceType(ty, false);
    try testing::expect(elemTy == super::Type::U8);
}

@test fn testResolveAsNumeric() throws (testing::TestError) {

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

/// The canonical unsafe ecall intrinsic declaration is accepted.
@test fn testResolveEcallIntrinsicCanonicalSignature() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "@intrinsic unsafe fn ecall(number: u32, arg1: i64, arg2: i64, arg3: i64, arg4: i64) -> i64;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// The ecall intrinsic cannot be exposed as a safe function.
@test fn testResolveEcallIntrinsicRequiresUnsafe() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "@intrinsic fn ecall(number: u32, arg1: i64, arg2: i64, arg3: i64, arg4: i64) -> i64;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(
        &result,
        super::ErrorKind::InvalidEcallIntrinsicSignature,
    );
}

/// The ecall intrinsic declaration must use its canonical ABI.
@test fn testResolveEcallIntrinsicRequiresCanonicalAbi() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "@intrinsic unsafe fn ecall(number: u32, arg1: i64, arg2: i64, arg3: i64) -> i64;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(
            &result,
            super::ErrorKind::InvalidEcallIntrinsicSignature,
        );
    } {
        let mut a = testResolver();
        let program = "@intrinsic unsafe fn ecall(number: u32, arg1: u64, arg2: i64, arg3: i64, arg4: i64) -> i64;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(
            &result,
            super::ErrorKind::InvalidEcallIntrinsicSignature,
        );
    } {
        let mut a = testResolver();
        let program = "@intrinsic unsafe fn ecall(number: u32, arg1: i64, arg2: i64, arg3: i64, arg4: i64) -> i32;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(
            &result,
            super::ErrorKind::InvalidEcallIntrinsicSignature,
        );
    }
}

@test 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 expectExprStmtType(&a, stmt, super::Type::I32);
}

@test 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 = "fn run(slice: &[i32]) { slice[1]; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let sliceStmt = try getBlockStmt(result.root, 1);
    let case ast::NodeValue::Let(sliceDecl) = sliceStmt.value
        else throw testing::TestError::Failed;
    let sliceTy = try typeOf(&a, sliceDecl.value);
    let elemTy = try expectSliceType(sliceTy, false);
    try testing::expect(elemTy == super::Type::I32);

    let indexStmt = try getBlockStmt(result.root, 2);
    try expectExprStmtType(&a, indexStmt, super::Type::I32);
    let body = try getFnDeclBody(result.root, 0);
    try testing::expect(body.statements.len == 1);
    try expectExprStmtType(&a, body.statements[0], super::Type::I32);
}

@test 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 = "fn run(slice: &[i32]) { 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 body = try getFnDeclBody(result.root, 0);
    try testing::expect(body.statements.len == 2);
    let case ast::NodeValue::ExprStmt(lenExpr) = body.statements[0].value
        else throw testing::TestError::Failed;
    let lenTy = try typeOf(&a, lenExpr);
    try testing::expect(lenTy == super::Type::U32);

    let ptrStmt = try getBlockStmt(result.root, 3);
    let case ast::NodeValue::ExprStmt(ptrExpr) = ptrStmt.value
    let case ast::NodeValue::ExprStmt(ptrExpr) = body.statements[1].value
        else throw testing::TestError::Failed;
    let ptrTy = try typeOf(&a, ptrExpr);
    let targetTy = try expectPointerType(ptrTy, false);
    try testing::expect(targetTy == super::Type::I32);
    let case super::Type::Pointer { class, target, mutable } = ptrTy
        else throw testing::TestError::Failed;
    try testing::expect(class == types::PointerClass::Ref);
    try testing::expect(not mutable);
    try testing::expect(*target == super::Type::I32);
}

@test fn testResolveSliceLiteralImmutable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let slice: *[i32] = &[1, 2, 3];";
    let program = "unsafe fn run() { 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) {
    let mut a = testResolver();
    let program = "let slice: *[i32] = &[];";
    let program = "unsafe fn run() { 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) {
    let mut a = testResolver();
    let program = "let slice: *[[i32; 2]] = &[[1, 2], [3, 4]];";
    let program = "unsafe fn run() { let slice: *[[i32; 2]] = &[[1, 2], [3, 4]]; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test fn testResolveSliceFromArray() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[..];";
        let program = "unsafe fn run() { let 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 = "unsafe fn run() { let 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 = "unsafe fn run() { let 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 = "unsafe fn run() { let xs: [u8; 2] = [1, 2]; let slice = &xs[1..1]; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}


        else throw testing::TestError::Failed;
}

@test fn testResolveSliceLiteralMutable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let slice: *mut [i32] = &mut [1, 2, 3];";
    let program = "unsafe fn run() { let slice: *mut [i32] = &mut [1, 2, 3]; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test fn testResolvePointerMutableAssignmentRequiresMut() throws (testing::TestError) {

        else throw testing::TestError::Failed;
}

@test 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 = "fn f(mptr: *mut i32) -> *i32 { return mptr; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test fn testResolveAddressOfRequiresMutableBinding() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let x: i32 = 0; let ptr = &mut x;";
        let program = "fn borrow(ptr: &mut i32) {} fn run() { let x: i32 = 0; borrow(&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 = "fn borrow(ptr: &mut i32) {} fn run() { let mut x: i32 = 0; borrow(&mut x); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test fn testResolveAddressOfSliceRequiresMutableBinding() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let xs: [i32; 3] = [1, 2, 3]; let slice = &mut xs[..];";
        let program = "fn borrow(slice: &mut [i32]) {} fn run() { let xs: [i32; 3] = [1, 2, 3]; borrow(&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 = "fn borrow(slice: &mut [i32]) {} fn run() { let mut xs: [i32; 3] = [1, 2, 3]; borrow(&mut xs[..]); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}


        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 = "fn assign(slice: &mut [u8]) { set slice[0] = 1; } fn run() { let mut xs: [u8; 2] = [0, 1]; assign(&mut xs[..]); }";
        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 = "fn f(input: *[u8]) { let mut slice: *[u8] = input; 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 = "fn f(slice: &[u8]) { set slice[0] = 1; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
}


}

@test fn testUndefinedCoercions() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let count: i32 = undefined;");
        let result = try resolveBlockStr(&mut a, "unsafe { let count: i32 = undefined; }");
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "let mut value: i32 = 0; set value = undefined;";
        let program = "let mut value: i32 = 0; unsafe { set value = undefined; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "fn f(x: i32) {} fn g() { f(undefined); }";
        let program = "fn f(x: i32) {} fn g() { unsafe { f(undefined); } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "fn fetch() -> i32 { return undefined; }";
        let program = "fn fetch() -> i32 { unsafe { return undefined; } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}


// Dereference tests //////////////////////////////////////////////////////////

@test 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 resolveProgramStr(&mut a, "fn f(ptr: &i32) { *ptr; }");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        let body = try getFnBody(&a, result.root, "f");
        if body.statements.len <> 1 {
            throw testing::TestError::Failed;
        }
        let stmt = body.statements[0];
        try expectExprStmtType(&a, stmt, super::Type::I32);
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "*42");
        try expectErrorKind(&result, super::ErrorKind::ExpectedPointer);

}

@test 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 = "fn f(ptr: &mut i32) { 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 = "fn f(ptr: &i32) { 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 = "fn f(input: *i32) { let mut ptr: *i32 = input; 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 = "fn f(ptr: &mut u8) { set *ptr = 255; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}


}

/// Test that mutable pointer parameters can be borrowed mutably.
@test fn testMutableBorrowFromMutablePointer() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(p: *mut i32) { let x: *mut i32 = &mut *p; }";
    let program = "fn borrow(value: &mut i32) {} fn f(p: &mut i32) { borrow(&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) {
    let mut a = testResolver();
    let program = "fn f(s: *mut [i32]) { let x: *mut i32 = &mut s[0]; }";
    let program = "fn borrow(value: &mut i32) {} fn f(s: &mut [i32]) { borrow(&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) {
    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; } unsafe fn f() -> *mut i32 { let mut b = Box { x: 1 }; let px: *mut i32 = &mut idBox(&mut b).x; return px; }";
    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) {
    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 borrow(px: &mut i32) {} fn f(b: *Box) { borrow(&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.

    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 appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::statics; fn main() { let p: *mut i32 = &mut statics::COUNTER; set *p = 7; }", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::statics; fn assign(p: &mut i32) { set *p = 7; } fn main() { assign(&mut statics::COUNTER); }", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}


}

/// Test that mutable bindings of immutable pointers cannot borrow mutably through the pointer.
@test 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 borrow(value: &mut i32) {} fn f(input: *i32) { let mut p: *i32 = input; borrow(&mut *p); }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}


/// Test that mutable slice parameters can be assigned through index.
@test 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 program = "fn f(slice: &mut [i32]) { set slice[0] = 1; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        // Immutable slice param: direct assignment should fail
        let mut a = testResolver();
        let program = "fn f(slice: *[i32]) { set slice[0] = 1; }";
        let program = "fn f(slice: &[i32]) { set slice[0] = 1; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
}


}

/// Test that record fields can be assigned through a mutable pointer.
@test 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 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.

// Opaque pointer tests.

/// You can assign any pointer (*T) to an opaque pointer (*opaque) without a cast.
@test 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(ptr: *i32) -> *opaque { return ptr; }");
    try expectNoErrors(&result);
}

/// You cannot assign an opaque pointer to a non-opaque pointer without a cast.
@test 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(o: *opaque) { let ptr: *i32 = o; }");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(mismatch) = err.kind
        else throw testing::TestError::Failed;
    let case super::Type::Pointer { target: expectedTarget, .. } = mismatch.expected
        else throw testing::TestError::Failed;

        let result = try resolveProgramStr(&mut a, "fn f(x: opaque) {}");
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::OpaqueTypeNotAllowed);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f() { let x: opaque = undefined; }");
        let result = try resolveProgramStr(&mut a, "fn f() { unsafe { let x: opaque = undefined; } }");
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::OpaqueTypeNotAllowed);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "record R { x: opaque }");

}

/// You cannot dereference an opaque pointer, you have to cast it first.
@test 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(o: *opaque) { 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) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn f() { let o: *opaque = undefined; let x = *(o as *i32); }");
    let result = try resolveProgramStr(&mut a, "unsafe fn f(o: *opaque) -> *i32 { let ptr = o as *i32; let x = *ptr; return ptr; }");
    try expectNoErrors(&result);
}

/// You cannot do pointer arithmetic with an opaque pointer.
@test 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(o: *opaque) { 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(o: *opaque) { 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(o: *opaque) { 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(o: *opaque) { let x = 1 - o; }");
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::OpaquePointerArithmetic);
    }
}


/// enabling compile-time evaluation of array sizes using imported constants.
@test 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 rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; unsafe mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export constant SIZE: u32 = 8;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; static BUFFER: [u8; consts::SIZE] = undefined;", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);

/// Test @sliceOf with correct arguments succeeds.
@test 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 program = "fn f(ptr: *u8, len: u32) -> *[u8] { unsafe { return @sliceOf(ptr, len); } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
    // Mutable pointer produces mutable slice.
    {
        let mut a = testResolver();
        let program = "fn f(ptr: *mut u8, len: u32) -> *mut [u8] { return @sliceOf(ptr, len); }";
        let program = "fn f(ptr: *mut u8, len: u32) -> *mut [u8] { unsafe { return @sliceOf(ptr, len); } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}


/// Test @sliceOf with wrong argument types produces errors.
@test 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 program = "fn f(val: u32, len: u32) -> *[u8] { return unsafe { @sliceOf(val, len) }; }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::ExpectedPointer = err.kind
            else throw testing::TestError::Failed;
    }
    // Array instead of pointer.
    {
        let mut a = testResolver();
        let program = "fn f(arr: [u8; 4], len: u32) -> *[u8] { return @sliceOf(arr, len); }";
        let program = "fn f(arr: [u8; 4], len: u32) -> *[u8] { return unsafe { @sliceOf(arr, len) }; }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::ExpectedPointer = err.kind
            else throw testing::TestError::Failed;
    }
    // Non-numeric second argument.
    {
        let mut a = testResolver();
        let program = "fn f(ptr: *u8, len: bool) -> *[u8] { return @sliceOf(ptr, len); }";
        let program = "fn f(ptr: *u8, len: bool) -> *[u8] { return unsafe { @sliceOf(ptr, len) }; }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
    // Pointer second argument.
    {
        let mut a = testResolver();
        let program = "fn f(ptr: *u8, len: *u32) -> *[u8] { return @sliceOf(ptr, len); }";
        let program = "fn f(ptr: *u8, len: *u32) -> *[u8] { return unsafe { @sliceOf(ptr, len) }; }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }


/// Test @sliceOf with 3 arguments (ptr, len, cap) succeeds.
@test 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 program = "fn f(ptr: *u8, len: u32, cap: u32) -> *[u8] { unsafe { return @sliceOf(ptr, len, cap); } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
    // Mutable pointer produces mutable slice.
    {
        let mut a = testResolver();
        let program = "fn f(ptr: *mut u8, len: u32, cap: u32) -> *mut [u8] { return @sliceOf(ptr, len, cap); }";
        let program = "fn f(ptr: *mut u8, len: u32, cap: u32) -> *mut [u8] { unsafe { return @sliceOf(ptr, len, cap); } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test @sliceOf with 3 arguments but wrong cap type.
@test 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 program = "fn f(ptr: *u8, len: u32, cap: bool) -> *[u8] { return unsafe { @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) {
    let mut a = testResolver();
    let program = "fn f(s: *[u8]) -> u32 { return s.cap; }";
    let program = "fn f(s: &[u8]) -> u32 { return s.cap; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Require a slice append allocator expression to produce a type mismatch.
fn expectSliceAppendAllocatorError(program: *[u8]) throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Test `.append()` on immutable slice produces an error.
@test 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);

    }
}

/// Test `.append()` with correct arguments succeeds.
@test fn testResolveSliceAppendCorrect() throws (testing::TestError) {
    // A structurally matching allocator record is accepted.
    {
        let mut a = testResolver();
        let program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } unsafe fn f(s: &mut [i32], a: A) { s.append(1, a); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
    // Function structural matching and concrete-to-opaque pointer coercion are preserved.
    {
        let mut a = testResolver();
        let program = "record C { value: u32 } record A { callback: fn(*mut opaque, u32, u32) -> *mut opaque, context: *mut opaque } fn allocate(ctx: *mut opaque, size: u32, alignment: u32) -> *mut opaque { return ctx; } unsafe fn f(s: &mut [i32], ctx: *mut C) { s.append(1, A { callback: allocate, context: ctx }); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test `.append()` requires an unsafe context even with a valid allocator.
@test fn testResolveSliceAppendRequiresUnsafe() 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 program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn f(s: &mut [i32], a: A) { s.append(1, a); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let err = try expectError(&result);
    let case super::ErrorKind::UnsafeOperation = err.kind
        else throw testing::TestError::Failed;
}

/// Test `.append()` rejects allocator values without the exact structural contract.
@test fn testResolveSliceAppendInvalidAllocator() throws (testing::TestError) {
    try expectSliceAppendAllocatorError(
        "unsafe fn f(s: *mut [i32]) { s.append(1, 0); }"
    );
    try expectSliceAppendAllocatorError(
        "unsafe fn f(s: *mut [i32]) { s.append(1, undefined); }"
    );
    try expectSliceAppendAllocatorError(
        "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque, extra: u32 } unsafe fn f(s: *mut [i32], a: A) { s.append(1, a); }"
    );
    try expectSliceAppendAllocatorError(
        "record A { ctx: *mut opaque, func: fn(*mut opaque, u32, u32) -> *mut opaque } unsafe fn f(s: *mut [i32], a: A) { s.append(1, a); }"
    );
    try expectSliceAppendAllocatorError(
        "record A { func: fn(*mut opaque, u64, u32) -> *mut opaque, ctx: *mut opaque } unsafe fn f(s: *mut [i32], a: A) { s.append(1, a); }"
    );
    try expectSliceAppendAllocatorError(
        "record A { func: fn(*mut opaque, u32, u32) -> *opaque, ctx: *mut opaque } unsafe fn f(s: *mut [i32], a: A) { s.append(1, a); }"
    );
    try expectSliceAppendAllocatorError(
        "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *opaque } unsafe fn f(s: *mut [i32], a: A) { s.append(1, a); }"
    );
    try expectSliceAppendAllocatorError(
        "record A { func: fn(*unsafe mut opaque, u32, u32) -> *unsafe mut opaque, ctx: *unsafe mut opaque } unsafe fn f(s: *mut [i32], a: A) { s.append(1, a); }"
    );
}

/// Test `.append()` with wrong element type produces an error.
@test 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 program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } unsafe 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()` with correct arguments succeeds.
@test fn testResolveSliceDeleteCorrect() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(s: *mut [i32]) { s.delete(0); }";
    let program = "unsafe 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.

    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Safe slice delete borrows its receiver for the call and leaves it available.
@test fn testLinearSliceDeletePreservesReceiver() throws (testing::TestError) {
    let program = "fn consumeSlice(slice: *mut [u32]) { consumeSlice(slice); } fn run(slice: *mut [u32]) { slice.delete(0); consumeSlice(slice); }";
    try expectAnalyzeOk(program);
}

/// Slice append consumes its receiver, element, and allocator before rebinding.
@test fn testLinearSliceAppendInUnsafeBlock() throws (testing::TestError) {
    let program = "record Token: Linear {} record Allocator { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn consumeSlice(slice: *mut [Token]) { consumeSlice(slice); } fn run(slice: *mut [Token], token: Token, allocator: Allocator) { unsafe { set slice = slice.append(token, allocator); } consumeSlice(slice); }";
    try expectAnalyzeOk(program);
}

/// Test `match &opt` produces immutable pointer bindings.
@test 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);

}

/// A mutable slice pointer should be assignable to an immutable slice pointer.
@test 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 resolveProgramStr(&mut a, "fn f(slice: *mut [i32]) -> *[i32] { return slice; }");
    try expectNoErrors(&result);
}

/// Comprehensive tests for `as` cast expressions.
/// Safe `as` casts preserve pointer representation or discard mutability.
@test 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 resolveProgramStr(&mut a, "fn f(p: *i32) { p as u64; }");
        try expectNoErrors(&result);
    } { // Function pointer to numeric.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let f: fn() = undefined; f as u32;");
        let result = try resolveProgramStr(&mut a, "fn target() {} fn f() { target as u32; }");
        try expectNoErrors(&result);
    } { // *u8 to *i32 (u8 to i32 is valid).
    } { // Identity cast: *mut [i32] to *mut [i32].
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let p: *u8 = undefined; p as *i32;");
        let result = try resolveProgramStr(&mut a, "fn f(s: *mut [i32]) -> *mut [i32] { return s as *mut [i32]; }");
        try expectNoErrors(&result);
    } { // **u8 to **i32 (*u8 to *i32 is valid).
    } { // Identity cast: *i32 to *i32.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let p: **u8 = undefined; p as **i32;");
        let result = try resolveProgramStr(&mut a, "fn f(p: *i32) -> *i32 { return p as *i32; }");
        try expectNoErrors(&result);
    }

    { // *[i32] to *[opaque].
    } { // Identity cast: i32 to i32.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let s: *[i32] = undefined; s as *[opaque];");
        let result = try resolveBlockStr(&mut a, "let x: i32 = 0; x as i32;");
        try expectNoErrors(&result);
    } { // *[opaque] to *[i32].
    } { // Mutable pointer to immutable pointer.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let s: *[opaque] = undefined; s as *[i32];");
        let result = try resolveProgramStr(&mut a, "fn f(p: *mut i32) -> *i32 { return p as *i32; }");
        try expectNoErrors(&result);
    } { // Mutable slice to immutable slice.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(s: *mut [i32]) -> *[i32] { return s as *[i32]; }");
        try expectNoErrors(&result);
    }
}

    { // *[i32] to *[u8].
/// Representation-changing pointer and slice casts require an unsafe context.
@test fn testResolveAsCastsRequireUnsafe() throws (testing::TestError) {
    { // Pointer pointee representation.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let s: *[i32] = undefined; s as *[u8];");
        try expectNoErrors(&result);
    } { // *[record] to *[u8].
        let result = try resolveProgramStr(&mut a, "fn f(p: *u8) -> *i32 { return p as *i32; }");
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    } { // Nested pointer pointee representation.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "record R { x: i32 } fn f(s: *[R]) { s as *[u8]; }");
        try expectNoErrors(&result);
        let result = try resolveProgramStr(&mut a, "fn f(p: **u8) -> **i32 { return p as **i32; }");
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    } { // Concrete pointer to opaque pointer.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(p: *i32) -> *opaque { return p as *opaque; }");
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    } { // Opaque pointer to concrete pointer.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(p: *opaque) -> *i32 { return p as *i32; }");
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    } { // Concrete slice to opaque slice.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(s: *[i32]) -> *[opaque] { return s as *[opaque]; }");
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    } { // Opaque slice to concrete slice.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(s: *[opaque]) -> *[i32] { return s as *[i32]; }");
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    } { // Integer slice to byte slice.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(s: *[i32]) -> *[u8] { return s as *[u8]; }");
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    } { // Byte slice to integer slice.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(s: *[u8]) -> *[i32] { return s as *[i32]; }");
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    } { // Record slice to byte slice.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "record R { x: i32 } fn f(s: *[R]) -> *[u8] { return s as *[u8]; }");
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    } { // Nested slice element representation.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(s: *[*unsafe u8]) -> *[*unsafe i32] { return s as *[*unsafe i32]; }");
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    } { // Record pointer representation.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "record R { x: i32 } fn f(p: *R) -> *i32 { return p as *i32; }");
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    } { // Record slice element representation.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "record R { x: i32 } fn f(s: *[R]) -> *[i32] { return s as *[i32]; }");
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    }
}

    { // *[u8] to *[i32].
/// Unsafe blocks may reinterpret pointers and slices without changing their class.
@test fn testResolveAsCastsInUnsafeBlock() throws (testing::TestError) {
    { // Pointer pointee representation.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let s: *[u8] = undefined; s as *[i32];");
        let result = try resolveProgramStr(&mut a, "fn f(p: *u8) -> *i32 { unsafe { return p as *i32; } }");
        try expectNoErrors(&result);
    } { // *[*u8] to *[*i32]
    } { // Nested pointer pointee representation.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let s: *[*u8] = undefined; s as *[*i32];");
        let result = try resolveProgramStr(&mut a, "fn f(p: **u8) -> **i32 { unsafe { return p as **i32; } }");
        try expectNoErrors(&result);
    }

    { // Identity cast: *mut [i32] to *mut [i32].
    } { // Concrete pointer to opaque pointer.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let s: *mut [i32] = undefined; s as *mut [i32];");
        let result = try resolveProgramStr(&mut a, "fn f(p: *i32) -> *opaque { unsafe { return p as *opaque; } }");
        try expectNoErrors(&result);
    } { // Identity cast: *i32 to *i32.
    } { // Opaque pointer to concrete pointer.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let p: *i32 = undefined; p as *i32;");
        let result = try resolveProgramStr(&mut a, "fn f(p: *opaque) -> *i32 { unsafe { return p as *i32; } }");
        try expectNoErrors(&result);
    } { // Identity cast: i32 to i32.
    } { // Concrete slice to opaque slice.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: i32 = 0; x as i32;");
        let result = try resolveProgramStr(&mut a, "fn f(s: *[i32]) -> *[opaque] { unsafe { return s as *[opaque]; } }");
        try expectNoErrors(&result);
    } { // Opaque slice to concrete slice.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(s: *[opaque]) -> *[i32] { unsafe { return s as *[i32]; } }");
        try expectNoErrors(&result);
    } { // Integer slice to byte slice.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(s: *[i32]) -> *[u8] { unsafe { return s as *[u8]; } }");
        try expectNoErrors(&result);
    } { // Byte slice to integer slice.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(s: *[u8]) -> *[i32] { unsafe { return s as *[i32]; } }");
        try expectNoErrors(&result);
    } { // Record slice to byte slice.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "record R { x: i32 } fn f(s: *[R]) -> *[u8] { unsafe { return s as *[u8]; } }");
        try expectNoErrors(&result);
    } { // Nested slice element representation.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(s: *[*unsafe u8]) -> *[*unsafe i32] { unsafe { return s as *[*unsafe i32]; } }");
        try expectNoErrors(&result);
    } { // Record pointer representation.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "record R { x: i32 } fn f(p: *R) -> *i32 { unsafe { return p as *i32; } }");
        try expectNoErrors(&result);
    } { // Record slice element representation.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "record R { x: i32 } fn f(s: *[R]) -> *[i32] { unsafe { return s as *[i32]; } }");
        try expectNoErrors(&result);
    }
}

/// Tests for invalid `as` casts that should be rejected.
/// Tests for invalid `as` casts that should be rejected even in unsafe code.
@test 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 result = try resolveBlockStr(&mut a, "unsafe { let p: *i32 = undefined; p as *[i32]; }");
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
    } { // Slice to pointer is invalid.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let s: *[i32] = undefined; s as *i32;");
        let result = try resolveBlockStr(&mut a, "unsafe { let s: *[i32] = undefined; s as *i32; }");
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
    } { // *T to *i32 is invalid.
    } { // Slice to numeric is invalid.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "record R { x: i32 } fn f(p: *R) { p as *i32; }");
        let result = try resolveBlockStr(&mut a, "unsafe { let s: *[i32] = undefined; s as u32; }");
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
    } { // *[T] to *[i32] is invalid.
    } { // Integer to pointer is invalid.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "record R { x: i32 } fn f(s: *[R]) { s as *[i32]; }");
        let result = try resolveBlockStr(&mut a, "let address: u64 = 0; unsafe { address as *u8; }");
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
    } { // Slice to numeric is invalid.
    } { // Pointer cast cannot add mutability.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let s: *[i32] = undefined; s as u32;");
        let result = try resolveBlockStr(&mut a, "unsafe { let p: *i32 = undefined; p as *mut i32; }");
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
    } { // *record to *u8 is invalid.
    } { // Slice cast cannot add mutability.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "record R { x: i32 } fn f(p: *R) { p as *u8; }");
        let result = try resolveBlockStr(&mut a, "unsafe { let s: *[i32] = undefined; s as *mut [i32]; }");
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

        else throw testing::TestError::Failed;
}

@test 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 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).

@test 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 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 dispatch(a: &mut opaque defs::Adder) -> i32 { return a.add(5); } fn test() -> i32 { let mut c = defs::Counter { value: 10 }; return dispatch(&mut c); }", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}


@test 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 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 dispatch(a: &mut opaque defs::Adder) -> i32 { return a.add(5); } fn test() -> i32 { let mut c = defs::Counter { value: 10 }; return dispatch(&mut c); }", &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) {
    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 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) {
    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 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) {
    let mut a = testResolver();
    let program = "record Counter { value: i32 } trait Ops { fn (*mut Ops) inc(); fn (*Ops) get() -> i32; } instance Ops for Counter { fn (c: *mut Counter) inc() { set c.value = c.value + 1; } fn (c: *Counter) get() -> i32 { return c.value; } } fn caller(o: *mut opaque Ops) -> i32 { o.inc(); return o.get(); }";
    let program = "record Counter { value: i32 } trait Ops { fn (&mut Ops) inc(); fn (&Ops) get() -> i32; } instance Ops for Counter { fn (c: &mut Counter) inc() { set c.value = c.value + 1; } fn (c: &Counter) get() -> i32 { return c.value; } } fn caller(o: &mut opaque Ops) -> i32 { o.inc(); return o.get(); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Instance method body type must match the trait return type.

}

/// Instance method correctly matches the trait's throws clause.
@test 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 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 //////////////////////////////////////////

/// Test cross-module constant expression used as array size.
@test 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 rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; unsafe mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export constant WIDTH: u32 = 8; export constant HEIGHT: u32 = 4;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; constant TOTAL: u32 = consts::WIDTH * consts::HEIGHT; static BUF: [u8; TOTAL] = undefined;", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);

    let program = "record Marker: Linear {} fn bad(value: &u32) -> &u32 { return value; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
}

/// Field observation cannot read an owner after it was moved.
@test fn testLinearFieldObserveAfterMoveRejected() throws (testing::TestError) {
    let program = "record Token: Linear { value: u32 } fn consume(token: Token) { consume(token); } fn run() { let token = Token { value: 1 }; consume(token); token.value; }";
    try expectLinearUseAfterConsume(program, "token", 140);
}

/// Dereferencing cannot read an owner after it was moved.
@test fn testLinearDerefAfterMoveRejected() throws (testing::TestError) {
    let program = "fn consume(pointer: *u32) { consume(pointer); } fn run(pointer: *u32) { consume(pointer); *pointer; }";
    try expectLinearUseAfterConsume(program, "pointer", 91);
}

/// Immutable borrowing cannot borrow an owner after it was moved.
@test fn testLinearBorrowAfterMoveRejected() throws (testing::TestError) {
    let program = "record Token: Linear { value: u32 } fn consume(token: Token) { consume(token); } fn inspect(token: &Token) {} fn run() { let token = Token { value: 1 }; consume(token); inspect(&token); }";
    try expectLinearUseAfterConsume(program, "token", 178);
}

/// Mutable borrowing cannot borrow an owner after it was moved.
@test fn testLinearMutableBorrowAfterMoveRejected() throws (testing::TestError) {
    let program = "record Token: Linear { value: u32 } fn consume(token: Token) { consume(token); } fn inspect(token: &mut Token) {} fn run() { let mut token = Token { value: 1 }; consume(token); inspect(&mut token); }";
    try expectLinearUseAfterConsume(program, "token", 190);
}

/// A non-consuming receiver cannot borrow an owner after it was moved.
@test fn testLinearRefReceiverAfterMoveRejected() throws (testing::TestError) {
    let program = "record Token: Linear { value: u32 } fn consume(token: Token) { consume(token); } fn (token: &Token) inspect() {} fn run() { let token = Token { value: 1 }; consume(token); token.inspect(); }";
    try expectLinearUseAfterConsume(program, "token", 172);
}

/// A branch-joined consumed owner remains unavailable afterward.
@test fn testLinearObserveAfterBranchJoinedMoveRejected() throws (testing::TestError) {
    let program = "record Token: Linear { value: u32 } fn consume(token: Token) { consume(token); } fn run(flag: bool) { let token = Token { value: 1 }; if flag { consume(token); } else { consume(token); } token.value; }";
    try expectLinearUseAfterConsume(program, "token", 187);
}

/// Observation before exactly one move remains valid.
@test fn testLinearObserveBeforeMoveAllowed() throws (testing::TestError) {
    let program = "record Token: Linear { value: u32 } fn consume(token: Token) { consume(token); } fn run() { let token = Token { value: 1 }; token.value; consume(token); }";
    try expectAnalyzeOk(program);
}

/// A short-circuit RHS cannot be the only path that consumes an owner.
@test fn testLinearShortCircuitConsumptionRejected() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "record Token: Linear {} fn consume(token: Token) { consume(token); } fn take(token: Token) -> bool { consume(token); return true; } fn run(flag: bool) { let token = Token {}; flag and take(token); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::LinearBranchMismatch("token"));
    } {
        let mut a = testResolver();
        let program = "record Token: Linear {} fn consume(token: Token) { consume(token); } fn take(token: Token) -> bool { consume(token); return true; } fn run(flag: bool) { let token = Token {}; flag or take(token); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::LinearBranchMismatch("token"));
    }
}

/// Short-circuit branches with identical owner states remain valid.
@test fn testLinearShortCircuitIdenticalStatesAllowed() throws (testing::TestError) {
    try expectAnalyzeOk(
        "record Token: Linear {} fn consume(token: Token) { consume(token); } fn run(flag: bool) { let token = Token {}; flag and true; consume(token); }"
    );
    try expectAnalyzeOk(
        "record Token: Linear {} fn consume(token: Token) { consume(token); } fn run(flag: bool) { let token = Token {}; flag or false; consume(token); }"
    );
}

/// A propagated error exit must not leave an owner available.
@test fn testLinearTryPropagationChecksErrorExit() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Failure { Failed } record Token: Linear {} fn consume(token: Token) { consume(token); } fn fail() throws (Failure) { throw Failure::Failed; } fn run(token: Token) throws (Failure) { try fail(); consume(token); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::LinearNotConsumed("token"));
}

/// Propagation remains valid when the call consumes every live owner.
@test fn testLinearTryPropagationAfterConsumptionAllowed() throws (testing::TestError) {
    let program = "union Failure { Failed } record Token: Linear {} fn consume(token: Token) { consume(token); } fn fail(token: Token) throws (Failure) { consume(token); throw Failure::Failed; } fn run(token: Token) throws (Failure) { try fail(token); }";
    try expectAnalyzeOk(program);
}

/// Case-pattern fallbacks must terminate instead of synthesizing bindings.
@test 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);

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

/// A safe function may dereference an unsafe pointer inside an unsafe block.
@test fn testUnsafeBlockPointerOperationAllowed() throws (testing::TestError) {
    let program = "record Marker: Linear {} fn load(pointer: *unsafe u32) { unsafe { *pointer; } } fn run(pointer: *unsafe u32) { load(pointer); }";
    try expectAnalyzeOk(program);
}

/// An unsafe block permits calls to unsafe functions.
@test fn testUnsafeBlockCallAllowed() throws (testing::TestError) {
    let program = "unsafe fn dangerous() {} fn run() { unsafe { dangerous(); } }";
    try expectAnalyzeOk(program);
}

/// Unsafe context ends at the closing brace of an unsafe block.
@test fn testUnsafeBlockContextDoesNotLeak() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Linear {} fn load(pointer: *unsafe u32) { unsafe { *pointer; } *pointer; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
}

/// Leaving a nested unsafe block preserves the enclosing unsafe context.
@test fn testNestedUnsafeBlockPreservesContext() throws (testing::TestError) {
    let program = "record Marker: Linear {} fn load(pointer: *unsafe u32) { unsafe { unsafe { *pointer; } *pointer; } }";
    try expectAnalyzeOk(program);
}

/// Linear consumption inside an unsafe block remains visible after the block.
@test fn testUnsafeBlockPreservesLinearConsumption() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Token: Linear { Value(u32) } fn consume(token: Token) { match token { case Token::Value(value) => {} } } fn run() { let token = Token::Value(1); unsafe { consume(token); } consume(token); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(
        &result,
        super::ErrorKind::LinearUseAfterConsume("token"),
    );
}

/// Pointer arithmetic requires an unsafe context.
@test fn testPointerArithmeticRequiresUnsafe() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn advance(pointer: *u32) -> *u32 { return pointer + 1; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
}

/// An unsafe block permits pointer arithmetic.
@test fn testPointerArithmeticAllowedInUnsafeBlock() throws (testing::TestError) {
    let program = "fn advance(pointer: *u32) -> *u32 { unsafe { return pointer + 1; } }";
    try expectAnalyzeOk(program);
}

/// Unchecked slice construction requires an unsafe context.
@test fn testSliceOfRequiresUnsafe() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn make(pointer: *u32) -> *[u32] { return @sliceOf(pointer, 1); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
}

/// An unsafe block permits unchecked slice construction.
@test fn testSliceOfAllowedInUnsafeBlock() throws (testing::TestError) {
    let program = "fn make(pointer: *u32) -> *[u32] { unsafe { return @sliceOf(pointer, 1); } }";
    try expectAnalyzeOk(program);
}

/// Undefined source values require an unsafe context.
@test fn testUndefinedRequiresUnsafe() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn value() -> u32 { return undefined; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
}

/// An unsafe block permits an undefined source value.
@test fn testUndefinedAllowedInUnsafeBlock() throws (testing::TestError) {
    let program = "fn value() -> u32 { unsafe { return undefined; } }";
    try expectAnalyzeOk(program);
}

/// A safe static initializer cannot use an undefined value.
@test fn testUndefinedStaticRequiresUnsafe() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "static VALUE: u32 = undefined;");
    try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
}

/// An unsafe static initializer may use an undefined value.
@test fn testUndefinedAllowedInUnsafeStatic() throws (testing::TestError) {
    try expectAnalyzeOk("unsafe static VALUE: u32 = undefined;");
}

/// References cannot be embedded in aggregate fields.
@test fn testRefFieldRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Linear {} record Bad { value: &u32 }";
    let result = try resolveProgramStr(&mut a, program);

    let program = "record Token: Linear + Linear { value: u32 }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("Linear"));
}

/// A `Linear` marker does not change legacy pointer inference.
@test fn testLinearMarkerKeepsLegacyPointerInference() throws (testing::TestError) {
    let program = "record Marker: Linear {} fn run() { let value: u32 = 0; let pointer: *u32 = &value; pointer; }";
    try expectAnalyzeOk(program);
/// Address-of inference creates a loan that cannot be stored in a local.
@test fn testAddressOfInferenceCreatesLoan() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn run() { let value: u32 = 0; let pointer = &value; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::RefBinding);
}

/// Taking a local address cannot create an owner that escapes the function.
@test fn testAddressOfLocalCannotCreateOwner() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn bad() -> *u32 { let value: u32 = 0; return &value; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// A loan cannot be converted into an owning pointer.
@test fn testReferenceCannotBecomeOwner() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn bad(value: &u32) -> *u32 { return value; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// References are rejected from every nested or storable type position.
@test fn testNestedRefPositionsRejected() throws (testing::TestError) {
    {

}

/// Recursive cast validation cannot hide a checked-to-unsafe transition.
@test fn testNestedUnsafePointerCastRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Linear {} fn run(value: **u32) { value as **unsafe u32; }";
    let program = "record Marker: Linear {} fn run(value: &*u32) { unsafe { value as **unsafe u32; } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::InvalidAsCast(_) = err.kind
        else throw testing::TestError::Failed;
}

    let mut a = testResolver();
    let program = "record Marker: Linear {} 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);
}

/// Module-qualified statics retain one loan root across call arguments.
@test fn testScopedStaticLoanConflicts() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "loan_mut_root", "export mod values; mod app;", &mut arena);
        let valuesId = try registerModule(&mut MODULE_GRAPH, rootId, "values", "export static X: u32 = 0;", &mut arena);
        let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use loan_mut_root::values; fn both(left: &mut u32, right: &mut u32) {} fn run() { both(&mut values::X, &mut values::X); }", &mut arena);
        let result = try resolveModuleTree(&mut a, rootId);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("X"));
    } {
        let mut a = testResolver();
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "loan_shared_root", "export mod values; mod app;", &mut arena);
        let valuesId = try registerModule(&mut MODULE_GRAPH, rootId, "values", "export static X: u32 = 0;", &mut arena);
        let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use loan_shared_root::values; fn both(left: &u32, right: &mut u32) {} fn run() { both(&values::X, &mut values::X); }", &mut arena);
        let result = try resolveModuleTree(&mut a, rootId);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("X"));
    }
}

/// Distinct module-qualified statics do not overlap.
@test fn testDistinctScopedStaticLoansAllowed() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "loan_distinct_root", "export mod values; mod app;", &mut arena);
    let valuesId = try registerModule(&mut MODULE_GRAPH, rootId, "values", "export static X: u32 = 0; export static Y: u32 = 0;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use loan_distinct_root::values; fn both(left: &mut u32, right: &mut u32) {} fn run() { both(&mut values::X, &mut values::Y); }", &mut arena);
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

/// Earlier argument loans remain active inside later nested calls.
@test fn testOuterArgumentLoanConflictsWithNestedCall() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn observe(value: &u32) -> u32 { return *value; } fn pair(first: &mut u32, second: u32) {} fn run() { let mut value: u32 = 0; pair(&mut value, observe(&value)); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("value"));
    } {
        let mut a = testResolver();
        let program = "record Token: Linear { value: u32 } fn consume(token: Token) -> u32 { return consume(token); } fn pair(first: &Token, second: u32) {} fn run() { let token = Token { value: 0 }; pair(&token, consume(token)); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("token"));
    } {
        let mut a = testResolver();
        let program = "fn update(value: &mut u32) -> u32 { set *value = 1; return *value; } fn pair(first: &u32, second: u32) {} fn run() { let mut value: u32 = 0; pair(&value, update(&mut value)); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("value"));
    }
}

/// Nested later arguments may use a different root.
@test fn testNonOverlappingNestedCallArgumentsAllowed() throws (testing::TestError) {
    let program = "fn observe(value: &u32) -> u32 { return *value; } fn pair(first: &mut u32, second: u32) {} fn run() { let mut left: u32 = 0; let right: u32 = 1; pair(&mut left, observe(&right)); }";
    try expectAnalyzeOk(program);
}

/// Linear values cannot live in reusable global declarations.
@test fn testLinearGlobalsRejected() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "record Token: Linear { value: u32 } static TOKEN: Token = Token { value: 1 };";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::LinearDiscard);
    } {
        let mut a = testResolver();
        let program = "record Token: Linear { value: u32 } constant TOKEN: Token = Token { value: 1 };";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::LinearDiscard);
    }
    {
        let mut a = testResolver();
        let program = "constant TEXT: *[u8] = \"text\";";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::LinearDiscard);
    }
}

/// Function-typed unsafe statics require unsafe access like other globals.
@test fn testUnsafeFunctionStaticAccessRequiresUnsafe() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn callback() {} unsafe static CALLBACK: fn() = callback; fn run() { CALLBACK(); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
}

/// Assignments cannot overlap an earlier shared call-scoped loan.
@test fn testOuterArgumentLoanConflictsWithLaterAssignment() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Error { Fail } fn fail() -> i32 throws (Error) { return 0; } fn pair(first: &u32, second: i32) {} fn run() -> i32 { let mut value: u32 = 0; pair(&value, try fail() catch { set value = 1; return 0; }); return 0; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::BorrowConflict("value"));
}

/// Ordinary scalar globals remain reusable.
@test fn testScalarGlobalsAllowed() throws (testing::TestError) {
    try expectAnalyzeOk("static COUNT: u32 = 0; constant LIMIT: u32 = 1;");
}

/// Explicit unsafe globals may hold linear values.
@test fn testUnsafeLinearGlobalsAllowed() throws (testing::TestError) {
    let program = "record Token: Linear { value: u32 } unsafe static TOKEN: Token = Token { value: 1 }; unsafe constant TEXT: *[u8] = \"text\";";
    try expectAnalyzeOk(program);
}

/// Reading an unsafe global requires unsafe context.
@test fn testUnsafeGlobalAccessRequiresUnsafe() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "unsafe static VALUE: u32 = 0; fn read() -> u32 { return VALUE; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
}

/// Unsafe context permits reading an unsafe linear global.
@test fn testUnsafeGlobalAccessAllowedInUnsafeBlock() throws (testing::TestError) {
    let program = "unsafe constant TEXT: *[u8] = \"text\"; fn consume(value: *[u8]) { consume(value); } fn run() { unsafe { consume(TEXT); } }";
    try expectAnalyzeOk(program);
}

/// Exported unsafe globals retain their access requirement across modules.
@test fn testScopedUnsafeGlobalAccess() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "unsafe_global_root", "export mod values; mod app;", &mut arena);
        let valuesId = try registerModule(&mut MODULE_GRAPH, rootId, "values", "export unsafe static VALUE: u32 = 0;", &mut arena);
        let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use unsafe_global_root::values; fn read() -> u32 { return values::VALUE; }", &mut arena);
        let result = try resolveModuleTree(&mut a, rootId);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    } {
        let mut a = testResolver();
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "unsafe_global_ok_root", "export mod values; mod app;", &mut arena);
        let valuesId = try registerModule(&mut MODULE_GRAPH, rootId, "values", "export unsafe static VALUE: u32 = 0;", &mut arena);
        let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use unsafe_global_ok_root::values; fn read() -> u32 { unsafe { return values::VALUE; } }", &mut arena);
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    }
}

/// Identity casts do not hide duplicate or conflicting loans.
@test fn testCastWrappedLoanConflicts() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn both(left: &mut u32, right: &mut u32) {} fn run() { let mut value: u32 = 0; both(&mut value as &mut u32, &mut value); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("value"));
    } {
        let mut a = testResolver();
        let program = "fn both(left: &u32, right: &mut u32) {} fn run() { let mut value: u32 = 0; both(&value as &u32, &mut value); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("value"));
    }
}

lib/std/lang/scanner.rad +1 -1

    /// Corresponding token.
    tok: TokenKind,
}

/// Sorted keyword table for binary search.
constant KEYWORDS: [Keyword; 52] = [
unsafe constant KEYWORDS: [Keyword; 52] = [
    { name: "align", tok: TokenKind::Align },
    { name: "and", tok: TokenKind::And },
    { name: "as", tok: TokenKind::As },
    { name: "assert", tok: TokenKind::Assert },
    { name: "bool", tok: TokenKind::Bool },

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

use std::lang::strings;
use std::mem;
use std::testing;

/// String pool for testing.
static TEST_STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
unsafe static TEST_STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };

fn testScanner(source: *[u8]) -> super::Scanner {
    return super::scanner(super::SourceLoc::File("test.r"), source, &mut TEST_STRING_POOL);
}


lib/std/sys/unix.rad +46 -20

export constant STDERR: i64 = 2;

/// 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 {
/// Open a file at the given path and return a file descriptor.
/// Return a negative value on error.
///
/// The caller must ensure `path.ptr` identifies at least `path.len + 1`
/// readable bytes, that `path.ptr[path.len]` is NUL, and that those bytes
/// remain readable until the system call returns.
export unsafe 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 {
/// Open a file at the given path with mode and return a file descriptor.
///
/// The caller must ensure `path.ptr` identifies at least `path.len + 1`
/// readable bytes, that `path.ptr[path.len]` is NUL, and that those bytes
/// remain readable until the system call returns.
export unsafe 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 {
    return intrinsics::ecall(63, fd, buf.ptr as i64, buf.len as i64, 0);
    let mut result: i64 = 0;
    unsafe { set result = intrinsics::ecall(63, fd, buf.ptr as i64, buf.len as i64, 0); }
    return result;
}

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

}

/// 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 {
    return intrinsics::ecall(64, fd, buf.ptr as i64, buf.len as i64, 0);
    let mut result: i64 = 0;
    unsafe { set result = intrinsics::ecall(64, fd, buf.ptr as i64, buf.len as i64, 0); }
    return result;
}

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

}

/// Closes a file descriptor.
/// Returns `0` on success, or a negative value on error.
export fn close(fd: i64) -> i64 {
    return intrinsics::ecall(57, fd, 0, 0, 0);
    let mut result: i64 = 0;
    unsafe { set result = intrinsics::ecall(57, fd, 0, 0, 0); }
    return result;
}

/// 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] {
/// Read the entire contents of a file at the given path into the buffer.
/// Return a slice containing the data read, or `nil` on error.
///
/// The caller must ensure `path.ptr` identifies at least `path.len + 1`
/// readable bytes, that `path.ptr[path.len]` is NUL, and that those bytes
/// remain readable until this function returns.
export unsafe fn readFile(path: *[u8], buf: *mut [u8]) -> ?*[u8] {
    let fd = open(path, O_RDONLY);
    if fd < 0 {
        return nil;
    }
    let n = readToEnd(fd, buf);

    return &buf[..n as u32];
}

/// Exit the current process with the given status code.
export fn exit(status: i64) {
    intrinsics::ecall(93, status, 0, 0, 0);
    unsafe { 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 {
/// Write the entire contents of a buffer to a file at the given path.
/// Create the file if it does not exist and truncate it if it does.
/// Return `true` on success.
///
/// The caller must ensure `path.ptr` identifies at least `path.len + 1`
/// readable bytes, that `path.ptr[path.len]` is NUL, and that those bytes
/// remain readable until this function returns.
export unsafe fn writeFile(path: *[u8], data: *[u8]) -> bool {
    return writeFileParts(path, &[data]);
}

/// 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 {
/// Write each buffer to a file at the given path.
/// Create the file if it does not exist and truncate it if it does.
/// Return `true` only when every part and the final close succeed.
///
/// The caller must ensure `path.ptr` identifies at least `path.len + 1`
/// readable bytes, that `path.ptr[path.len]` is NUL, and that those bytes
/// remain readable until this function returns.
export unsafe 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 +1 -1

export fn test(module: *[u8], name: *[u8], func: 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 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");

lib/std/tests.rad +6 -2


@test fn testWriteFileParts() throws (testing::TestError) {
    let path = "/tmp/radiance-std-write-file-parts.test";
    let mut buffer: [u8; 16] = undefined;

    if not unix::writeFileParts(path, &["hello", " ", "world"]) {
    let mut wrote = false;
    unsafe { set wrote = unix::writeFileParts(path, &["hello", " ", "world"]); }
    if not wrote {
        throw testing::TestError::Failed;
    }
    let data = unix::readFile(path, &mut buffer[..]) else {
    let mut readResult: ?*[u8] = nil;
    unsafe { set readResult = unix::readFile(path, &mut buffer[..]); }
    let data = readResult else {
        throw testing::TestError::Failed;
    };
    try testing::expectBytesEq(data, "hello world");
}


lib/std/vec.rad +30 -5

}

/// 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 {
///
/// The caller must preserve the metadata invariants established by [`new`],
/// including `vec.stride > 0` and `vec.len <= capacity(vec)`. When the vector
/// has spare capacity, `elem` must point to at least `vec.stride` readable,
/// initialized bytes, and the destination range beginning at
/// `vec.len * vec.stride` in `vec.data` must be writable for `vec.stride`
/// bytes. The copy is byte-wise, so `elem` has no alignment requirement and
/// the destination need not already be initialized.
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];


/// 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 {
///
/// The caller must preserve the metadata invariants established by [`new`],
/// including `vec.stride > 0` and `vec.len <= capacity(vec)`. When the vector
/// is non-empty, `out` must point to at least `vec.stride` writable bytes, and
/// the source range for the last logical element in `vec.data` must contain
/// `vec.stride` initialized bytes. The copy is byte-wise, so `out` has no
/// alignment requirement and its previous contents need not be initialized.
export unsafe fn pop(vec: *mut RawVec, out: *mut opaque) -> bool {
    if vec.len == 0 {
        return false;
    }
    set vec.len -= 1;


}

/// 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 {
///
/// The caller must preserve the metadata invariants established by [`new`],
/// including `vec.stride > 0` and `vec.len <= capacity(vec)`. When `index` is
/// in bounds, `elem` must point to at least `vec.stride` readable, initialized
/// bytes, and the destination range beginning at `index * vec.stride` in
/// `vec.data` must be writable for `vec.stride` bytes. The copy is byte-wise,
/// so `elem` has no alignment requirement.
export unsafe 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];

    copyBytes(dst, src, vec.stride);

    return true;
}

/// Copy bytes from source to destination.
fn copyBytes(dst: *mut u8, src: *u8, count: u32) {
/// Copy `count` initialized bytes from `src` into writable storage at `dst`.
///
/// The caller must ensure both pointers are valid for `count` bytes. No
/// alignment is required because the copy operates one byte at a time.
unsafe fn copyBytes(dst: *mut u8, src: *u8, count: u32) {
    for i in 0..count {
        set *(dst + i) = *(src + i);
    }
}

seed/radiance.rv64 +0 -0

Binary file changed.

seed/radiance.rv64.git +1 -1

1		-	d024ed30c27cc671d9371988d0155b3e08ff004582cf59f1b7eac8ffdf3e3467
	1	+	1e2fdea952350036a4172f567442e608555094b9e18fa69f1fb615453d5352b6

seed/update +2 -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"
	45	+	OPTS="${OPTS} -mod compiler/radiance/codegenSink.rad -entry radiance"
45	46
46	47		# ---------------------------------------------------------------------------
47	48		# Emulator settings
48	49		# ---------------------------------------------------------------------------
49	50

std.lib.test +1 -0

lib/std/char/tests.rad
lib/std/arch/rv64/tests.rad
lib/std/arch/rv64/asm/tests.rad
lib/std/arch/rv64/asm/scanner/tests.rad
lib/std/lang/alloc/tests.rad
lib/std/lang/il/tests.rad
lib/std/lang/parser/tests.rad
lib/std/lang/module/tests.rad
lib/std/lang/scanner/tests.rad
lib/std/lang/resolver/tests.rad
lib/std/lang/gen/bitset/tests.rad

test/runner.rad +38 -27

/// Arena size for AST/IL allocations (512 KB).
constant ARENA_SIZE: u32 = 524288;
/// Maximum path length for expected IL file path.
constant MAX_PATH_LEN: u32 = 256;
/// Source file extension for binary tests.
constant SOURCE_EXT: *[u8] = ".rad";
unsafe constant SOURCE_EXT: *[u8] = ".rad";
/// IL snapshot file extension for binary tests.
constant SNAPSHOT_EXT: *[u8] = ".ril";
unsafe constant SNAPSHOT_EXT: *[u8] = ".ril";

/// String pool.
static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
unsafe static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };

/// Maximum number of AST nodes per test file.
constant MAX_NODE_DATA: u32 = 4096;
/// Maximum number of resolver errors per test file.
constant MAX_ERRORS: u32 = 16;

/// Maximum number of data bytes in a `.ras` test binary.
constant ASM_DATA_CAPACITY: u32 = 1024;

// Static storage for large buffers to avoid stack overflow.
// Tests run serially so sharing these is safe.
static SOURCE_BUF: [u8; SOURCE_BUF_SIZE] = undefined;
static EXPECTED_BUF: [u8; EXPECTED_BUF_SIZE] = undefined;
static OUTPUT_BUF: [u8; OUTPUT_BUF_SIZE] = undefined;
static AST_ARENA_STORAGE: [u8; ARENA_SIZE] = undefined;
static IL_ARENA_STORAGE: [u8; ARENA_SIZE] = undefined;
static PRINT_ARENA_STORAGE: [u8; ARENA_SIZE] = undefined;
static RESOLVER_ARENA_STORAGE: [u8; ARENA_SIZE] = undefined;
static NODE_DATA_STORAGE: [resolver::NodeData; MAX_NODE_DATA] = undefined;
static ERROR_STORAGE: [resolver::Error; MAX_ERRORS] = undefined;
static ASM_TEXT_STORAGE: [u32; ASM_TEXT_CAPACITY] = undefined;
static ASM_DATA_STORAGE: [u8; ASM_DATA_CAPACITY] = undefined;
unsafe static SOURCE_BUF: [u8; SOURCE_BUF_SIZE] = undefined;
unsafe static EXPECTED_BUF: [u8; EXPECTED_BUF_SIZE] = undefined;
unsafe static OUTPUT_BUF: [u8; OUTPUT_BUF_SIZE] = undefined;
unsafe static AST_ARENA_STORAGE: [u8; ARENA_SIZE] = undefined;
unsafe static IL_ARENA_STORAGE: [u8; ARENA_SIZE] = undefined;
unsafe static PRINT_ARENA_STORAGE: [u8; ARENA_SIZE] = undefined;
unsafe static RESOLVER_ARENA_STORAGE: [u8; ARENA_SIZE] = undefined;
unsafe static NODE_DATA_STORAGE: [resolver::NodeData; MAX_NODE_DATA] = undefined;
unsafe static ERROR_STORAGE: [resolver::Error; MAX_ERRORS] = undefined;
unsafe static ASM_TEXT_STORAGE: [u32; ASM_TEXT_CAPACITY] = undefined;
unsafe static ASM_DATA_STORAGE: [u8; ASM_DATA_CAPACITY] = undefined;

/// Strip a `//` comment from a line, preserving `//` inside quoted strings.
/// Returns the content before the comment, trimmed of trailing whitespace.
fn stripLine(line: *[u8]) -> *[u8] {
unsafe fn stripLine(line: *[u8]) -> *[u8] {
    let mut end = line.len;
    let mut i: u32 = 0;
    let mut inString = false;
    let mut escaped = false;


    }
    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] {
unsafe 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;

    }
    return line;
}

/// Compare two strings ignoring comments, line by line.
fn stringsEqual(a: *[u8], b: *[u8]) -> bool {
unsafe fn stringsEqual(a: *[u8], b: *[u8]) -> bool {
    let mut ai: u32 = 0;
    let mut bi: u32 = 0;

    while ai < a.len or bi < b.len {
        let mut aLine = "";

    }
    return true;
}

/// Print diff between expected and actual output.
fn printDiff(expected: *[u8], actual: *[u8]) {
unsafe fn printDiff(expected: *[u8], actual: *[u8]) {
    io::printLn("\n// Expected");
    io::print(expected);
    io::print("\n");

    io::printLn("// Actual");

}

/// 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] {
unsafe fn deriveRilPath(sourcePath: *[u8], buf: *mut [u8]) -> ?*[u8] {
    let len = sourcePath.len;
    if len < SOURCE_EXT.len {
        return nil;
    }
    let extStart = len - SOURCE_EXT.len;


    return &buf[..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 codeBytes = @sliceOf(code.ptr as *u8, code.len * rv64::INSTR_SIZE as u32);

    return unix::writeFileParts(path, &[headerBytes, codeBytes, roData, rwData]);
    let mut success = false;
    unsafe {
        set success = unix::writeFileParts(path, &[headerBytes, codeBytes, roData, rwData]);
    }
    return success;
}

fn assembleBinary(sourcePath: *[u8], outputPath: *[u8]) -> bool {
    let source = unix::readFile(sourcePath, &mut SOURCE_BUF[..]) else {
/// Assemble one source file and write its RV64 image.
unsafe fn assembleBinary(sourcePath: *[u8], outputPath: *[u8]) -> bool {
    let mut sourceResult: ?*[u8] = nil;
    unsafe { set sourceResult = unix::readFile(sourcePath, &mut SOURCE_BUF[..]); }
    let source = sourceResult else {
        io::printError("error: could not read source: ");
        io::printError(sourcePath);
        io::printError("\n");
        return false;
    };

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

    // Derive .ril path from source path.

        io::printLn(sourcePath);
        return false;
    };

    // Read expected IL.
    let expected = unix::readFile(rilPath, &mut EXPECTED_BUF[..]) else {
    let mut expectedResult: ?*[u8] = nil;
    unsafe { set expectedResult = unix::readFile(rilPath, &mut EXPECTED_BUF[..]); }
    let expected = expectedResult else {
        io::print("error: could not read expected IL: ");
        io::printLn(rilPath);
        return false;
    };

    // Read source file.
    let source = unix::readFile(sourcePath, &mut SOURCE_BUF[..]) else {
    let mut sourceResult: ?*[u8] = nil;
    unsafe { set sourceResult = unix::readFile(sourcePath, &mut SOURCE_BUF[..]); }
    let source = sourceResult else {
        io::print("error: could not read source: ");
        io::printLn(sourcePath);
        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 +2 -2

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 {
    return &arr[idx];
unsafe fn addressOfRecord(arr: [Point; 3], idx: u32) -> *Point {
    return &arr[idx] as *Point;
}

/// Array of arrays (16 bytes per element).
fn arrayOfArrays(arr: [[i32; 4]; 3], idx: u32) -> i32 {
    return arr[idx][0];

test/tests/array.slice.empty.rad +1 -1

//! returns: 0
fn length(slice: *[u8]) -> u32 {
fn length(slice: &[u8]) -> u32 {
  return slice.len;
}

@default fn main() -> u32 {
  return length(&[]);

test/tests/array.slice.full.rad +2 -2

1	1		/// Creates a slice from an array with full range.
2		-	fn sliceFull(a: [i32; 4]) -> *[i32] {
3		-	return &a[..];
	2	+	unsafe fn sliceFull(a: [i32; 4]) -> *[i32] {
	3	+	return &a[..] as *[i32];
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: *[i32] = &arr[..2] as *[i32];

    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: *[i32] = &arr[1..] as *[i32];

    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: *[i32] = &arr[..] as *[i32];

    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: *[i32] = &arr[1..3] as *[i32];

    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: *[i32] = &arr[2..] as *[i32];

    return 0;
}

test/tests/array.slice.openend.rad +2 -2

1	1		/// Creates a slice from an array with open end bound.
2		-	fn sliceOpenEnd(a: [i32; 4], start: u32) -> *[i32] {
3		-	return &a[start..];
	2	+	unsafe fn sliceOpenEnd(a: [i32; 4], start: u32) -> *[i32] {
	3	+	return &a[start..] as *[i32];
4	4		}

test/tests/array.slice.openstart.rad +2 -2

1	1		/// Creates a slice from an array with open start bound.
2		-	fn sliceOpenStart(a: [i32; 4], end: u32) -> *[i32] {
3		-	return &a[..end];
	2	+	unsafe fn sliceOpenStart(a: [i32; 4], end: u32) -> *[i32] {
	3	+	return &a[..end] as *[i32];
4	4		}

test/tests/array.slice.rad +5 -5

//! 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: *[i32] = &arr[..] as *[i32];
    let slice2: *[i32] = &arr[1..4] as *[i32];
    let slice3: *[i32] = &arr[..3] as *[i32];
    let slice4: *[i32] = &arr[2..] as *[i32];

    assert slice1.len == 5;
    assert slice2.len == 3;
    assert slice3.len == 3;
    assert slice4.len == 3;

test/tests/asm.rodata.prefix.rad +1 -1

//! returns: 0

fn asmDataValue() -> i32;

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let s = "hello";

    assert s.len == 5;
    assert s[0] == 'h' as u8;
    assert s[4] == 'o' as u8;

test/tests/average.rad +1 -1

/// Compute the sum of a list of numbers.
fn average(numbers: *[u32]) -> u32 {
fn average(numbers: &[u32]) -> u32 {
    let mut sum: u32 = 0;

    for i in numbers {
        set sum += i;
    }

test/tests/bool.comparison.slice.rad +46 -46

1	1		//! returns: 0
2		-	fn memEq(a: [u8], b: [u8]) -> bool {
	2	+	unsafe 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 sliceI32(input: *[i32]) -> *[i32] {
    return input;
}

fn sliceEqualU32(a: *[u32], b: *[u32]) -> bool {
unsafe 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 {
unsafe 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] {

41	41		}
42	42		}
43	43		return true;
44	44		}
45	45
46		-	fn sliceEqual1() -> bool {
	46	+	unsafe fn sliceEqual1() -> bool {
47	47		let a1: [u32; 3] = [9, 42, 3];
48	48
49		-	let s1: *[u32] = &a1[..];
50		-	let s2: *[u32] = &a1[..];
	49	+	let s1: [u32] = &a1[..] as [u32];
	50	+	let s2: [u32] = &a1[..] as [u32];
51	51
52	52		return s1 == s2 and sliceEqualU32(s1, s2);
53	53		}
54	54
55		-	fn sliceEqual2() -> bool {
	55	+	unsafe fn sliceEqual2() -> bool {
56	56		let a1: [u32; 3] = [9, 42, 3];
57	57
58		-	let s1: *[u32] = &a1[1..];
59		-	let s2: *[u32] = &a1[1..];
	58	+	let s1: [u32] = &a1[1..] as [u32];
	59	+	let s2: [u32] = &a1[1..] as [u32];
60	60
61	61		return s1 == s2 and sliceEqualU32(s1, s2);
62	62		}
63	63
64		-	fn sliceEqual3() -> bool {
	64	+	unsafe fn sliceEqual3() -> bool {
65	65		let a1: [u32; 3] = [9, 42, 3];
66	66
67		-	let s1: *[u32] = &a1[..1];
68		-	let s2: *[u32] = &a1[..1];
	67	+	let s1: [u32] = &a1[..1] as [u32];
	68	+	let s2: [u32] = &a1[..1] as [u32];
69	69
70	70		return s1 == s2 and sliceEqualU32(s1, s2);
71	71		}
72	72
73		-	fn sliceEqual4() -> bool {
	73	+	unsafe fn sliceEqual4() -> bool {
74	74		let a1: [u32; 3] = [9, 42, 3];
75	75
76		-	let s1: *[u32] = &a1[2..];
77		-	let s2: *[u32] = &a1[2..];
	76	+	let s1: [u32] = &a1[2..] as [u32];
	77	+	let s2: [u32] = &a1[2..] as [u32];
78	78
79	79		return s1 == s2 and sliceEqualU32(s1, s2);
80	80		}
81	81
82		-	fn sliceNotEqualSameArray1() -> bool {
	82	+	unsafe fn sliceNotEqualSameArray1() -> bool {
83	83		let a1: [u32; 3] = [42, 8, 3];
84	84
85		-	let s1: *[u32] = &a1[..2];
86		-	let s2: *[u32] = &a1[1..3];
	85	+	let s1: [u32] = &a1[..2] as [u32];
	86	+	let s2: [u32] = &a1[1..3] as [u32];
87	87
88	88		return s1 <> s2 and not sliceEqualU32(s1, s2);
89	89		}
90	90
91		-	fn sliceNotEqualSameArray2() -> bool {
	91	+	unsafe fn sliceNotEqualSameArray2() -> bool {
92	92		let a1: [u32; 3] = [42, 8, 3];
93	93
94		-	let s1: *[u32] = &a1[..2];
95		-	let s2: *[u32] = &a1[..3];
	94	+	let s1: [u32] = &a1[..2] as [u32];
	95	+	let s2: [u32] = &a1[..3] as [u32];
96	96
97	97		return s1 <> s2 and not sliceEqualU32(s1, s2);
98	98		}
99	99
100		-	fn sliceEqualDifferentArray() -> bool {
	100	+	unsafe fn sliceEqualDifferentArray() -> bool {
101	101		let a1: [u32; 3] = [42, 8, 3];
102	102		let a2: [u32; 3] = [42, 8, 3];
103	103
104		-	let s1: *[u32] = &a1[..];
105		-	let s2: *[u32] = &a2[..];
	104	+	let s1: [u32] = &a1[..] as [u32];
	105	+	let s2: [u32] = &a2[..] as [u32];
106	106
107	107		return sliceEqualU32(s1, s2) and s1 <> s2;
108	108		}
109	109
110		-	fn sliceEqualString1() -> bool {
	110	+	unsafe fn sliceEqualString1() -> bool {
111	111		let s1: *[u8] = "ABC";
112	112		let s2: *[u8] = "ABC";
113	113
114	114		return memEq(s1, s2);
115	115		}
116	116
117		-	fn sliceEqualString2() -> bool {
	117	+	unsafe fn sliceEqualString2() -> bool {
118	118		let s1: *[u8] = "ABC";
119	119		let s2: *[u8] = "DEF";
120	120
121	121		return not memEq(s1, s2);
122	122		}
123	123
124		-	fn sliceEqualString3() -> bool {
	124	+	unsafe fn sliceEqualString3() -> bool {
125	125		let a1: [u8; 3] = ['A', 'B', 'C'];
126		-	let s1: *[u8] = &a1[..];
	126	+	let s1: [u8] = &a1[..] as [u8];
127	127		let s2: *[u8] = "ABC";
128	128
129	129		return memEq(s1, s2)
130	130		and memEq(s1, "ABC")
131		-	and memEq(&a1[..], "ABC");
	131	+	and memEq(&a1[..] as *[u8], "ABC");
132	132		}
133	133
134		-	fn sliceEqualString4() -> bool {
	134	+	unsafe fn sliceEqualString4() -> bool {
135	135		let s1: *[u8] = "ABC";
136		-	let s2: *[u8] = &['A', 'B', 'C'];
	136	+	let s2: [u8] = &['A', 'B', 'C'] as [u8];
137	137
138	138		return memEq(s1, s2);
139	139		}
140	140
141		-	fn sliceEqualString5() -> bool {
	141	+	unsafe fn sliceEqualString5() -> bool {
142	142		let s1: *[u8] = "ABC";
143	143
144	144		// Sub-slicing a slice currently trips a separate compiler bug.
145	145		// Keep this check focused on slice equality behavior itself.
146	146		return memEq(s1, "ABC");
147	147		}
148	148
149		-	fn sliceNotEqualU8() -> bool {
	149	+	unsafe fn sliceNotEqualU8() -> bool {
150	150		let a: [u8; 3] = [1, 2, 3];
151	151		let b: [u8; 3] = [1, 2, 4];
152		-	let s: *[u8] = &[1, 2, 3];
	152	+	let s: [u8] = &[1, 2, 3] as [u8];
153	153
154		-	return not memEq(s, &[1, 2, 4])
155		-	and not memEq(s, &[1, 0, 3])
	154	+	return not memEq(s, &[1, 2, 4] as *[u8])
	155	+	and not memEq(s, &[1, 0, 3] as *[u8])
156	156		and not memEq("ABC", "ABCD")
157	157		and not memEq("ABC", "ABD")
158		-	and not memEq(&a[..], &a[1..])
159		-	and not memEq(&a[..], &b[..])
160		-	and not memEq(&a[..], &[1, 3, 3]);
	158	+	and not memEq(&a[..] as [u8], &a[1..] as [u8])
	159	+	and not memEq(&a[..] as [u8], &b[..] as [u8])
	160	+	and not memEq(&a[..] as [u8], &[1, 3, 3] as [u8]);
161	161		}
162	162
163		-	fn sliceNotEqualU16() -> bool {
	163	+	unsafe fn sliceNotEqualU16() -> bool {
164	164		let a: [u16; 3] = [1, 2, 3];
165	165		let b: [u16; 3] = [1, 2, 4];
166		-	let s: *[u16] = &[1, 2, 3];
	166	+	let s: [u16] = &[1, 2, 3] as [u16];
167	167
168		-	return s <> &[1, 2, 4]
169		-	and s <> &[1, 0, 3]
	168	+	return s <> &[1, 2, 4] as *[u16]
	169	+	and s <> &[1, 0, 3] as *[u16]
170	170		and &a[..] <> &a[1..]
171	171		and &a[..] <> &b[..]
172	172		and &a[..] <> &[1, 3, 3];
173	173		}
174	174
175		-	fn sliceReturnEqual() -> bool {
	175	+	unsafe fn sliceReturnEqual() -> bool {
176	176		return memEq(sliceU8("ABC"), "ABC")
177		-	and sliceEqualI32(sliceI32(&[1, 2, 3]), &[1, 2, 3]);
	177	+	and sliceEqualI32(sliceI32(&[1, 2, 3] as [i32]), &[1, 2, 3] as [i32]);
178	178		}
179	179
180		-	@default fn main() -> i32 {
	180	+	@default unsafe fn main() -> i32 {
181	181		assert sliceEqual1();
182	182		assert sliceEqual2();
183	183		assert sliceEqual3();
184	184		assert sliceEqual4();
185	185		assert sliceEqualString1();

test/tests/bool.comparison.slice.record.gen.rad +15 -15


record Line {
    points: *[Point],
}

fn pointsEqual(a: *[Point], b: *[Point]) -> bool {
unsafe 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 {
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[..]);
    return pointsEqual(&a[..] as *[Point], &b[..] as *[Point]);
}

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[..]);
    return not pointsEqual(&a[..] as *[Point], &b[..] as *[Point]);
}

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[..]);
    return not pointsEqual(&a[..] as *[Point], &b[..] as *[Point]);
}

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[..] };
    let line1: Line = Line { points: &pts1[..] as *[Point] };
    let line2: Line = Line { points: &pts2[..] as *[Point] };

    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[..] };
    let line1: Line = Line { points: &pts1[..] as *[Point] };
    let line2: Line = Line { points: &pts2[..] as *[Point] };

    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 +16 -16

union Shape {
    points(*[Point]),
    sizes(*[Size]),
}

fn pointsEqual(a: *[Point], b: *[Point]) -> bool {
unsafe 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 {
unsafe 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 false;

        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[..]);
    let s1: Shape = Shape::points(&pts1[..] as *[Point]);
    let s2: Shape = Shape::points(&pts2[..] as *[Point]);

    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[..]);
    let s1: Shape = Shape::points(&pts1[..] as *[Point]);
    let s2: Shape = Shape::points(&pts2[..] as *[Point]);

    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[..]);
    let s1: Shape = Shape::sizes(&sizes1[..] as *[Size]);
    let s2: Shape = Shape::sizes(&sizes2[..] as *[Size]);

    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[..]);
    let s1: Shape = Shape::points(&pts[..] as *[Point]);
    let s2: Shape = Shape::sizes(&sizes[..] as *[Size]);

    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 +2 -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 ptr: *i32 = &arr[0] as *i32;
    let slice: *[i32] = @sliceOf(ptr, 4, 3);

    return slice.len as i32;
}

test/tests/builtin.sliceof.mut.rad +2 -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: *mut i32 = &mut arr[0] as *mut i32;

    // Create a mutable slice from the pointer and length
    let slice: *mut [i32] = @sliceOf(ptr, 4);

    // Double each element via the slice

test/tests/builtin.sliceof.rad +2 -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: *i32 = &arr[0] as *i32;

    // Create a slice from the pointer and length
    let slice: *[i32] = @sliceOf(ptr, 4);

    // Access elements via the slice and sum them

test/tests/byte.load.store.rad +4 -4

// Test byte-level load and store operations (W8)

fn loadByte(ptr: *u8) -> u8 {
unsafe fn loadByte(ptr: *u8) -> u8 {
    return *ptr;
}

fn storeByte(ptr: *mut u8, val: u8) {
unsafe fn storeByte(ptr: *mut u8, val: u8) {
    set *ptr = val;
}

fn loadStoreByte(src: *u8, dst: *mut u8) {
unsafe fn loadStoreByte(src: *u8, dst: *mut u8) {
    set *dst = *src;
}

fn byteArrayAccess(arr: [u8; 4], idx: u32) -> u8 {
    return arr[idx];
}

fn byteSliceAccess(slice: *[u8], idx: u32) -> u8 {
unsafe fn byteSliceAccess(slice: *[u8], idx: u32) -> u8 {
    return slice[idx];
}

test/tests/call.aggregate.arg.snapshot.rad +1 -1

record Pair {
    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 +4 -4

//! returns: 0
//! Test that values live across function calls are not clobbered.
fn modify(counter: *mut i32, ret: bool) -> bool {
unsafe fn modify(counter: *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);
    let r: bool = modify(&mut x as *mut i32, false);
    assert x == 1;
    assert not r;

    // Pointer live across call.
    let mut y: i32 = 42;
    let p: *mut i32 = &mut y;
    let p: *mut i32 = &mut y as *mut i32;
    let r2: bool = modify(p, true);
    assert *p == 43;
    assert r2;
    return 0;
}

test/tests/cast.basic.rad +1 -1

fn i32ToI16(x: i32) -> i16 {
    return x as i16;
}

/// Cast pointer types (same size, no instruction).
fn ptrCast(x: *u8) -> *i32 {
unsafe fn ptrCast(x: *u8) -> *i32 {
    return x as *i32;
}

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: *mut i32 = &mut val as *mut i32;
    set *p += 50;
    assert val == 150;

    // Test chained compound assignments.
    let mut x: i32 = 1;

test/tests/cond.iflet.optional.rad +1 -1

// Returns 1 when the optional pointer is present, otherwise returns 0.
fn ifLetOptional(p: ?*i32) -> i32 {
unsafe fn ifLetOptional(p: ?*i32) -> i32 {
    if let x = p {
        return 1;
    } else {
        return 0;
    }

test/tests/cond.letelse.optional.rad +1 -1

// Returns 1 when the optional pointer is present, otherwise returns 0.
fn letElseOptional(p: ?*i32) -> i32 {
unsafe fn letElseOptional(p: ?*i32) -> i32 {
    let x = p else { return 0; };
    return 1;
}

test/tests/cond.match.guard.regalloc.rad +6 -6

    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]]) -> *[*[u8]] {
    let mut out: *[*[u8]] = &[] as *[*[u8]];

    match node.kind {
        case Kind::Name(name) if name.len > 0 => {
            set buf[0] = name;
            set out = &buf[..1];
            set out = &buf[..1] as *[*[u8]];
        }
        case Kind::Pair { a, b } => {
            set out = &buf[..1];
            set out = &buf[..1] as *[*[u8]];
        }
        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;
    let path = getPath(&n, &mut buffer[..]);
    let path = getPath(&n as *Node, &mut buffer[..] as *mut [*[u8]]);

    let pathLen = path.len as i32;
    assert pathLen <= 1;
    assert pathLen > 0;


test/tests/const-expr-array-size.rad +2 -2


constant ROWS: u32 = 3;
constant COLS: u32 = 4;
constant TOTAL: u32 = ROWS * COLS;

static DATA: [i32; TOTAL] = undefined;
unsafe static DATA: [i32; TOTAL] = undefined;

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    // Verify the array has the expected length.
    if DATA.len <> 12 { return 1; }
    return 0;
}

test/tests/const-expr-cast.rad +2 -2

constant SHIFTED: u64 = 4 as u64;

// Chained casts.
constant LEN: u32 = 8;
constant LEN2: u32 = (LEN as u64) as u32;
static BUF: [u8; LEN2] = undefined;
unsafe static BUF: [u8; LEN2] = undefined;

// Cast of unsuffixed literal arithmetic.
constant E: u32 = (3 + 4) as u32;
// Nested casts of literal arithmetic.
constant F: u32 = ((3 + 4) as u64) as u32;

// Typed constant * typed constant through cast.
constant X: u8 = 3;
constant Y: u8 = 4;
constant Z: i32 = (X as i32) * (Y as i32);

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    assert BUF.len == 8;
    assert WIDE == 255;
    assert Z == 12;
    assert E == 7;
    assert F == 7;

test/tests/const-expr-literal.rad +3 -3

constant E: u32 = 2 * 3 + 4;
// Unary negation with literal.
constant F: i32 = -5;
constant G: i32 = F * 2;

static BUF: [u8; A] = undefined;
static BUF2: [u8; C] = undefined;
unsafe static BUF: [u8; A] = undefined;
unsafe static BUF2: [u8; C] = undefined;

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    assert A == 16;
    assert BUF.len == 16;
    assert C == 20;
    assert BUF2.len == 20;
    assert D == 10;

test/tests/const.array.repeat.string.slice.rad +2 -2

//! returns: 0
/// Repeated string slices in constant arrays must emit complete slice headers.
constant WORDS: [*[u8]; 2] = ["abc"; 2];
unsafe constant WORDS: [*[u8]; 2] = ["abc"; 2];

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    assert WORDS[0].len == 3;
    assert WORDS[1].len == 3;
    assert WORDS[0][0] == 'a';
    assert WORDS[1][2] == 'c';
    return 0;

test/tests/const.array.strings.slice.rad +2 -2

/// Const array of string slices lowers to slice headers (sym+len+padding)
/// and reuses deduplicated string storage.
constant WORDS: [*[u8]; 3] = [
unsafe constant WORDS: [*[u8]; 3] = [
    "apple",
    "pencil",
    "apple",
];

fn totalLen() -> u32 {
unsafe fn totalLen() -> u32 {
    return WORDS[0].len + WORDS[1].len + WORDS[2].len;
}

test/tests/const.record.union.rad +2 -2

record Keyword {
    name: *[u8],
    tok: TokenKind,
}

constant KEYWORDS: [Keyword; 3] = [
unsafe constant KEYWORDS: [Keyword; 3] = [
    Keyword { name: "fn", tok: TokenKind::Fn },
    Keyword { name: "let", tok: TokenKind::Let },
    Keyword { name: "if", tok: TokenKind::If },
];

fn getFirstTag() -> i32 {
unsafe fn getFirstTag() -> i32 {
    match KEYWORDS[0].tok {
        case TokenKind::Fn => return 0,
        case TokenKind::Let => return 1,
        case TokenKind::If => return 2,
    }

test/tests/const.slice.of.slices.rad +2 -2

/// Const nested slices should lower through generic constant `&[...]` support.
constant GROUPS: [*[*[u8]]; 2] = [
unsafe constant GROUPS: [*[*[u8]]; 2] = [
    &["ab", "cd"],
    &["efg"],
];

fn totalLen() -> u32 {
unsafe fn totalLen() -> u32 {
    return GROUPS[0].len + GROUPS[1].len + GROUPS[0][1].len;
}

test/tests/const.slice.param.rad +4 -5

//! returns: 36

constant DATA: [i32; 4] = [3, 5, 7, 9];

fn sumPair(slice: *[i32]) -> i32 {
fn sumPair(slice: &[i32]) -> i32 {
    return slice[0] + slice[1];
}

@default fn main() -> i32 {
    let all: *[i32] = &DATA[..];
    let head: i32 = sumPair(all);
    let tail: i32 = sumPair(&all[2..]);
    let mid: i32 = sumPair(&all[1..3]);
    let head: i32 = sumPair(&DATA[..]);
    let tail: i32 = sumPair(&DATA[2..]);
    let mid: i32 = sumPair(&DATA[1..3]);

    return head + tail + mid;
}

test/tests/const.string.rad +2 -2

/// Test string constant lowering.
constant HELLO: *[u8] = "hello";
unsafe constant HELLO: *[u8] = "hello";

fn getLen() -> u32 {
unsafe fn getLen() -> u32 {
    return HELLO.len;
}

test/tests/const.string.scoped.names.rad +4 -4

/// Backing string symbols should be declaration-scoped.
constant HELLO1: *[u8] = "hello";
constant HELLO2: *[u8] = "hello";
constant MSGS: [*[u8]; 2] = ["hello", "world"];
unsafe constant HELLO1: *[u8] = "hello";
unsafe constant HELLO2: *[u8] = "hello";
unsafe constant MSGS: [*[u8]; 2] = ["hello", "world"];

fn totalLen() -> u32 {
unsafe fn totalLen() -> u32 {
    return HELLO1.len + HELLO2.len + MSGS[0].len + MSGS[1].len;
}

test/tests/const.union.payload.record.array.rad +2 -2

record Entry {
    name: *[u8],
    spec: InstrSpec,
}

constant ENTRIES: [Entry; 4] = [
unsafe constant ENTRIES: [Entry; 4] = [
    Entry { name: "empty", spec: InstrSpec::Empty },
    Entry { name: "small", spec: InstrSpec::Small { flag: true } },
    Entry { name: "addi", spec: InstrSpec::Imm { opcode: 0x13, funct3: 0, imm: -7 } },
    Entry { name: "add", spec: InstrSpec::Reg { opcode: 0x33, funct3: 0, funct7: 0 } },
];

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    match ENTRIES[0].spec {
        case InstrSpec::Empty => {}
        else => return 1,
    }
    assert ENTRIES[0].name[0] == 'e';

test/tests/data.simple.rad +2 -2

//! returns: 0
//! Simple test for data symbol access.
constant DATA: [u8; 4] = [10, 20, 30, 40];

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    if DATA[0] == 10 and
       DATA[1] == 20 and
       DATA[2] == 30 and
       DATA[3] == 40 and DATA.len == 4 {
        let ptr = &DATA[..];
        let ptr = &DATA[..] as *[u8];

        if ptr[0] == 10 and
           ptr[1] == 20 and
           ptr[2] == 30 and
           ptr[3] == 40 and ptr.len == 4 {

test/tests/ecall.i64.rad +8 -2

//! returns: 0

@intrinsic fn ecall(number: u32, arg1: i64, arg2: i64, arg3: i64, arg4: i64) -> i64;
/// Issue a raw environment call for this intrinsic ABI test.
///
/// The caller must satisfy the selected system call's ABI, including every
/// memory extent represented by an integer argument.
@intrinsic unsafe fn ecall(number: u32, arg1: i64, arg2: i64, arg3: i64, arg4: i64) -> i64;

/// Test that ecall can pass and return i64 values.
@default fn main() -> i32 {
///
/// The execution environment must provide writable standard output.
@default unsafe fn main() -> i32 {
    // ecall(64, fd, buf, len, 0) = write(fd, buf, len).
    let msg: *[u8] = "ok\n";

    // Write to stdout. The pointer is passed as i64.
    let n = ecall(64, 1, msg.ptr as i64, msg.len as i64, 0);

test/tests/edge.cases.2.rad +2 -2


export record Scanner {
    source: *[u8],
}

fn peek(s: *Scanner) -> ?u8 {
fn peek(s: &Scanner) -> ?u8 {
    if 0 + 0 >= s.source.len {
        return nil;
    }
    return 'a';
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let s: Scanner = Scanner { source: "xyz" };

    if let z = peek(&s) {
        return 0;
    }

test/tests/edge.cases.3.rad +4 -4

export record Scanner {
    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];
}

@default fn main() -> u8 {
@default unsafe fn main() -> u8 {
    let s: Scanner = Scanner { source: "abc", cursor: 0 };
    if let c = current(&s) {
        return c;
    }
    return 1;

test/tests/edge.cases.4.rad +4 -4


record Node {
    value: NodeValue,
}

fn node(nodes: *mut Node, count: *mut u32, value: NodeValue) -> *Node {
unsafe fn node(nodes: *mut Node, count: &mut u32, value: NodeValue) -> *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: *mut Node, count: &mut u32, width: u8, sign: Signedness) -> *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: *mut Node = &mut nodes[0] as *mut Node;
    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.6.rad +8 -8

25	25		}
26	26
27	27		record Analyzer {
28	28		pad0: u32,
29	29		pad1: u32,
30		-	entries: *mut [Entry],
	30	+	entries: *unsafe mut [Entry],
31	31		len: u32,
32	32		}
33	33
34	34		static STORAGE: [Entry; 2] = [
35	35		Entry { a: 0, b: 0, c: 0, d: 0, e: 0, f: 0, g: 0, h: 0, i: 0, j: 0, k: 0, l: 0, m: 0, n: 0, o: 0, p: 0, q: 0, r: 0, s: 0, t: 0 },

    q: 0x1234560C,
    r: 0x1234560D,
    s: 0x1234560E,
    t: 0x1234560F,
};
static ANALYZER: Analyzer = undefined;
unsafe static ANALYZER: Analyzer = undefined;

fn fillEntry(out: *mut Entry) {
unsafe fn fillEntry(out: *mut Entry) {
    set *out = DEFAULT_ENTRY;
}

fn mkEntry() -> Entry {
    return DEFAULT_ENTRY;

        return nil;
    }
    return mkEntry();
}

fn init(entries: *mut [Entry]) {
unsafe fn init(entries: *unsafe mut [Entry]) {
    set ANALYZER = Analyzer {
        pad0: 0xDEADAAA0,
        pad1: 0xDEADAAA1,
        entries,
        len: 0,
    };
}

fn add() {
unsafe fn add() {
    let idx = ANALYZER.len;
    let entry = mkOptEntry(true) else {
        return;
    };
    set ANALYZER.entries[idx] = entry;
    set ANALYZER.len = idx + 1;
}

fn checkHeader(expected: *[Entry]) -> i32 {
unsafe fn checkHeader(expected: *unsafe [Entry]) -> i32 {
    if ANALYZER.entries.ptr <> expected.ptr or ANALYZER.entries.len <> expected.len {
        // Slice header got clobbered instead of the backing storage.
        return 1;
    }
    if ANALYZER.len <> 1 {

        return 3;
    }
    return 0;
}

@default fn main() -> i32 {
    let target = &mut STORAGE[..];
@default unsafe fn main() -> i32 {
    let target = &mut STORAGE[..] as *unsafe mut [Entry];
    init(target);
    add();
    return checkHeader(target);
}

test/tests/edge.cases.7.addr.bug.rad +4 -4

//! returns: 42

record PtrHolder {
    ptr: *mut i32,
    ptr: *unsafe mut i32,
}

static target: i32 = 10;
static holder: PtrHolder = undefined;
unsafe static holder: PtrHolder = undefined;

@default fn main() -> i32 {
    set holder.ptr = &mut target;
@default unsafe fn main() -> i32 {
    set holder.ptr = &mut target as *unsafe mut i32;
    set *holder.ptr = 42;

    return target;
}

test/tests/edge.cases.8.bug.rad +2 -2

record Outer {
    padding: i32,
    inner: Inner,
}

static global: Outer = undefined;
unsafe static global: Outer = undefined;

fn readInner(i: Inner) -> i32 {
    return i.value;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    set global = Outer { padding: 0, inner: Inner { value: 42 } };

    assert readInner(global.inner) == 42;
    return 0;
}

test/tests/edge.cases.rad +2 -2


export record Scanner {
    source: *[u8],
}

fn peek(s: *Scanner)  -> i32 {
fn peek(s: &Scanner)  -> i32 {
    assert 0 + 0 <= s.source.len;
    return 0;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let s: Scanner = Scanner { source: "1" };
    return peek(&s);
}

test/tests/error.catch.rad +4 -4

//! returns: 0

union TestError { Fail }
static PTR_VALUE: i32 = 7;

@default fn main() -> u32 {
@default unsafe fn main() -> u32 {
    // Catch block with early return
    let val1: u32 = catchWithReturn(true);
    assert val1 == 42;

    // Catch block with early return (success case)


fn returnsErr() -> u32 throws (TestError) {
    throw TestError::Fail;
}

fn returnsPtrOk() -> *i32 throws (TestError) {
    return &PTR_VALUE;
unsafe fn returnsPtrOk() -> *i32 throws (TestError) {
    return &PTR_VALUE as *i32;
}

fn returnsPtrErr() -> *i32 throws (TestError) {
unsafe fn returnsPtrErr() -> *i32 throws (TestError) {
    throw TestError::Fail;
}

test/tests/error.slice.bounds.rad +1 -2

//! returns: 133
//! Test slice bounds checking with runtime EBREAK.

@default fn main() -> i32 {
    let arr: [i32; 3] = [1, 2, 3];
    let slice: *[i32] = &arr[..];
    let value: i32 = slice[3];
    let value: i32 = (&arr[..])[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

    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 };
    let r = HasSlice { data: &arr[..] as *[i32], z: 77 };
    return r.data.len;
}

test/tests/fn.callback.nested.rad +5 -6

        return n + 1;
    }
    return current;
}

fn maxRegCallback(reg: Reg, ctx: *mut opaque) {
    let max = ctx as *mut u32;
    set *max = maxRegNum(reg.n, *max);
fn maxRegCallback(reg: Reg, ctx: &mut opaque) {
    unsafe { set *(ctx as &mut u32) = maxRegNum(reg.n, *(ctx as &mut u32)); }
}

fn withReg(val: Val, callback: fn(Reg, *mut opaque), ctx: *mut opaque) {
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
    );

    // maxReg should be 6 (max register 5 + 1)
    if maxReg == 6 {
        return 0;

test/tests/for.else.continue.rad +5 -5

record Field {
    name: ?*[u8],
    value: i32,
}

fn findField(fields: *[Field], target: *[u8]) -> ?i32 {
unsafe 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;

        }
    }
    return nil;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut fields: [Field; 4] = undefined;
    set fields[0] = Field { name: nil, value: 10 };
    set fields[1] = Field { name: "foo", value: 20 };
    set fields[2] = Field { name: nil, value: 30 };
    set fields[3] = Field { name: "bar", value: 40 };

    let v1 = findField(&fields[..], "foo") else {
    let v1 = findField(&fields[..] as *[Field], "foo") else {
        return 1;
    };
    assert v1 == 20;

    let v2 = findField(&fields[..], "bar") else {
    let v2 = findField(&fields[..] as *[Field], "bar") else {
        return 3;
    };
    assert v2 == 40;

    if let _ = findField(&fields[..], "baz") {
    if let _ = findField(&fields[..] as *[Field], "baz") {
        return 5;
    }

    return 0;
}

test/tests/frame.large.rad +4 -4

//! returns: 0
//! Test large stack frames and addressing near top of frame.
fn bigFrame1() -> i32 {
unsafe fn bigFrame1() -> i32 {
    let pad: [u8; 2024] = undefined;
    let n: i32 = 491823;

    return n + 1;
}

fn bigFrame2() -> i32 {
unsafe fn bigFrame2() -> i32 {
    let pad: [u8; 2028] = undefined;
    let arr: [i32; 4] = [1, 2, 3, 4];

    return arr[0] + arr[1] + arr[3];
}

fn bigFrame3() -> i32 {
unsafe fn bigFrame3() -> i32 {
    let mut ary: [u8; 4096] = undefined;
    set ary[4091] = 192;

    return ary[4091] as i32;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    assert bigFrame1() == 491824;
    assert bigFrame2() == 7;
    assert bigFrame3() == 192;
    return 0;
}

test/tests/index.eval.order.rad +2 -2

//! The container expression of a subscript must run before its index expression.

static VALUES: [i32; 2] = [1, 42];
static NEXT_INDEX: u32 = 0;

fn selectValues() -> *[i32] {
unsafe fn selectValues() -> *[i32] {
    set NEXT_INDEX = 1;
    return &VALUES[..];
}

fn selectIndex() -> u32 {
    return NEXT_INDEX;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    return selectValues()[selectIndex()];
}

test/tests/index.u8.rad +1 -2

    // Unsuffixed integer literal index.
    if arr[1] <> 20 {
        return 4;
    }
    // u8 index into slice.
    let s = &arr[..];
    let si: u8 = 1;
    if s[si] <> 20 {
    if (&arr[..])[si] <> 20 {
        return 5;
    }
    return 0;
}

test/tests/intrinsic.ecall.rad +3 -3

//! Test intrinsic ecall lowering.

@intrinsic fn ecall(num: u32, a0: i32, a1: i32, a2: i32, a3: i32) -> i32;
@intrinsic unsafe fn ecall(num: u32, a0: i64, a1: i64, a2: i64, a3: i64) -> i64;

fn test() -> i32 {
    return ecall(64, 1, 100, 5, 0);
fn test() -> i64 {
    unsafe { return ecall(64, 1, 100, 5, 0); }
}

test/tests/intrinsic.ecall.ril +2 -2

extern fn w32 $ecall(w32 %0, w32 %1, w32 %2, w32 %3, w32 %4);
extern fn w64 $ecall(w32 %0, w64 %1, w64 %2, w64 %3, w64 %4);

fn w32 $test() {
fn w64 $test() {
  @entry0
    ecall %0 64 1 100 5 0;
    ret %0;
}

test/tests/large.blit.store.rad +4 -4

}

/// Store at offset 2200 (> MAX_IMM) into a record field.
/// Generates `store w32 <imm> %0 2200` in IL, which triggers the
/// SCRATCH1 aliasing bug when adjustOffset clobbers the value.
fn storeLargeOffset() -> i32 {
unsafe fn storeLargeOffset() -> i32 {
    let mut b: Big = undefined;
    set b.tag = 42;
    assert b.tag == 42;
    set b.tag = 99;
    assert b.tag == 99;
    return 0;
}

/// Copy a >2047 byte struct (triggers blit offset overflow).
fn copyBig() -> i32 {
unsafe fn copyBig() -> i32 {
    let mut src: Big = undefined;
    set src.a[0] = 10;
    set src.a[1000] = 20;
    set src.a[2199] = 30;
    set src.tag = 77;

    assert dst.tag == 77;
    return 0;
}

/// Mutate a copy to ensure the blit produced an independent copy.
fn copyIndependence() -> i32 {
unsafe fn copyIndependence() -> i32 {
    let mut a: Big = undefined;
    set a.a[0] = 1;
    set a.a[2199] = 2;
    set a.tag = 100;


    assert b.a[2199] == 2;
    assert b.tag == 200;
    return 0;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let r1 = storeLargeOffset();
    if r1 <> 0 {
        return 10 + r1;
    }


test/tests/let.guard.rad +6 -6

    let value = opt else return true;

    return false;
}

fn caseGuardSuccess() -> bool {
unsafe fn caseGuardSuccess() -> bool {
    let resp: Response = Response::success(9);
    let case Response::success(inner) = resp else {
        return false;
    };
    return inner == 9;
}

fn caseGuardElseBlk() -> bool {
unsafe fn caseGuardElseBlk() -> bool {
    let resp: Response = Response::failure;
    let case Response::success(inner) = resp else {
        return true;
    };
    return false;
}

fn caseGuardElseStmt() -> bool {
unsafe fn caseGuardElseStmt() -> bool {
    let resp: Response = Response::failure;
    let case Response::success(inner) = resp else return true;

    return false;
}

    let b = second else return false;

    return a == 1 and b == 2;
}

fn caseGuardNoPayload() -> bool {
unsafe fn caseGuardNoPayload() -> bool {
    let resp: Response = Response::failure;
    let case Response::failure = resp else {
        return false;
    };
    return true;
}

fn caseGuardStruct() -> bool {
unsafe fn caseGuardStruct() -> bool {
    let resp: Response = Response::other { message: "ouch" };
    let case Response::other { message } = resp else {
        return false;
    };
    return message.len == 4;
}

@default fn main() -> bool {
@default unsafe fn main() -> bool {
    return
        optionGuardSuccess() and
        optionGuardElseBlk() and
        optionGuardElseStmt() and
        caseGuardSuccess() and

test/tests/let.placeholder.rad +1 -1

fn placeholder() -> i32 {
    let _: i32 = 42;
    return 1;
}

fn placeholderWithSideEffect(ptr: *mut i32) -> i32 {
fn placeholderWithSideEffect(ptr: &i32) -> i32 {
    let _ = *ptr;
    return 0;
}

fn placeholderIgnoreResult() -> i32 {

test/tests/literal.slice.bytes.rad +1 -1

/// Test byte slice literal with alignment 1.
fn byteSlice() -> u32 {
unsafe fn byteSlice() -> u32 {
    let s: *[u8] = &[65, 66, 67];
    return s.len;
}

test/tests/literal.slice.dedup.rad +1 -1

/// Test that duplicate slice literals are deduplicated into a single data entry.
fn dedupSlice() -> u32 {
unsafe fn dedupSlice() -> u32 {
    let a: *[i32] = &[1, 2, 3];
    let b: *[i32] = &[1, 2, 3];
    return a.len + b.len;
}

test/tests/literal.slice.empty.rad +1 -1

/// Test empty slice literal.
fn emptySlice() -> u32 {
unsafe fn emptySlice() -> u32 {
    let s: *[i32] = &[];
    return s.len;
}

test/tests/literal.slice.multi.rad +1 -1

/// Test multiple slice literals get unique data names.
fn multiSlice() -> u32 {
unsafe fn multiSlice() -> u32 {
    let a: *[i32] = &[1, 2];
    let b: *[i32] = &[3, 4, 5];
    return a.len + b.len;
}

test/tests/literal.slice.rad +1 -1

/// Test slice literal creates static data.
fn sliceLiteral() -> u32 {
unsafe fn sliceLiteral() -> u32 {
    let s: *[i32] = &[1, 2, 3];
    return s.len;
}

test/tests/literal.slice.record.rad +1 -1

/// Test slice literal with record elements.
record Point { x: i32, y: i32 }

fn localSliceOfRecords() -> i32 {
unsafe fn localSliceOfRecords() -> i32 {
    let s: *[Point] = &[Point { x: 5, y: 6 }, Point { x: 7, y: 8 }];
    return s[0].x + s[1].y;
}

test/tests/literal.string.dedup.rad +1 -1

/// Test that duplicate string literals are deduplicated into a single data entry.
fn dedupString() -> u32 {
unsafe fn dedupString() -> u32 {
    let a = "hello";
    let b = "hello";
    return a.len + b.len;
}

test/tests/literal.string.empty.rad +1 -1

/// Test empty string literal.
fn emptyString() -> u32 {
unsafe fn emptyString() -> u32 {
    let s = "";
    return s.len;
}

test/tests/literal.string.fns.rad +2 -2

/// Test string data names are prefixed with function name.
fn first() -> u32 {
unsafe fn first() -> u32 {
    let s = "foo";
    return s.len;
}

fn second() -> u32 {
unsafe fn second() -> u32 {
    let s = "bar";
    return s.len;
}

test/tests/literal.string.multi.rad +1 -1

/// Test multiple string literals get unique data names.
fn multiString() -> u32 {
unsafe fn multiString() -> u32 {
    let a = "hello";
    let b = "world";
    return a.len + b.len;
}

test/tests/literal.string.rad +1 -1

/// Return the length of a string literal.
fn stringLen() -> u32 {
unsafe fn stringLen() -> u32 {
    let s = "hello";
    return s.len;
}

test/tests/loc.addr.offset.bug.rad +2 -2

record Outer {
    pad: i32,      // offset 0, size 4
    inner: Inner,  // offset 4, size 4
}

static outer: Outer = undefined;
unsafe static outer: Outer = undefined;

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    set outer.inner.value = 42;

    let ptr: *Inner = &outer.inner;

    assert (*ptr).value == 42;

test/tests/loc.addr.opt.to.opt.rad +2 -2

record Container {
    pad: i32,           // offset 0
    opt: ?i32,          // offset 4
}

static container: Container = undefined;
unsafe static container: Container = undefined;

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let sourceOpt: ?i32 = 42;

    set container.opt = sourceOpt;

    if let val = container.opt {

test/tests/loc.addr.optional.assign.rad +2 -2

record Container {
    pad: i32,           // offset 0, size 4
    opt: ?i32,          // offset 4, size 8 (tag + value)
}

static container: Container = undefined;
unsafe static container: Container = undefined;

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    set container.opt = 42;

    if let val = container.opt {
        assert val == 42;
        return 0;

test/tests/loc.addr.record.assign.rad +3 -3

record Outer {
    pad: i32,      // offset 0, size 4
    inner: Inner,  // offset 4, size 4
}

static outer: Outer = undefined;
static source: Inner = undefined;
unsafe static outer: Outer = undefined;
unsafe static source: Inner = undefined;

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    set source.value = 42;

    set outer.inner = source;

    assert outer.inner.value == 42;

test/tests/loop.for.slice.rad +1 -1

/// Iterates over a slice with index binding and sums elements.
fn forSliceIndexed(s: *[i32]) -> i32 {
fn forSliceIndexed(s: &[i32]) -> i32 {
    let mut sum: i32 = 0;
    for elem, idx in s {
        set sum += elem + idx as i32;
    }
    return sum;

test/tests/loop.mutable.rad +1 -1

    }
    return b;
}

/// Computes the maximum alignment from a slice of alignment values.
fn computeMaxAlign(items: *[u32]) -> u32 {
fn computeMaxAlign(items: &[u32]) -> u32 {
    let mut maxAlign: u32 = 1;
    for i in 0..items.len {
        set maxAlign = max(maxAlign, items[i]);
    }
    return maxAlign;

test/tests/loop.whilelet.optional.rad +1 -1

// Returns the iteration count for a single guarded loop.
fn whileLetOptional(p: ?*i32) -> i32 {
unsafe fn whileLetOptional(p: ?*i32) -> i32 {
    let mut steps: i32 = 0;
    while let _ = p {
        set steps += 1;
        break;
    }

test/tests/lower.const.record.ident.rad +2 -2

record Entry {
    name: *[u8],
    reg: Reg,
}

constant ENTRIES: [Entry; 2] = [
unsafe constant ENTRIES: [Entry; 2] = [
    { name: "a0", reg: A0 },
    { name: "a1", reg: A1 },
];

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    return ENTRIES.len as i32;
}

test/tests/lower.private.union.const.rad +2 -2

record Entry {
    name: *[u8],
    kind: Kind,
}

constant ENTRIES: [Entry; 2] = [
unsafe constant ENTRIES: [Entry; 2] = [
    { name: "a", kind: Kind::A },
    { name: "b", kind: Kind::B },
];

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    return ENTRIES.len as i32;
}

test/tests/lower.record.scalar.record.const.rad +2 -2

record Entry {
    name: *[u8],
    reg: Reg,
}

constant ENTRIES: [Entry; 2] = [
unsafe constant ENTRIES: [Entry; 2] = [
    { name: "a0", reg: Reg(10) },
    { name: "a1", reg: Reg(11) },
];

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    return ENTRIES.len as i32;
}

test/tests/match.mutref.push.rad +3 -3

union Sealed {
    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 {
    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 +9 -9

    Some(*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;
}


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

union Holder {
    Ptr { p: *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/match.nested.whilelet.rad +15 -15

union Opt {
    Some { pair: Pair },
    None,
}

fn get(items: *[Opt], idx: u32) -> Opt {
fn get(items: &[Opt], idx: u32) -> Opt {
    if idx < items.len {
        return items[idx];
    }
    return Opt::None;
}

/// While-let with nested record destructuring.
fn sumPairs(items: *[Opt]) -> i32 {
fn sumPairs(items: &[Opt]) -> i32 {
    let mut sum: i32 = 0;
    let mut i: u32 = 0;
    while let case Opt::Some { pair: Pair { a, b } } = get(items, i) {
        set sum = sum + a + b;
        set i = i + 1;
    }
    return sum;
}

/// While-let with nested record and guard.
fn sumPositive(items: *[Opt]) -> i32 {
fn sumPositive(items: &[Opt]) -> i32 {
    let mut sum: i32 = 0;
    let mut i: u32 = 0;
    while let case Opt::Some { pair: Pair { a, b } } = get(items, i); a > 0 {
        set sum = sum + a + b;
        set i = i + 1;

union Command {
    Move { dir: Dir, speed: i32 },
    Stop,
}

fn getCmd(items: *[Command], idx: u32) -> Command {
fn getCmd(items: &[Command], idx: u32) -> Command {
    if idx < items.len {
        return items[idx];
    }
    return Command::Stop;
}

/// While-let with nested union variant pattern.
fn sumNorthSpeeds(items: *[Command]) -> i32 {
fn sumNorthSpeeds(items: &[Command]) -> i32 {
    let mut sum: i32 = 0;
    let mut i: u32 = 0;
    while let case Command::Move { dir: Dir::North, speed } = getCmd(items, i) {
        set sum = sum + speed;
        set i = i + 1;

    return sum;
}

@default fn main() -> i32 {
    // sumPairs
    let items: *[Opt] = &[
    let items: [Opt; 2] = [
        Opt::Some { pair: Pair { a: 1, b: 2 } },
        Opt::Some { pair: Pair { a: 3, b: 4 } },
    ];
    assert sumPairs(items) == 10;
    assert sumPairs(&items[..]) == 10;

    // sumPairs: empty
    let empty: *[Opt] = &[];
    assert sumPairs(empty) == 0;
    let empty: [Opt; 0] = [];
    assert sumPairs(&empty[..]) == 0;

    // sumPositive: stops at first non-positive a.
    let mixed: *[Opt] = &[
    let mixed: [Opt; 3] = [
        Opt::Some { pair: Pair { a: 3, b: 4 } },
        Opt::Some { pair: Pair { a: -1, b: 5 } },
        Opt::Some { pair: Pair { a: 2, b: 6 } },
    ];
    assert sumPositive(mixed) == 7;
    assert sumPositive(&mixed[..]) == 7;

    // sumNorthSpeeds
    let cmds: *[Command] = &[
    let cmds: [Command; 2] = [
        Command::Move { dir: Dir::North, speed: 5 },
        Command::Move { dir: Dir::North, speed: 10 },
    ];
    assert sumNorthSpeeds(cmds) == 15;
    assert sumNorthSpeeds(&cmds[..]) == 15;

    // sumNorthSpeeds: stops at South.
    let cmds2: *[Command] = &[
    let cmds2: [Command; 3] = [
        Command::Move { dir: Dir::North, speed: 3 },
        Command::Move { dir: Dir::South, speed: 7 },
        Command::Move { dir: Dir::North, speed: 9 },
    ];
    assert sumNorthSpeeds(cmds2) == 3;
    assert sumNorthSpeeds(&cmds2[..]) == 3;

    return 0;
}

test/tests/match.optional.rad +1 -1

// Returns 1 when the optional pointer is present, otherwise returns 0.
fn matchOptional(p: ?*i32) -> i32 {
unsafe fn matchOptional(p: ?*i32) -> i32 {
    match p {
        case nil => return 0,
        x => return 1,
    }
}

test/tests/match.optional.ref.rad +1 -1

/// Match an optional aggregate through a reference. The value binding is a pointer.
fn matchOptionalRef(ptr: *?u32) -> u32 {
fn matchOptionalRef(ptr: &?u32) -> u32 {
    match ptr {
        value => return *value,
        case nil => return 0,
    }
}

test/tests/match.string.rad +5 -5

//! returns: 0
//! Test string literal patterns in match statements.

/// Top-level string match.
fn classify(s: *[u8]) -> i32 {
unsafe fn classify(s: *[u8]) -> i32 {
    match s {
        case "red" => {
            return 1;
        }
        case "green" => {

union Cmd {
    Say { msg: *[u8], count: i32 },
    Quit,
}

fn dispatch(c: Cmd) -> i32 {
unsafe fn dispatch(c: Cmd) -> i32 {
    match c {
        case Cmd::Say { msg: "hello", count } => {
            return count;
        }
        case Cmd::Say { msg: "bye", count } => {

        }
    }
}

/// String pattern in if-let-case.
fn isHello(c: Cmd) -> bool {
unsafe fn isHello(c: Cmd) -> bool {
    if let case Cmd::Say { msg: "hello", .. } = c {
        return true;
    }
    return false;
}

/// String pattern in let-else.
fn extractBye(c: Cmd) -> i32 {
unsafe fn extractBye(c: Cmd) -> i32 {
    let case Cmd::Say { msg: "bye", count } = c
        else { return -1; };
    return count;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    // classify
    assert classify("red") == 1;
    assert classify("green") == 2;
    assert classify("blue") == 3;
    assert classify("other") == 0;

test/tests/memzero.union.bug.rad +1 -1

    guard1: u16,
    val: Payload,
    guard2: u32,
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut f: Frame = Frame { guard1: 0xDEAD, val: undefined, guard2: 0xDEADBEEF };

    set f.val = Payload::Small(7);
    set f.val = Payload::Big([1, 2, 3]);


test/tests/method.basic.rad +4 -4

record Point {
    x: i32,
    y: i32,
}

fn (p: *Point) sum() -> i32 {
unsafe fn (p: *Point) sum() -> i32 {
    return p.x + p.y;
}

fn (p: *mut Point) translate(dx: i32, dy: i32) {
unsafe 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: *Point = &pt;
    assert ptr.sum() == 37;

    return 0;
}

test/tests/method.chain.rad +4 -4

record Builder {
    x: i32,
    y: i32,
}

fn (b: *mut Builder) setX(x: i32) -> *mut Builder {
unsafe fn (b: *mut Builder) setX(x: i32) -> *mut Builder {
    set b.x = x;
    return b;
}

fn (b: *mut Builder) setY(y: i32) -> *mut Builder {
unsafe fn (b: *mut Builder) setY(y: i32) -> *mut Builder {
    set b.y = y;
    return b;
}

fn (b: *Builder) sum() -> i32 {
unsafe fn (b: *Builder) sum() -> i32 {
    return b.x + b.y;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut b = Builder { x: 0, y: 0 };

    // Chain method calls.
    let p = b.setX(10).setY(20);
    assert p.sum() == 30;

test/tests/method.multiple.rad +4 -4

record Vec2 {
    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 {
fn (v: &Vec2) dot(other: &Vec2) -> i32 {
    return v.x * other.x + v.y * other.y;
}

fn (v: *mut Vec2) add(other: *Vec2) {
fn (v: &mut Vec2) add(other: &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 {

test/tests/method.ptr.rad +5 -5


record Counter {
    value: i32,
}

fn (c: *Counter) get() -> i32 {
unsafe fn (c: *Counter) get() -> i32 {
    return c.value;
}

fn (c: *mut Counter) inc() {
unsafe 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: *Counter = &c;
    assert p.get() == 1;

    // Call via mutable pointer.
    let mp = &mut c;
    let mp: *mut Counter = &mut c;
    mp.inc();
    assert mp.get() == 2;

    // Original value also updated.
    assert c.get() == 2;

test/tests/method.pub.rad +1 -1


record Foo {
    x: i32,
}

export fn (f: *Foo) getX() -> i32 {
export fn (f: &Foo) getX() -> i32 {
    return f.x;
}

@default fn main() -> i32 {
    let f = Foo { x: 42 };

test/tests/method.return.rad +4 -4

record Pair {
    a: i32,
    b: i32,
}

fn (p: *Pair) sum() -> i32 {
fn (p: &Pair) sum() -> i32 {
    return p.a + p.b;
}

fn (p: *Pair) swapped() -> Pair {
fn (p: &Pair) swapped() -> Pair {
    return Pair { a: p.b, b: p.a };
}

fn (p: *Pair) firstPtr() -> *i32 {
unsafe fn (p: *Pair) firstPtr() -> *i32 {
    return &p.a;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let pair = Pair { a: 10, b: 20 };

    // Scalar return.
    assert pair.sum() == 30;


test/tests/method.throws.rad +2 -2

record Parser {
    pos: i32,
    len: i32,
}

fn (p: *mut Parser) advance() throws (ParseError) {
fn (p: &mut Parser) advance() throws (ParseError) {
    if p.pos >= p.len {
        throw ParseError::Invalid;
    }
    set p.pos = p.pos + 1;
}

fn (p: *Parser) remaining() -> i32 {
fn (p: &Parser) remaining() -> i32 {
    return p.len - p.pos;
}

@default fn main() -> i32 {
    let mut parser = Parser { pos: 0, len: 2 };

test/tests/method.union.rad +1 -1

union Shape {
    Circle(i32),
    Rect { w: i32, h: i32 },
}

fn (s: *Shape) isCircle() -> bool {
fn (s: &Shape) isCircle() -> bool {
    match *s {
        case Shape::Circle(_) => return true,
        else => return false,
    }
}

test/tests/method.with.trait.rad +4 -4

    x: i32,
    y: i32,
}

// Standalone method.
fn (w: *Widget) area() -> i32 {
unsafe fn (w: *Widget) area() -> i32 {
    return w.x * w.y;
}

// Trait with its own method.
trait Printable {
    fn (*Printable) code() -> i32;
    unsafe fn (*Printable) code() -> i32;
}

instance Printable for Widget {
    fn (w: *Widget) code() -> i32 {
    unsafe fn (w: *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;


test/tests/mutref.call.result.rad +2 -2


record Box {
    x: i32,
}

fn idBox(b: *mut Box) -> *mut Box {
unsafe fn idBox(b: *mut Box) -> *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;
    set *px = 9;


test/tests/mutref.loop.bug.rad +5 -5

//!
//! 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) {
unsafe 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
/// merge tries to `load` through it as if it were a pointer.
fn testZeroIter(n: u32) -> u32 {
unsafe fn testZeroIter(n: u32) -> u32 {
    let mut val: u32 = 42;
    let mut i: u32 = 0;
    while i < n {
        store(&mut val, val + 1);
        set i += 1;
    }
    return val;
}

/// Multiple iterations: accumulate via &mut pointer in a loop.
fn testMultiIter() -> u32 {
unsafe fn testMultiIter() -> u32 {
    let mut acc: u32 = 0;
    let mut i: u32 = 0;
    while i < 5 {
        store(&mut acc, acc + i);
        set i += 1;
    }
    return acc;
}

/// Multiple address-taken variables in the same loop.
fn testMultipleVars() -> u32 {
unsafe fn testMultipleVars() -> u32 {
    let mut a: u32 = 0;
    let mut b: u32 = 100;
    let mut i: u32 = 0;
    while i < 3 {
        store(&mut a, a + 1);

        set i += 1;
    }
    return a + b;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    // Zero iterations: the critical regression case.
    assert testZeroIter(0) == 42;
    // Non-zero iterations still work.
    assert testZeroIter(3) == 45;
    // Accumulation: 0+0+1+2+3+4 = 10

test/tests/mutref.loop.rad +3 -4

fn callback(val: u32, ctx: *mut opaque) {
    let max = ctx as *mut u32;
    set *max = val;
fn callback(val: u32, ctx: &mut opaque) {
    unsafe { set *(ctx as &mut u32) = val; }
}

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);
        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/nil.cmp.rad +2 -2

fn nilNeNil() -> bool {
    return nil <> nil;
}

// nil == opt (reversed order, pointer optional)
fn nilEqOptPtr(a: ?*i32) -> bool {
unsafe fn nilEqOptPtr(a: ?*i32) -> bool {
    return nil == a;
}

// nil <> opt (reversed order, pointer optional)
fn nilNeOptPtr(a: ?*i32) -> bool {
unsafe fn nilNeOptPtr(a: ?*i32) -> bool {
    return nil <> a;
}

// nil == opt (reversed order, aggregate optional)
fn nilEqOptAgg(a: ?i32) -> bool {

test/tests/opt.nil.check.rad +4 -4

//! 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() -> *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;
}

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

    // The pointer is not nil, but its low byte is 0x00.
    // A W8 comparison would wrongly say it's nil.

    }
    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 ..];

        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.ptr.return.nil.rad +1 -1

1	1		// Returns a nil optional pointer.
2		-	fn optPtrReturnNil() -> ?*i32 {
	2	+	unsafe fn optPtrReturnNil() -> ?*i32 {
3	3		return nil;
4	4		}

test/tests/opt.slice.npo.rad +11 -11

//! returns: 0
//! Test null pointer optimization for optional slices (?*[T]).
//! Optional slices should have the same size as slices (16 bytes),
//! using a null data pointer to represent `nil`.

fn checkSizes() -> u8 {
unsafe 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;
    return 0;
}

fn checkNil() -> u8 {
unsafe fn checkNil() -> u8 {
    let x: ?*[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;

    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;

    if let val = opt {

        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 val = opt else {

    };
    assert val.len == 3;
    return 0;
}

fn returnNil() -> ?*[u8] {
unsafe fn returnNil() -> ?*[u8] {
    return nil;
}

fn returnSome() -> ?*[u8] {
unsafe fn returnSome() -> ?*[u8] {
    let arr: [u8; 2] = [42, 99];
    return &arr[..];
}

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;

    match opt {

101	101		}
102	102		}
103	103		return 0;
104	104		}
105	105
106		-	fn checkEq() -> u8 {
	106	+	unsafe fn checkEq() -> u8 {
107	107		let a: ?*[u8] = nil;
108	108		let b: ?*[u8] = nil;
109	109
110	110		// nil == nil
111	111		assert a == b;

    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/optional.ptr.eq.rad +4 -4

// Test optional pointer equality (fast path in lowerOptionalEq)

fn optPtrEq(a: ?*i32, b: ?*i32) -> bool {
unsafe fn optPtrEq(a: ?*i32, b: ?*i32) -> bool {
    return a == b;
}

fn optPtrNeq(a: ?*i32, b: ?*i32) -> bool {
unsafe fn optPtrNeq(a: ?*i32, b: ?*i32) -> bool {
    return a <> b;
}

fn optPtrEqNil(a: ?*i32) -> bool {
unsafe fn optPtrEqNil(a: ?*i32) -> bool {
    return a == nil;
}

fn optPtrNeqNil(a: ?*i32) -> bool {
unsafe fn optPtrNeqNil(a: ?*i32) -> bool {
    return a <> nil;
}

test/tests/pointer.copy.edge.case.rad +3 -3

record Parser {
    nodes: [Node; 1],
    count: u32,
}

fn makeNode(p: *mut Parser, kind: NodeKind) -> *mut Node {
unsafe fn makeNode(p: *mut Parser, kind: NodeKind) -> *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: *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],

test/tests/pointer.slice.index.rad +1 -1

    ptr: *[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.slice.store.rad +4 -4


record PtrBox {
    ptr: *mut *mut [Entry],
}

static STORAGE: [Entry; 2] = undefined;
static TABLE: Table = undefined;
static HOLDER: PtrBox = undefined;
unsafe static STORAGE: [Entry; 2] = undefined;
unsafe static TABLE: Table = undefined;
unsafe static HOLDER: PtrBox = undefined;

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    set TABLE.entries = &mut STORAGE[..];
    set TABLE.len     = 0;

    set HOLDER.ptr = &mut TABLE.entries;


test/tests/pointerfn.rad +1 -1

1		-	fn takePointer(p: i32) -> i32 {
	1	+	unsafe fn takePointer(p: i32) -> i32 {
2	2		return p;
3	3		}

test/tests/prog.bignum.rad +18 -18


/// 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) {
unsafe 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]) {
unsafe 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]) {
unsafe 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 {
unsafe 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 {
unsafe 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 {
unsafe 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]) {
unsafe 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]) {
unsafe 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]) {
unsafe 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;

        set carry = newCarry;
    }
}

/// Test basic addition.
fn testAdd() -> i32 {
unsafe fn testAdd() -> i32 {
    let mut a: [u32; 4] = [0; 4];
    let mut b: [u32; 4] = [0; 4];
    let mut c: [u32; 4] = [0; 4];
    let mut d: [u32; 4] = [0; 4];



    return 0;
}

/// Test subtraction.
fn testSub() -> i32 {
unsafe fn testSub() -> i32 {
    let mut a: [u32; 4] = [0; 4];
    let mut b: [u32; 4] = [0; 4];
    let mut c: [u32; 4] = [0; 4];

    bnZero(&mut a[..]);


    return 0;
}

/// Test multiplication.
fn testMul() -> i32 {
unsafe fn testMul() -> i32 {
    let mut a: [u32; 4] = [0; 4];
    let mut b: [u32; 4] = [0; 4];
    let mut wide: [u32; 8] = [0; 8];

    bnFromU32(&mut a[..], 12345);


    return 0;
}

/// Test the identity a + b - b = a.
fn testAddSubIdentity() -> i32 {
unsafe fn testAddSubIdentity() -> i32 {
    let mut a: [u32; 4] = [0; 4];
    let mut b: [u32; 4] = [0; 4];
    let mut c: [u32; 4] = [0; 4];
    let mut d: [u32; 4] = [0; 4];



    return 0;
}

/// Test shift operations.
fn testShift() -> i32 {
unsafe fn testShift() -> i32 {
    let mut a: [u32; 4] = [0; 4];
    let mut b: [u32; 4] = [0; 4];
    let mut c: [u32; 4] = [0; 4];

    bnFromU32(&mut a[..], 1);


    return 0;
}

/// Test large multiply.
fn testLargeMultiply() -> i32 {
unsafe fn testLargeMultiply() -> i32 {
    let mut a: [u32; 4] = [0; 4];
    let mut b: [u32; 4] = [0; 4];
    let mut wide: [u32; 8] = [0; 8];

    set a[0] = 0xFFFFFFFF;


    return 0;
}

/// Test Fibonacci sequence with big numbers.
fn testFibonacci() -> i32 {
unsafe fn testFibonacci() -> i32 {
    let mut fibA: [u32; 4] = [0; 4];
    let mut fibB: [u32; 4] = [0; 4];
    let mut fibC: [u32; 4] = [0; 4];

    set fibA[0] = 0;


    return 0;
}

/// Test compare function.
fn testCompare() -> i32 {
unsafe fn testCompare() -> i32 {
    let mut a: [u32; 4] = [0; 4];
    let mut b: [u32; 4] = [0; 4];

    bnFromU32(&mut a[..], 100);
    bnFromU32(&mut b[..], 200);

    assert bnCmp(&a[..], &b[..]) == 1;

    return 0;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let r1: i32 = testAdd();
    if r1 <> 0 {
        return 10 + r1;
    }


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 +18 -18

    numNodes: u32,
    heap: *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 +50 -30

union EvalError {
    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));
    let three = num(pool, 3);
    let four = num(pool, 4);
    let root = add(pool, three, four);
    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 two = num(pool, 2);
    let three = num(pool, 3);
    let left = add(pool, two, three);
    let four = num(pool, 4);
    let one = num(pool, 1);
    let right = sub(pool, four, one);
    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));
    let ten = num(pool, 10);
    let five = num(pool, 5);
    let a = add(pool, ten, five);
    let two = num(pool, 2);
    let b = mul(pool, a, two);
    let six = num(pool, 6);
    let c = sub(pool, b, six);
    let four = num(pool, 4);
    let root = div(pool, c, four);
    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)));
    let three = num(pool, 3);
    let four = num(pool, 4);
    let sum = add(pool, three, four);
    let root = neg(pool, sum);
    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));
        let node = num(pool, v);
        set root = add(pool, root, node);
    }
    assert try! eval(&pool.nodes[..], root) == 36;
    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));
    let two = num(pool, 2);
    let eight = num(pool, 8);
    let inner = add(pool, two, eight);
    let three = num(pool, 3);
    let product = mul(pool, three, inner);
    let hundred = num(pool, 100);
    let diff = sub(pool, hundred, product);
    let seven = num(pool, 7);
    let root = div(pool, diff, seven);
    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 {
    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 +21 -21

    codeLen: *mut [u32],
    bitstream: *mut [u8],
    bitCount: u32,
}

fn newLeaf(s: *mut HuffState, freq: u32, symbol: u32) -> u32 {
unsafe fn newLeaf(s: *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: *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: *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: *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: *HuffState, i: u32) -> u32 {
    return s.nodes[s.heap[i]].freq;
}

fn siftUp(s: *mut HuffState, pos: u32) {
unsafe fn siftUp(s: *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: *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: *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: *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: *mut HuffState, freqs: *[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: *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: *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: *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: *mut HuffState, msg: *[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: *HuffState, root: u32, numSymbols: u32, out: *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: *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: *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: *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: *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: *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 +18 -18

    decoded: *mut [u8],
    decLen: u32,
    temp: *mut [u8],
}

fn initEncDict(s: *mut LzwState) {
unsafe fn initEncDict(s: *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: *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: *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: *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: *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: *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: *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: *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: *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: *mut LzwState, b: u8) {
    set s.decoded[s.decLen] = b;
    set s.decLen += 1;
}

fn decode(s: *mut LzwState) {
unsafe fn decode(s: *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: *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: *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: *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: *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: *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: *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 {
    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 +10 -10

record MtState {
    mt: *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 +7 -7

    queens: *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 +16 -16

    root: u32,
    inorder: *mut [i32],
    inorderCount: u32,
}

fn allocNode(t: *mut RBTree, key: i32) -> u32 {
unsafe fn allocNode(t: *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: *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: *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: *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: *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: *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: *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: *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: *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: *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: *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: *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: *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: *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: *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 +21 -21

    closure: *mut [u32],
    fragStack: *mut [Frag],
    fragTop: u32,
}

fn newState(nfa: *mut NfaState) -> u32 {
unsafe fn newState(nfa: *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: *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: *mut NfaState, f: Frag) {
    set nfa.fragStack[nfa.fragTop] = f;
    set nfa.fragTop += 1;
}

fn popFrag(nfa: *mut NfaState) -> Frag {
unsafe fn popFrag(nfa: *mut NfaState) -> Frag {
    set nfa.fragTop -= 1;
    return nfa.fragStack[nfa.fragTop];
}

fn setEmpty(s: *mut [u32]) {
unsafe fn setEmpty(s: *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: *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: *[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: *[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: *mut [u32], src: *[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: *mut NfaState, states: *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: *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: *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: *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: *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: *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: *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: *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: *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: *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: *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 +7 -7

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]) {
unsafe 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]) {
unsafe 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) {
unsafe 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 {
unsafe 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 {
unsafe 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 {
unsafe 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;

    //   result = 0x0F ^ 0xF0 ^ 0x00 = 0xFF
    assert maj(0xFF, 0x0F, 0xF0) == 0xFF;
    return 0;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    // SHA-256 round constants (first 32 bits of fractional parts of cube roots
    // of the first 64 primes).
    let k: [u32; 64] = [
        0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
        0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,

test/tests/prog.sieve.rad +7 -7

//! 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) {
unsafe 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]) {
unsafe 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 {
unsafe 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 {
unsafe 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 {
unsafe 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;


        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 +15 -15

    scopeDepth: u32,
    buckets: *mut [u32],
}

/// Simple string hash function.
fn hashName(name: *[u8]) -> u32 {
unsafe 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 +28 -28

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: *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: *mut Lexer) {
    if lex.pos < lex.source.len {
        set lex.pos += 1;
    }
}

/// Skip whitespace characters.
fn skipWhitespace(lex: *mut Lexer) {
unsafe fn skipWhitespace(lex: *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: *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: *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: *mut Lexer, list: *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: *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: *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: *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: *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: *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: *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: *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: *[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: *[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]
) -> ?i32 {
    let mut lex = Lexer { source, pos: 0 };

    };
    return eval(exprBuf, root);
}

/// Test simple number.
fn testNumber(tokenBuf: *mut [Token], exprBuf: *mut [Expr]) -> i32 {
unsafe fn testNumber(tokenBuf: *mut [Token], exprBuf: *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: *mut [Token], exprBuf: *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: *mut [Token], exprBuf: *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: *mut [Token], exprBuf: *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: *mut [Token], exprBuf: *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: *mut [Token], exprBuf: *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: *mut [Token], exprBuf: *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: *mut [Token], exprBuf: *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: *mut [Token], exprBuf: *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: *mut [Token], exprBuf: *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: *mut [Token], exprBuf: *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 +19 -19

    /// Too many nested calls.
    CallOverflow,
}

/// Push a value onto the stack.
fn push(vm: *mut VM, value: i32) throws (VmError) {
unsafe fn push(vm: *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: *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: *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: *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(
unsafe fn runProgram(
    code: *[Op],
    codeLen: u32,
    stackBuf: *mut [i32],
    localsBuf: *mut [i32],
    framesBuf: *mut [Frame]

    };
    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: *mut [i32], localsBuf: *mut [i32], framesBuf: *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: *mut [i32], localsBuf: *mut [i32], framesBuf: *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: *mut [i32], localsBuf: *mut [i32], framesBuf: *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: *mut [i32], localsBuf: *mut [i32], framesBuf: *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: *mut [i32], localsBuf: *mut [i32], framesBuf: *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: *mut [i32], localsBuf: *mut [i32], framesBuf: *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: *mut [i32], localsBuf: *mut [i32], framesBuf: *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: *mut [i32], localsBuf: *mut [i32], framesBuf: *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: *mut [i32], localsBuf: *mut [i32], framesBuf: *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: *mut [i32], localsBuf: *mut [i32], framesBuf: *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: *mut [i32], localsBuf: *mut [i32], framesBuf: *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: *mut [i32], localsBuf: *mut [i32], framesBuf: *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: *mut [i32], localsBuf: *mut [i32], framesBuf: *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.field.rad +1 -1

record Point { x: i32, y: i32 }

/// Takes the address of a record field.
fn addressOfField(p: *Point) -> *i32 {
unsafe fn addressOfField(p: *Point) -> *i32 {
    return &p.y;
}

test/tests/ptr.addressof.local.rad +3 -3

record Point { x: i32, y: i32 }

/// Address of a record local (aggregate) - value is already a pointer.
fn addressOfRecordLocal() -> *Point {
unsafe fn addressOfRecordLocal() -> *Point {
    let p = Point { x: 1, y: 2 };
    return &p;
}

/// Address of a scalar local - requires stack allocation.
fn addressOfScalarLocal() -> *i32 {
unsafe fn addressOfScalarLocal() -> *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) -> *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) -> *i32 {
3	3		return &arr[idx];
4	4		}

test/tests/ptr.assign.rad +1 -1

//! returns: 42
@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut x: i32 = 1;
    let mut ptr: *mut i32 = &mut x;

    set *ptr = 42;


test/tests/ptr.deref.rad +4 -4

//! returns: 65
//! Test pointer dereference in various contexts.

fn derefArrayIndex(ary: [i32; 3]) -> i32 {
unsafe fn derefArrayIndex(ary: [i32; 3]) -> i32 {
    let x: *i32 = &ary[1];
    return *x;
}

fn derefSliceIndex(slc: *[i32]) -> i32 {
unsafe fn derefSliceIndex(slc: *[i32]) -> i32 {
    let x: *i32 = &slc[2];
    return *x;
}

fn derefBinop(x: i32, y: i32) -> i32 {
unsafe fn derefBinop(x: i32, y: i32) -> i32 {
    let px: *i32 = &x;
    let py: *i32 = &y;

    return *px + *py;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let x: i32  = 42;
    let y: *i32 = &x;
    let z: i32  = *y; // 42
    let r: i32 = derefBinop(3, 6); // 9
    let a: i32 = derefArrayIndex([7, 8, 9]); // 8

test/tests/ptr.deref.record.rad +2 -2

record Point { x: i32, y: i32 }

/// Dereferences a record pointer and accesses a field.
fn derefField(p: *Point) -> i32 {
unsafe fn derefField(p: *Point) -> i32 {
    return (*p).x;
}

/// Dereferences a record pointer and copies to a local.
fn derefCopy(p: *Point) -> i32 {
unsafe fn derefCopy(p: *Point) -> i32 {
    let copy: Point = *p;
    return copy.y;
}

test/tests/ptr.eq.rad +4 -4

    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;

    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;

    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;

    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 +3 -3

//! returns: 42

fn mutate1(ptr: *mut i32) {
unsafe fn mutate1(ptr: *mut i32) {
    set *ptr = 39;
}

fn mutate2(ptr: *mut i32) {
unsafe fn mutate2(ptr: *mut i32) {
    set *ptr += 2;
    set *ptr += 1;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut ptr: i32 = 0;

    mutate1(&mut ptr);
    mutate2(&mut ptr);


test/tests/ptr.opaque.rad +7 -7

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

    return back == ptr;
}

/// Test that opaque can be used in function parameters.
fn takesOpaque(ptr: *opaque, orig: *u8) -> bool {
unsafe fn takesOpaque(ptr: *opaque, orig: *u8) -> bool {
    let back: *u8 = ptr as *u8;
    return back == orig;
}

fn testOpaqueParams() -> bool {
unsafe fn testOpaqueParams() -> bool {
    let x: u32 = 42;
    let ptr: *u8 = &x as *u8;
    return takesOpaque(ptr, ptr);  // Automatic coercion in function call.
}

/// Test that opaque can be used in return types.
fn returnsOpaque(ptr: *u8) -> *opaque {
unsafe fn returnsOpaque(ptr: *u8) -> *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;
}

/// Test nullable opaque pointers.
fn testNullableOpaque() -> bool {
unsafe fn testNullableOpaque() -> bool {
    let mut opt: ?*opaque = nil;
    if opt == nil {
        let x: u32 = 42;
        let ptr: *u8 = &x as *u8;
        set opt = ptr;  // Automatic coercion in assignment.

        }
    }
    return false;
}

@default fn main() -> u32 {
@default unsafe fn main() -> u32 {
    assert testOpaqueCasting();
    assert testOpaqueParams();
    assert testOpaqueReturn();
    assert testNullableOpaque();
    return 0;

test/tests/ptr.subscript.assign.rad +1 -1

1	1		/// Writes to a slice element through subscript.
2		-	fn subscriptAssign(arr: *mut [i32], idx: u32, val: i32) {
	2	+	unsafe fn subscriptAssign(arr: *mut [i32], idx: u32, val: i32) {
3	3		set arr[idx] = val;
4	4		}

test/tests/range.arithmetic.rad +1 -1

//! 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];

test/tests/record.copy.rad +3 -3

69	69		assert a[2].x == 561;
70	70		assert a[3].x == 12;
71	71		return 0;
72	72		}
73	73
74		-	fn func4(s: S) -> i32 {
	74	+	unsafe fn func4(s: S) -> i32 {
75	75		let mut a: [S; 2] = undefined;
76	76		set a[0] = s;
77	77
78	78		assert a[0].x == 561;
79	79		assert a[0].y == 938;
80	80		assert a[0].z == 102;
81	81		return 0;
82	82		}
83	83
84		-	fn func5(s: S) -> i32 {
	84	+	unsafe fn func5(s: S) -> i32 {
85	85		let mut a: [S; 2] = undefined;
86	86		let t: S = makeS(s.x, s.y, s.z);
87	87		set a[0] = t;
88	88
89	89		assert a[0].x == 561;
90	90		assert a[0].y == 938;
91	91		assert a[0].z == 102;
92	92		return 0;
93	93		}
94	94
95		-	@default fn main() -> i32 {
	95	+	@default unsafe fn main() -> i32 {
96	96		let s: S = S { x: 561, y: 938, z: 102 };
97	97
98	98		let r1: i32 = func1(s);
99	99		if r1 <> 0 {
100	100		return 10 + r1;

test/tests/record.ptr.access.rad +1 -1

record Point {
    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 x: i32 = r.x;
    let mut y: i32 = r.y;

test/tests/record.ptr.mutate.rad +2 -2

record Point {
    x: i32,
    y: i32,
}

fn mutate(p: *mut Point) {
unsafe fn mutate(p: *mut Point) {
    set p.x = 4;
    set p.y = 38;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut p: Point = Point { x: 0, y: 0 };

    mutate(&mut p);

    return p.x + p.y;

test/tests/ref.if.bug.rad +3 -3

//! 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) {
unsafe fn store(ptr: *mut u32, val: u32) {
    set *ptr = val;
}

fn testIfBranch(cond: bool) -> u32 {
unsafe fn testIfBranch(cond: bool) -> u32 {
    let mut val: u32 = 42;
    if cond {
        store(&mut val, 99);
    }
    return val;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    assert testIfBranch(false) == 42;
    assert testIfBranch(true) == 99;
    return 0;
}

test/tests/ref.immut.loop.bug.rad +3 -3

//! 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 {
unsafe fn read(ptr: *u32) -> u32 {
    return *ptr;
}

fn testZeroIter(n: u32) -> u32 {
unsafe fn testZeroIter(n: u32) -> u32 {
    let val: u32 = 42;
    let mut i: u32 = 0;
    while i < n {
        let _ = read(&val);
        set i += 1;
    }
    return val;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    assert testZeroIter(0) == 42;
    assert testZeroIter(3) == 42;
    return 0;
}

test/tests/ref.mut.ptr.rad +2 -2

//! returns: 84
//! Test mutable pointer references.

fn store(ptr: *mut i32) {
unsafe fn store(ptr: *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;
    store(p);

    let mut b: i32 = 0;

test/tests/reference.array.repeat.rad +1 -1

1	1		/// Taking a reference to an array repeat literal yields a static slice.
2		-	fn repeatedSlice() -> *[u32] {
	2	+	unsafe fn repeatedSlice() -> *[u32] {
3	3		return &[(7 as u32); 3];
4	4		}

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: *mut [u8], count: u32) -> *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: *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 +9 -7

record Arena {
    data: *mut [u8],
    offset: u32,
}

fn newArena(data: *mut [u8]) -> Arena {
unsafe fn newArena(data: *mut [u8]) -> Arena {
    return Arena { data, offset: 0 };
}

fn arenaAlloc(arena: *mut Arena, size: u32, al: u32) -> *mut opaque {
unsafe fn arenaAlloc(arena: *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;


    func: fn(*mut opaque, u32, u32) -> *mut opaque,
    ctx: *mut opaque,
}

fn arenaAllocFn(ctx: *mut opaque, size: u32, al: u32) -> *mut opaque {
    let arena = ctx as *mut Arena;
    return arenaAlloc(arena, size, al);
    unsafe {
        let arena = ctx as *mut Arena;
        return arenaAlloc(arena, size, al);
    }
}

fn arenaAllocator(arena: *mut Arena) -> Allocator {
unsafe fn arenaAllocator(arena: *mut Arena) -> Allocator {
    return Allocator {
        func: arenaAllocFn,
        ctx: arena as *mut opaque,
    };
}

static BUF: [u8; 4096] = undefined;
unsafe static BUF: [u8; 4096] = undefined;

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut arena = newArena(&mut BUF[..]);
    let a = arenaAllocator(&mut arena);

    // Allocate initial capacity of 4.
    let ptr = arenaAlloc(&mut arena, @sizeOf(i32) * 4, @alignOf(i32));

test/tests/slice.assign.rad +1 -2

//! 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];


test/tests/slice.basic.rad +6 -6

/// Returns the length field from a slice header.
fn sliceLen(s: *[i32]) -> u32 {
unsafe fn sliceLen(s: *[i32]) -> u32 {
    return s.len;
}

/// Returns the capacity field from a slice header.
fn sliceCap(s: *[i32]) -> u32 {
unsafe fn sliceCap(s: *[i32]) -> u32 {
    return s.cap;
}

/// Returns the pointer field from a slice header.
fn slicePtr(s: *[i32]) -> *i32 {
unsafe fn slicePtr(s: *[i32]) -> *i32 {
    return s.ptr;
}

/// Copies a slice header into a new binding and returns it.
fn sliceCopy(s: *[i32]) -> *[i32] {
unsafe fn sliceCopy(s: *[i32]) -> *[i32] {
    let c: *[i32] = s;
    return c;
}

/// Builds a slice header from a pointer and length.
fn sliceOf(ptr: *i32, len: u32) -> *[i32] {
unsafe fn sliceOf(ptr: *i32, len: u32) -> *[i32] {
    return @sliceOf(ptr, len);
}

/// Builds a slice header from pointer, length, and capacity.
fn sliceOfWithCap(ptr: *i32, len: u32, cap: u32) -> *[i32] {
unsafe fn sliceOfWithCap(ptr: *i32, len: u32, cap: u32) -> *[i32] {
    return @sliceOf(ptr, len, cap);
}

test/tests/slice.cap.rad +1 -1

//! 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[..];

    if s.cap <> 4 {

test/tests/slice.delete.rad +1 -1

//! 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[..];

    // Delete middle element (index 2: value 30).
    s.delete(2);

test/tests/slice.empty.suffix.rad +4 -4

//! returns: 0

fn checkArraySuffix() {
unsafe fn checkArraySuffix() {
    let xs: [u8; 3] = [10, 20, 30];
    let empty = &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 empty = &slice[slice.len..slice.len];

    assert empty.len == 0;
}

fn checkStringSuffix() {
unsafe fn checkStringSuffix() {
    let text = "abc";
    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.eq.rad +1 -1

1	1		// Returns true when the slice pointer and length both match.
2		-	fn sliceEq(a: [i32], b: [i32]) -> bool {
	2	+	unsafe fn sliceEq(a: [i32], b: [i32]) -> bool {
3	3		return a == b;
4	4		}

test/tests/slice.index.rad +1 -1

1	1		/// Returns an element from the slice.
2		-	fn sliceIndex(s: *[i32], idx: u32) -> i32 {
	2	+	fn sliceIndex(s: &[i32], idx: u32) -> i32 {
3	3		return s[idx];
4	4		}

test/tests/slice.mutable.rad +3 -3

// Test mutable slice operations

fn mutSliceStore(s: *mut [i32], idx: u32, val: i32) {
fn mutSliceStore(s: &mut [i32], idx: u32, val: i32) {
    set s[idx] = val;
}

fn mutSliceIncrement(s: *mut [i32], idx: u32) {
fn mutSliceIncrement(s: &mut [i32], idx: u32) {
    set s[idx] += 1;
}

fn mutSliceSwap(s: *mut [i32], i: u32, j: u32) {
fn mutSliceSwap(s: &mut [i32], i: u32, j: u32) {
    let tmp = s[i];
    set s[i] = s[j];
    set s[j] = tmp;
}

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] {
unsafe fn makeSlice(ptr: *mut i32, count: u32) -> *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 +1 -1


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 bad = &slice[id(4)..id(4)];

    return bad.len as i32;

test/tests/slice.range.dynamic.rad +1 -1

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	9		let slice: *[u8] = &xs[..];
10	10
11	11		let start = id(1);
12	12		let end = id(4);

test/tests/slice.range.order.check.rad +1 -1


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 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) -> *[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) -> *[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) -> *[i32] {
    return &s[..end];
}

/// Returns a full reslice of a slice.
fn sliceRangeFull(s: *[i32]) -> *[i32] {
unsafe fn sliceRangeFull(s: *[i32]) -> *[i32] {
    return &s[..];
}

/// Returns a subslice from an array parameter.
fn sliceArray(a: [i32; 4]) -> *[i32] {
unsafe fn sliceArray(a: [i32; 4]) -> *[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) -> *[i32] {
    return &[c];
}

fn sliceWithVars(a: i32, b: i32) -> *[i32] {
unsafe fn sliceWithVars(a: i32, b: i32) -> *[i32] {
    return &[a, b];
}

fn sliceWithMixed(a: i32) -> *[i32] {
unsafe fn sliceWithMixed(a: i32) -> *[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) -> *[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) -> *[u8] {
    return &[a, b];
}

test/tests/slice.subslice.rad +5 -5

//! 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]

    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]

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

    return subslice.len == 2;
}

fn testEdgeCases() -> bool {
unsafe fn testEdgeCases() -> bool {
    let arr: [i32; 3] = [7, 8, 9];
    let slice: *[i32] = &arr[..];

    // Test single element subslice
    let single: *[i32] = &slice[1..2];

        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 +3 -3

record State {
    h: [u32; 8],
    w: [u32; 64],
}

fn prepareSchedule(s: *mut State, block: *[u32]) {
unsafe 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]) {
unsafe 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];

    set s.h[5] += f;
    set s.h[6] += g;
    set s.h[7] += hh;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let k: [u32; 64] = [
        0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
        0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,
        0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,
        0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,

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/static.slice.index.assign.rad +2 -2

record Container {
    pad: i32,
    items: [Inner; 3],
}

static container: Container = undefined;
unsafe static container: Container = undefined;

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    set container.items[0].value = 10;
    set container.items[1].value = 20;
    set container.items[2].value = 30;

    let slice: *mut [Inner] = &mut container.items[..];

test/tests/static.slice.offset.rad +2 -2

static SCRATCH: [Entry; 1] = [Entry { a: 0, b: 0 }];
static STORAGE: [Entry; 2] = [
    Entry { a: 0, b: 0 },
    Entry { a: 0, b: 0 },
];
static TBL: Table = undefined;
unsafe static TBL: Table = undefined;

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    set TBL.scratch = &mut SCRATCH[..];
    set TBL.entries = &mut STORAGE[..];
    set TBL.len     = 0;

    set TBL.entries[TBL.len] = Entry { a: 7, b: 9 };

test/tests/static.zero.bss.rad +2 -2

    /// Field that forces padding after `tag`.
    value: u32,
}

/// Partially initialized aggregate where all concrete bytes are zero.
static POOL: Pool = Pool { table: undefined, count: 0 };
unsafe static POOL: Pool = Pool { table: undefined, count: 0 };

/// Repeated scalar zeros.
static FLAGS: [bool; 4] = [false; 4];

/// Explicit zero fields with undefined padding.
static PADDED: Padded = Padded { tag: 0, value: 0 };

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    assert POOL.count == 0;
    assert FLAGS[0] == false;
    assert FLAGS[3] == false;
    assert PADDED.tag == 0;
    assert PADDED.value == 0;

test/tests/string.basic.rad +1 -1

//! returns: 0
// Test string literals.

@default fn main() -> u32 {
@default unsafe fn main() -> u32 {
    let s: *[u8] = "fnord";

    // Return the length of the string.
    return (s.len) - 5;
}

test/tests/string.escape.rad +1 -1

//! returns: 0
//! Test string escape sequences.
@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let s1: *[u8] = "Hello\tWorld!\n";
    assert s1.len == 13;

    let s2: *[u8] = "\"";
    assert s2.len == 1;

test/tests/string.index.rad +1 -1

//! returns: 0
// Test string indexing.

@default fn main() -> u8 {
@default unsafe fn main() -> u8 {
    let s: *[u8] = "fnord";

    return (s[1] + s[2]) - 221;
}

test/tests/trait.aggregate.ret.rad +23 -15

    y: i32,
    z: i32,
}

trait Geometry {
    fn (*Geometry) origin() -> Point;
    fn (*Geometry) center() -> Vec3;
    fn (*Geometry) maybe() -> ?i32;
    fn (&Geometry) origin() -> Point;
    fn (&Geometry) center() -> Vec3;
    fn (&Geometry) maybe() -> ?i32;
}

record Circle {
    cx: i32,
    cy: i32,
    radius: i32,
}

instance Geometry for Circle {
    fn (c: *Circle) origin() -> Point {
    fn (c: &Circle) origin() -> Point {
        return Point { x: c.cx, y: c.cy };
    }

    fn (c: *Circle) center() -> Vec3 {
    fn (c: &Circle) center() -> Vec3 {
        return Vec3 { x: c.cx, y: c.cy, z: 0 };
    }

    fn (c: *Circle) maybe() -> ?i32 {
    fn (c: &Circle) maybe() -> ?i32 {
        if c.radius > 0 {
            return c.radius;
        }
        return nil;
    }
}

@default fn main() -> i32 {
    let c = Circle { cx: 10, cy: 20, radius: 5 };
    let g: *opaque Geometry = &c;

fn checkCircle(g: &opaque Geometry) -> i32 {
    // Small struct return (Point, 8 bytes = pointer size).
    let p = g.origin();
    assert p.x == 10;
    assert p.y == 20;


    if let val = m {
        assert val == 5;
    } else {
        return 7;
    }
    return 0;
}

fn checkEmptyCircle(g: &opaque Geometry) -> i32 {
    // Optional return - None case.
    let c2 = Circle { cx: 0, cy: 0, radius: 0 };
    let g2: *opaque Geometry = &c2;
    let m2 = g2.maybe();
    if let _ = m2 {
    let m = g.maybe();
    if let _ = m {
        return 8;
    }

    return 0;
}

@default fn main() -> i32 {
    let c = Circle { cx: 10, cy: 20, radius: 5 };
    let result = checkCircle(&c);
    if result <> 0 {
        return result;
    }

    let c2 = Circle { cx: 0, cy: 0, radius: 0 };
    return checkEmptyCircle(&c2);
}

test/tests/trait.array.optional.rad +6 -6

record Multiplier {
    n: i32,
}

trait Transform {
    fn (*Transform) apply(x: i32) -> i32;
    unsafe fn (*Transform) apply(x: i32) -> i32;
}

instance Transform for Adder {
    fn (a: *Adder) apply(x: i32) -> i32 {
    unsafe fn (a: *Adder) apply(x: i32) -> i32 {
        return x + a.n;
    }
}

instance Transform for Multiplier {
    fn (m: *Multiplier) apply(x: i32) -> i32 {
    unsafe fn (m: *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: *[*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: ?*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;

test/tests/trait.basic.rad +8 -6

record Counter {
    value: i32,
}

trait Adder {
    fn (*mut Adder) add(n: i32) -> i32;
    fn (&mut Adder) add(n: i32) -> i32;
}

instance Adder for Counter {
    fn (c: *mut Counter) add(n: i32) -> i32 {
    fn (c: &mut Counter) add(n: i32) -> i32 {
        set c.value = c.value + n;
        return c.value;
    }
}

@default fn main() -> i32 {
    let mut c = Counter { value: 10 };
    let a: *mut opaque Adder = &mut c;

fn exerciseAdder(a: &mut opaque Adder) -> i32 {
    let result = a.add(5);
    // c.value should be 15 now.
    assert result == 15;
    let result2 = a.add(3);
    // c.value should be 18 now.
    assert result2 == 18;
    return 0;
}

@default fn main() -> i32 {
    let mut c = Counter { value: 10 };
    return exerciseAdder(&mut c);
}

test/tests/trait.control.flow.rad +10 -8

record Counter {
    value: i32,
}

trait Stepper {
    fn (*mut Stepper) step() -> i32;
    fn (*Stepper) current() -> i32;
    fn (&mut Stepper) step() -> i32;
    fn (&Stepper) current() -> i32;
}

instance Stepper for Counter {
    fn (c: *mut Counter) step() -> i32 {
    fn (c: &mut Counter) step() -> i32 {
        set c.value = c.value + 1;
        return c.value;
    }

    fn (c: *Counter) current() -> i32 {
    fn (c: &Counter) current() -> i32 {
        return c.value;
    }
}

@default fn main() -> i32 {
    let mut c = Counter { value: 0 };
    let s: *mut opaque Stepper = &mut c;

fn exerciseStepper(s: &mut opaque Stepper) -> i32 {
    // Dispatch in a while loop.
    let mut i: i32 = 0;
    while i < 5 {
        s.step();
        set i = i + 1;

    // Dispatch result used in conditional expression.
    let v = s.current();
    assert v == 10;
    return 0;
}

@default fn main() -> i32 {
    let mut c = Counter { value: 0 };
    return exerciseStepper(&mut c);
}

test/tests/trait.dispatch.rad +5 -5

record Acc {
    n: i32,
}

trait Ops {
    fn (*Ops) get() -> i32;
    fn (*mut Ops) put(n: i32);
    fn (&Ops) get() -> i32;
    fn (&mut Ops) put(n: i32);
}

instance Ops for Acc {
    fn (a: *Acc) get() -> i32 {
    fn (a: &Acc) get() -> i32 {
        return a.n;
    }

    fn (a: *mut Acc) put(n: i32) {
    fn (a: &mut Acc) put(n: i32) {
        set a.n = n;
    }
}

fn dispatch(o: *mut opaque Ops) -> i32 {
fn dispatch(o: &mut opaque Ops) -> i32 {
    o.put(42);
    return o.get();
}

test/tests/trait.fn.param.rad +12 -15

record Square {
    side: i32,
}

trait Shape {
    fn (*Shape) area() -> i32;
    fn (&Shape) area() -> i32;
}

trait Scalable {
    fn (*mut Scalable) scale(factor: i32);
    fn (&mut Scalable) scale(factor: i32);
}

instance Shape for Circle {
    fn (c: *Circle) area() -> i32 {
    fn (c: &Circle) area() -> i32 {
        return c.radius * c.radius * 3;
    }
}

instance Shape for Square {
    fn (s: *Square) area() -> i32 {
    fn (s: &Square) area() -> i32 {
        return s.side * s.side;
    }
}

instance Scalable for Circle {
    fn (c: *mut Circle) scale(factor: i32) {
    fn (c: &mut Circle) scale(factor: i32) {
        set c.radius = c.radius * factor;
    }
}

/// Accept an immutable trait object parameter.
fn getArea(s: *opaque Shape) -> i32 {
fn getArea(s: &opaque Shape) -> i32 {
    return s.area();
}

/// Accept a mutable trait object parameter.
fn doubleSize(s: *mut opaque Scalable) {
fn doubleSize(s: &mut opaque Scalable) {
    s.scale(2);
}

/// Accept two trait object parameters.
fn totalArea(a: *opaque Shape, b: *opaque Shape) -> i32 {
fn totalArea(a: &opaque Shape, b: &opaque Shape) -> i32 {
    return a.area() + b.area();
}

@default 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 ca = getArea(cs);
    let ca = getArea(&c);
    assert ca == 75;

    let ss: *opaque Shape = &s;
    let sa = getArea(ss);
    let sa = getArea(&s);
    assert sa == 16;

    // Pass two different trait objects to same function.
    let total = totalArea(cs, ss);
    let total = totalArea(&c, &s);
    assert total == 91;

    // Pass mutable trait object to function.
    let mut c2 = Circle { radius: 3 };
    let sc: *mut opaque Scalable = &mut c2;
    doubleSize(sc);
    doubleSize(&mut c2);
    assert c2.radius == 6;
    return 0;
}

test/tests/trait.multiple.methods.rad +14 -11

record Accumulator {
    total: i32,
}

trait Collector {
    fn (*mut Collector) add(n: i32) -> i32;
    fn (*mut Collector) clear();
    fn (*mut Collector) isEmpty() -> bool;
    fn (&mut Collector) add(n: i32) -> i32;
    fn (&mut Collector) clear();
    fn (&Collector) isEmpty() -> bool;
}

instance Collector for Accumulator {
    fn (a: *mut Accumulator) add(n: i32) -> i32 {
    fn (a: &mut Accumulator) add(n: i32) -> i32 {
        set a.total = a.total + n;
        return a.total;
    }

    fn (a: *mut Accumulator) clear() {
    fn (a: &mut Accumulator) clear() {
        set a.total = 0;
    }

    fn (a: *mut Accumulator) isEmpty() -> bool {
    fn (a: &Accumulator) isEmpty() -> bool {
        return a.total == 0;
    }
}

@default fn main() -> i32 {
    let mut acc = Accumulator { total: 0 };
    let c: *mut opaque Collector = &mut acc;

fn exerciseCollector(c: &mut opaque Collector) -> i32 {
    // Initially empty.
    assert c.isEmpty();

    // Add returns running total.
    let v1 = c.add(10);

        return 4;
    }

    // Void return: clear.
    c.clear();
    assert acc.total == 0;
    assert c.isEmpty();
    return 0;
}

@default fn main() -> i32 {
    let mut acc = Accumulator { total: 0 };
    let result = exerciseCollector(&mut acc);
    assert acc.total == 0;
    return result;
}

test/tests/trait.multiple.traits.rad +24 -14

record Counter {
    value: i32,
}

trait Incrementable {
    fn (*mut Incrementable) inc() -> i32;
    fn (&mut Incrementable) inc() -> i32;
}

trait Resettable {
    fn (*mut Resettable) reset();
    fn (*mut Resettable) isZero() -> bool;
    fn (&mut Resettable) reset();
    fn (&Resettable) isZero() -> bool;
}

instance Incrementable for Counter {
    fn (c: *mut Counter) inc() -> i32 {
    fn (c: &mut Counter) inc() -> i32 {
        set c.value = c.value + 1;
        return c.value;
    }
}

instance Resettable for Counter {
    fn (c: *mut Counter) reset() {
    fn (c: &mut Counter) reset() {
        set c.value = 0;
    }

    fn (c: *mut Counter) isZero() -> bool {
    fn (c: &Counter) isZero() -> bool {
        return c.value == 0;
    }
}

fn increment(i: &mut opaque Incrementable) -> i32 {
    return i.inc();
}

fn resetCounter(r: &mut opaque Resettable) -> i32 {
    if r.isZero() {
        return 2;
    }
    r.reset();
    assert r.isZero();
    return 0;
}

@default fn main() -> i32 {
    let mut c = Counter { value: 10 };

    // Dispatch through Incrementable.
    let i: *mut opaque Incrementable = &mut c;
    let v1 = i.inc();
    let v1 = increment(&mut c);
    assert v1 == 11;

    // Dispatch through Resettable.
    let r: *mut opaque Resettable = &mut c;
    if r.isZero() {
        return 2;
    let result = resetCounter(&mut c);
    if result <> 0 {
        return result;
    }
    r.reset();
    assert r.isZero();
    assert c.value == 0;

    // Increment again after reset.
    let v2 = i.inc();
    let v2 = increment(&mut c);
    assert v2 == 1;
    return 0;
}

test/tests/trait.multiple.types.rad +18 -17

//! returns: 0
//! Test multiple types implementing the same trait, and immutable receivers.
//!
//! Exercises: two different concrete types implementing the same trait,
//! coerced to the same trait object type. Also tests immutable `*Trait`
//! coerced to the same trait object type. Also tests immutable `&Trait`
//! receivers. Verifies each type dispatches through its own vtable.

record Dog {
    age: i32,
}

record Cat {
    lives: i32,
}

trait Speaker {
    fn (*Speaker) speak() -> i32;
    fn (*Speaker) isOld() -> bool;
    fn (&Speaker) speak() -> i32;
    fn (&Speaker) isOld() -> bool;
}

instance Speaker for Dog {
    fn (d: *Dog) speak() -> i32 {
    fn (d: &Dog) speak() -> i32 {
        return d.age;
    }

    fn (d: *Dog) isOld() -> bool {
    fn (d: &Dog) isOld() -> bool {
        return d.age > 10;
    }
}

instance Speaker for Cat {
    fn (c: *Cat) speak() -> i32 {
    fn (c: &Cat) speak() -> i32 {
        return c.lives * 10;
    }

    fn (c: *Cat) isOld() -> bool {
    fn (c: &Cat) isOld() -> bool {
        return c.lives < 5;
    }
}

fn checkYoungSpeaker(s: &opaque Speaker, expected: i32) -> bool {
    return s.speak() == expected and not s.isOld();
}

fn checkOldSpeaker(s: &opaque Speaker) -> bool {
    return s.isOld();
}

@default fn main() -> i32 {
    let d = Dog { age: 5 };
    let c = Cat { lives: 9 };

    // Immutable trait object from Dog.
    let sd: *opaque Speaker = &d;
    let v1 = sd.speak();
    assert v1 == 5;
    if sd.isOld() {
    if not checkYoungSpeaker(&d, 5) {
        return 2;
    }

    // Immutable trait object from Cat.
    let sc: *opaque Speaker = &c;
    let v2 = sc.speak();
    assert v2 == 90;
    if sc.isOld() {
    if not checkYoungSpeaker(&c, 90) {
        return 4;
    }

    // Old dog.
    let oldDog = Dog { age: 15 };
    let so: *opaque Speaker = &oldDog;
    assert so.isOld();
    assert checkOldSpeaker(&oldDog);
    return 0;
}

test/tests/trait.object.rad +7 -4

record Counter {
    value: i32,
}

trait Adder {
    fn (*mut Adder) add(n: i32) -> i32;
    fn (&mut Adder) add(n: i32) -> i32;
}

instance Adder for Counter {
    fn (c: *mut Counter) add(n: i32) -> i32 {
    fn (c: &mut Counter) add(n: i32) -> i32 {
        set c.value = c.value + n;
        return c.value;
    }
}

fn addOne(a: &mut opaque Adder) -> i32 {
    return a.add(1);
}

fn use_adder() -> i32 {
    let mut c = Counter { value: 0 };
    let a: *mut opaque Adder = &mut c;
    return a.add(1);
    return addOne(&mut c);
}

test/tests/trait.object.ril +11 -5

    store w32 %3 %0 0;
    sload w32 %4 %0 0;
    ret %4;
}

fn w32 $addOne(w64 %0) {
  @entry0
    load w64 %1 %0 0;
    load w64 %2 %0 8;
    load w64 %3 %2 0;
    call w32 %4 %3(%1, 1);
    ret %4;
}

fn w32 $use_adder() {
  @entry0
    reserve %0 4 4;
    store w32 0 %0 0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store w64 $"vtable::Counter::Adder" %1 8;
    load w64 %2 %1 0;
    load w64 %3 %1 8;
    load w64 %4 %3 0;
    call w32 %5 %4(%2, 1);
    ret %5;
    call w32 %2 $addOne(%1);
    ret %2;
}

test/tests/trait.supertrait.forward.rad +10 -7

//! returns: 0
//! A supertrait declared later must contribute methods to its child trait.

trait Child: Parent {
    fn (*Child) child() -> i32;
    fn (&Child) child() -> i32;
}

trait Parent {
    fn (*Parent) parent() -> i32;
    fn (&Parent) parent() -> i32;
}

record Value {
    n: i32,
}

instance Parent for Value {
    fn (self: *Value) parent() -> i32 {
    fn (self: &Value) parent() -> i32 {
        return self.n;
    }
}

instance Child for Value {
    fn (self: *Value) child() -> i32 {
    fn (self: &Value) child() -> i32 {
        return self.n + 1;
    }
}

@default fn main() -> i32 {
    let value = Value { n: 41 };
    let object: *opaque Child = &value;
fn checkChild(object: &opaque Child) {
    assert object.parent() == 41;
    assert object.child() == 42;
}

@default fn main() -> i32 {
    let value = Value { n: 41 };
    checkChild(&value);
    return 0;
}

test/tests/trait.supertrait.rad +24 -13

//! Test supertrait bounds: a trait that requires its implementors to also
//! implement another trait.
//!
//! Exercises: trait Reader with a `read` method, trait Writer with a `write`
//! method, and trait ReadWriter: Reader + Writer that combines both.
//! A Socket type implements all three. Coercing a `*opaque ReadWriter` to
//! `*opaque Reader` or `*opaque Writer` should work, and dispatching through
//! A Socket type implements all three. Coercing an `&mut opaque ReadWriter` to
//! `&mut opaque Reader` or `&mut 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;
    fn (&mut Reader) read(buf: &mut [u8]) -> i32;
}

trait Writer {
    fn (*mut Writer) write(data: *[u8]) -> i32;
    fn (&mut Writer) write(data: &[u8]) -> i32;
}

trait ReadWriter: Reader + Writer {
    fn (*mut ReadWriter) flush() -> i32;
    fn (&mut ReadWriter) flush() -> i32;
}

record Socket {
    rbuf: [u8; 32],
    rpos: i32,

    wbuf: [u8; 32],
    wpos: i32,
}

instance Reader for Socket {
    fn (s: *mut Socket) read(buf: *mut [u8]) -> i32 {
    fn (s: &mut Socket) read(buf: &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 {
    fn (s: &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 {
    fn (s: &mut Socket) flush() -> i32 {
        let pos = s.wpos;
        set s.wpos = 0;
        return pos;
    }
}

@default fn main() -> i32 {
fn writeThrough(rw: &mut opaque ReadWriter, data: &[u8]) -> i32 {
    return rw.write(data);
}

fn readThrough(rw: &mut opaque ReadWriter, buf: &mut [u8]) -> i32 {
    return rw.read(buf);
}

fn flushThrough(rw: &mut opaque ReadWriter) -> i32 {
    return rw.flush();
}

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

    // Test 2: Write through the ReadWriter (dispatches via Writer supertrait).
    let wn = rw.write("abc");
    let wn = writeThrough(&mut sock, &"abc"[..]);
    assert wn == 3;
    assert sock.wpos == 3;

    // Test 3: Read through the ReadWriter (dispatches via Reader supertrait).
    let mut rbuf: [u8; 8] = undefined;
    let rn = rw.read(&mut rbuf[0..8]);
    let rn = readThrough(&mut sock, &mut rbuf[..]);
    assert rn == 5;
    assert rbuf[0] == 'h' as u8;
    assert rbuf[4] == 'o' as u8;

    // Test 4: Call ReadWriter's own method.
    let flushed = rw.flush();
    let flushed = flushThrough(&mut sock);
    assert flushed == 3;
    assert sock.wpos == 0;
    return 0;
}

test/tests/trait.supertrait.ril +59 -29

    sload w32 %1 %0 72;
    store w32 0 %0 72;
    ret %1;
}

fn w32 $writeThrough(w64 %0, w64 %1) {
  @entry0
    load w64 %2 %0 0;
    load w64 %3 %0 8;
    load w64 %4 %3 8;
    call w32 %5 %4(%2, %1);
    ret %5;
}

fn w32 $readThrough(w64 %0, w64 %1) {
  @entry0
    load w64 %2 %0 0;
    load w64 %3 %0 8;
    load w64 %4 %3 0;
    call w32 %5 %4(%2, %1);
    ret %5;
}

fn w32 $flushThrough(w64 %0) {
  @entry0
    load w64 %1 %0 0;
    load w64 %2 %0 8;
    load w64 %3 %2 16;
    call w32 %4 %3(%1);
    ret %4;
}

fn w32 $main() {
  @entry0
    reserve %0 76 4;
    store w32 0 %0 32;
    store w32 5 %0 36;

    add w64 %4 %0 4;
    store w8 111 %4 0;
    reserve %5 16 8;
    store w64 %0 %5 0;
    store w64 $"vtable::Socket::ReadWriter" %5 8;
    load w64 %6 %5 0;
    load w64 %7 %5 8;
    load w64 %8 %7 8;
    copy %9 $main$literal$0;
    copy %6 $main$literal$0;
    reserve %7 16 8;
    store w64 %6 %7 0;
    store w32 3 %7 8;
    store w32 3 %7 12;
    load w64 %8 %7 0;
    load w32 %9 %7 8;
    reserve %10 16 8;
    store w64 %9 %10 0;
    store w32 3 %10 8;
    store w32 3 %10 12;
    call w32 %11 %8(%6, %10);
    store w64 %8 %10 0;
    store w32 %9 %10 8;
    store w32 %9 %10 12;
    call w32 %11 $writeThrough(%5, %10);
    br.eq w32 %11 3 @assert.ok2 @assert.fail1;
  @assert.fail1
    unreachable;
  @assert.ok2
    sload w32 %12 %0 72;
    br.eq w32 %12 3 @assert.ok4 @assert.fail3;
  @assert.fail3
    unreachable;
  @assert.ok4
    reserve %13 8 1;
    load w64 %14 %5 0;
    load w64 %15 %5 8;
    load w64 %16 %15 0;
    reserve %17 16 8;
    store w64 %13 %17 0;
    store w32 8 %17 8;
    store w32 8 %17 12;
    call w32 %18 %16(%14, %17);
    br.eq w32 %18 5 @assert.ok6 @assert.fail5;
    reserve %14 16 8;
    store w64 %0 %14 0;
    store w64 $"vtable::Socket::ReadWriter" %14 8;
    reserve %15 16 8;
    store w64 %13 %15 0;
    store w32 8 %15 8;
    store w32 8 %15 12;
    call w32 %16 $readThrough(%14, %15);
    br.eq w32 %16 5 @assert.ok6 @assert.fail5;
  @assert.fail5
    unreachable;
  @assert.ok6
    load w8 %19 %13 0;
    br.eq w8 %19 104 @assert.ok8 @assert.fail7;
    load w8 %17 %13 0;
    br.eq w8 %17 104 @assert.ok8 @assert.fail7;
  @assert.fail7
    unreachable;
  @assert.ok8
    add w64 %20 %13 4;
    load w8 %21 %20 0;
    br.eq w8 %21 111 @assert.ok10 @assert.fail9;
    add w64 %18 %13 4;
    load w8 %19 %18 0;
    br.eq w8 %19 111 @assert.ok10 @assert.fail9;
  @assert.fail9
    unreachable;
  @assert.ok10
    load w64 %22 %5 0;
    load w64 %23 %5 8;
    load w64 %24 %23 16;
    call w32 %25 %24(%22);
    br.eq w32 %25 3 @assert.ok12 @assert.fail11;
    reserve %20 16 8;
    store w64 %0 %20 0;
    store w64 $"vtable::Socket::ReadWriter" %20 8;
    call w32 %21 $flushThrough(%20);
    br.eq w32 %21 3 @assert.ok12 @assert.fail11;
  @assert.fail11
    unreachable;
  @assert.ok12
    sload w32 %26 %0 72;
    br.eq w32 %26 0 @assert.ok14 @assert.fail13;
    sload w32 %22 %0 72;
    br.eq w32 %22 0 @assert.ok14 @assert.fail13;
  @assert.fail13
    unreachable;
  @assert.ok14
    ret 0;
}

test/tests/trait.throws.rad +3 -3

record StrictParser {
    limit: i32,
}

trait Parser {
    fn (*Parser) parse(n: i32) -> i32 throws (ParseError);
    unsafe fn (*Parser) parse(n: i32) -> i32 throws (ParseError);
}

instance Parser for StrictParser {
    fn (p: *StrictParser) parse(n: i32) -> i32 throws (ParseError) {
    unsafe fn (p: *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;

    // Success path.
    let r1 = try p.parse(5) catch {

test/tests/trait.writer.rad +8 -8

//! 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 (*mut Writer) write(data: *[u8]) -> i32;
    unsafe fn (*Writer) total() -> i32;
}

/// Writes bytes into a fixed-size buffer.
record BufferWriter {
    buf: [u8; 64],
    pos: i32,
}

instance Writer for BufferWriter {
    fn (w: *mut BufferWriter) write(data: *[u8]) -> i32 {
    unsafe fn (w: *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: *BufferWriter) total() -> i32 {
        return w.pos;
    }
}

/// Counts bytes written through it, forwarding to an inner writer.

    inner: *mut opaque Writer,
    count: i32,
}

instance Writer for CountingWriter {
    fn (w: *mut CountingWriter) write(data: *[u8]) -> i32 {
    unsafe fn (w: *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: *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: *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;
    emit(w, "hello");
    assert w.total() == 5;

test/tests/type.unify.rad +6 -6


    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;


    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[..];

    return true;
}


    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;

    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 arrLarge: [i32; 3] = [10, 20, 30];
    let sliceLarge: *[i32] = &arrLarge[..];


    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;

    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/undefined.aggregate.rad +1 -1

/// Test lowering of undefined for aggregate types.
record Point { x: i32, y: i32 }

fn test() -> i32 {
unsafe fn test() -> i32 {
    let p: Point = undefined;
    return p.x;
}

test/tests/undefined.primitive.rad +1 -1

/// Test lowering of undefined for primitive types.
fn test() -> i32 {
unsafe fn test() -> i32 {
    let x: i32 = undefined;
    return x;
}

test/tests/undefined.rad +1 -1

//! returns: 0
//! Test undefined values for arrays and assignment.
@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut ary: [u16; 32] = undefined;
    let x: u32 = 8;
    let y: u32 = 9;

    set ary[0] = 1;

test/tests/undefined.record.field.rad +3 -3

    len: i32,
}

/// Construct a record with one field `undefined` (named-field syntax).
/// The IL must not contain a `blit` or `store` for `x`.
fn partialInit() -> i32 {
unsafe fn partialInit() -> i32 {
    let s = Small { x: undefined, y: 42 };
    return s.y;
}

/// Construct a record with an array field `undefined` (named-field syntax).
/// The IL must not contain a `blit` for `data`.
fn arrayFieldUndef() -> i32 {
unsafe fn arrayFieldUndef() -> i32 {
    let w = WithArray { data: undefined, len: 3 };
    return w.len;
}

/// Both fields defined - normal case for comparison.

    B,
}

/// Union variant with record payload containing an `undefined` field.
/// This exercises `lowerRecordCtor` (positional constructor path).
fn unionPayloadUndef() -> i32 {
unsafe fn unionPayloadUndef() -> i32 {
    let t = Tagged::A { data: undefined, tag: 99 };
    match t {
        case Tagged::A { tag, .. } => return tag,
        else => return -1,
    }

test/tests/union-tag.rad +2 -2

    V18,
    V19,
    V20,
}

fn tag(u: *BigUnion) -> u8 {
unsafe fn tag(u: *BigUnion) -> u8 {
    let p = u as *opaque as *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 {
    root: Node,
}

fn node(p: *mut Parser, value: Node) -> *Node {
unsafe fn node(p: *mut Parser, value: Node) -> *Node {
    set p.root = value;
    return &p.root;
}

fn nodeBool(p: *mut Parser, value: bool) -> *Node {
unsafe fn nodeBool(p: *mut Parser, value: bool) -> *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.match.ref.rad +5 -5


/// Non-void union for testing ref matching.
union Option { None, Some(u32) }

/// Match on a void union reference.
fn matchColorRef(ptr: *Color) -> u32 {
fn matchColorRef(ptr: &Color) -> u32 {
    match ptr {
        case Color::Red => return 0,
        case Color::Green => return 1,
        case Color::Blue => return 2,
    }
}

/// Match on a non-void union reference. Bindings become pointers.
fn matchRef(ptr: *Option) -> u32 {
fn matchRef(ptr: &Option) -> u32 {
    match ptr {
        case Option::None => return 0,
        case Option::Some(val) => return *val,
    }
}

/// If-let on a union reference.
fn ifLetRef(ptr: *Option) -> u32 {
fn ifLetRef(ptr: &Option) -> u32 {
    if let case Option::Some(val) = ptr {
        return *val;
    }
    return 0;
}

/// While-let on a mutable union reference.
fn whileLetRef(ptr: *mut Option) -> u32 {
fn whileLetRef(ptr: &mut Option) -> u32 {
    let mut sum: u32 = 0;
    while let case Option::Some(val) = ptr {
        set sum += *val;
        set *ptr = Option::None;
    }
    return sum;
}

/// Match on an optional reference with binding pattern.
fn optionalRef(ptr: ?*u32) -> u32 {
unsafe fn optionalRef(ptr: ?*u32) -> u32 {
    if let x = ptr {
        return *x;
    }
    return 0;
}

test/tests/union.mixed.assign.rad +2 -2


record Holder {
    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 +2 -2

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

208	203		io::printError("\n");
209	204		return Error::Other;
210	205		}
211	206
212	207		/// Print a log line for the given package.
213		-	fn pkgLog(pkg: package::Package, msg: [*[u8]]) {
	208	+	unsafe fn pkgLog(pkg: package::Package, msg: [*[u8]]) {
214	209		io::printError("radiance: ");
215	210		io::printError(pkg.name);
216	211		io::printError(": ");
217	212
218	213		for part, i in msg {

223	218		}
224	219		io::printError("\n");
225	220		}
226	221
227	222		/// Return `true` when `path` ends with `ext`.
228		-	fn hasExtension(path: [u8], ext: [u8]) -> bool {
	223	+	unsafe fn hasExtension(path: [u8], ext: [u8]) -> bool {
229	224		if path.len < ext.len {
230	225		return false;
231	226		}
232	227		let start = path.len - ext.len;
233	228		return mem::eq(&path[start..], ext);
234	229		}
235	230
236	231		/// Create an empty source input set for one package.
237		-	fn packageInput(name: *[u8]) -> PackageInput {
	232	+	unsafe fn packageInput(name: *[u8]) -> PackageInput {
238	233		return PackageInput {
239	234		name,
240	235		startupPath: nil,
241	236		radPaths: undefined,
242	237		radPathCount: 0,

244	239		asmPathCount: 0,
245	240		};
246	241		}
247	242
248	243		/// Register, load, and parse `path` within `pkg`.
249		-	fn processModule(
	244	+	unsafe fn processModule(
250	245		pkg: *mut package::Package,
251	246		graph: *mut module::ModuleGraph,
252	247		path: *[u8],
253	248		nodeArena: *mut ast::NodeArena,
254	249		sourceArena: *mut alloc::Arena

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	+	unsafe 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	293		arena: *mut ast::NodeArena
299	294		) -> CompileContext throws (Error) {
300	295		let mut buildTest = false;
301	296		let mut debugEnabled = false;

476	471		};
477	472		return RootModule { entry: rootEntry, ast: rootAst };
478	473		}
479	474
480	475		/// Dump the module graph.
481		-	fn dumpGraph(ctx: *CompileContext) {
	476	+	unsafe fn dumpGraph(ctx: *CompileContext) {
482	477		let mut arena = alloc::new(&mut MAIN_ARENA[..]);
483	478		module::printer::printGraph(&ctx.graph, &mut arena);
484	479		}
485	480
486	481		/// Dump the parsed AST.
487		-	fn dumpAst(ctx: *CompileContext) throws (Error) {
	482	+	unsafe fn dumpAst(ctx: *CompileContext) throws (Error) {
488	483		let pkg = try getEntryPackage(ctx);
489	484		let root = try getRootModule(pkg, &ctx.graph);
490	485		let mut arena = alloc::new(&mut MAIN_ARENA[..]);
491	486
492	487		ast::printer::printTree(root.ast, &mut arena);
493	488		}
494	489
495	490		/// Lower all packages into a single IL program.
496	491		/// Dependencies are lowered first, then the entry package.
497		-	fn lowerAllPackages(
	492	+	unsafe fn lowerAllPackages(
498	493		ctx: *mut CompileContext,
499	494		res: *mut resolver::Resolver
500	495		) -> il::Program throws (Error) {
501	496		let entryIdx = ctx.entryPkgIdx else {
502	497		panic "lowerAllPackages: no entry package";

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	+	SEED_OPTS := $(STD) -pkg radiance -mod compiler/radiance.rad -mod compiler/radiance/codegenSink.rad -entry radiance
42	42
43		-	$(RAD_BIN): $(STD_LIB) compiler/radiance.rad \| $(BIN_DIR)
	43	+	$(RAD_BIN): $(STD_LIB) compiler/radiance.rad compiler/radiance/codegenSink.rad \| $(BIN_DIR)
44	44		@echo "radiance $(SEED) => $@"
45	45		@$(EMU) $(EMU_FLAGS) -run $(SEED) $(SEED_OPTS) -o $@
46	46
47	47		$(BIN_DIR):
48	48		@mkdir -p $@

42	42		/// Main arena size (96 MB) - lives throughout compilation.
43	43		/// Used for: resolver data, types, symbols, global IL data, and codegen output.
44	44		constant MAIN_ARENA_SIZE: u32 = 100663296;
45	45
46	46		/// AST storage arena.
47		-	static TEMP_ARENA: [u8; TEMP_ARENA_SIZE] = undefined;
	47	+	unsafe static TEMP_ARENA: [u8; TEMP_ARENA_SIZE] = undefined;
48	48		/// Scratch storage reclaimed after each generated function.
49		-	static FN_ARENA: [u8; FN_ARENA_SIZE] = undefined;
	49	+	unsafe static FN_ARENA: [u8; FN_ARENA_SIZE] = undefined;
50	50		/// Main storage arena - persists throughout compilation.
51		-	static MAIN_ARENA: [u8; MAIN_ARENA_SIZE] = undefined;
	51	+	unsafe static MAIN_ARENA: [u8; MAIN_ARENA_SIZE] = undefined;
52	52
53	53		/// Module source code.
54		-	static MODULE_SOURCES: [u8; MAX_SOURCES_SIZE] = undefined;
	54	+	unsafe static MODULE_SOURCES: [u8; MAX_SOURCES_SIZE] = undefined;
55	55		/// Module entries for all packages.
56		-	static MODULE_ENTRIES: [module::ModuleEntry; MAX_TOTAL_MODULES] = undefined;
	56	+	unsafe static MODULE_ENTRIES: [module::ModuleEntry; MAX_TOTAL_MODULES] = undefined;
57	57		/// String pool.
58		-	static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
	58	+	unsafe static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
59	59
60	60		/// Package scope.
61		-	static RESOLVER_PKG_SCOPE: resolver::Scope = undefined;
	61	+	unsafe static RESOLVER_PKG_SCOPE: resolver::Scope = undefined;
62	62		/// Errors emitted by resolver.
63		-	static RESOLVER_ERRORS: [resolver::Error; resolver::MAX_ERRORS] = undefined;
	63	+	unsafe static RESOLVER_ERRORS: [resolver::Error; resolver::MAX_ERRORS] = undefined;
64	64
65	65		/// Code generation storage.
66		-	static CODEGEN_DATA_SYMS: [data::DataSym; data::MAX_DATA_SYMS] = undefined;
	66	+	unsafe static CODEGEN_DATA_SYMS: [data::DataSym; data::MAX_DATA_SYMS] = undefined;
67	67		/// Hash table entries for data symbol lookup.
68		-	static CODEGEN_DATA_SYM_ENTRIES: [dict::Entry; data::DATA_SYM_TABLE_SIZE] = undefined;
	68	+	unsafe static CODEGEN_DATA_SYM_ENTRIES: [dict::Entry; data::DATA_SYM_TABLE_SIZE] = undefined;
69	69
70	70		/// Debug info file extension.
71		-	constant DEBUG_EXT: *[u8] = ".debug";
	71	+	unsafe constant DEBUG_EXT: *[u8] = ".debug";
72	72
73	73		/// Maximum rodata size (4MB).
74	74		constant MAX_RO_DATA_SIZE: u32 = 4194304;
75	75		/// Maximum rwdata size (4MB).
76	76		constant MAX_RW_DATA_SIZE: u32 = 4194304;
77	77		/// Maximum path length.
78	78		constant MAX_PATH_LEN: u32 = 256;
79	79		/// Read-only data buffer.
80		-	static RO_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = undefined;
	80	+	unsafe static RO_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = undefined;
81	81		/// Read-write data buffer.
82		-	static RW_DATA_BUF: [u8; MAX_RW_DATA_SIZE] = undefined;
	82	+	unsafe static RW_DATA_BUF: [u8; MAX_RW_DATA_SIZE] = undefined;
83	83		/// Assembly module source buffer.
84		-	static ASM_SOURCE_BUF: [u8; MAX_SOURCES_SIZE] = undefined;
	84	+	unsafe static ASM_SOURCE_BUF: [u8; MAX_SOURCES_SIZE] = undefined;
85	85		/// Temporary assembly text buffer.
86		-	static ASM_TEXT_BUF: [u32; 262144] = undefined;
	86	+	unsafe static ASM_TEXT_BUF: [u32; 262144] = undefined;
87	87		/// Temporary assembly data buffer.
88		-	static ASM_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = undefined;
	88	+	unsafe static ASM_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = undefined;
89	89		/// Accumulated assembly read-only data.
90		-	static ASM_RO_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = undefined;
	90	+	unsafe static ASM_RO_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = undefined;
91	91
92	92		/// Assembly source file extension.
93		-	constant ASM_SOURCE_EXT: *[u8] = ".ras";
	93	+	unsafe constant ASM_SOURCE_EXT: *[u8] = ".ras";
94	94		/// Symbol name exported for startup code to call the semantic entry function.
95		-	constant DEFAULT_ENTRY_SYMBOL: *[u8] = "::default";
	95	+	unsafe constant DEFAULT_ENTRY_SYMBOL: *[u8] = "::default";
96	96
97	97		/// Usage string.
98		-	constant USAGE: *[u8] =
	98	+	unsafe constant USAGE: *[u8] =
99	99		"usage: radiance -pkg <name> [-start <input.ras>] -mod <input>.. [-pkg <name> -mod <input>..] -entry <pkg> -o <output>\n";
100	100
101	101		/// Compiler error.
102	102		union Error {
103	103		Other,

167	167		record RootModule {
168	168		entry: *module::ModuleEntry,
169	169		ast: *mut ast::Node,
170	170		}
171	171
172		-	/// State carried by the streaming lowerer/codegen callback.
173		-	record CodegenSinkContext {
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		-	}
	172	+	/// Trusted implementation for streamed code generation.
	173	+	unsafe mod codegenSink;
179	174
180	175		/// Entry handling for streamed code generation.
181	176		union CodegenEntryMode {
182	177		/// Do not reserve an entry jump.
183	178		None,

194	189		/// How the generated program should handle entry.
195	190		entryMode: CodegenEntryMode,
196	191		}
197	192
198	193		/// Print a driver error line.
199		-	fn error(msg: [[u8]]) -> Error {
	194	+	unsafe fn error(msg: [[u8]]) -> Error {
200	195		io::printError("radiance: ");
201	196
202	197		for part, i in msg {
203	198		io::printError(part);
204	199		if i < msg.len - 1 {

446	441		}
447	442		return ctx;
448	443		}
449	444
450	445		/// Get the entry package from the context.
451		-	fn getEntryPackage(ctx: CompileContext) -> package::Package throws (Error) {
	446	+	unsafe fn getEntryPackage(ctx: CompileContext) -> package::Package throws (Error) {
452	447		let entryIdx = ctx.entryPkgIdx else {
453	448		throw error(&["no entry package specified"]);
454	449		};
455	450		return &ctx.packages[entryIdx];
456	451		}
457	452
458	453		/// Return the startup assembly path for the entry package, if one was supplied.
459		-	fn getEntryStartupPath(ctx: CompileContext) -> ?[u8] {
	454	+	unsafe fn getEntryStartupPath(ctx: CompileContext) -> ?[u8] {
460	455		let entryIdx = ctx.entryPkgIdx else {
461	456		panic "getEntryStartupPath: no entry package";
462	457		};
463	458		return ctx.inputs[entryIdx].startupPath;
464	459		}
465	460
466	461		/// Get root module info from a package.
467		-	fn getRootModule(pkg: package::Package, graph: module::ModuleGraph) -> RootModule throws (Error) {
	462	+	unsafe fn getRootModule(pkg: package::Package, graph: module::ModuleGraph) -> RootModule throws (Error) {
468	463		let rootId = pkg.rootModuleId else {
469	464		throw error(&["no root module found"]);
470	465		};
471	466		let rootEntry = module::get(graph, rootId) else {
472	467		throw error(&["root module entry not found"]);

513	508		// Finalize and return the unified program.
514	509		return lower::finalize(&low);
515	510		}
516	511
517	512		/// Lower all packages into an existing lowerer.
518		-	fn lowerAllPackagesInto(
	513	+	unsafe fn lowerAllPackagesInto(
519	514		ctx: *mut CompileContext,
520	515		res: *mut resolver::Resolver,
521	516		low: *mut lower::Lowerer
522	517		) throws (Error) {
523	518		let entryIdx = ctx.entryPkgIdx else {

532	527		// Lower entry package.
533	528		try lowerPackage(ctx, res, low, &mut ctx.packages[entryIdx], true);
534	529		}
535	530
536	531		/// Lower all modules in a package into the lowerer accumulator.
537		-	fn lowerPackage(
	532	+	unsafe fn lowerPackage(
538	533		ctx: *CompileContext,
539	534		res: *mut resolver::Resolver,
540	535		low: *mut lower::Lowerer,
541	536		pkg: *mut package::Package,
542	537		isEntry: bool

550	545
551	546		try lowerModuleTreeInto(ctx, low, &ctx.graph, rootId, isEntry, pkg);
552	547		}
553	548
554	549		/// Recursively lower a module and all its children into the accumulator.
555		-	fn lowerModuleTreeInto(
	550	+	unsafe fn lowerModuleTreeInto(
556	551		ctx: *CompileContext,
557	552		low: *mut lower::Lowerer,
558	553		graph: *module::ModuleGraph,
559	554		modId: u16,
560	555		isRoot: bool,

582	577		try lowerModuleTreeInto(ctx, low, graph, childId, false, pkg);
583	578		}
584	579		}
585	580
586	581		/// Build a scope access chain: a::b::c from a slice of identifiers.
587		-	fn synthScopeAccess(arena: mut ast::NodeArena, path: [[u8]]) -> ast::Node {
	582	+	unsafe fn synthScopeAccess(arena: mut ast::NodeArena, path: [[u8]]) -> ast::Node {
588	583		let mut result = ast::synthNode(
589	584		arena,
590	585		ast::NodeValue::Ident(strings::intern(&mut STRING_POOL, path[0]))
591	586		);
592	587		for i in 1..path.len {

600	595		}
601	596		return result;
602	597		}
603	598
604	599		/// Check if a function declaration has the `@test` attribute and return its name if so.
605		-	fn getTestFnName(decl: ast::FnDecl) -> ?[u8] {
	600	+	unsafe fn getTestFnName(decl: ast::FnDecl) -> ?[u8] {
606	601		let attrs = decl.attrs else { return nil; };
607	602		if not ast::attributesContains(&attrs, ast::Attribute::Test) {
608	603		return nil;
609	604		}
610	605		let case ast::NodeValue::Ident(name) = decl.name.value

612	607
613	608		return name;
614	609		}
615	610
616	611		/// Scan a single module's AST for `@test` functions and append them to `tests`.
617		-	fn collectModuleTests(
	612	+	unsafe fn collectModuleTests(
618	613		entry: *module::ModuleEntry,
619	614		tests: *mut [TestDesc],
620	615		testCount: *mut u32
621	616		) {
622	617		let modAst = entry.ast else {

640	635		}
641	636		}
642	637		}
643	638
644	639		/// Synthesize a `testing::test("mod", "name", mod::fn)` call for one test.
645		-	fn synthTestCall(arena: mut ast::NodeArena, desc: TestDesc) -> *ast::Node {
	640	+	unsafe fn synthTestCall(arena: mut ast::NodeArena, desc: TestDesc) -> *ast::Node {
646	641		let callee = synthScopeAccess(arena, &["testing", "test"]);
647	642		let modStr = il::formatQualifiedName(
648	643		&mut arena.arena,
649	644		&desc.modPath[..desc.modPath.len - 1],
650	645		desc.modPath[desc.modPath.len - 1]

682	677		/// ]);
683	678		/// }
684	679		/// ```
685	680		///
686	681		/// Uses `#`-prefixed names to avoid conflicts with user code.
687		-	fn generateTestRunner(
	682	+	unsafe fn generateTestRunner(
688	683		ctx: *mut CompileContext,
689	684		arena: *mut ast::NodeArena
690	685		) throws (Error) {
691	686		let entryPkg = try getEntryPackage(ctx);
692	687		let root = try getRootModule(entryPkg, &ctx.graph);

712	707
713	708		injectIntoBlock(root.ast, arena, fnDecl);
714	709		}
715	710
716	711		/// Synthesize the test entry point.
717		-	fn synthTestMainFn(arena: mut ast::NodeArena, tests: [TestDesc]) -> *ast::Node {
	712	+	unsafe fn synthTestMainFn(arena: mut ast::NodeArena, tests: [TestDesc]) -> *ast::Node {
718	713		// Build array literal: `[testing::test(...), ...]`.
719	714		let a = alloc::arenaAllocator(&mut arena.arena);
720	715		let mut elements = ast::nodeSlice(arena, tests.len as u32);
721	716		for i in 0..tests.len {
722	717		elements.append(synthTestCall(arena, &tests[i]), a);

760	755		name: fnName, sig: fnSig, body: fnBody, attrs: fnAttrs,
761	756		}));
762	757		}
763	758
764	759		/// Append a declaration to a block node's statement list.
765		-	fn injectIntoBlock(
	760	+	unsafe fn injectIntoBlock(
766	761		blockNode: *mut ast::Node,
767	762		arena: *mut ast::NodeArena,
768	763		decl: *ast::Node
769	764		) {
770	765		let case ast::NodeValue::Block(block) = blockNode.value else {

773	768		let stmts = block.statements.append(decl, alloc::arenaAllocator(&mut arena.arena));
774	769		set blockNode.value = ast::NodeValue::Block(ast::Block { statements: stmts });
775	770		}
776	771
777	772		/// Write a self-contained RV64 image containing text and data sections.
778		-	fn writeImage(
	773	+	unsafe fn writeImage(
779	774		code: *[u32],
780	775		roData: *[u8],
781	776		rwData: *[u8],
782	777		path: *[u8]
783	778		) -> bool {

789	784		return unix::writeFileParts(path, &[headerBytes, codeBytes, roData, rwData]);
790	785		}
791	786
792	787		/// Write a data section to a file at `basePath` + `ext`.
793	788		/// Empty data truncates any stale sidecar left by an earlier build.
794		-	fn writeDataWithExt(
	789	+	unsafe fn writeDataWithExt(
795	790		data: *[u8],
796	791		basePath: *[u8],
797	792		ext: *[u8]
798	793		) throws (Error) {
799	794		let mut path: [u8; MAX_PATH_LEN] = undefined;

809	804		}
810	805
811	806		/// Serialize debug entries and write the `.debug` file.
812	807		/// Resolves module IDs to file paths via the module graph.
813	808		/// Format per entry is `{pc: u32, offset: u32, filePath: [u8], NULL}`.
814		-	fn writeDebugInfo(
	809	+	unsafe fn writeDebugInfo(
815	810		entries: *[types::DebugEntry],
816	811		graph: *module::ModuleGraph,
817	812		basePath: *[u8],
818	813		arena: *mut alloc::Arena
819	814		) throws (Error) {

838	833		}
839	834		try writeDataWithExt(&buf[..pos], basePath, DEBUG_EXT);
840	835		}
841	836
842	837		/// Run the resolver on the parsed modules.
843		-	fn runResolver(ctx: *mut CompileContext, nodeCount: u32) -> resolver::Resolver throws (Error) {
	838	+	unsafe fn runResolver(ctx: *mut CompileContext, nodeCount: u32) -> resolver::Resolver throws (Error) {
844	839		let mut mainArena = alloc::new(&mut MAIN_ARENA[..]);
845	840		let entryPkg = try getEntryPackage(ctx);
846	841
847	842		pkgLog(entryPkg, &["resolving", ".."]);
848	843

885	880		throw error(&["failed:", countStr, "errors"]);
886	881		}
887	882		return res;
888	883		}
889	884
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	885
912	886		/// Assemble one `.ras` input and merge it into the active code generator.
913	887		///
914	888		/// Text symbols are appended to `generator`. Data emitted by the assembler is
915	889		/// copied into `ASM_RO_DATA_BUF` at `asmDataLen`, and `asmDataLen` is advanced
916	890		/// so the next assembly module receives the correct rodata base address.
917		-	fn assembleAsmModule(
	891	+	unsafe fn assembleAsmModule(
918	892		generator: *mut rv64::Generator,
919	893		pkg: *package::Package,
920	894		path: *[u8],
921	895		asmDataLen: *mut u32,
922	896		arena: *mut alloc::Arena

948	922
949	923		rv64::addAssembly(generator, program);
950	924		}
951	925
952	926		/// Assemble all inputs collected in the package inputs.
953		-	fn assembleAsmInputs(
	927	+	unsafe fn assembleAsmInputs(
954	928		ctx: *CompileContext,
955	929		generator: *mut rv64::Generator,
956	930		asmDataLen: *mut u32,
957	931		arena: *mut alloc::Arena
958	932		) -> *[u8] throws (Error) {

970	944		}
971	945		return &ASM_RO_DATA_BUF[..*asmDataLen];
972	946		}
973	947
974	948		/// Lower all packages while streaming each lowered function into RV64 codegen.
975		-	fn lowerAndGenerateAllPackages(
	949	+	unsafe fn lowerAndGenerateAllPackages(
976	950		ctx: *mut CompileContext,
977	951		res: *mut resolver::Resolver,
978	952		fnArena: *mut alloc::Arena,
979	953		codegenOptions: CodegenOptions
980	954		) -> rv64::Program throws (Error) {

997	971		}
998	972		let mut generator = rv64::beginProgram(
999	973		rv64::ProgramOptions { entryPatch, debug: codegenOptions.debug },
1000	974		&mut res.arena
1001	975		);
1002		-	let mut codegenCtx = CodegenSinkContext {
	976	+	let mut codegenCtx = codegenSink::Context {
1003	977		generator: &mut generator,
1004	978		fnArena,
1005	979		};
1006	980		let mut low = lower::lowerer(
1007	981		res, &ctx.graph, entryPkg.name, &mut res.arena, fnArena, options
1008	982		);
1009	983		set low.output = lower::FnOutput::Stream(lower::FnSink {
1010		-	ctx: &mut codegenCtx as *mut opaque,
1011		-	emitFn: generateLoweredFn,
	984	+	ctx: codegenSink::eraseContext(&mut codegenCtx),
	985	+	emitFn: codegenSink::generate,
1012	986		});
1013	987		let mut asmDataLen: u32 = 0;
1014	988		if let path = startupPath {
1015	989		try assembleAsmModule(&mut generator, entryPkg, path, &mut asmDataLen, &mut res.arena);
1016	990		}

1030	1004		}
1031	1005		return rv64::finishProgram(&mut generator, &low.data[..], storage, asmData, &mut RO_DATA_BUF[..], &mut RW_DATA_BUF[..]);
1032	1006		}
1033	1007
1034	1008		/// Lower, optionally dump, and optionally generate binary output.
1035		-	fn compile(
	1009	+	unsafe fn compile(
1036	1010		ctx: *mut CompileContext,
1037	1011		res: *mut resolver::Resolver,
1038	1012		fnArena: *mut alloc::Arena
1039	1013		) throws (Error) {
1040	1014		let entryPkg = try getEntryPackage(ctx);

1086	1060		try writeDebugInfo(result.debugEntries, &ctx.graph, outPath, &mut res.arena);
1087	1061		}
1088	1062		pkgLog(entryPkg, &["ok", "(", outPath, ")"]);
1089	1063		}
1090	1064
1091		-	@default fn main(env: *sys::Env) -> i32 {
	1065	+	@default unsafe fn main(env: *sys::Env) -> i32 {
1092	1066		let mut arena = ast::nodeArena(&mut TEMP_ARENA[..]);
1093	1067		let mut ctx = try processCommand(env.args, &mut arena) catch {
1094	1068		return 1;
1095	1069		};
1096	1070		match ctx.dump {

1	1		//! The Radiance Standard Library.
2	2
3		-	export mod io;
4		-	export mod collections;
	3	+	export unsafe mod io;
	4	+	export unsafe mod collections;
5	5		export mod char;
6		-	export mod lang;
7		-	export mod sys;
8		-	export mod arch;
9		-	export mod fmt;
10		-	export mod mem;
11		-	export mod vec;
12		-	export mod intrinsics;
	6	+	export unsafe mod lang;
	7	+	export unsafe mod sys;
	8	+	export unsafe mod arch;
	9	+	export unsafe mod fmt;
	10	+	export unsafe mod mem;
	11	+	export unsafe mod vec;
	12	+	export unsafe mod intrinsics;
13	13
14	14		// Test modules.
15		-	@test export mod testing;
16		-	@test export mod tests;
	15	+	@test export unsafe mod testing;
	16	+	@test export unsafe mod tests;

260	260		export constant SHIFT_LIMIT: i32 = 64;
261	261		/// Largest `lui` or `auipc` immediate.
262	262		export constant UPPER_IMM_MAX_VALUE: i64 = 0xFFFFF;
263	263
264	264		/// Sorted instruction descriptor table used by the assembler parser.
265		-	export constant INSTRUCTIONS: [InstructionEntry; 88] = [
	265	+	export unsafe constant INSTRUCTIONS: [InstructionEntry; 88] = [
266	266		{ name: "add", encoder: InstructionEncoder::RRR { enc: encode::add } },
267	267		{ name: "addi", encoder: InstructionEncoder::RRI { enc: encode::addi } },
268	268		{ name: "addiw", encoder: InstructionEncoder::RRI { enc: encode::addiw } },
269	269		{ name: "addw", encoder: InstructionEncoder::RRR { enc: encode::addw } },
270	270		{ name: "and", encoder: InstructionEncoder::RRR { enc: encode::and_ } },

352	352		{ name: "xor", encoder: InstructionEncoder::RRR { enc: encode::xor } },
353	353		{ name: "xori", encoder: InstructionEncoder::RRI { enc: encode::xori } },
354	354		];
355	355
356	356		/// Sorted directive lookup table used by the assembler parser.
357		-	export constant DIRECTIVES: [DirectiveEntry; 10] = [
	357	+	export unsafe constant DIRECTIVES: [DirectiveEntry; 10] = [
358	358		{ name: "align", kind: DirectiveKind::Align },
359	359		{ name: "ascii", kind: DirectiveKind::Ascii },
360	360		{ name: "byte", kind: DirectiveKind::Byte },
361	361		{ name: "constant", kind: DirectiveKind::Constant },
362	362		{ name: "data", kind: DirectiveKind::Data },

366	366		{ name: "text", kind: DirectiveKind::Text },
367	367		{ name: "word", kind: DirectiveKind::Word },
368	368		];
369	369
370	370		/// Sorted register-name lookup table used by the assembler parser.
371		-	export constant REGISTERS: [RegisterEntry; 33] = [
	371	+	export unsafe constant REGISTERS: [RegisterEntry; 33] = [
372	372		{ name: "a0", reg: rv64::A0 },
373	373		{ name: "a1", reg: rv64::A1 },
374	374		{ name: "a2", reg: rv64::A2 },
375	375		{ name: "a3", reg: rv64::A3 },
376	376		{ name: "a4", reg: rv64::A4 },

403	403		{ name: "tp", reg: rv64::TP },
404	404		{ name: "zero", reg: rv64::ZERO },
405	405		];
406	406
407	407		/// Sorted CSR-name lookup table used by the assembler parser.
408		-	export constant CSRS: [CsrEntry; 9] = [
	408	+	export unsafe constant CSRS: [CsrEntry; 9] = [
409	409		{ name: "mcause", csr: 0x342 },
410	410		{ name: "mepc", csr: 0x341 },
411	411		{ name: "mhartid", csr: 0xF14 },
412	412		{ name: "mie", csr: 0x304 },
413	413		{ name: "mip", csr: 0x344 },