radiance · commit

compiler/radiance.rad +33 -33

    };
}

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

    let mut pkgNames: [*[u8]; MAX_PACKAGES] = undefined;
    let mut pkgCount: u32 = 0;
    let mut currentPkgIdx: ?u32 = nil;

    for i in 0..MAX_PACKAGES {
        moduleCounts[i] = 0;
        set moduleCounts[i] = 0;
    }
    if args.len == 0 {
        io::printError(USAGE);
        throw Error::Other;
    }

            try nextArg(args, &mut idx, "radiance: `-pkg` requires a package name\n");
            if pkgCount >= MAX_PACKAGES {
                io::printError("radiance: too many packages specified\n");
                throw Error::Other;
            }
            pkgNames[pkgCount] = args[idx];
            currentPkgIdx = pkgCount;
            pkgCount += 1;
            set pkgNames[pkgCount] = args[idx];
            set currentPkgIdx = pkgCount;
            set pkgCount += 1;
        } else if mem::eq(arg, "-mod") {
            try nextArg(args, &mut idx, "radiance: `-mod` requires a module path\n");
            let pkgIdx = currentPkgIdx else {
                io::printError("radiance: `-mod` must follow a `-pkg` argument\n");
                throw Error::Other;
            };
            if moduleCounts[pkgIdx] >= MAX_LOADED_MODULES {
                io::printError("radiance: too many modules specified for package\n");
                throw Error::Other;
            }
            modulePaths[pkgIdx][moduleCounts[pkgIdx]] = args[idx];
            moduleCounts[pkgIdx] += 1;
            set modulePaths[pkgIdx][moduleCounts[pkgIdx]] = args[idx];
            set moduleCounts[pkgIdx] += 1;
        } else if mem::eq(arg, "-entry") {
            try nextArg(args, &mut idx, "radiance: `-entry` requires a package name\n");
            entryPkgName = args[idx];
            set entryPkgName = args[idx];
        } else if mem::eq(arg, "-test") {
            buildTest = true;
            set buildTest = true;
        } else if mem::eq(arg, "-debug") {
            debugEnabled = true;
            set debugEnabled = true;
        } else if mem::eq(arg, "-o") {
            try nextArg(args, &mut idx, "radiance: `-o` requires an output path\n");
            outputPath = args[idx];
            set outputPath = args[idx];
        } else if mem::eq(arg, "-dump") {
            try nextArg(args, &mut idx, "radiance: `-dump` requires a mode (eg. ast)\n");
            let mode = args[idx];
            if mem::eq(mode, "ast") {
                dump = Dump::Ast;
                set dump = Dump::Ast;
            } else if mem::eq(mode, "graph") {
                dump = Dump::Graph;
                set dump = Dump::Graph;
            } else if mem::eq(mode, "il") {
                dump = Dump::Il;
                set dump = Dump::Il;
            } else if mem::eq(mode, "asm") {
                dump = Dump::Asm;
                set dump = Dump::Asm;
            } else {
                io::printError("radiance: unknown dump mode `");
                io::printError(mode);
                io::printError("` (expected: ast, graph, il, asm)\n");
                throw Error::Other;

            io::printError("radiance: unknown argument `");
            io::printError(arg);
            io::printError("`\n");
            throw Error::Other;
        }
        idx += 1;
        set idx += 1;
    }
    if pkgCount == 0 {
        io::printError("radiance: no package specified\n");
        throw Error::Other;
    }

    // Determine entry package index.
    let mut entryPkgIdx: ?u32 = nil;
    if pkgCount == 1 {
        // Single package: it is the entry.
        entryPkgIdx = 0;
        set entryPkgIdx = 0;
    } else {
        // Multiple packages: need -entry.
        let entryName = entryPkgName else {
            io::printError("radiance: `-entry` required when multiple packages specified\n");
            throw Error::Other;
        };
        for i in 0..pkgCount {
            if mem::eq(pkgNames[i], entryName) {
                entryPkgIdx = i;
                set entryPkgIdx = i;
                break;
            }
        }
        if entryPkgIdx == nil {
            io::printError("radiance: fatal: entry package `");

    for i in 1..path.len {
        let child = ast::synthNode(
            arena,
            ast::NodeValue::Ident(strings::intern(&mut STRING_POOL, path[i]))
        );
        result = ast::synthNode(arena, ast::NodeValue::ScopeAccess(ast::Access {
        set result = ast::synthNode(arena, ast::NodeValue::ScopeAccess(ast::Access {
            parent: result, child,
        }));
    }
    return result;
}


    for stmt in block.statements {
        if let case ast::NodeValue::FnDecl(decl) = stmt.value {
            if let fnName = getTestFnName(&decl) {
                if *testCount < tests.len {
                    tests[*testCount] = TestDesc { modPath, fnName };
                    *testCount += 1;
                    set tests[*testCount] = TestDesc { modPath, fnName };
                    set *testCount += 1;
                } else {
                    panic "collectModuleTests: too many tests";
                }
            }
        }

    let nameArg = ast::synthNode(arena, ast::NodeValue::String(desc.fnName));

    // Intra-package path: skip the package name prefix.
    let mut funcPath: [*[u8]; 16] = undefined;
    for j in 1..desc.modPath.len {
        funcPath[j - 1] = desc.modPath[j];
        set funcPath[j - 1] = desc.modPath[j];
    }
    funcPath[desc.modPath.len - 1] = desc.fnName;
    set funcPath[desc.modPath.len - 1] = desc.fnName;
    let funcArg = synthScopeAccess(arena, &funcPath[..desc.modPath.len]);

    let a = alloc::arenaAllocator(&mut arena.arena);
    let args = ast::nodeSlice(arena, 3)
        .append(modArg, a)

) {
    let case ast::NodeValue::Block(block) = blockNode.value else {
        panic "injectIntoBlock: expected Block node";
    };
    let stmts = block.statements.append(decl, alloc::arenaAllocator(&mut arena.arena));
    blockNode.value = ast::NodeValue::Block(ast::Block { statements: stmts });
    set blockNode.value = ast::NodeValue::Block(ast::Block { statements: stmts });
}

/// Write code buffer to file as raw bytes.
fn writeCode(code: *[u32], path: *[u8]) -> bool {
    // Convert `u32` slice to `u8` slice (little-endian).

        return;
    }
    let mut path: [u8; MAX_PATH_LEN] = undefined;
    let mut pos: u32 = 0;

    pos += try! mem::copy(&mut path[pos..], basePath);
    pos += try! mem::copy(&mut path[pos..], ext);
    path[pos] = 0; // Null-terminate for syscall.
    set pos += try! mem::copy(&mut path[pos..], basePath);
    set pos += try! mem::copy(&mut path[pos..], ext);
    set path[pos] = 0; // Null-terminate for syscall.

    if not unix::writeFile(&path[..pos], data) {
        io::printError("radiance: fatal: failed to write data file\n");
        throw Error::Other;
    }

    for i in 0..entries.len {
        let entry = &entries[i];
        let modEntry = module::get(graph, entry.moduleId) else {
            panic "writeDebugInfo: module not found for debug entry";
        };
        pos += try! mem::copy(&mut buf[pos..], @sliceOf(&entry.pc as *u8, 4));
        pos += try! mem::copy(&mut buf[pos..], @sliceOf(&entry.offset as *u8, 4));
        pos += try! mem::copy(&mut buf[pos..], modEntry.filePath);
        set pos += try! mem::copy(&mut buf[pos..], @sliceOf(&entry.pc as *u8, 4));
        set pos += try! mem::copy(&mut buf[pos..], @sliceOf(&entry.offset as *u8, 4));
        set pos += try! mem::copy(&mut buf[pos..], modEntry.filePath);

        buf[pos] = 0;
        pos += 1;
        set buf[pos] = 0;
        set pos += 1;
    }
    try writeDataWithExt(&buf[..pos], basePath, DEBUG_EXT);
}

/// Run the resolver on the parsed modules.

    let mut packages: [resolver::Pkg; MAX_PACKAGES] = undefined;
    for i in 0..ctx.packageCount {
        let pkg = &ctx.packages[i];
        let root = try getRootModule(pkg, &ctx.graph);

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


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


    // Emit placeholder entry jump to default function if there is one.
    // We'll patch this at the end once we know where the function is.
    let mut defaultName: ?*[u8] = nil;
    if let defIdx = program.defaultFnIdx {
        defaultName = program.fns[defIdx].name;
        set defaultName = program.fns[defIdx].name;
        emit::emit(&mut e, encode::nop()); // Placeholder for two-instruction jump.
        emit::emit(&mut e, encode::nop()); //
    }

    // Generate code for all functions.

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

    let savedRegs = mem::popCount(usedCalleeSaved) + 2;
    let totalSize = mem::alignUpI32(
        localSize + savedRegs * super::DWORD_SIZE,
        super::STACK_ALIGNMENT
    );
    frame.totalSize = totalSize;
    set frame.totalSize = totalSize;

    // Build list of callee-saved registers with offsets.
    let mut offset = totalSize - (super::DWORD_SIZE * 3);
    for reg, i in super::CALLEE_SAVED {
        // Check if this register is in use.
        if (usedCalleeSaved & (1 << i)) <> 0 {
            frame.savedRegs[frame.savedRegsLen] = SavedReg {
            set frame.savedRegs[frame.savedRegsLen] = SavedReg {
                reg,
                offset,
            };
            frame.savedRegsLen += 1;
            offset -= super::DWORD_SIZE;
            set frame.savedRegsLen += 1;
            set offset -= super::DWORD_SIZE;
        }
    }
    return frame;
}


    let funcEntries = try alloc::allocSlice(arena, @sizeOf(dict::Entry), @alignOf(dict::Entry), labels::FUNC_TABLE_SIZE);
    let funcs = try alloc::allocSlice(arena, @sizeOf(types::FuncAddr), @alignOf(types::FuncAddr), MAX_FUNCS);

    let mut debugEntries: *mut [types::DebugEntry] = &mut [];
    if debug {
        debugEntries = try alloc::allocSlice(
        set debugEntries = try alloc::allocSlice(
            arena, @sizeOf(types::DebugEntry), @alignOf(types::DebugEntry), MAX_DEBUG_ENTRIES
        ) as *mut [types::DebugEntry];
    }
    return Emitter {
        code: code as *mut [u32],

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

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

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

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

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

}

/// Record a function's start position for printing.
export fn recordFunc(e: *mut Emitter, name: *[u8]) {
    assert e.funcsLen < e.funcs.len, "recordFunc: funcs buffer full";
    e.funcs[e.funcsLen] = types::FuncAddr { name, index: e.codeLen };
    e.funcsLen += 1;
    set e.funcs[e.funcsLen] = types::FuncAddr { name, index: e.codeLen };
    set e.funcsLen += 1;
}

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

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

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

/// Record a function call needing later patching.
/// Emits placeholder instructions that will be patched later.
/// Uses two slots to support long-distance calls.
export fn recordCall(e: *mut Emitter, target: *[u8]) {
    assert e.pendingCallsLen < e.pendingCalls.len, "recordCall: buffer full";
    e.pendingCalls[e.pendingCallsLen] = PendingCall {
    set e.pendingCalls[e.pendingCallsLen] = PendingCall {
        index: e.codeLen,
        target,
    };
    e.pendingCallsLen += 1;
    set e.pendingCallsLen += 1;

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

/// Record a function address load needing later patching.
/// Emits placeholder instructions that will be patched to load the function's address.
/// Uses two slots to compute long-distance addresses.
export fn recordAddrLoad(e: *mut Emitter, target: *[u8], rd: gen::Reg) {
    assert e.pendingAddrLoadsLen < e.pendingAddrLoads.len, "recordAddrLoad: buffer full";
    e.pendingAddrLoads[e.pendingAddrLoadsLen] = PendingAddrLoad {
    set e.pendingAddrLoads[e.pendingAddrLoadsLen] = PendingAddrLoad {
        index: e.codeLen,
        target,
        rd: rd,
    };
    e.pendingAddrLoadsLen += 1;
    set e.pendingAddrLoadsLen += 1;

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


                assert encode::isJumpImm(offset), "patchLocalBranches: jump offset too large";
                patch(e, p.index, encode::jal(super::ZERO, offset));
            },
        }
    }
    e.pendingBranchesLen = 0;
    set e.pendingBranchesLen = 0;
}

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

    let lo = imm & 0xFFF;
    let mut hi = (imm >> 12) & 0xFFFFF;
    // If `lo`'s sign bit is set, it will be sign-extended to negative.
    // Compensate by incrementing `hi`.
    if (lo & 0x800) <> 0 {
        hi += 1;
        set hi += 1;
        return SplitImm { hi, lo: lo | 0xFFFFF000 as i32 };
    }
    return SplitImm { hi, lo };
}


        if prev.offset == loc.offset and prev.moduleId == loc.moduleId {
            return;
        }
    }
    assert e.debugEntriesLen < e.debugEntries.len, "recordSrcLoc: debug entry buffer full";
    e.debugEntries[e.debugEntriesLen] = types::DebugEntry {
    set e.debugEntries[e.debugEntriesLen] = types::DebugEntry {
        pc,
        moduleId: loc.moduleId,
        offset: loc.offset,
    };
    e.debugEntriesLen += 1;
    set e.debugEntriesLen += 1;
}

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

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

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


/// Resolve a value, trap if zero (unless known non-zero), and return the register.
fn resolveAndTrapIfZero(s: *mut Selector, b: il::Val) -> gen::Reg {
    let rs2 = resolveVal(s, super::SCRATCH2, b);
    let mut knownNonZero = false;
    if let case il::Val::Imm(imm) = b {
        knownNonZero = imm <> 0;
        set knownNonZero = imm <> 0;
    }
    if not knownNonZero {
        emit::emit(s.e, encode::bne(rs2, super::ZERO, super::INSTR_SIZE * 2));
        emit::emit(s.e, encode::ebreak());
    }

        let block = &func.blocks[b];
        for instr in block.instrs {
            match instr {
                case il::Instr::Reserve { size, alignment, .. } => {
                    if let case il::Val::Imm(sz) = size {
                        offset = mem::alignUpI32(offset, alignment as i32);
                        offset += sz as i32;
                        set offset = mem::alignUpI32(offset, alignment as i32);
                        set offset += sz as i32;
                    } else {
                        isDynamic = true;
                        set isDynamic = true;
                    }
                },
                else => {},
            }
        }

    for instr, i in block.instrs {
        // Record debug location before emitting machine instructions.
        if hasLocs {
            emit::recordSrcLoc(s.e, block.locs[i]);
        }
        s.pendingSpill = nil;
        set s.pendingSpill = nil;
        selectInstr(s, blockIdx, instr, frame, func);

        // Flush the pending spill store, if any.
        if let p = s.pendingSpill {
            if let slot = regalloc::spill::spillSlot(&s.ralloc.spill, p.ssa) {
                emit::emitSd(s.e, p.rd, spillBase(s), spillOffset(s, slot));
            }
            s.pendingSpill = nil;
            set s.pendingSpill = nil;
        }
    }
}

/// Select instructions for a single IL instruction.

                    let base = spillBase(s);
                    let offset = s.ralloc.spill.frameSize + aligned
                        - (s.frameSize if s.isDynamic else 0);

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

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

            // For large blits where both pointers are in real registers,

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

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

            // Copy remaining: 8 bytes, then 4 bytes, then 1 byte at a time.
            // Before each load/store pair, check whether the offset is
            // about to exceed the 12-bit signed immediate range. When

                if offset > super::MAX_IMM - super::DWORD_SIZE {
                    emit::emitAddImm(s.e, rsrc, rsrc, offset);
                    if *rdst <> *rsrc {
                        emit::emitAddImm(s.e, rdst, rdst, offset);
                    }
                    offset = 0;
                    set offset = 0;
                }
                if let off = srcReload {
                    emit::emitLd(s.e, super::SCRATCH1, spillBase(s), off);
                    emit::emitLd(s.e, super::SCRATCH1, super::SCRATCH1, offset);
                } else {
                    emit::emitLd(s.e, super::SCRATCH1, rsrc, offset);
                }
                emit::emitSd(s.e, super::SCRATCH1, rdst, offset);
                offset += super::DWORD_SIZE;
                remaining -= super::DWORD_SIZE;
                set offset += super::DWORD_SIZE;
                set remaining -= super::DWORD_SIZE;
            }
            if remaining >= super::WORD_SIZE {
                if offset > super::MAX_IMM - super::WORD_SIZE {
                    emit::emitAddImm(s.e, rsrc, rsrc, offset);
                    if *rdst <> *rsrc {
                        emit::emitAddImm(s.e, rdst, rdst, offset);
                    }
                    offset = 0;
                    set offset = 0;
                }
                if let off = srcReload {
                    emit::emitLd(s.e, super::SCRATCH1, spillBase(s), off);
                    emit::emitLw(s.e, super::SCRATCH1, super::SCRATCH1, offset);
                } else {
                    emit::emitLw(s.e, super::SCRATCH1, rsrc, offset);
                }
                emit::emitSw(s.e, super::SCRATCH1, rdst, offset);
                offset += super::WORD_SIZE;
                remaining -= super::WORD_SIZE;
                set offset += super::WORD_SIZE;
                set remaining -= super::WORD_SIZE;
            }
            while remaining > 0 {
                if offset > super::MAX_IMM - 1 {
                    emit::emitAddImm(s.e, rsrc, rsrc, offset);
                    if *rdst <> *rsrc {
                        emit::emitAddImm(s.e, rdst, rdst, offset);
                    }
                    offset = 0;
                    set offset = 0;
                }
                if let off = srcReload {
                    emit::emitLd(s.e, super::SCRATCH1, spillBase(s), off);
                    emit::emitLb(s.e, super::SCRATCH1, super::SCRATCH1, offset);
                } else {
                    emit::emitLb(s.e, super::SCRATCH1, rsrc, offset);
                }
                emit::emitSb(s.e, super::SCRATCH1, rdst, offset);
                offset += 1;
                remaining -= 1;
                set offset += 1;
                set remaining -= 1;
            }
            // Restore base registers if they were advanced (never happens
            // in the both-spilled case since size <= MAX_IMM).
            if not bothSpilled {
                let advanced = staticSize as i32 - offset;

            // Skip extension for zero register.
            // Determine extension mode: sign-extend for W32 or SLT,
            // zero-extend otherwise.
            let mut useSext: bool = undefined;
            if let case il::CmpOp::Slt = op {
                useSext = true;
                set useSext = true;
            } else {
                useSext = typ == il::Type::W32;
                set useSext = typ == il::Type::W32;
            }
            if useSext {
                if not aIsZero and not isExtendedImm(a, typ, true) {
                    emitSext(s.e, rs1, rs1, typ);
                }

            for c in cases {
                emit::loadImm(s.e, super::SCRATCH2, c.value);

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

                    emit::recordBranch(s.e, skip, emit::BranchKind::InvertedCond {
                        op: il::CmpOp::Eq, rs1, rs2: super::SCRATCH2,
                    });
                    emitBlockArgs(s, func, c.target, c.args);

        if dst <> super::ZERO { // Skip entries with no destination.
            match args[i] {
                case il::Val::Reg(r) => {
                    if let _ = regalloc::spill::spillSlot(&s.ralloc.spill, r) {
                        // Spilled value needs load, not a register move.
                        pending[i] = true;
                        numPending += 1;
                        set pending[i] = true;
                        set numPending += 1;
                    } else {
                        let src = getReg(s, r);
                        if src <> dst {
                            // Register-to-register move needed.
                            srcRegs[i] = src;
                            isRegMove[i] = true;
                            pending[i] = true;
                            numPending += 1;
                            set srcRegs[i] = src;
                            set isRegMove[i] = true;
                            set pending[i] = true;
                            set numPending += 1;
                        } else {
                            // No move needed.
                        }
                    }
                },
                case il::Val::Imm(_), il::Val::DataSym(_), il::Val::FnAddr(_) => {
                    pending[i] = true;
                    numPending += 1;
                    set pending[i] = true;
                    set numPending += 1;
                },
                case il::Val::Undef => {
                    // Undefined values don't need any move.
                }
            }

                let mut isReady = true;

                // Check if `dst` is used as source by any other pending register move.
                for j in 0..n {
                    if j <> i and pending[j] and isRegMove[j] and srcRegs[j] == dst {
                        isReady = false;
                        set isReady = false;
                        break;
                    }
                }
                if isReady {
                    // Execute this move.

                        emitMv(s, dst, srcRegs[i]);
                    } else {
                        // Load immediate, symbol, or spilled value.
                        loadVal(s, dst, args[i]);
                    }
                    found = true;
                    pending[i] = false;
                    numPending -= 1;
                    set found = true;
                    set pending[i] = false;
                    set numPending -= 1;

                    break;
                }
            }
        }

                    // Save this source to scratch.
                    emitMv(s, super::SCRATCH1, src);
                    // Update all pending moves that use this source.
                    for j in 0..n {
                        if pending[j] and isRegMove[j] and srcRegs[j] == src {
                            srcRegs[j] = super::SCRATCH1;
                            set srcRegs[j] = super::SCRATCH1;
                        }
                    }
                    break;
                }
            }

            } else {
                let rs = resolveVal(s, super::SCRATCH1, arg);
                emit::emitSd(s.e, rs, spillBase(s), spillOffset(s, slot));
            }
        } else {
            dsts[i] = getReg(s, param);
            set dsts[i] = getReg(s, param);
        }
    }
    emitParallelMoves(s, &dsts[..], args);
}


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

fn writeMnem(out: *mut sexpr::Output, m: *[u8]) {
    write(out, m);
    let mut i = m.len;
    while i < MNEMONIC_WIDTH {
        write(out, " ");
        i += 1;
        set i += 1;
    }
}

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

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


/// Create a dict backed by the given entry storage.
/// The storage length must be a power of two.
export fn init(entries: *mut [Entry]) -> Dict {
    for i in 0..entries.len {
        entries[i] = Entry { key: &[], value: 0 };
        set entries[i] = Entry { key: &[], value: 0 };
    }
    return Dict { entries, count: 0 };
}

/// Insert or update a key-value pair. Panics if the table exceeds 50% load.


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

/// Look up a value by key. Returns `nil` if not found.
export fn get(m: *Dict, key: *[u8]) -> ?i32 {

            return nil;
        }
        if mem::eq(entry.key, key) {
            return entry.value;
        }
        idx = (idx + 1) & mask;
        set idx = (idx + 1) & mask;
    }
}

/// DJB2 hash function.
export fn hash(str: *[u8]) -> u32 {
    let mut h: u32 = 5381;
    for b in str {
        h = ((h << 5) + h) + b as u32;
        set h = ((h << 5) + h) + b as u32;
    }
    return h;
}

lib/std/fmt.rad +24 -24

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

    // Handle the zero case separately to ensure a single '0' is written.
    if x == 0 {
        i -= 1;
        buffer[i] = '0';
        set i -= 1;
        set buffer[i] = '0';
    } else {
        // Write digits backwards from the end of the buffer.
        while x <> 0 {
            i -= 1;
            buffer[i] = ('0' + (x % 10) as u8);
            x /= 10;
            set i -= 1;
            set buffer[i] = ('0' + (x % 10) as u8);
            set x /= 10;
        }
    }
    // Return the slice from the start of the written number to
    // the end of the buffer.
    return &buffer[i..];

    let neg: bool = val < 0;
    let mut x: u32 = -val as u32 if neg else val as u32;
    let mut i: u32 = buffer.len;
    // Handle the zero case separately to ensure a single '0' is written.
    if x == 0 {
        i -= 1;
        buffer[i] = '0';
        set i -= 1;
        set buffer[i] = '0';
    } else {
        // Write digits backwards from the end of the buffer.
        while x <> 0 {
            i -= 1;
            buffer[i] = '0' + (x % 10) as u8;
            x /= 10;
            set i -= 1;
            set buffer[i] = '0' + (x % 10) as u8;
            set x /= 10;
        }
        // Add the negative sign if needed.
        if neg {
            i -= 1;
            buffer[i] = '-';
            set i -= 1;
            set buffer[i] = '-';
        }
    }
    return &buffer[i..];
}


69	69
70	70		let mut x: u64 = val;
71	71		let mut i: u32 = buffer.len;
72	72
73	73		if x == 0 {
74		-	i -= 1;
75		-	buffer[i] = '0';
	74	+	set i -= 1;
	75	+	set buffer[i] = '0';
76	76		} else {
77	77		while x <> 0 {
78		-	i -= 1;
79		-	buffer[i] = ('0' + (x % 10) as u8);
80		-	x /= 10;
	78	+	set i -= 1;
	79	+	set buffer[i] = ('0' + (x % 10) as u8);
	80	+	set x /= 10;
81	81		}
82	82		}
83	83		return &buffer[i..];
84	84		}
85	85

89	89
90	90		let neg: bool = val < 0;
91	91		let mut x: u64 = -val as u64 if neg else val as u64;
92	92		let mut i: u32 = buffer.len;
93	93		if x == 0 {
94		-	i -= 1;
95		-	buffer[i] = '0';
	94	+	set i -= 1;
	95	+	set buffer[i] = '0';
96	96		} else {
97	97		while x <> 0 {
98		-	i -= 1;
99		-	buffer[i] = '0' + (x % 10) as u8;
100		-	x /= 10;
	98	+	set i -= 1;
	99	+	set buffer[i] = '0' + (x % 10) as u8;
	100	+	set x /= 10;
101	101		}
102	102		if neg {
103		-	i -= 1;
104		-	buffer[i] = '-';
	103	+	set i -= 1;
	104	+	set buffer[i] = '-';
105	105		}
106	106		}
107	107		return &buffer[i..];
108	108		}
109	109

lib/std/io.rad +2 -2


        if n == 0 {
            break;
        }
        if n > chunk.len {
            total = buf.len;
            set total = buf.len;
            break;
        }
        total += n;
        set total += n;
    }
    return &buf[..total];
}

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


    if newOffset > arena.data.len as u32 {
        throw AllocError::OutOfMemory;
    }
    let base: *mut u8 = &mut arena.data[aligned];
    arena.offset = newOffset;
    set arena.offset = newOffset;

    return base as *mut opaque;
}

/// Reset the arena, allowing all memory to be reused.
///
/// Does not zero the memory.
export fn reset(arena: *mut Arena) {
    arena.offset = 0;
    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) {
    arena.offset = savedOffset;
    set arena.offset = savedOffset;
}

/// Returns the number of bytes currently allocated.
export fn used(arena: *Arena) -> u32 {
    return 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) {
    arena.offset += size;
    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]`.

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

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

    // Arena is now full, this should fail.
    let mut failed = false;
    try super::alloc(&mut arena, 1, 1) catch {
        failed = true;
        set failed = true;
    };
    try testing::expect(failed);
}

/// Test that reset allows reuse of memory.


    // Try to allocate 16 bytes with 4-byte alignment.
    // Aligned offset would be 4, then 4 + 16 = 20 > 16, so should fail.
    let mut failed = false;
    try super::alloc(&mut arena, 16, 4) catch {
        failed = true;
        set failed = true;
    };
    try testing::expect(failed);
}

/// Test the Allocator interface backed by an arena.

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

    ConstDecl(ConstDecl),
    /// Static storage declaration.
    StaticDecl(StaticDecl),
    /// Type signature node.
    TypeSig(TypeSig),
    /// Assignment expression.
    /// Assignment statement.
    Assign(Assign),
    /// Expression statement.
    ExprStmt(*Node),
    /// Module declaration (`mod`).
    Mod(Mod),

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

    *node = Node { id: nodeId, span, value };
    set *node = Node { id: nodeId, span, value };

    return node;
}

/// Allocate a synthetic AST node with a zero-length span.

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

        case super::TypeSig::Record { fields, .. } =>
            return sexpr::list(a, "record", nodeListToExprs(a, &fields[..])),
        case super::TypeSig::Fn(sig) => {
            let mut ret = sexpr::sym("void");
            if let rt = sig.returnType {
                ret = toExpr(a, rt);
                set ret = toExpr(a, rt);
            }
            return sexpr::list(a, "fn", &[sexpr::list(a, "params", nodeListToExprs(a, &sig.params[..])), ret]);
        }
        case super::TypeSig::TraitObject { traitName, mutable } =>
            return sexpr::list(a, "obj", &[sexpr::sym("mut"), toExpr(a, traitName)]) if mutable

    if nodes.len == 0 {
        return &[];
    }
    let buf = try! sexpr::allocExprs(a, nodes.len as u32);
    for node, i in nodes {
        buf[i] = toExpr(a, node);
        set buf[i] = toExpr(a, node);
    }
    return buf;
}

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

    }
    let buf = try! sexpr::allocExprs(a, nodes.len as u32);
    for prong, i in nodes {
        match prong.value {
            case super::NodeValue::MatchProng(p) => {
                buf[i] = prongToExpr(a, p);
                set buf[i] = prongToExpr(a, p);
            }
            else => {
                buf[i] = sexpr::sym("<invalid>");
                set buf[i] = sexpr::sym("<invalid>");
            }
        }
    }
    return buf;
}

    }
    let buf = try! sexpr::allocExprs(a, nodes.len as u32);
    for node, i in nodes {
        match node.value {
            case super::NodeValue::RecordField { field, type, value } => {
                buf[i] = fieldToExpr(a, field, type, value);
                set buf[i] = fieldToExpr(a, field, type, value);
            }
            else => {
                buf[i] = sexpr::sym("<invalid>");
                set buf[i] = sexpr::sym("<invalid>");
            }
        }
    }
    return buf;
}

    }
    let buf = try! sexpr::allocExprs(a, nodes.len as u32);
    for node, i in nodes {
        match node.value {
            case super::NodeValue::UnionDeclVariant(v) => {
                buf[i] = variantToExpr(a, v.name, v.type);
                set buf[i] = variantToExpr(a, v.name, v.type);
            }
            else => {
                buf[i] = sexpr::sym("<invalid>");
                set buf[i] = sexpr::sym("<invalid>");
            }
        }
    }
    return buf;
}

            return sexpr::list(a, binOpName(b.op), &[toExpr(a, b.left), toExpr(a, b.right)]),
        case super::NodeValue::UnOp(u) =>
            return sexpr::list(a, unOpName(u.op), &[toExpr(a, u.value)]),
        case super::NodeValue::Call(c) => {
            let buf = try! sexpr::allocExprs(a, c.args.len as u32 + 1);
            buf[0] = toExpr(a, c.callee);
            for arg, i in c.args { buf[i + 1] = toExpr(a, arg); }
            set buf[0] = toExpr(a, c.callee);
            for arg, i in c.args { set buf[i + 1] = toExpr(a, arg); }
            return sexpr::Expr::List { head: "call", tail: buf, multiline: false };
        }
        case super::NodeValue::BuiltinCall { kind, args } =>
            return sexpr::list(a, builtinName(kind), nodeListToExprs(a, &args[..])),
        case super::NodeValue::Subscript { container, index } =>

        case super::NodeValue::ArrayRepeatLit(rep) =>
            return sexpr::list(a, "array-repeat", &[toExpr(a, rep.item), toExpr(a, rep.count)]),
        case super::NodeValue::RecordLit(lit) => {
            let mut total: u32 = lit.fields.len as u32;
            if let _ = lit.typeName {
                total += 1;
                set total += 1;
            }
            let buf = try! sexpr::allocExprs(a, total);
            let mut idx: u32 = 0;
            if let tn = lit.typeName {
                buf[idx] = toExpr(a, tn); idx = idx + 1;
                set buf[idx] = toExpr(a, tn); set idx = idx + 1;
            }
            for field, i in lit.fields {
                buf[idx + i] = toExpr(a, field);
                set buf[idx + i] = toExpr(a, field);
            }
            return sexpr::Expr::List { head: "record-lit", tail: buf, multiline: lit.fields.len > 2 };
        }
        case super::NodeValue::RecordLitField(f) =>
            return sexpr::list(a, "field", &[toExprOpt(a, f.label), toExpr(a, f.value)]),

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

        case super::NodeValue::CatchClause(clause) => {
            let mut head = "catch";
            let mut children: [sexpr::Expr; 3] = undefined;
            let mut len: u32 = 0;
            if let b = clause.binding {
                children[len] = toExpr(a, b);
                len += 1;
                set children[len] = toExpr(a, b);
                set len += 1;
            }
            if let t = clause.typeNode {
                children[len] = toExpr(a, t);
                len += 1;
                set children[len] = toExpr(a, t);
                set len += 1;
            }
            children[len] = toExpr(a, clause.body);
            len += 1;
            set children[len] = toExpr(a, clause.body);
            set len += 1;
            return sexpr::list(a, head, &children[..len]);
        }
        case super::NodeValue::Block(blk) => {
            let children = nodeListToExprs(a, &blk.statements[..]);
            return sexpr::block(a, "block", &[], children);
        }
        case super::NodeValue::Let(decl) => {
            let mut head = "let";
            if decl.mutable { head = "let-mut"; }
            if decl.mutable { set head = "let-mut"; }
            return sexpr::list(a, head, &[
                toExpr(a, decl.ident),
                toExprOrNull(a, decl.type),
                toExpr(a, decl.value)
            ]);

lib/std/lang/gen/bitset.rad +17 -17

}

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

/// Create a bitset from arena allocation.

        return;
    }
    let word = n / 32;
    let b = n % 32;

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

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

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

/// Check if bit `n` is set.
export fn contains(bs: *Bitset, n: u32) -> bool {
    if n >= bs.len {

    let mut total: u32 = 0;
    let numWords = bs.bits.len;
    for i in 0..numWords {
        let word = bs.bits[i];
        if word <> 0 {
            total += popCount(word);
            set total += popCount(word);
        }
    }
    return total;
}

/// Population count for a 32-bit word.
fn popCount(x: u32) -> u32 {
    let mut n = x;
    n -= ((n >> 1) & 0x55555555);
    n = (n & 0x33333333) + ((n >> 2) & 0x33333333);
    n = (n + (n >> 4)) & 0x0F0F0F0F;
    n += (n >> 8);
    n += (n >> 16);
    set n -= ((n >> 1) & 0x55555555);
    set n = (n & 0x33333333) + ((n >> 2) & 0x33333333);
    set n = (n + (n >> 4)) & 0x0F0F0F0F;
    set n += (n >> 8);
    set n += (n >> 16);

    return n & 0x3F;
}

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

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

/// Check if two bitsets are equal.
export fn eq(a: *Bitset, b: *Bitset) -> bool {

    let numWords = dst.bits.len;
    let srcWords = src.bits.len;
    let minWords = min(numWords, srcWords);

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

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

/// Iterator state for iterating set bits.
export record BitIter {

/// Get the next set bit, or nil if none remain.
export fn iterNext(it: *mut BitIter) -> ?u32 {
    let numWords = it.bs.bits.len;
    // Skip to next non-zero word.
    while it.remaining == 0 {
        it.wordIdx += 1;
        set it.wordIdx += 1;
        if it.wordIdx >= numWords {
            return nil;
        }
        it.remaining = it.bs.bits[it.wordIdx];
        set it.remaining = it.bs.bits[it.wordIdx];
    }
    // Find lowest set bit position using de Bruijn sequence.
    let b = ctz(it.remaining);
    let n = it.wordIdx * 32 + b;
    if n >= it.bs.len {
        return nil;
    }
    // Clear the lowest set bit.
    it.remaining &= it.remaining - 1;
    set it.remaining &= it.remaining - 1;

    return n;
}

/// Count trailing zeros in a 32-bit value.

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

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

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

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

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


    // Initialized data first.
    for i in 0..program.data.len {
        let data = &program.data[i];
        if data.readOnly == readOnly and not data.isUndefined {
            offset = mem::alignUp(offset, data.alignment);
            syms[*count] = DataSym { name: data.name, addr: base + offset };
            *count += 1;
            offset += data.size;
            set offset = mem::alignUp(offset, data.alignment);
            set syms[*count] = DataSym { name: data.name, addr: base + offset };
            set *count += 1;
            set offset += data.size;
        }
    }
    // Uninitialized data after.
    for i in 0..program.data.len {
        let data = &program.data[i];
        if data.readOnly == readOnly and data.isUndefined {
            offset = mem::alignUp(offset, data.alignment);
            syms[*count] = DataSym { name: data.name, addr: base + offset };
            *count += 1;
            offset += data.size;
            set offset = mem::alignUp(offset, data.alignment);
            set syms[*count] = DataSym { name: data.name, addr: base + offset };
            set *count += 1;
            set offset += data.size;
        }
    }
    return offset;
}


    let mut offset: u32 = 0;

    for i in 0..program.data.len {
        let data = &program.data[i];
        if data.readOnly == readOnly and not data.isUndefined {
            offset = mem::alignUp(offset, data.alignment);
            set offset = mem::alignUp(offset, data.alignment);
            assert offset + data.size <= buf.len, "emitSection: buffer overflow";
            for j in 0..data.values.len {
                let v = &data.values[j];
                for _ in 0..v.count {
                    match v.item {
                        case il::DataItem::Val { typ, val } => {
                            let size = il::typeSize(typ);
                            let valPtr = &val as *u8;
                            try! mem::copy(&mut buf[offset..], @sliceOf(valPtr, size));
                            offset += size;
                            set offset += size;
                        },
                        case il::DataItem::Sym(name) => {
                            let addr = lookupAddr(dataSymMap, name) else {
                                panic "emitSection: data symbol not found";
                            };
                            let addr64: u64 = addr as u64;
                            let addrPtr = &addr64 as *u8;

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

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

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

                            offset += 8;
                            set offset += 8;
                        },
                        case il::DataItem::Str(s) => {
                            try! mem::copy(&mut buf[offset..], s);
                            offset += s.len;
                            set offset += s.len;
                        },
                        case il::DataItem::Undef => {
                            buf[offset] = 0;
                            offset += 1;
                            set buf[offset] = 0;
                            set offset += 1;
                        },
                    }
                }
            }
        }

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

    };
}

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

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

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

lib/std/lang/gen/regalloc/assign.rad +21 -21

    }

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


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

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

        // Initialize from predecessor if single predecessor.
        // Only copy values that are live-in to this block.
        if block.preds.len == 1 {
            let pred = &blkEnd[block.preds[0]];
            for k in 0..pred.n {
                if bitset::contains(&live.liveIn[b], pred.virtRegs[k]) {
                    current.virtRegs[current.n] = pred.virtRegs[k];
                    current.physRegs[current.n] = pred.physRegs[k];
                    current.n += 1;
                    set current.virtRegs[current.n] = pred.virtRegs[k];
                    set current.physRegs[current.n] = pred.physRegs[k];
                    set current.n += 1;
                    bitset::put(&mut usedRegs, *pred.physRegs[k] as u32);
                }
            }
        }


                    // Also track in current mapping for block-end state.
                    if rmapFind(&current, ssaReg) == nil {
                        rmapSet(&mut current, ssaReg, phys);
                    }
                } else {
                    assignments[ssaReg] = rallocReg(&mut current, &mut usedRegs, ssaReg, allocatable, config.calleeSaved, spillInfo);
                    set assignments[ssaReg] = rallocReg(&mut current, &mut usedRegs, ssaReg, allocatable, config.calleeSaved, spillInfo);
                }
            }
        }

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

        // Process each instruction.
        for instr, i in block.instrs {

            il::forEachReg(instr, processInstrRegCb, &mut ctx as *mut opaque);

            // Allocate destination.
            if let dst = il::instrDst(instr) {
                if dst.n < maxReg and not spill::isSpilled(spillInfo, dst) {
                    assignments[dst.n] = rallocReg(&mut current, &mut usedRegs, dst.n, allocatable, config.calleeSaved, spillInfo);
                    set assignments[dst.n] = rallocReg(&mut current, &mut usedRegs, dst.n, allocatable, config.calleeSaved, spillInfo);
                }
            }
        }
        // Save block-end state.
        blkEnd[b].n = current.n;
        set blkEnd[b].n = current.n;
        for ri in 0..current.n {
            blkEnd[b].virtRegs[ri] = current.virtRegs[ri];
            blkEnd[b].physRegs[ri] = current.physRegs[ri];
            set blkEnd[b].virtRegs[ri] = current.virtRegs[ri];
            set blkEnd[b].physRegs[ri] = current.physRegs[ri];
        }
    }
    // Compute bitmask of used callee-saved registers.
    let mut usedCalleeSaved: u32 = 0;
    for i in 0..maxReg {
        if let phys = assignments[i] {
            for saved, j in config.calleeSaved {
                if *phys == *saved {
                    usedCalleeSaved |= (1 << j);
                    set usedCalleeSaved |= (1 << j);
                }
            }
        }
    }


}

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

/// Remove a mapping from register map.
fn rmapRemove(rmap: *mut RegMap, virtReg: u32) {
    for i in 0..rmap.n {
        if rmap.virtRegs[i] == virtReg {
            // Swap with last and decrement.
            rmap.n -= 1;
            set rmap.n -= 1;
            if i < rmap.n {
                rmap.virtRegs[i] = rmap.virtRegs[rmap.n];
                rmap.physRegs[i] = rmap.physRegs[rmap.n];
                set rmap.virtRegs[i] = rmap.virtRegs[rmap.n];
                set rmap.physRegs[i] = rmap.physRegs[rmap.n];
            }
            return;
        }
    }
    panic "rmapRemove: register not found";

    assert reg.n < ctx.assignments.len, "processInstrRegCb: register out of bounds";
    if spill::isSpilled(ctx.spillInfo, reg) {
        return; // Spilled values don't get physical registers.
    }
    if ctx.assignments[reg.n] == nil {
        ctx.assignments[reg.n] = rallocReg(
        set ctx.assignments[reg.n] = rallocReg(
            ctx.current, ctx.usedRegs, reg.n, ctx.allocatable,
            ctx.calleeSaved, ctx.spillInfo
        );
    }
}

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

    }

    // Find max register number.
    let mut maxReg: u32 = 0;
    for p in func.params {
        maxReg = maxRegNum(p.value.n, maxReg);
        set maxReg = maxRegNum(p.value.n, maxReg);
    }
    for b in 0..blockCount {
        let block = &func.blocks[b];
        for p in block.params {
            maxReg = maxRegNum(p.value.n, maxReg);
            set maxReg = maxRegNum(p.value.n, maxReg);
        }
        for i in 0..block.instrs.len {
            il::forEachReg(block.instrs[i], maxRegCallback, &mut maxReg as *mut opaque);
            if let dst = il::instrDst(block.instrs[i]) {
                maxReg = maxRegNum(dst.n, maxReg);
                set maxReg = maxRegNum(dst.n, maxReg);
            }
        }
    }
    assert maxReg <= MAX_SSA_REGS, "analyze: maximum SSA registers exceeded";
    // Allocate per-block bitsets.

    let liveOut = try alloc::allocSlice(arena, @sizeOf(bitset::Bitset), @alignOf(bitset::Bitset), blockCount) as *mut [bitset::Bitset];
    let defs = try alloc::allocSlice(arena, @sizeOf(bitset::Bitset), @alignOf(bitset::Bitset), blockCount) as *mut [bitset::Bitset];
    let uses = try alloc::allocSlice(arena, @sizeOf(bitset::Bitset), @alignOf(bitset::Bitset), blockCount) as *mut [bitset::Bitset];

    for b in 0..blockCount {
        liveIn[b] = try bitset::allocate(arena, maxReg);
        liveOut[b] = try bitset::allocate(arena, maxReg);
        defs[b] = try bitset::allocate(arena, maxReg);
        uses[b] = try bitset::allocate(arena, maxReg);
        set liveIn[b] = try bitset::allocate(arena, maxReg);
        set liveOut[b] = try bitset::allocate(arena, maxReg);
        set defs[b] = try bitset::allocate(arena, maxReg);
        set uses[b] = try bitset::allocate(arena, maxReg);
    }

    // Compute local defs and uses for each block.
    for b in 0..blockCount {
        computeLocalDefsUses(&func.blocks[b], &mut defs[b], &mut uses[b]);

    // Iterative dataflow analysis.
    let mut changed = true;
    let mut scratch = try bitset::allocate(arena, maxReg);

    while changed {
        changed = false;
        set changed = false;

        // Process blocks in reverse order (approximates post-order).
        let mut b = blockCount;
        while b > 0 {
            b -= 1;
            set b -= 1;
            let block = &func.blocks[b];

            // Compute new `liveOut` as union of successor `liveIn` sets.
            bitset::clearAll(&mut scratch);
            addSuccessorLiveIn(func, block, liveIn, &mut scratch);

            if not bitset::eq(&liveOut[b], &scratch) {
                bitset::copy(&mut liveOut[b], &scratch);
                changed = true;
                set changed = true;
            }
            if computeAndUpdateLiveIn(&mut liveIn[b], &liveOut[b], &defs[b], &uses[b]) {
                changed = true;
                set changed = true;
            }
        }
    }
    return LiveInfo { liveIn, liveOut, defs, uses, blockCount, maxReg };
}

    let numWords = dst.bits.len;
    let mut changed = false;
    for i in 0..numWords {
        let newWord = uses.bits[i] | (liveOut.bits[i] & ~defs.bits[i]);
        if dst.bits[i] <> newWord {
            dst.bits[i] = newWord;
            changed = true;
            set dst.bits[i] = newWord;
            set changed = true;
        }
    }
    return changed;
}


}

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

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


/// 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 {
        c.found = true;
        set c.found = true;
    }
}

lib/std/lang/gen/regalloc/spill.rad +15 -15

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

    // Phase 2: Find values that exceed register pressure.

        bitset::copy(&mut scratch, &live.liveOut[b]);

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

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


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

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

/// Calculate spill costs for all registers, weighted by loop depth.

        let weight: u32 = 1 << depth;

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

            // Count definition.
            if let dst = il::instrDst(instr) {
                if dst.n < costs.len {
                    costs[dst.n].defs = costs[dst.n].defs + weight;
                    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);

    // Insertion sort ascending by cost.
    for i in 1..c.n {
        let key = c.entries[i];
        let mut j: u32 = i;
        while j > 0 and c.entries[j - 1].cost > key.cost {
            c.entries[j] = c.entries[j - 1];
            j -= 1;
            set c.entries[j] = c.entries[j - 1];
            set j -= 1;
        }
        c.entries[j] = key;
        set c.entries[j] = key;
    }
    let toSpill = c.n if excess > c.n else excess;
    for i in 0..toSpill {
        bitset::put(spilled, c.entries[i].reg);
        bitset::clear(source, c.entries[i].reg);

    let mut c = Candidates { entries: undefined, n: 0 };
    let mut it = bitset::iter(bs);
    while let reg = bitset::iterNext(&mut it) {
        assert c.n < MAX_CANDIDATES, "collectCandidates: too many live values";
        if reg < costs.len {
            c.entries[c.n] = CostEntry { reg, cost: costs[reg].defs + costs[reg].uses };
            c.n += 1;
            set c.entries[c.n] = CostEntry { reg, cost: costs[reg].defs + costs[reg].uses };
            set c.n += 1;
        }
    }
    return c;
}


    let mut candidates: [CostEntry; 256] = undefined;
    let mut numCandidates: u32 = 0;
    let mut it = bitset::iter(live);
    while let n = bitset::iterNext(&mut it) {
        if not isCallDst(callDst, n) and n < costs.len {
            candidates[numCandidates] = CostEntry {
            set candidates[numCandidates] = CostEntry {
                reg: n,
                cost: costs[n].defs + costs[n].uses,
            };
            numCandidates += 1;
            set numCandidates += 1;
        }
    }
    // Spill cheapest candidates if crossing count exceeds callee-saved capacity.
    if numCandidates > numCalleeSaved {
        let mut c = Candidates { entries: candidates, n: numCandidates };


/// 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";
    ctx.costs[reg.n].uses = ctx.costs[reg.n].uses + ctx.weight;
    set ctx.costs[reg.n].uses = ctx.costs[reg.n].uses + ctx.weight;
}

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

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


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

    for segment in path {
        pos += try! mem::copy(&mut buf[pos..], segment);
        pos += try! mem::copy(&mut buf[pos..], PATH_SEPARATOR);
        set pos += try! mem::copy(&mut buf[pos..], segment);
        set pos += try! mem::copy(&mut buf[pos..], PATH_SEPARATOR);
    }
    try! mem::copy(&mut buf[pos..], name);

    return &buf[..totalLen];
}

lib/std/lang/il/printer.rad +1 -1

/// Concatenate prefix and string in the arena.
fn prefixStr(a: *mut alloc::Arena, prefix: u8, str: *[u8]) -> *[u8] {
    let len = str.len + 1;
    let ptr = try! alloc::allocSlice(a, 1, 1, len);
    let slice = ptr as *mut [u8];
    slice[0] = prefix;
    set slice[0] = prefix;
    try! mem::copy(&mut slice[1..], str);

    return slice;
}


lib/std/lang/lower.rad +227 -236

fn maxErrSize(throwList: *[*resolver::Type]) -> u32 {
    let mut maxSize: u32 = 0;
    for ty in throwList {
        let size = resolver::getTypeLayout(*ty).size;
        if size > maxSize {
            maxSize = size;
            set maxSize = size;
        }
    }
    return maxSize;
}


            return entry.tag;
        }
    }
    let tag = self.errTagCounter;

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

    return tag;
}


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

    if value.item <> il::DataItem::Undef {
        b.allUndef = false;
        set b.allUndef = false;
    }
}

/// Return the accumulated values.
fn dataBuilderFinish(b: *DataValueBuilder) -> ConstDataResult {

    low: *mut Lowerer,
    moduleId: u16,
    root: *ast::Node,
    isRoot: bool
) -> ?u32 throws (LowerError) {
    low.currentMod = moduleId;
    set low.currentMod = moduleId;
    return try lowerDecls(low, root, isRoot);
}

/// Lower all top-level declarations in a block.
fn lowerDecls(low: *mut Lowerer, root: *ast::Node, isRoot: bool) -> ?u32 throws (LowerError) {

    for node in stmtsList {
        match node.value {
            case ast::NodeValue::FnDecl(decl) => {
                if let f = try lowerFnDecl(low, node, decl) {
                    if isRoot and checkAttr(decl.attrs, ast::Attribute::Default) {
                        defaultFnIdx = low.fns.len;
                        set defaultFnIdx = low.fns.len;
                    }
                    low.fns.append(f, low.allocator);
                }
            }
            case ast::NodeValue::ConstDecl(decl) => {

    let graph = self.moduleGraph else {
        return &[];
    };
    let mut id = modId;
    if id == nil {
        id = self.currentMod;
        set id = self.currentMod;
    }
    let actualId = id else {
        return &[];
    };
    let entry = module::get(graph, actualId) else {

}

/// Set the package context for lowering.
/// Called before lowering each package.
export fn setPackage(self: *mut Lowerer, graph: *module::ModuleGraph, pkgName: *[u8]) {
    self.moduleGraph = graph;
    self.pkgName = pkgName;
    self.currentMod = nil;
    set self.moduleGraph = graph;
    set self.pkgName = pkgName;
    set self.currentMod = nil;
}

/// Create a new function lowerer for a given function type and name.
fn fnLowerer(
    self: *mut Lowerer,

    };
    if self.options.debug {
        let modId = self.currentMod else {
            panic "fnLowerer: debug enabled but no current module";
        };
        fnLow.srcLoc = il::SrcLoc {
        set fnLow.srcLoc = il::SrcLoc {
            moduleId: modId,
            offset: node.span.offset,
        };
    }
    return fnLow;


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

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

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

    return func;
}

/// Build a qualified name of the form "Type::method".

    let sepLen: u32 = 2; // "::"
    let totalLen = typeName.len + sepLen + methodName.len;
    let buf = try! alloc::allocSlice(self.arena, 1, 1, totalLen) as *mut [u8];
    let mut pos: u32 = 0;

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

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


    let sepLen: u32 = 2; // "::"
    let totalLen = prefix.len + typeName.len + sepLen + traitName.len;
    let buf = try! alloc::allocSlice(self.arena, 1, 1, totalLen) as *mut [u8];
    let mut pos: u32 = 0;

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

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


        self.fns.append(func, self.allocator);

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

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

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

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

    for i in 0..traitInfo.methods.len {
        values[i] = il::DataValue {
        set values[i] = il::DataValue {
            item: il::DataItem::Fn(methodNames[i]),
            count: 1,
        };
    }
    self.data.append(il::Data {

    let sym = data.sym else throw LowerError::MissingSymbol(node);
    registerFnSym(self, sym, qualName);

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

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

    return func;
}

/// Lower a standalone method declaration.

}

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

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

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

        return il::DataItem::Str(s);
    }
    // Bool and char are byte-sized; integer uses the declared type.
    let mut irTyp = il::Type::W8;
    if let case resolver::ConstValue::Int(_) = val {
        irTyp = ilType(self, typ);
        set irTyp = ilType(self, typ);
    }
    return il::DataItem::Val { typ: irTyp, val: constToScalar(val) };
}

/// Lower a constant or static declaration to the data section.

    let backing = dataBuilderFinish(&nested);
    let readOnly = not mutable;
    let mut dataName: *[u8] = undefined;
    if readOnly {
        if let found = findConstData(self, backing.values, layout.alignment) {
            dataName = found;
            set dataName = found;
        } else {
            dataName = try pushDeclData(self, layout.size, layout.alignment, readOnly, backing.values, dataPrefix);
            set dataName = try pushDeclData(self, layout.size, layout.alignment, readOnly, backing.values, dataPrefix);
        }
    } else {
        dataName = try pushDeclData(self, layout.size, layout.alignment, readOnly, backing.values, dataPrefix);
        set dataName = try pushDeclData(self, layout.size, layout.alignment, readOnly, backing.values, dataPrefix);
    }
    dataSliceHeader(b, dataName, arrInfo.length);
}

/// Lower a constant expression into a builder, padding to slotSize.

) throws (LowerError) {
    let layout = recInfo.layout;
    for argNode, i in args {
        let mut valueNode = argNode;
        if let case ast::NodeValue::RecordLitField(fieldLit) = argNode.value {
            valueNode = fieldLit.value;
            set valueNode = fieldLit.value;
        }
        let fieldInfo = recInfo.fields[i];
        let fieldOffset = fieldInfo.offset as u32;

        // Slot extends to the next field's offset,

    let suffixStart = prefix.len + 1;
    let totalLen = suffixStart + suffix.len;
    let buf = try! alloc::allocSlice(self.arena, 1, 1, totalLen) as *mut [u8];

    try! mem::copy(&mut buf[..prefix.len], prefix);
    buf[prefix.len] = '$';
    set buf[prefix.len] = '$';
    try! mem::copy(&mut buf[suffixStart..], suffix);

    return &buf[..totalLen];
}


    }
    let values = try! alloc::allocSlice(
        self.arena, @sizeOf(il::DataValue), @alignOf(il::DataValue), 1
    ) as *mut [il::DataValue];

    values[0] = il::DataValue {
    set values[0] = il::DataValue {
        item: il::DataItem::Str(s),
        count: 1
    };
    return try pushDeclData(self, s.len, 1, true, &values[..1], dataPrefix);
}

    let elemLayout = resolver::getTypeLayout(*elemTy);
    let size = elemLayout.size * length;
    let mut dataName: *[u8] = undefined;
    if readOnly {
        if let found = findConstData(self.low, values, alignment) {
            dataName = found;
            set dataName = found;
        } else {
            dataName = try nextDataName(self);
            set dataName = try nextDataName(self);
            self.low.data.append(il::Data { name: dataName, size, alignment, readOnly, isUndefined: false, values }, self.low.allocator);
        }
    } else {
        dataName = try nextDataName(self);
        set dataName = try nextDataName(self);
        self.low.data.append(il::Data { name: dataName, size, alignment, readOnly, isUndefined: false, values }, self.low.allocator);
    }

    // Get data address.
    let ptrReg = nextReg(self);

}

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

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

/// Look up the resolved type of an AST node, or throw `MissingType`.
fn typeOf(self: *mut FnLowerer, node: *ast::Node) -> resolver::Type throws (LowerError) {

/// Used when detecting a trivial phi that can be eliminated.
fn removeLastBlockParam(self: *mut FnLowerer, block: BlockId) {
    let blk = getBlockMut(self, block);
    if blk.params.len > 0 {
        // TODO: Use `pop`?
        blk.params = @sliceOf(blk.params.ptr, blk.params.len - 1, blk.params.cap);
        set blk.params = @sliceOf(blk.params.ptr, blk.params.len - 1, blk.params.cap);
    }
    if blk.paramVars.len > 0 {
        // TODO: Use `pop`?
        blk.paramVars = @sliceOf(blk.paramVars.ptr, blk.paramVars.len - 1, blk.paramVars.cap);
        set blk.paramVars = @sliceOf(blk.paramVars.ptr, blk.paramVars.len - 1, blk.paramVars.cap);
    }
}

/// Rewrite cached SSA values for a variable across all blocks, and also
/// rewrite any terminator arguments that reference the provisional register.

/// found to be trivial.
fn rewriteCachedVarValue(self: *mut FnLowerer, v: Var, from: il::Val, to: il::Val) {
    for i in 0..self.blockData.len {
        let blk = getBlockMut(self, BlockId(i));
        if blk.vars[*v] == from {
            blk.vars[*v] = to;
            set blk.vars[*v] = to;
        }
        if blk.instrs.len > 0 {
            let ix = blk.instrs.len - 1;
            match &mut blk.instrs[ix] {
                case il::Instr::Jmp { args, .. } =>


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

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

    let id = BlockId(self.blockData.len);
    let varCount = self.fnType.localCount;
    let vars = try! alloc::allocSlice(self.low.arena, @sizeOf(?il::Val), @alignOf(?il::Val), varCount) as *mut [?il::Val];

    for i in 0..varCount {
        vars[i] = nil;
        set vars[i] = nil;
    }
    self.blockData.append(BlockData {
        label,
        params: &mut [],
        paramVars: &mut [],

}

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

/// Seal a block, indicating all predecessor edges are now known.
///
/// Sealing enables SSA construction to resolve variable uses by looking up

fn sealBlock(self: *mut FnLowerer, block: BlockId) throws (LowerError) {
    let blk = getBlockMut(self, block);
    let case Sealed::No { incompleteVars } = blk.sealState else {
        return; // Already sealed.
    };
    blk.sealState = Sealed::Yes;
    set blk.sealState = Sealed::Yes;

    // Complete all incomplete block parameters.
    for varId in incompleteVars {
        try resolveBlockArgs(self, block, Var(varId));
    }


    // Track whether this function is a leaf.
    if self.isLeaf {
        match instr {
            case il::Instr::Call { .. },
                 il::Instr::Ecall { .. } => self.isLeaf = false,
                 il::Instr::Ecall { .. } => set self.isLeaf = false,
            else => {},
        }
    }
    // Record source location alongside instruction when enabled.
    if self.low.options.debug {

            if unionInfo.isAllVoid {
                let mut tagVal = subject.val;
                match subject.by {
                    case resolver::MatchBy::Ref, resolver::MatchBy::MutRef => {
                        let base = emitValToReg(self, subject.val);
                        tagVal = loadTag(self, base, 0, il::Type::W8);
                        set tagVal = loadTag(self, base, 0, il::Type::W8);
                    }
                    case resolver::MatchBy::Value => {}
                }
                try emitBrCmp(self, il::CmpOp::Eq, il::Type::W8, tagVal, il::Val::Imm(variantTag as i64), matchBlock, fallthrough);
            } else {

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

    ) as *mut [il::Block];

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

        blocks[i] = il::Block {
        set blocks[i] = il::Block {
            label: data.label,
            params: &data.params[..],
            instrs: data.instrs,
            locs: &data.locs[..],
            preds: &data.preds[..],

/// `continueBlock` is `nil` when the continue target is created lazily.
fn enterLoop(self: *mut FnLowerer, breakBlock: BlockId, continueBlock: ?BlockId) {
    assert self.loopDepth < self.loopStack.len, "enterLoop: loop depth overflow";
    let slot = &mut self.loopStack[self.loopDepth];

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

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

/// Get the current loop context.
fn currentLoop(self: *mut FnLowerer) -> ?*mut LoopCtx {
    if self.loopDepth == 0 {

    };
    if let block = ctx.continueTarget {
        return block;
    }
    let block = try createBlock(self, "step");
    ctx.continueTarget = block;
    set ctx.continueTarget = block;
    return block;
}

/// Allocate a slice of values in the lowering arena.
fn allocVals(self: *mut FnLowerer, len: u32) -> *mut [il::Val] throws (LowerError) {

}

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

////////////////////////
// SSA Var Management //

/// current block. Called when a variable is assigned or initialized (`let`
/// bindings, assignments, loop updates). When [`useVar`] is later called,
/// it will retrieve this value.
fn defVar(self: *mut FnLowerer, v: Var, val: il::Val) {
    assert *v < self.vars.len;
    getBlockMut(self, currentBlock(self)).vars[*v] = val;
    set getBlockMut(self, currentBlock(self)).vars[*v] = val;
}

/// Use (read) the current value of a variable in the current block.
/// May insert block parameters if the value must come from predecessors.
fn useVar(self: *mut FnLowerer, v: Var) -> il::Val throws (LowerError) {

        // available without a block parameter.
        if blk.preds.len == 1 {
            let pred = BlockId(blk.preds[0]);
            if *pred <> *block {
                let val = try useVarInBlock(self, pred, v);
                blk.vars[*v] = val; // Cache.
                set blk.vars[*v] = val; // Cache.
                return val;
            }
        }
    }
    // Multiple predecessors or unsealed block: need a block parameter to merge

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

    return self.vars.len;
}

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

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

    blk.params.append(param, self.allocator);
    blk.paramVars.append(*v, self.allocator); // Associate variable with parameter.

    // Record that this variable's value in this block is now the parameter register.
    // This must happen before the predecessor loop to handle self-referential loops.
    blk.vars[*v] = il::Val::Reg(reg);
    set blk.vars[*v] = il::Val::Reg(reg);

    match &mut blk.sealState {
        case Sealed::No { incompleteVars } => {
            // Block unsealed: defer until sealing.
            incompleteVars.append(*v, self.allocator);

            // just created and use that value directly.
            if let trivial = try getTrivialPhiVal(self, block, v) {
                let provisional = il::Val::Reg(reg);
                removeLastBlockParam(self, block);
                rewriteCachedVarValue(self, v, provisional, trivial);
                getBlockMut(self, block).vars[*v] = trivial;
                set getBlockMut(self, block).vars[*v] = trivial;
                return trivial;
            }
            // Non-trivial phi: patch predecessors to pass their values.
            try resolveBlockArgs(self, block, v);
        },

    // Find the parameter index corresponding to this variable.
    // Each variable that needs merging gets its own block parameter slot.
    let mut paramIdx: u32 = 0;
    for i in 0..blk.paramVars.len {
        if blk.paramVars[i] == *v {
            paramIdx = i;
            set paramIdx = i;
            break;
        }
    }

    // For each predecessor, recursively look up the variable's reaching definition

                if val <> sv {
                    // Multiple different values, not trivial.
                    return nil;
                }
            } else {
                sameVal = val;
                set sameVal = val;
            }
        } else { // No param reg set yet, can't be trivial.
            return nil;
        }
    }


    // TODO: We shouldn't need to use a mutable subscript here, given that the
    // fields are already mutable.
    match &mut data.instrs[ix] {
        case il::Instr::Jmp { args, .. } => {
            *args = growArgs(self, *args, paramIdx + 1);
            args[paramIdx] = val;
            set *args = growArgs(self, *args, paramIdx + 1);
            set args[paramIdx] = val;
        }
        case il::Instr::Br { thenTarget, thenArgs, elseTarget, elseArgs, .. } => {
            // Nb. both branches could target the same block (e.g. `if cond { x } else { x }`).
            if *thenTarget == target {
                *thenArgs = growArgs(self, *thenArgs, paramIdx + 1);
                thenArgs[paramIdx] = val;
                set *thenArgs = growArgs(self, *thenArgs, paramIdx + 1);
                set thenArgs[paramIdx] = val;
            }
            if *elseTarget == target {
                *elseArgs = growArgs(self, *elseArgs, paramIdx + 1);
                elseArgs[paramIdx] = val;
                set *elseArgs = growArgs(self, *elseArgs, paramIdx + 1);
                set elseArgs[paramIdx] = val;
            }
        }
        case il::Instr::Switch { defaultTarget, defaultArgs, cases, .. } => {
            if *defaultTarget == target {
                *defaultArgs = growArgs(self, *defaultArgs, paramIdx + 1);
                defaultArgs[paramIdx] = val;
                set *defaultArgs = growArgs(self, *defaultArgs, paramIdx + 1);
                set defaultArgs[paramIdx] = val;
            }
            let idx = paramIdx + 1;
            for ci in 0..cases.len {
                if cases[ci].target == target {
                    cases[ci].args = growArgs(self, cases[ci].args, idx);
                    cases[ci].args[paramIdx] = val;
                    set cases[ci].args = growArgs(self, cases[ci].args, idx);
                    set cases[ci].args[paramIdx] = val;
                }
            }
        }
        else => {
            // Other terminators (e.g. `Ret`, `Unreachable`) don't have successor blocks.

    let newArgs = try! alloc::allocSlice(
        self.low.arena, @sizeOf(il::Val), @alignOf(il::Val), capacity
    ) as *mut [il::Val];

    for arg, i in args {
        newArgs[i] = arg;
        set newArgs[i] = arg;
    }
    for i in args.len..capacity {
        newArgs[i] = il::Val::Undef;
        set newArgs[i] = il::Val::Undef;
    }
    return newArgs;
}

/// Extract the parameter name from an [`FnParam`] AST node value.

    let params = try! alloc::allocSlice(
        self.low.arena, @sizeOf(il::Param), @alignOf(il::Param), totalLen
    ) as *mut [il::Param];

    if let reg = self.returnReg {
        params[0] = il::Param { value: reg, type: il::Type::W64 };
        set params[0] = il::Param { value: reg, type: il::Type::W64 };
    }
    for i in 0..fnType.paramTypes.len as u32 {
        let type = ilType(self.low, *fnType.paramTypes[i]);
        let reg = nextReg(self);

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

        // Declare the parameter variable. For the receiver, the name comes
        // from the receiver node.
        // For all other parameters, the name comes from the AST params.
        let mut name: *[u8] = undefined;
        if let recNode = receiverName {
            if i == 0 {
                let case ast::NodeValue::Ident(recName) = recNode.value else {
                    throw LowerError::ExpectedIdentifier;
                };
                name = recName;
                set name = recName;
            } else {
                name = try paramName(&astParams[i - 1].value);
                set name = try paramName(&astParams[i - 1].value);
            }
        } else {
            name = try paramName(&astParams[i].value);
            set name = try paramName(&astParams[i].value);
        }
        let v = newVar(self, name, type, false, il::Val::Undef);

        self.params.append(FnParamBinding { var: v, reg }, self.allocator);
    }

    // When matching an aggregate by value, copy it to a fresh stack slot so
    // that bindings are independent of the original memory.  Without this,
    // the lowerer returns a pointer into the source and mutations to the
    // source silently corrupt the bound variables.
    if unwrapped.by == resolver::MatchBy::Value and isAggregateType(unwrapped.effectiveTy) {
        val = try emitStackVal(self, unwrapped.effectiveTy, val);
        set val = try emitStackVal(self, unwrapped.effectiveTy, val);
    }

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

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

    let base = emitValToReg(self, subjectVal);
    let mut payload: il::Val = undefined;

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

fn bindMatchVariable(

            let mut derefType = fieldInfo.fieldType;
            let mut nestedBase = emitPtrOffset(self, base, fieldInfo.offset);
            if let case resolver::Type::Pointer { target, .. } = fieldInfo.fieldType {
                let ptrReg = nextReg(self);
                emitLoadW64At(self, ptrReg, nestedBase, 0);
                nestedBase = ptrReg;
                derefType = *target;
                set nestedBase = ptrReg;
                set derefType = *target;
            }
            let recInfo = resolver::getRecord(derefType)
                else throw LowerError::ExpectedRecord;

            try bindNestedRecordFields(self, nestedBase, lit, recInfo, matchBy, failBlock);

    let mut derefBase: ?il::Reg = nil;
    if let case resolver::Type::Pointer { target, .. } = fieldType {
        if resolver::isDestructuringPattern(pattern) {
            let ptrReg = nextReg(self);
            emitLoadW64At(self, ptrReg, fieldPtr, 0);
            derefBase = ptrReg;
            fieldType = *target;
            set derefBase = ptrReg;
            set fieldType = *target;
        }
    }
    // Build a MatchSubject for the nested field.
    let ilTy = ilType(self.low, fieldType);
    let kind = matchSubjectKind(fieldType);

    // Determine the subject value.
    let mut val: il::Val = undefined;
    if let reg = derefBase {
        // Auto-deref: the loaded pointer is the address of the target value.
        val = il::Val::Reg(reg);
        set val = il::Val::Reg(reg);
    } else if isAggregateType(fieldType) {
        // Aggregate: use the pointer.
        val = il::Val::Reg(fieldPtr);
        set val = il::Val::Reg(fieldPtr);
    } else {
        // Scalar: load the value.
        val = emitRead(self, base, fieldInfo.offset, fieldType);
        set val = emitRead(self, base, fieldInfo.offset, fieldType);
    }
    let nestedSubject = MatchSubject {
        val,
        type: fieldType,
        ilType: ilTy,


/// Lower function body to a list of basic blocks.
fn lowerFnBody(self: *mut FnLowerer, body: *ast::Node) -> *[il::Block] throws (LowerError) {
    // Create and switch to entry block.
    let entry = try createBlock(self, "entry");
    self.entryBlock = entry;
    set self.entryBlock = entry;
    switchToBlock(self, entry);

    /// Bind parameter registers to variables in the entry block.
    for def in self.params {
        defVar(self, def.var, il::Val::Reg(def.reg));

        let case ast::NodeValue::MatchProng(prong) = p.value
            else throw LowerError::UnexpectedNodeValue(p);

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

                    cases.append(il::SwitchCase {

        // The guard block must be created before the body block so that
        // block indices are in reverse post-order (RPO), which the register
        // allocator requires.
        let mut entryBlock: BlockId = undefined;
        if hasGuard {
            entryBlock = try createBlock(self, "guard");
            set entryBlock = try createBlock(self, "guard");
        }
        // Body block: where the case body lives.
        let mut bodyLabel = "case";
        if prong.arm == ast::ProngArm::Else {
            bodyLabel = "else";
            set bodyLabel = "else";
        }
        let mut bodyBlock = try createBlock(self, bodyLabel);
        if not hasGuard {
            entryBlock = bodyBlock;
            set entryBlock = bodyBlock;
        }
        // Fallthrough block: jumped to when pattern or guard fails.
        let nextArm = try createBlock(self, "arm");

        // Emit pattern test: branch to entry block on match, next arm on fail.

        if let g = prong.guard {
            try emitCondBranch(self, g, bodyBlock, nextArm);
        } else if *currentBlock(self) <> *bodyBlock {
            // Nested tests changed the current block. Create a new body block
            // after the nest blocks to maintain RPO ordering, and jump to it.
            bodyBlock = try createBlock(self, bodyLabel);
            set bodyBlock = try createBlock(self, bodyLabel);
            try emitJmp(self, bodyBlock);
        }
        // Lower prong body and jump to merge if unterminated.
        try switchToAndSeal(self, bodyBlock);
        try lowerNode(self, prong.body);

fn lowerIfLet(self: *mut FnLowerer, cond: ast::IfLet) throws (LowerError) {
    let savedVarsLen = enterVarScope(self);
    let subject = try lowerMatchSubject(self, cond.pattern.scrutinee);
    let mut thenBlock: BlockId = undefined;
    if cond.pattern.guard == nil {
        thenBlock = try createBlock(self, "then");
        set thenBlock = try createBlock(self, "then");
    }
    let elseBlock = try createBlock(self, "else");
    let mut mergeBlock: ?BlockId = nil;

    // Pattern match: jump to @then on success, @else on failure.

    // If guard present, pattern match jumps to @guard, then guard evaluation
    // jumps to `successBlock` or `failBlock`. Otherwise, jump directly to
    // `successBlock`.
    let mut targetBlock: BlockId = undefined;
    if pat.guard <> nil {
        targetBlock = try createBlock(self, "guard");
        *successBlock = try createBlock(self, successLabel);
        set targetBlock = try createBlock(self, "guard");
        set *successBlock = try createBlock(self, successLabel);
    } else {
        targetBlock = *successBlock;
        set targetBlock = *successBlock;
    }
    match pat.kind {
        case ast::PatternKind::Case => {
            let patterns: *mut [*ast::Node] = &mut [pat.pattern];
            // Jump to `targetBlock` if the pattern matches, `failBlock` otherwise.

        try emitCondBranch(self, g, *successBlock, failBlock);
        try switchToAndSeal(self, *successBlock);
    } else if *currentBlock(self) <> *targetBlock {
        // Nested tests changed the current block. Create a new success block
        // after the nest blocks to maintain RPO ordering, and jump to it.
        *successBlock = try createBlock(self, successLabel);
        set *successBlock = try createBlock(self, successLabel);

        try emitJmp(self, *successBlock);
        try switchToAndSeal(self, *successBlock);
    }
}

/// Lower a `let-else` statement.
fn lowerLetElse(self: *mut FnLowerer, letElse: ast::LetElse) throws (LowerError) {
    let subject = try lowerMatchSubject(self, letElse.pattern.scrutinee);
    let mut mergeBlock: BlockId = undefined;
    if letElse.pattern.guard == nil {
        mergeBlock = try createBlock(self, "merge");
        set mergeBlock = try createBlock(self, "merge");
    }
    // Else branch executes when the pattern fails to match.
    let elseBlock = try createBlock(self, "else");

    // Evaluate pattern and jump to @end or @else.

    // Create control flow blocks: loop header, body (created lazily when
    // there's a guard), and exit.
    let whileBlock = try createBlock(self, "while");
    let mut bodyBlock: BlockId = undefined;
    if w.pattern.guard == nil {
        bodyBlock = try createBlock(self, "body");
        set bodyBlock = try createBlock(self, "body");
    }
    let endBlock = try createBlock(self, "merge");

    // Enter loop context and jump to loop header.
    enterLoop(self, endBlock, whileBlock);

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

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

        return nil;
    }
    return index as i64;
}

/// Check if an expression has persistent storage, ie. is an "lvalue".
/// Such expressions need to be copied when used to initialize a variable,
/// since their storage continues to exist independently. Temporaries (literals,
/// call results) can be adopted directly without copying.
fn hasStorage(node: *ast::Node) -> bool {
    match node.value {
        case ast::NodeValue::Ident(_),
             ast::NodeValue::FieldAccess(_),
             ast::NodeValue::Subscript { .. },
             ast::NodeValue::Deref(_) => return true,
        else => return false,
    }
}

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

    let reg = emitValToReg(self, val);

    // For all-void unions, the value *is* the tag, not a pointer.
    let mut tag: il::Val = undefined;
    if resolver::isVoidUnion(valType) {
        tag = il::Val::Reg(reg);
        set tag = il::Val::Reg(reg);
    } else {
        tag = loadTag(self, reg, TVAL_TAG_OFFSET, il::Type::W8);
        set tag = loadTag(self, reg, TVAL_TAG_OFFSET, il::Type::W8);
    }
    let binOp = il::BinOp::Eq if op == ast::BinaryOp::Eq else il::BinOp::Ne;
    return emitTypedBinOp(self, binOp, il::Type::W8, tag, il::Val::Imm(tagIdx));
}


    let mut result: ?il::Val = nil;

    for field in recInfo.fields {
        let cmp = try emitEqAtOffset(self, a, b, offset + field.offset, field.fieldType);

        result = emitLogicalAnd(self, result, cmp);
        set result = emitLogicalAnd(self, result, cmp);
    }
    if let r = result {
        return r;
    }
    return il::Val::Imm(1);

    // Unions and nested optionals may contain uninitialized payload bytes
    // when nil, so they need a guarded comparison.
    let isUnion = unionInfoFromType(inner) <> nil;
    let mut isOptional = false;
    if let case resolver::Type::Optional(_) = inner {
        isOptional = true;
        set isOptional = true;
    }
    if not isUnion and not isOptional {
        let tagEq = emitTypedBinOp(self, il::BinOp::Eq, il::Type::W8, tagA, tagB);
        let tagNil = emitTypedBinOp(self, il::BinOp::Eq, il::Type::W8, tagA, il::Val::Imm(0));
        let payloadEq = try emitEqAtOffset(self, a, b, offset + valOffset, inner);

    ) as *mut [il::SwitchCase];

    let mut caseBlocks: [?BlockId; resolver::MAX_UNION_VARIANTS] = undefined;
    for variant, i in unionInfo.variants {
        if variant.valueType == resolver::Type::Void {
            cases[i] = il::SwitchCase {
            set cases[i] = il::SwitchCase {
                value: i as i64,
                target: *mergeBlock,
                args: trueArgs
            };
            caseBlocks[i] = nil;
            set caseBlocks[i] = nil;
        } else {
            let payloadBlock = try createBlock(self, "eq#payload");
            cases[i] = il::SwitchCase {
            set cases[i] = il::SwitchCase {
                value: i as i64,
                target: *payloadBlock,
                args: &mut []
            };
            caseBlocks[i] = payloadBlock;
            set caseBlocks[i] = payloadBlock;
        }
    }

    // Emit switch in @tag block. Default arm is unreachable since we cover all variants.
    let unreachableBlock = try createBlock(self, "eq#unreachable");

    let mut result: ?il::Val = nil;

    for i in 0..arr.length {
        let elemOffset = offset + (i as i32) * stride;
        let cmp = try emitEqAtOffset(self, a, b, elemOffset, *arr.item);
        result = emitLogicalAnd(self, result, cmp);
        set result = emitLogicalAnd(self, result, cmp);
    }
    if let r = result {
        return r;
    }
    // Empty arrays are always equal.

        let mut fieldIdx: u32 = i;
        if recInfo.labeled {
            let idx = resolver::recordFieldIndexFor(self.low.resolver, fieldNode) else {
                throw LowerError::MissingMetadata;
            };
            fieldIdx = idx;
            set fieldIdx = idx;
        }
        // Skip `undefined` fields, they need no initialization.
        // Emitting a blit from an uninitialised reserve produces a
        // phantom SSA source value that the backend cannot handle.
        if not isUndef(field.value) {

    let mut payloadVal: ?il::Val = nil;
    if payloadType <> resolver::Type::Void {
        let case resolver::Type::Nominal(payloadNominal) = payloadType else {
            throw LowerError::MissingMetadata;
        };
        payloadVal = try lowerRecordCtor(self, payloadNominal, call.args);
        set payloadVal = try lowerRecordCtor(self, payloadNominal, call.args);
    }
    return try buildTagged(self, resolver::getTypeLayout(unionTy), index as i64, payloadVal, payloadType, 1, valOffset);
}

/// Lower a field access into a pointer to the field.


    // Extract data pointer and container length.
    let mut dataReg = baseReg;
    let mut containerLen: il::Val = undefined;
    if let cap = info.capacity { // Slice from array.
        containerLen = il::Val::Imm(cap as i64);
        set containerLen = il::Val::Imm(cap as i64);
    } else { // Slice from slice.
        dataReg = loadSlicePtr(self, baseReg);
        containerLen = loadSliceLen(self, baseReg);
        set dataReg = loadSlicePtr(self, baseReg);
        set containerLen = loadSliceLen(self, baseReg);
    }

    // Compute range bounds.
    let mut startVal: il::Val = il::Val::Imm(0);
    if let start = range.start {
        startVal = try lowerExpr(self, start);
        set startVal = try lowerExpr(self, start);
    }
    let mut endVal = containerLen;
    if let end = range.end {
        endVal = try lowerExpr(self, end);
        set endVal = try lowerExpr(self, end);
    }

    // If the start value is known to be zero, the count is just the end
    // value. Otherwise, we have to compute it.
    let mut count = endVal;

    // Only compute range offset and count if the start value is not
    // statically known to be zero.
    if startVal <> il::Val::Imm(0) {
        // Offset the data pointer by the start value.
        dataReg = emitElem(
        set dataReg = emitElem(
            self, resolver::getTypeLayout(*info.itemType).size, dataReg, startVal
        );
        // Compute the count as `end - start`.
        let lenReg = nextReg(self);
        emit(self, il::Instr::BinOp {

            typ: il::Type::W32,
            dst: lenReg,
            a: endVal,
            b: startVal,
        });
        count = il::Val::Reg(lenReg);
        set count = il::Val::Reg(lenReg);
    }
    return SliceRangeResult { dataReg, count };
}

/// Lower a slice range expression into a slice header value.

            let layout = resolver::getLayout(self.low.resolver, addr.target, typ);
            let slot = emitReserveLayout(self, layout);
            try emitStore(self, slot, 0, typ, val);
            let stackVal = il::Val::Reg(slot);

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

            return stackVal;
        }
        // Fall back to symbol lookup for constants/statics.

    let mut dataReg = baseReg;
    let mut elemType: resolver::Type = undefined;

    match subjectTy {
        case resolver::Type::Slice { item, .. } => {
            elemType = *item;
            set elemType = *item;
            let sliceLen = loadSliceLen(self, baseReg);
            // Runtime safety check: index must be strictly less than slice length.
            try emitTrapUnlessCmp(self, il::CmpOp::Ult, il::Type::W32, indexVal, sliceLen);

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

    // Temporaries such as literals or call results can be adopted directly.
    // This is because aggregates are represented as memory addresses
    // internally, even though they have value semantics, so without an explicit
    // copy, only the address is is written. Function calls on the other hand
    // reserve their own local stack space, so copying would be redundant.
    if isAggregateType(typ) and hasStorage(l.value) {
        varVal = try emitStackVal(self, typ, val);
    // Void variant literals (e.g. `Option::None`) use scope access syntax and
    // are flagged as place expressions, but they are freshly constructed
    // temporaries with no persistent storage.
    if isAggregateType(typ) and
        ast::isPlaceExpr(l.value) and
        voidVariantIndex(self.low.resolver, l.value) == nil {
        set varVal = try emitStackVal(self, typ, val);
    }

    // If the resolver determined that this variable's address is taken
    // anywhere in the function, allocate a stack slot immediately so the
    // SSA value is always a pointer. This avoids mixing integer and pointer

                let layout = resolver::getLayout(self.low.resolver, node, typ);
                let slot = emitReserveLayout(self, layout);
                try emitStore(self, slot, 0, typ, varVal);

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

                return;
            }
        }
    }

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

            let mut indexVar: ?Var = nil;
            if indexName <> nil { // Optional index always starts at zero.
                indexVar = newVar(self, indexName, il::Type::W32, false, il::Val::Imm(0));
                set indexVar = newVar(self, indexName, il::Type::W32, false, il::Val::Imm(0));
            }
            let iter = ForIter::Range {
                valVar, indexVar, endVal, valType: iterType,
                unsigned: isUnsignedType(*valType),
            };

            let containerReg = emitValToReg(self, containerVal);

            let mut dataReg = containerReg;
            let mut lengthVal: il::Val = undefined;
            if let len = length { // Array (length is known).
                lengthVal = il::Val::Imm(len as i64);
                set lengthVal = il::Val::Imm(len as i64);
            } else { // Slice (length must be loaded).
                lengthVal = loadSliceLen(self, containerReg);
                dataReg = loadSlicePtr(self, containerReg);
                set lengthVal = loadSliceLen(self, containerReg);
                set dataReg = loadSlicePtr(self, containerReg);
            }
            // Declare index value binidng.
            let idxVar = newVar(self, indexName, il::Type::W32, false, il::Val::Imm(0));

            // Declare element value binding.
            let mut valVar: ?Var = nil;
            if bindingName <> nil {
                valVar = newVar(
                set valVar = newVar(
                    self,
                    bindingName,
                    ilType(self.low, *elemType),
                    false,
                    il::Val::Undef


/// Lower a return statement.
fn lowerReturnStmt(self: *mut FnLowerer, node: *ast::Node, value: ?*ast::Node) throws (LowerError) {
    let mut val = il::Val::Undef;
    if let expr = value {
        val = try lowerExpr(self, expr);
        set val = try lowerExpr(self, expr);
    }
    val = try applyCoercion(self, node, val);
    set val = try applyCoercion(self, node, val);
    try emitRetVal(self, val);
}

/// Lower a throw statement.
fn lowerThrowStmt(self: *mut FnLowerer, expr: *ast::Node) throws (LowerError) {

    // Result when short-circuiting (`0` or `1`).
    let mut shortCircuitVal: i64 = undefined;

    match op {
        case LogicalOp::And => {
            shortCircuitBlock = elseBlock;
            evalBlock = thenBlock;
            shortCircuitVal = 0;
            set shortCircuitBlock = elseBlock;
            set evalBlock = thenBlock;
            set shortCircuitVal = 0;
        }
        case LogicalOp::Or => {
            shortCircuitBlock = thenBlock;
            evalBlock = elseBlock;
            shortCircuitVal = 1;
            set shortCircuitBlock = thenBlock;
            set evalBlock = elseBlock;
            set shortCircuitVal = 1;
        }
    }
    // Emit short-circuit branch: jump to merge with constant result.
    try switchToAndSeal(self, shortCircuitBlock);
    try emitJmpWithArg(self, mergeBlock, il::Val::Imm(shortCircuitVal));

        // Aggregate types require element-wise comparison.
        // When comparing `?T` with `T`, wrap the scalar side.
        if isAggregateType(leftTy) {
            let mut rhs = b;
            if not isAggregateType(rightTy) {
                rhs = try wrapInOptional(self, rhs, leftTy);
                set rhs = try wrapInOptional(self, rhs, leftTy);
            }
            return try emitAggregateEqOp(self, binop.op, leftTy, a, rhs);
        }
        if isAggregateType(rightTy) {
            let lhs = try wrapInOptional(self, a, rightTy);
            return try emitAggregateEqOp(self, binop.op, rightTy, lhs, b);
        }
        resultTy = leftTy;
        set resultTy = leftTy;
    }
    return emitScalarBinOp(self, binop.op, ilType(self.low, resultTy), a, b, isUnsignedType(resultTy));
}

/// Emit an aggregate equality or inequality comparison.

    let dst = nextReg(self);
    let mut needsExt: bool = false;
    match op {
        case ast::BinaryOp::Add => {
            emit(self, il::Instr::BinOp { op: il::BinOp::Add, typ, dst, a, b });
            needsExt = true;
            set needsExt = true;
        }
        case ast::BinaryOp::Sub => {
            emit(self, il::Instr::BinOp { op: il::BinOp::Sub, typ, dst, a, b });
            needsExt = true;
            set needsExt = true;
        }
        case ast::BinaryOp::Mul => {
            emit(self, il::Instr::BinOp { op: il::BinOp::Mul, typ, dst, a, b });
            needsExt = true;
            set needsExt = true;
        }
        case ast::BinaryOp::Div => {
            let op = il::BinOp::Udiv if unsigned else il::BinOp::Sdiv;
            emit(self, il::Instr::BinOp { op, typ, dst, a, b });
            needsExt = true;
            set needsExt = true;
        }
        case ast::BinaryOp::Mod => {
            let op = il::BinOp::Urem if unsigned else il::BinOp::Srem;
            emit(self, il::Instr::BinOp { op, typ, dst, a, b });
            needsExt = true;
            set needsExt = true;
        }
        case ast::BinaryOp::BitAnd => emit(self, il::Instr::BinOp { op: il::BinOp::And, typ, dst, a, b }),
        case ast::BinaryOp::BitOr => emit(self, il::Instr::BinOp { op: il::BinOp::Or, typ, dst, a, b }),
        case ast::BinaryOp::BitXor => emit(self, il::Instr::BinOp { op: il::BinOp::Xor, typ, dst, a, b }),
        case ast::BinaryOp::Shl => {
            emit(self, il::Instr::BinOp { op: il::BinOp::Shl, typ, dst, a, b });
            needsExt = true;
            set needsExt = true;
        }
        case ast::BinaryOp::Shr => {
            let op = il::BinOp::Ushr if unsigned else il::BinOp::Sshr;
            emit(self, il::Instr::BinOp { op, typ, dst, a, b });
        }

        case ast::UnaryOp::Not => {
            emit(self, il::Instr::BinOp { op: il::BinOp::Eq, typ, dst, a: val, b: il::Val::Imm(0) });
        }
        case ast::UnaryOp::Neg => {
            emit(self, il::Instr::UnOp { op: il::UnOp::Neg, typ, dst, a: val });
            needsExt = true;
            set needsExt = true;
        }
        case ast::UnaryOp::BitNot => {
            emit(self, il::Instr::UnOp { op: il::UnOp::Not, typ, dst, a: val });
            needsExt = true;
            set needsExt = true;
        }
    }
    if needsExt {
        return normalizeSubword(self, typ, isUnsignedType(t), il::Val::Reg(dst));
    }

    // Build the string data value.
    let ptr = try! alloc::alloc(
        self.low.arena, @sizeOf(il::DataValue), @alignOf(il::DataValue)
    ) as *mut il::DataValue;

    *ptr = il::DataValue { item: il::DataItem::Str(s), count: 1 };
    set *ptr = il::DataValue { item: il::DataItem::Str(s), count: 1 };

    return try lowerConstDataAsSlice(self, @sliceOf(ptr, 1), 1, true, item, mutable, s.len);
}

/// Lower a builtin call expression.

    };
    let ptrVal = try lowerExpr(self, args[0]);
    let lenVal = try lowerExpr(self, args[1]);
    let mut capVal = lenVal;
    if args.len == 3 {
        capVal = try lowerExpr(self, args[2]);
        set capVal = try lowerExpr(self, args[2]);
    }
    return try buildSliceValue(self, item, mutable, ptrVal, lenVal, capVal);
}

/// Lower a `try` expression.

    let mut resVal: il::Val = undefined;
    let callNodeExtra = resolver::nodeData(self.low.resolver, t.expr).extra;
    if let case resolver::NodeExtra::TraitMethodCall {
        traitInfo, methodIndex
    } = callNodeExtra {
        resVal = try lowerTraitMethodCall(self, t.expr, callExpr, traitInfo, methodIndex);
        set resVal = try lowerTraitMethodCall(self, t.expr, callExpr, traitInfo, methodIndex);
    } else if let case resolver::NodeExtra::MethodCall { method } = callNodeExtra {
        resVal = try lowerMethodCall(self, t.expr, callExpr, method);
        set resVal = try lowerMethodCall(self, t.expr, callExpr, method);
    } else {
        resVal = try lowerCall(self, t.expr, callExpr);
        set resVal = try lowerCall(self, t.expr, callExpr);
    }
    let base = emitValToReg(self, resVal); // The result value.
    let tagReg = resultTagReg(self, base); // The result tag.

    let okBlock = try createBlock(self, "ok"); // Block if success.


    // Check if the `try` returns a success value or not. If so, reserve
    // space for it.
    let isVoid = tryExprTy == resolver::Type::Void;
    if not isVoid {
        resultSlot = try emitReserve(self, tryExprTy);
        set resultSlot = try emitReserve(self, tryExprTy);
    }
    // Branch on tag: zero means ok, non-zero means error.
    try emitBr(self, tagReg, errBlock, okBlock);

    // We can now seal the blocks since all predecessors are known.

        // type (e.g. `try?` wrapping `T` into `?T`), wrap the value.
        let payloadVal = tvalPayloadVal(self, base, okValueTy, RESULT_VAL_OFFSET);
        let mut okVal = payloadVal;

        if t.returnsOptional and tryExprTy <> okValueTy {
            okVal = try wrapInOptional(self, payloadVal, tryExprTy);
            set okVal = try wrapInOptional(self, payloadVal, tryExprTy);
        }
        try emitStore(self, slot, 0, tryExprTy, okVal);
    }
    // Jump to merge block if unterminated.
    try emitMergeIfUnterminated(self, &mut mergeBlock);


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

        blocks[i] = try createBlock(self, "catch");
        set blocks[i] = try createBlock(self, "catch");
        addPredecessor(self, blocks[i], entry);

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

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

    // Emit switch. Default target is the catch-all block, or an unreachable block.
    let mut defaultTarget: BlockId = undefined;
    if let idx = defaultIdx {
        defaultTarget = blocks[idx];
        set defaultTarget = blocks[idx];
    } else {
        defaultTarget = try createBlock(self, "unreachable");
        set defaultTarget = try createBlock(self, "unreachable");
        addPredecessor(self, defaultTarget, entry);
    }
    emit(self, il::Instr::Switch {
        val: il::Val::Reg(tagReg),
        defaultTarget: *defaultTarget,

    emitLoadW64At(self, allocCtxReg, allocReg, 8);

    let byteSize = emitTypedBinOp(self, il::BinOp::Mul, il::Type::W32, newCapVal, il::Val::Imm(stride as i64));
    let args = try allocVals(self, 3);

    args[0] = il::Val::Reg(allocCtxReg);
    args[1] = byteSize;
    args[2] = il::Val::Imm(alignment as i64);
    set args[0] = il::Val::Reg(allocCtxReg);
    set args[1] = byteSize;
    set args[2] = il::Val::Imm(alignment as i64);

    let newPtrReg = nextReg(self);
    emit(self, il::Instr::Call {
        retTy: il::Type::W64,
        dst: newPtrReg,

    let methodFnType = traitInfo.methods[methodIndex].fnType;

    // Build args: optional return param slot + data pointer (receiver) + user args.
    let argOffset: u32 = 1 if requiresReturnParam(methodFnType) else 0;
    let args = try allocVals(self, call.args.len + 1 + argOffset);
    args[argOffset] = il::Val::Reg(dataReg);
    set args[argOffset] = il::Val::Reg(dataReg);

    for arg, i in call.args {
        args[i + 1 + argOffset] = try lowerExpr(self, arg);
        set args[i + 1 + argOffset] = try lowerExpr(self, arg);
    }
    return try emitCallValue(self, il::Val::Reg(fnPtrReg), methodFnType, args);
}

/// Emit a function call with return-parameter and small-aggregate handling.

    let retTy = *fnInfo.returnType;

    if requiresReturnParam(fnInfo) {
        if fnInfo.throwList.len > 0 {
            let layout = resolver::getResultLayout(retTy, fnInfo.throwList);
            args[0] = il::Val::Reg(emitReserveLayout(self, layout));
            set args[0] = il::Val::Reg(emitReserveLayout(self, layout));
        } else {
            args[0] = il::Val::Reg(try emitReserve(self, retTy));
            set args[0] = il::Val::Reg(try emitReserve(self, retTy));
        }
        let dst = nextReg(self);

        emit(self, il::Instr::Call {
            retTy: il::Type::W64,

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

        else panic "lowerMethodCall: expected Fn type on method symbol";

    // Build args: optional return param slot + receiver + user args.
    let argOffset: u32 = 1 if requiresReturnParam(fnInfo) else 0;
    let args = try allocVals(self, call.args.len + 1 + argOffset);
    args[argOffset] = receiverVal;
    set args[argOffset] = receiverVal;
    for arg, i in call.args {
        args[i + 1 + argOffset] = try lowerExpr(self, arg);
        set args[i + 1 + argOffset] = try lowerExpr(self, arg);
    }
    return try emitCallValue(self, il::Val::FnAddr(qualName), fnInfo, args);
}

/// Check if a call is to a compiler intrinsic and lower it directly.

    };
    let callee = try lowerCallee(self, call.callee);
    let offset: u32 = 1 if requiresReturnParam(fnInfo) else 0;
    let args = try allocVals(self, call.args.len + offset);
    for arg, i in call.args {
        args[i + offset] = try lowerExpr(self, arg);
        set args[i + offset] = try lowerExpr(self, arg);
    }

    return try emitCallValue(self, callee, fnInfo, args);
}



/// Lower an expression AST node to an IL value.
/// This is the main expression dispatch, all expression nodes go through here.
fn lowerExpr(self: *mut FnLowerer, node: *ast::Node) -> il::Val throws (LowerError) {
    if self.low.options.debug {
        self.srcLoc.offset = node.span.offset;
        set self.srcLoc.offset = node.span.offset;
    }
    let mut val: il::Val = undefined;

    match node.value {
        case ast::NodeValue::Ident(_) => {
            // First try local variable lookup.
            // Otherwise fall back to global symbol lookup.
            if let v = lookupLocalVar(self, node) {
                val = try useVar(self, v);
                set val = try useVar(self, v);
                if self.vars[*v].addressTaken {
                    let typ = try typeOf(self, node);
                    let ptr = emitValToReg(self, val);
                    val = emitRead(self, ptr, 0, typ);
                    set val = emitRead(self, ptr, 0, typ);
                }
            } else {
                val = try lowerGlobalSymbol(self, node);
                set val = try lowerGlobalSymbol(self, node);
            }
        }
        case ast::NodeValue::ScopeAccess(_) => {
            val = try lowerScopeAccess(self, node);
            set val = try lowerScopeAccess(self, node);
        }
        case ast::NodeValue::Number(lit) => {
            let mag = -(lit.magnitude as i64) if lit.negative else lit.magnitude as i64;
            val = il::Val::Imm(mag);
            set val = il::Val::Imm(mag);
        }
        case ast::NodeValue::Bool(b) => {
            val = il::Val::Imm(1) if b else il::Val::Imm(0);
            set val = il::Val::Imm(1) if b else il::Val::Imm(0);
        }
        case ast::NodeValue::Char(c) => {
            val = il::Val::Imm(c as i64);
            set val = il::Val::Imm(c as i64);
        }
        case ast::NodeValue::Nil => {
            let typ = try typeOf(self, node);
            if let case resolver::Type::Optional(_) = typ {
                val = try buildNilOptional(self, typ);
                set val = try buildNilOptional(self, typ);
            } else if let case resolver::Type::Nil = typ {
                // Standalone `nil` without a concrete optional type. We can't
                // generate a proper value representation.
                throw LowerError::MissingType(node);
            } else {
                throw LowerError::NilInNonOptional;
            }
        }
        case ast::NodeValue::RecordLit(lit) => {
            val = try lowerRecordLit(self, node, lit);
            set val = try lowerRecordLit(self, node, lit);
        }
        case ast::NodeValue::AddressOf(addr) => {
            val = try lowerAddressOf(self, node, addr);
            set val = try lowerAddressOf(self, node, addr);
        }
        case ast::NodeValue::Deref(target) => {
            val = try lowerDeref(self, node, target);
            set val = try lowerDeref(self, node, target);
        }
        case ast::NodeValue::BinOp(binop) => {
            val = try lowerBinOp(self, node, binop);
            set val = try lowerBinOp(self, node, binop);
        }
        case ast::NodeValue::UnOp(unop) => {
            val = try lowerUnOp(self, node, unop);
            set val = try lowerUnOp(self, node, unop);
        }
        case ast::NodeValue::Subscript { container, index } => {
            val = try lowerSubscript(self, node, container, index);
            set val = try lowerSubscript(self, node, container, index);
        }
        case ast::NodeValue::BuiltinCall { kind, args } => {
            val = try lowerBuiltinCall(self, node, kind, args);
            set val = try lowerBuiltinCall(self, node, kind, args);
        }
        case ast::NodeValue::Call(call) => {
            val = try lowerCallOrCtor(self, node, call);
            set val = try lowerCallOrCtor(self, node, call);
        }
        case ast::NodeValue::Try(t) => {
            val = try lowerTry(self, node, t);
            set val = try lowerTry(self, node, t);
        }
        case ast::NodeValue::FieldAccess(access) => {
            // Check for compile-time constant (e.g., `arr.len` on fixed-size arrays).
            if let constVal = resolver::constValueEntry(self.low.resolver, node) {
                match constVal {
                    // TODO: Handle `u32` values that don't fit in an `i32`.
                    //       Perhaps just store the `ConstInt`.
                    case resolver::ConstValue::Int(i) => val = il::Val::Imm(constIntToI64(i)),
                    else => val = try lowerFieldAccess(self, access),
                    case resolver::ConstValue::Int(i) => set val = il::Val::Imm(constIntToI64(i)),
                    else => set val = try lowerFieldAccess(self, access),
                }
            } else {
                val = try lowerFieldAccess(self, access);
                set val = try lowerFieldAccess(self, access);
            }
        }
        case ast::NodeValue::ArrayLit(elements) => {
            val = try lowerArrayLit(self, node, elements);
            set val = try lowerArrayLit(self, node, elements);
        }
        case ast::NodeValue::ArrayRepeatLit(repeat) => {
            val = try lowerArrayRepeatLit(self, node, repeat);
            set val = try lowerArrayRepeatLit(self, node, repeat);
        }
        case ast::NodeValue::As(cast) => {
            val = try lowerCast(self, node, cast);
            set val = try lowerCast(self, node, cast);
        }
        case ast::NodeValue::CondExpr(cond) => {
            val = try lowerCondExpr(self, node, cond);
            set val = try lowerCondExpr(self, node, cond);
        }
        case ast::NodeValue::String(s) => {
            val = try lowerStringLit(self, node, s);
            set val = try lowerStringLit(self, node, s);
        }
        case ast::NodeValue::Undef => {
            let typ = try typeOf(self, node);
            if isAggregateType(typ) {
                // When `undefined` appears as a stand-alone expression,
                /// we need a stack slot for reads and writes.
                let slot = try emitReserve(self, typ);
                val = il::Val::Reg(slot);
                set val = il::Val::Reg(slot);
            } else {
                val = il::Val::Undef;
                set val = il::Val::Undef;
            }
        }
        case ast::NodeValue::Panic { .. } => {
            // Panic in expression context (e.g. match arm). Emit unreachable
            // and return a dummy value since control won't continue.
            emit(self, il::Instr::Unreachable);
            val = il::Val::Undef;
            set val = il::Val::Undef;
        }
        case ast::NodeValue::Assert { .. } => {
            // Assert in expression context. Lower as statement, return `void`.
            try lowerNode(self, node);
            val = il::Val::Undef;
            set val = il::Val::Undef;
        }
        case ast::NodeValue::Block(_) => {
            try lowerBlock(self, node);
            val = il::Val::Undef;
            set val = il::Val::Undef;
        }
        case ast::NodeValue::ExprStmt(expr) => {
            let _ = expr;
            val = il::Val::Undef;
            set val = il::Val::Undef;
        }
        // Lower these as statements.
        case ast::NodeValue::ConstDecl(decl) => {
            try lowerDataDecl(self.low, node, decl.value, true);
            val = il::Val::Undef;
            set val = il::Val::Undef;
        }
        case ast::NodeValue::StaticDecl(decl) => {
            try lowerDataDecl(self.low, node, decl.value, false);
            val = il::Val::Undef;
            set val = il::Val::Undef;
        }
        case ast::NodeValue::Throw { .. },
             ast::NodeValue::Return { .. },
             ast::NodeValue::Continue,
             ast::NodeValue::Break => {
            try lowerNode(self, node);
            val = il::Val::Undef;
            set val = il::Val::Undef;
        }
        else => {
            panic "lowerExpr: node is not an expression";
        }
    }

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

    filePath: *[u8]
) -> u16 throws (ModuleError) {
    let m = try allocModule(graph, packageId, name, filePath);
    try appendPathSegment(m, m.name);

    m.state = ModuleState::Registered;
    set m.state = ModuleState::Registered;

    return m.id;
}

/// Register a child module.

        return child.id;
    }
    // Inherit packageId from parent.
    let m = try allocModule(graph, parent.packageId, name, filePath);

    m.dirLen = dirLength(m.filePath);
    m.state = ModuleState::Registered;
    m.parent = parentId;
    set m.dirLen = dirLength(m.filePath);
    set m.state = ModuleState::Registered;
    set m.parent = parentId;

    // Inherit path prefix from parent.
    for p in moduleQualifiedPath(parent) {
        try appendPathSegment(m, p);
    }

}

/// Record the parsed AST root for `id`.
export fn setAst(graph: *mut ModuleGraph, id: u16, root: *mut ast::Node) throws (ModuleError) {
    let m = getMut(graph, id) else throw ModuleError::NotFound(id);
    m.ast = root;
    m.state = ModuleState::Parsed;
    set m.ast = root;
    set m.state = ModuleState::Parsed;
}

/// Set the source text for a module.
export fn setSource(graph: *mut ModuleGraph, id: u16, source: *[u8]) throws (ModuleError) {
    let m = getMut(graph, id) else throw ModuleError::NotFound(id);
    m.source = source;
    set m.source = source;
}

/// Look up a child module by name under the given parent.
export fn findChild(graph: *ModuleGraph, name: *[u8], parentId: u16) -> ?*ModuleEntry {
    assert isValidId(graph, parentId), "findChild: parent identifier is valid";

    // Split on '/' to extract all but the last component.
    for i in 0..filePath.len {
        if filePath[i] == PATH_SEP {
            if i > last {
                assert count < components.len, "parsePath: output slice is large enough";
                components[count] = &filePath[last..i];
                count += 1;
                set components[count] = &filePath[last..i];
                set count += 1;
            }
            last = i + 1;
            set last = i + 1;
        }
    }
    if last >= filePath.len {
        return nil; // Path ends with separator or is empty.
    }

    // Handle the last component by removing extension.
    assert count < components.len, "parsePath: output slice is large enough";
    if let name = trimExtension(&filePath[last..]) {
        components[count] = name;
        set components[count] = name;
    } else {
        return nil;
    };
    count += 1;
    set count += 1;

    return count;
}

/// Register a module from a file path, creating the full hierarchy as needed.

    let mut parentId = root;
    for part in &childPath[..childPath.len - 1] {
        let child = findChild(graph, part, parentId) else {
            throw ModuleError::MissingParent;
        };
        parentId = child.id;
        set parentId = child.id;
    }
    return try registerChild(graph, parentId, childName, filePath);
}

/// Allocate a fresh entry in the graph.
fn allocModule(graph: *mut ModuleGraph, packageId: u16, name: *[u8], filePath: *[u8]) -> *mut ModuleEntry throws (ModuleError) {
    if graph.entriesLen >= graph.entries.len {
        throw ModuleError::CapacityExceeded;
    }
    let idx = graph.entriesLen;
    graph.entriesLen += 1;
    set graph.entriesLen += 1;

    // TODO: This is a common pattern that needs better syntax.
    let m = &mut graph.entries[idx];
    *m = ModuleEntry {
    set *m = ModuleEntry {
        id: idx as u16,
        packageId,
        parent: nil,
        filePath,
        dirLen: 0,

        children: undefined,
        childrenLen: 0,
        ast: nil,
        source: nil,
    };
    m.dirLen = dirLength(m.filePath);
    set m.dirLen = dirLength(m.filePath);

    return m;
}

/// Append a logical path segment (module identifier) to the entry.
fn appendPathSegment(entry: *mut ModuleEntry, segment: *[u8]) throws (ModuleError) {
    if entry.pathDepth >= entry.path.len {
        throw ModuleError::PathTooDeep;
    }
    entry.path[entry.pathDepth] = segment;
    entry.pathDepth += 1;
    set entry.path[entry.pathDepth] = segment;
    set entry.pathDepth += 1;
}

/// Append a child identifier to the parent's child list.
fn addChild(parent: *mut ModuleEntry, childId: u16) -> u16 throws (ModuleError) {
    if parent.childrenLen >= parent.children.len {
        throw ModuleError::CapacityExceeded;
    }
    parent.children[parent.childrenLen] = childId;
    parent.childrenLen += 1;
    set parent.children[parent.childrenLen] = childId;
    set parent.childrenLen += 1;

    return childId;
}

/// Check if `id` points at an allocated entry.

        return 0;
    }
    let mut last: i32 = -1;
    for i in 0..path.len {
        if path[i] == PATH_SEP {
            last = i as i32;
            set last = i as i32;
        }
    }
    if last < 0 {
        return 0;
    }

/// Find the byte offset immediately following the last separator.
fn basenameStart(path: *[u8]) -> u32 {
    let mut start: u32 = 0;
    for i in 0..path.len {
        if path[i] == PATH_SEP {
            start = i + 1;
            set start = i + 1;
        }
    }
    return start;
}


lib/std/lang/module/printer.rad +4 -4

    let idText = formatId(a, entry.id as u32);
    let path = super::moduleQualifiedPath(entry);
    let mut pathBuf: *[sexpr::Expr] = &[];
    if path.len > 0 {
        let buf = try! sexpr::allocExprs(a, path.len);
        for seg, i in path { buf[i] = sexpr::sym(seg); }
        pathBuf = buf;
        for seg, i in path { set buf[i] = sexpr::sym(seg); }
        set pathBuf = buf;
    }

    let mut childBuf: *[sexpr::Expr] = &[];
    if entry.childrenLen > 0 {
        let buf = try! sexpr::allocExprs(a, entry.childrenLen);
        for i in 0..entry.childrenLen {
            if let child = super::get(graph, entry.children[i]) {
                buf[i] = subtreeToExpr(a, graph, child);
                set buf[i] = subtreeToExpr(a, graph, child);
            }
        }
        childBuf = buf;
        set childBuf = buf;
    }

    return sexpr::block(a, "module", &[
        sexpr::sym(entry.name),
        sexpr::list(a, "id", &[sexpr::sym(idText)]),

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

    pkg: *mut Package,
    id: u16,
    name: *[u8],
    pool: *mut strings::Pool
) -> *mut Package {
    pkg.id = id;
    pkg.name = strings::intern(pool, name);
    pkg.rootModuleId = nil;
    set pkg.id = id;
    set pkg.name = strings::intern(pool, name);
    set pkg.rootModuleId = nil;

    return pkg;
}

/// Register a module described by the file path.

    throws (module::ModuleError)
{
    let modId = try module::registerFromPath(graph, pkg.id, pkg.rootModuleId, filePath);
    // First registered module becomes the root.
    if pkg.rootModuleId == nil {
        pkg.rootModuleId = modId;
        set pkg.rootModuleId = modId;
    }
    return modId;
}

lib/std/lang/parser.rad +124 -129


    // Default to an out-of-range value so non-digits fall through to `nil`.
    let mut value: u32 = 36;

    if ch >= '0' and ch <= '9' {
        value = (ch - '0') as u32;
        set value = (ch - '0') as u32;
    } else if radix > 10 {
        // Mask to convert ASCII letters to uppercase.
        let upper = ch & 0xDF;
        if upper >= 'A' and upper <= 'Z' {
            value = (upper - 'A') as u32 + 10;
            set value = (upper - 'A') as u32 + 10;
        }
    }
    if value < radix {
        return value;
    }

    let mut start: u32 = 0;
    let mut radix: u32 = 10;
    let mut radixType = ast::Radix::Decimal;

    if signed {
        start = 1;
        set start = 1;
        if start >= text.len {
            throw failParsing(p, "integer literal requires digits after sign");
        }
    }
    if start + 1 < text.len and text[start] == '0' {
        let prefix = text[start + 1];
        if prefix == 'x' or prefix == 'X' {
            radix = 16;
            radixType = ast::Radix::Hex;
            start += 2;
            set radix = 16;
            set radixType = ast::Radix::Hex;
            set start += 2;
        } else if prefix == 'b' or prefix == 'B' {
            radix = 2;
            radixType = ast::Radix::Binary;
            start += 2;
            set radix = 2;
            set radixType = ast::Radix::Binary;
            set start += 2;
        }
        if start >= text.len {
            throw failParsing(p, "integer literal prefix must be followed by digits");
        }
    }

            throw failParsing(p, "invalid digit in integer literal");
        };
        if value > (U64_MAX / radix64) {
            throw failParsing(p, "integer literal overflow");
        }
        value *= radix64;
        set value *= radix64;

        if value > U64_MAX - (digit as u64) {
            throw failParsing(p, "integer literal overflow");
        }
        value += (digit as u64);
        set value += (digit as u64);
    }
    return ast::IntLiteral {
        text, magnitude: value, radix: radixType, signed, negative,
    };
}

275	275		let mut j: u32 = 0;
276	276
277	277		while i < raw.len {
278	278		if raw[i] == '\\' and i + 1 < raw.len {
279	279		match raw[i + 1] {
280		-	case 'n' => dst[j] = '\n',
281		-	case 't' => dst[j] = '\t',
282		-	case 'r' => dst[j] = '\r',
283		-	case '\\' => dst[j] = '\\',
284		-	case '"' => dst[j] = '"',
285		-	case '0' => dst[j] = 0,
286		-	else => dst[j] = raw[i + 1],
	280	+	case 'n' => set dst[j] = '\n',
	281	+	case 't' => set dst[j] = '\t',
	282	+	case 'r' => set dst[j] = '\r',
	283	+	case '\\' => set dst[j] = '\\',
	284	+	case '"' => set dst[j] = '"',
	285	+	case '0' => set dst[j] = 0,
	286	+	else => set dst[j] = raw[i + 1],
287	287		}
288		-	i += 2;
	288	+	set i += 2;
289	289		} else {
290		-	dst[j] = raw[i];
291		-	i += 1;
	290	+	set dst[j] = raw[i];
	291	+	set i += 1;
292	292		}
293		-	j += 1;
	293	+	set j += 1;
294	294		}
295	295		return j;
296	296		}
297	297
298	298		/// Emit a single attribute node.

    throws (ParseError)
{
    try expect(p, scanner::TokenKind::LParen, "expected `(`");

    let saved = p.context;
    p.context = Context::Normal;
    set p.context = Context::Normal;
    let expr = try parseExpr(p);
    p.context = saved;
    set p.context = saved;

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

    return expr;
}

    let mut result = expr;

    while consume(p, scanner::TokenKind::As) {
        let target = try parseType(p);

        result = node(p, ast::NodeValue::As(
        set result = node(p, ast::NodeValue::As(
            ast::As { value: result, type: target }
        ));
    }
    return result;
}


    if consume(p, scanner::TokenKind::DotDot) {
        // Either `..` or `..end`.
        let mut endExpr: ?*ast::Node = nil;
        if not check(p, scanner::TokenKind::RBracket) {
            endExpr = try parseExpr(p);
            set endExpr = try parseExpr(p);
        }
        index = node(p, ast::NodeValue::Range(
        set index = node(p, ast::NodeValue::Range(
            ast::Range { start: nil, end: endExpr }
        ));
    } else {
        // Either `n`, `n..` or `n..end`.
        let startExpr = try parseExpr(p);

        if consume(p, scanner::TokenKind::DotDot) {
            // Either `n..` or `n..end`.
            let mut endExpr: ?*ast::Node = nil;
            if not check(p, scanner::TokenKind::RBracket) {
                endExpr = try parseExpr(p);
                set endExpr = try parseExpr(p);
            }
            index = node(p, ast::NodeValue::Range(
            set index = node(p, ast::NodeValue::Range(
                ast::Range { start: startExpr, end: endExpr }
            ));
        } else {
            // Just `n` - regular indexing.
            index = startExpr;
            set index = startExpr;
        }
    }
    try expect(p, scanner::TokenKind::RBracket, "expected `]` after array index");

    return node(p, ast::NodeValue::Subscript { container, index });

        match p.current.kind {
            case scanner::TokenKind::Dot => {
                advance(p);

                let field = try parseIdent(p, "expected field name after `.`");
                result = node(p, ast::NodeValue::FieldAccess(
                set result = node(p, ast::NodeValue::FieldAccess(
                    ast::Access { parent: result, child: field }
                ));
            }
            case scanner::TokenKind::ColonColon => {
                advance(p);

                let ident = try parseIdent(p, "expected identifier after `::`");
                result = node(p, ast::NodeValue::ScopeAccess(
                set result = node(p, ast::NodeValue::ScopeAccess(
                    ast::Access { parent: result, child: ident }
                ));
            }
            case scanner::TokenKind::LBracket => {
                result = try parseSubscriptOrSlice(p, result);
                set result = try parseSubscriptOrSlice(p, result);
            }
            case scanner::TokenKind::LParen => {
                result = try parseCall(p, result);
                set result = try parseCall(p, result);
            }
            case scanner::TokenKind::LBrace if p.context <> Context::Condition => {
                result = try parseRecordLit(p, result);
                set result = try parseRecordLit(p, result);
            }
            else => {
                break;
            }
        }

}

/// Parse a conditional expression.
export fn parseCond(p: *mut Parser) -> *ast::Node throws (ParseError) {
    let saved = p.context;
    p.context = Context::Condition;
    set p.context = Context::Condition;
    let expr = try parseExpr(p);
    p.context = saved;
    set p.context = saved;

    return expr;
}

/// Parse unary expression followed by optional `as` cast.

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

    if not isRangeTerminator(p.current.kind) {
        let right = try parseUnary(p);
        endExpr = try parseBinary(p, right, -1);
        set endExpr = try parseBinary(p, right, -1);
    }
    return node(p, ast::NodeValue::Range(
        ast::Range { start, end: endExpr }
    ));
}

    let mut result = left;

    loop {
        if p.current.kind == scanner::TokenKind::DotDot {
            advance(p);
            result = try parseRangeExpr(p, result);
            set result = try parseRangeExpr(p, result);
        } else {
            let opInfo = findNextOp(p.current.kind, minPrec) else break;
            advance(p);

            let mut right = try parseUnary(p);

            while let _ = findNextOp(p.current.kind, opInfo.prec)  {
                right = try parseBinary(p, right, opInfo.prec);
                set right = try parseBinary(p, right, opInfo.prec);
            }
            result = node(p, ast::NodeValue::BinOp(ast::BinOp {
            set result = node(p, ast::NodeValue::BinOp(ast::BinOp {
                op: opInfo.op, left: result, right,
            }));
        }
    }
    return result;

            return true,
        else =>
            return false,
    }
}

/// Check if a statement requires a semicolon after it.
///
/// Statements that end with blocks don't require semicolons.
/// All other statements do.
fn expectsSemicolon(stmt: *ast::Node) -> bool {

702	701		let src = p.previous.source;
703	702		let mut ch: u8 = 0;
704	703
705	704		if src[1] == '\\' { // Handle escape sequences.
706	705		match src[2] {
707		-	case 'n' => { ch = '\n'; }
708		-	case 't' => { ch = '\t'; }
709		-	case 'r' => { ch = '\r'; }
710		-	case '\'' => { ch = '\''; }
711		-	case '\\' => { ch = '\\'; }
712		-	else => { ch = src[2]; }
	706	+	case 'n' => { set ch = '\n'; }
	707	+	case 't' => { set ch = '\t'; }
	708	+	case 'r' => { set ch = '\r'; }
	709	+	case '\'' => { set ch = '\''; }
	710	+	case '\\' => { set ch = '\\'; }
	711	+	else => { set ch = src[2]; }
713	712		}
714	713		} else {
715		-	ch = src[1];
	714	+	set ch = src[1];
716	715		}
717	716		return node(p, ast::NodeValue::Char(ch));
718	717		}
719	718		case scanner::TokenKind::String => {
720	719		advance(p);

    advance(p);

    let mut kind: ast::Builtin = undefined;
    // TODO: Use `match`.
    if ident == "@sizeOf" {
        kind = ast::Builtin::SizeOf;
        set kind = ast::Builtin::SizeOf;
    } else if ident == "@alignOf" {
        kind = ast::Builtin::AlignOf;
        set kind = ast::Builtin::AlignOf;
    } else if ident == "@sliceOf" {
        kind = ast::Builtin::SliceOf;
        set kind = ast::Builtin::SliceOf;
    } else {
        throw failParsing(p, "unknown builtin");
    }
    try expect(p, scanner::TokenKind::LParen, "expected `(` after builtin name");


/// Parse an expression statement.
export fn parseExprStmt(p: *mut Parser) -> *ast::Node
    throws (ParseError)
{
    let expr = try parseExpr(p);
    return node(p, ast::NodeValue::ExprStmt(expr));
}

/// Parse a `set` statement assignment.
fn parseSetStmt(p: *mut Parser) -> *ast::Node
    throws (ParseError)
{
    let target = try parseUnary(p);
    if not ast::isPlaceExpr(target) {
        throw failParsing(p, "invalid assignment target");
    }
    if consume(p, scanner::TokenKind::Equal) {
        if not isAssignableTarget(expr) {
            throw failParsing(p, "invalid assignment target");
        }
        let value = try parseExpr(p);

        return node(p, ast::NodeValue::Assign(
            ast::Assign { left: expr, right: value }
            ast::Assign { left: target, right: value }
        ));
    }
    // Compound assignment: desugar `x <op>= y` into `x = x <op> y`.
    // The left-hand side node is shared between the assignment target and the
    // binary operand. This is safe because the resolver caches results by node
    // and returns the same type on repeated visits.
    // Compound assignment: desugar `set x <op>= y` into `set x = x <op> y`.
    // The target node is shared with the binary operand.
    if let op = tryCompoundAssignOp(p) {
        if not isAssignableTarget(expr) {
            throw failParsing(p, "invalid compound assignment target");
        }
        let rhs = try parseExpr(p);
        let binop = node(p, ast::NodeValue::BinOp(
            ast::BinOp { op, left: expr, right: rhs }
            ast::BinOp { op, left: target, right: rhs }
        ));

        return node(p, ast::NodeValue::Assign(
            ast::Assign { left: expr, right: binop }
            ast::Assign { left: target, right: binop }
        ));
    }
    return node(p, ast::NodeValue::ExprStmt(expr));
    throw failParsing(p, "expected assignment after `set`");
}

/// Parse leading attributes attached to the next declaration statement.
fn parseAttributes(p: *mut Parser) -> ?ast::Attributes {
    let mut attrs = ast::nodeSlice(p.arena, 4);

            }
            return try parseLet(p, false);
        }
        case scanner::TokenKind::Set => {
            advance(p);
            let stmt = try parseExprStmt(p);
            if let case ast::NodeValue::Assign(_) = stmt.value {
                return stmt;
            }
            throw failParsing(p, "expected assignment after `set`");
            return try parseSetStmt(p);
        }
        case scanner::TokenKind::Constant => {
            return try parseConst(p, attrs);
        }
        case scanner::TokenKind::Static => {

fn finishSpan(p: *mut Parser, node: *mut ast::Node) {
    let start: u32 = node.span.offset;
    let mut end: u32 = p.previous.offset + p.previous.source.len;

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

/// Save parser state for speculative parsing.
fn saveState(p: *Parser) -> SavedState {

}

/// Restore parser state from a snapshot, fully undoing any
/// side effects of a failed speculative parse.
fn restoreState(p: *mut Parser, s: *SavedState) {
    *p = s.parser;
    set *p = s.parser;
    alloc::restore(&mut p.arena.arena, s.arena);
    p.arena.nextId = s.nextId;
    set p.arena.nextId = s.nextId;
}

/// Report a parser error.
fn reportError(p: *mut Parser, token: scanner::Token, message: *[u8]) {
    assert message.len > 0;

    // Ignore errors once the error list is full.
    if p.errors.count < p.errors.list.len {
        p.errors.list[p.errors.count] = Error { message, token };
        p.errors.count += 1;
        set p.errors.list[p.errors.count] = Error { message, token };
        set p.errors.count += 1;
    }
}

/// Fail the parsing process with the given error.
fn failParsing(p: *mut Parser, err: *[u8]) -> ParseError {

    return p.current.kind == kind;
}

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

/// Parse an `if let` pattern matching statement.
///
/// Syntax: `if let binding = scrutinee { ... }`

    let mut pattern: *ast::Node = undefined;
    let mut kind = ast::PatternKind::Binding;
    let mut mutable = false;

    if consume(p, scanner::TokenKind::Case) {
        pattern = try parseMatchPattern(p);
        kind = ast::PatternKind::Case;
        set pattern = try parseMatchPattern(p);
        set kind = ast::PatternKind::Case;
    } else {
        mutable = consume(p, scanner::TokenKind::Mut);
        pattern = try parseIdentOrPlaceholder(p, "expected `case`, `mut`, or identifier after `let`");
        set mutable = consume(p, scanner::TokenKind::Mut);
        set pattern = try parseIdentOrPlaceholder(p, "expected `case`, `mut`, or identifier after `let`");
    }
    try expect(p, scanner::TokenKind::Equal, "expected `=` after pattern");

    let scrutinee = try parseCond(p);
    let mut guard: ?*ast::Node = nil;

    if consume(p, scanner::TokenKind::Semicolon) {
        guard = try parseCond(p);
        set guard = try parseCond(p);
    }
    let thenBranch = try parseBlock(p);
    let mut elseBranch: ?*ast::Node = nil;

    if consume(p, scanner::TokenKind::Else) {
        if check(p, scanner::TokenKind::If) {
            elseBranch = node(p, ast::NodeValue::Block(
            set elseBranch = node(p, ast::NodeValue::Block(
                mkBlockWith(p, try parseIf(p))
            ));
        } else {
            elseBranch = try parseBlock(p);
            set elseBranch = try parseBlock(p);
        }
    }

    return node(p, ast::NodeValue::IfLet(ast::IfLet {
        pattern: ast::PatternMatch { pattern, scrutinee, guard, kind, mutable },

    // Parse pattern: either `case <pattern>`, `mut <ident>`, or simple `<ident>`.
    let mut pattern: *ast::Node = undefined;
    let mut kind = ast::PatternKind::Binding;
    let mut mutable = false;
    if consume(p, scanner::TokenKind::Case) {
        pattern = try parseMatchPattern(p);
        kind = ast::PatternKind::Case;
        set pattern = try parseMatchPattern(p);
        set kind = ast::PatternKind::Case;
    } else {
        mutable = consume(p, scanner::TokenKind::Mut);
        pattern = try parseIdentOrPlaceholder(p, "expected `case`, `mut`, or identifier after `let`");
        set mutable = consume(p, scanner::TokenKind::Mut);
        set pattern = try parseIdentOrPlaceholder(p, "expected `case`, `mut`, or identifier after `let`");
    }
    try expect(p, scanner::TokenKind::Equal, "expected `=` after pattern");

    let scrutinee = try parseCond(p);
    let mut guard: ?*ast::Node = nil;

    if consume(p, scanner::TokenKind::Semicolon) {
        guard = try parseCond(p);
        set guard = try parseCond(p);
    }
    let body = try parseBlock(p);
    let mut elseBranch: ?*ast::Node = nil;

    if consume(p, scanner::TokenKind::Else) {
        elseBranch = try parseBlock(p);
        set elseBranch = try parseBlock(p);
    }
    return node(p, ast::NodeValue::WhileLet(ast::WhileLet {
        pattern: ast::PatternMatch { pattern, scrutinee, guard, kind, mutable },
        body,
        elseBranch,

    let condition = try parseCond(p);
    let body = try parseBlock(p);
    let mut elseBranch: ?*ast::Node = nil;

    if consume(p, scanner::TokenKind::Else) {
        elseBranch = try parseBlock(p);
        set elseBranch = try parseBlock(p);
    }
    return node(p, ast::NodeValue::While(ast::While {
        condition, body, elseBranch,
    }));
}


    let binding = try parseIdentOrPlaceholder(p, "expected identifier or `_`");
    let mut index: ?*ast::Node = nil;

    if consume(p, scanner::TokenKind::Comma) {
        index = try parseIdentOrPlaceholder(p, "expected index identifier or `_` after `,`");
        set index = try parseIdentOrPlaceholder(p, "expected index identifier or `_` after `,`");
    }
    try expect(p, scanner::TokenKind::In, "expected `in`");

    let iterable = try parseCond(p);
    let body = try parseBlock(p);
    let mut elseBranch: ?*ast::Node = nil;

    if consume(p, scanner::TokenKind::Else) {
        elseBranch = try parseBlock(p);
        set elseBranch = try parseBlock(p);
    }
    return node(p, ast::NodeValue::For(ast::For {
        binding, index, iterable, body, elseBranch,
    }));
}

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

    // `assert { expr }` block form or `assert <expr>`.
    let mut condition: *ast::Node = undefined;
    if consume(p, scanner::TokenKind::LBrace) {
        condition = try parseExpr(p);
        set condition = try parseExpr(p);
        try expect(p, scanner::TokenKind::RBrace, "expected closing `}` after expression");
    } else {
        condition = try parseExpr(p);
        set condition = try parseExpr(p);
    }
    let mut message: ?*ast::Node = nil;
    if consume(p, scanner::TokenKind::Comma) {
        message = try parseExpr(p);
        set message = try parseExpr(p);
    }
    return node(p, ast::NodeValue::Assert { condition, message });
}

/// Parse a `try` expression with optional `catch` clause(s).

        let mut typeNode: ?*ast::Node = nil;

        // Check for optional error binding: `catch ident { ... }` or
        // `catch ident as Type { ... }`.
        if check(p, scanner::TokenKind::Ident) {
            binding = try parseIdent(p, "expected identifier after `catch`");
            set binding = try parseIdent(p, "expected identifier after `catch`");
            if consume(p, scanner::TokenKind::As) {
                typeNode = try parseType(p);
                set typeNode = try parseType(p);
            }
        }
        if not check(p, scanner::TokenKind::LBrace) {
            throw failParsing(p, "expected `{` after `catch`");
        }


    if consume(p, scanner::TokenKind::Else) {
        // Check for `else if` construct.
        if check(p, scanner::TokenKind::If) {
            // Set the else branch to a block containing the nested if.
            elseBranch = node(p, ast::NodeValue::Block(
            set elseBranch = node(p, ast::NodeValue::Block(
                mkBlockWith(p, try parseIf(p))
            ));
        } else {
            // Regular else clause.
            elseBranch = try parseBlock(p);
            set elseBranch = try parseBlock(p);
        }
    }
    return node(p, ast::NodeValue::If(ast::If {
        condition: cond, thenBranch, elseBranch,
    }));

            if check(p, scanner::TokenKind::Case) or check(p, scanner::TokenKind::Else) {
                throw failParsing(p, "unexpected keyword after `,` in case pattern list");
            }
        }
        if consume(p, scanner::TokenKind::If) {
            guard = try parseCond(p);
            set guard = try parseCond(p);
        }
        try expect(p, scanner::TokenKind::FatArrow, "expected `=>` after case pattern");
        let body = try parseStmt(p);

        return node(p, ast::NodeValue::MatchProng(

        ));
    }
    // Else prong: `else if <guard> => <body>`.
    if consume(p, scanner::TokenKind::Else) {
        if consume(p, scanner::TokenKind::If) {
            guard = try parseCond(p);
            set guard = try parseCond(p);
        }
        try expect(p, scanner::TokenKind::FatArrow, "expected `=>` after else");
        let body = try parseStmt(p);

        return node(p, ast::NodeValue::MatchProng(

    }
    // Binding prong: `<ident> if <guard> => <body>` or `_ if <guard> => <body>`.
    let binding = try parseIdentOrPlaceholder(p, "expected `case`, `else`, or identifier");

    if consume(p, scanner::TokenKind::If) {
        guard = try parseCond(p);
        set guard = try parseCond(p);
    }
    try expect(p, scanner::TokenKind::FatArrow, "expected `=>` after binding");
    let body = try parseStmt(p);

    return node(p, ast::NodeValue::MatchProng(

/// Uses `Pattern` context to allow record literals but not conditional expressions.
fn parseMatchPattern(p: *mut Parser) -> *ast::Node
    throws (ParseError)
{
    let saved = p.context;
    p.context = Context::Pattern;
    set p.context = Context::Pattern;
    let pattern = try parseExpr(p);
    p.context = saved;
    set p.context = saved;

    return pattern;
}

/// Parse an identifier.

                    throw failParsing(p, "record fields cannot specify alignment");
                }
                if field.value <> nil and mode <> RecordFieldMode::Labeled {
                    throw failParsing(p, "record fields cannot have initializers");
                }
                recordField = ast::NodeValue::RecordField {
                set recordField = ast::NodeValue::RecordField {
                    field: field.name, type, value: field.value,
                };
            }
            case RecordFieldMode::Unlabeled => {
                let type = try parseType(p);
                recordField = ast::NodeValue::RecordField {
                set recordField = ast::NodeValue::RecordField {
                    field: nil, type, value: nil,
                };
            }
        }
        fields.append(node(p, recordField), p.allocator);

    try expect(p, scanner::TokenKind::LBrace, "expected `{` to begin record literal");

    while not check(p, scanner::TokenKind::RBrace) {
        // Check for `..` to ignore remaining fields.
        if consume(p, scanner::TokenKind::DotDot) {
            ignoreRest = true;
            set ignoreRest = true;
            break;
        }
        let field = try parseRecordLitField(p);
        fields.append(field, p.allocator);


        let mut payloadType: ?*ast::Node = nil;
        let mut explicitValue: ?*ast::Node = nil;

        if consume(p, scanner::TokenKind::LParen) { // `Variant(T, U)`.
            let fields = try parseRecordFields(p, RecordFieldMode::Unlabeled);
            payloadType = node(p, ast::NodeValue::TypeSig(
            set payloadType = node(p, ast::NodeValue::TypeSig(
                ast::TypeSig::Record { fields, labeled: false }
            ));
        } else if consume(p, scanner::TokenKind::LBrace) { // `Variant { x: T, y: T }`.
            let fields = try parseRecordFields(p, RecordFieldMode::Labeled);
            payloadType = node(p, ast::NodeValue::TypeSig(
            set payloadType = node(p, ast::NodeValue::TypeSig(
                ast::TypeSig::Record { fields, labeled: true }
            ));
        } else if consume(p, scanner::TokenKind::Equal) {
            // TODO: Support constant expressions.
            try expect(p, scanner::TokenKind::Number, "expected integer literal after `=`");
            let literal = try parseIntLiteral(p, p.previous.source);
            explicitValue = nodeNumber(p, literal);
            set explicitValue = nodeNumber(p, literal);
        }

        let variant = node(p, ast::NodeValue::UnionDeclVariant(
            ast::UnionDeclVariant {
                name: variantName, index: variants.len as u32, value: explicitValue, type: payloadType,

        parseType
    );
    let mut returnType: ?*ast::Node = nil;

    if consume(p, scanner::TokenKind::Arrow) {
        returnType = try parseType(p);
        set returnType = try parseType(p);
    }
    let throwList = try parseThrowList(p);
    let sig = ast::FnSig { params, returnType, throwList };
    return node(p, ast::NodeValue::TypeSig(
        ast::TypeSig::Fn(sig)

    }
    try expect(p, scanner::TokenKind::RParen, "expected `)` after function parameters");

    let mut returnType: ?*ast::Node = nil;
    if consume(p, scanner::TokenKind::Arrow) {
        returnType = try parseType(p);
        set returnType = try parseType(p);
    }
    let throwList = try parseThrowList(p);

    return ast::FnSig { params, returnType, throwList };
}

                    list.append(a.list[i], p.allocator);
                }
            }
            let attrNode = nodeAttribute(p, ast::Attribute::Extern);
            list.append(attrNode, p.allocator);
            fnAttrs = ast::Attributes { list };
            set fnAttrs = ast::Attributes { list };
        }
    } else {
        body = try parseBlock(p);
        set body = try parseBlock(p);
    }
    return node(p, ast::NodeValue::FnDecl(
        ast::FnDecl { name, sig, body, attrs: fnAttrs }
    ));
}

    throws (ParseError)
{
    let mut path: *ast::Node = undefined;
    if p.current.kind == scanner::TokenKind::Super {
        advance(p);
        path = nodeSuper(p);
        set path = nodeSuper(p);
    } else {
        path = try parseIdent(p, "expected type identifier");
        set path = try parseIdent(p, "expected type identifier");
    }
    while consume(p, scanner::TokenKind::ColonColon) {
        let part = try parseIdent(p, "expected identifier after `::`");
        path = node(p, ast::NodeValue::ScopeAccess(
        set path = node(p, ast::NodeValue::ScopeAccess(
            ast::Access { parent: path, child: part }
        ));
    }
    return path;
}

    let mut type: ?*ast::Node = nil;
    let mut alignment: ?*ast::Node = nil;
    let mut value: ?*ast::Node = nil;

    if consume(p, scanner::TokenKind::Colon) {
        type = try parseType(p);
        set type = try parseType(p);

        if check(p, scanner::TokenKind::Align) {
            alignment = try parseAlign(p);
            set alignment = try parseAlign(p);
        }
    }
    if consume(p, scanner::TokenKind::Equal) {
        value = try parseExpr(p);
        set value = try parseExpr(p);
    }
    return NameTypeValue { name, type, value, alignment };
}

/// Parse a constant declaration.

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

    // Allow `super` or identifier as the first part of the path.
    let mut path: *ast::Node = undefined;
    if consume(p, scanner::TokenKind::Super) {
        path = nodeSuper(p);
        set path = nodeSuper(p);
    } else {
        path = try parseIdent(p, "expected module name or `super` after `use`");
        set path = try parseIdent(p, "expected module name or `super` after `use`");
    }
    while consume(p, scanner::TokenKind::ColonColon) {
        // Check for wildcard import (e.g., `use parser::*`)
        if consume(p, scanner::TokenKind::Star) {
            return node(p, ast::NodeValue::Use(
                ast::Use { path, wildcard: true, attrs }
            ));
        }
        let part = try parseIdent(p, "expected identifier or `*` after `::`");
        path = node(p, ast::NodeValue::ScopeAccess(
        set path = node(p, ast::NodeValue::ScopeAccess(
            ast::Access { parent: path, child: part }
        ));
    }
    return node(p, ast::NodeValue::Use(
        ast::Use { path, wildcard: false, attrs }

    try expect(p, scanner::TokenKind::Equal, "expected `=` after pattern");
    let expr = try parseCond(p);

    let mut guard: ?*ast::Node = nil;
    if consume(p, scanner::TokenKind::If) {
        guard = try parseCond(p);
        set guard = try parseCond(p);
    }

    try expect(p, scanner::TokenKind::Else, "expected `else` after pattern");
    let elseBranch = try parseLetElseBranch(p);


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

}

/// Test parsing assignment expressions.
@test fn testParseAssignment() throws (testing::TestError) {
    {
        let assign = try! parseStmtStr("x = 1;");
        let assign = try! parseStmtStr("set x = 1;");
        let case ast::NodeValue::Assign(node) = assign.value
            else throw testing::TestError::Failed;
        try expectIdent(node.left, "x");
        let case ast::NodeValue::Number(_) = node.right.value
            else throw testing::TestError::Failed;
    }
    {
        let assign = try! parseStmtStr("obj.field = value;");
        let assign = try! parseStmtStr("set obj.field = value;");
        let case ast::NodeValue::Assign(node) = assign.value
            else throw testing::TestError::Failed;
        let case ast::NodeValue::FieldAccess(access) = node.left.value
            else throw testing::TestError::Failed;
        try expectIdent(access.parent, "obj");
        try expectIdent(access.child, "field");
        try expectIdent(node.right, "value");
    }
    {
        let assign = try! parseStmtStr("*ptr = rhs;");
        let assign = try! parseStmtStr("set *ptr = rhs;");
        let case ast::NodeValue::Assign(node) = assign.value
            else throw testing::TestError::Failed;
        let case ast::NodeValue::Deref(target) = node.left.value
            else throw testing::TestError::Failed;
        try expectIdent(target, "ptr");
        try expectIdent(node.right, "rhs");
    }
    {
        let assign = try! parseStmtStr("x = 1 + 2;");
        let assign = try! parseStmtStr("set x = 1 + 2;");
        let case ast::NodeValue::Assign(node) = assign.value
            else throw testing::TestError::Failed;
        let case ast::NodeValue::BinOp(bin) = node.right.value
            else throw testing::TestError::Failed;
        try testing::expect(bin.op == ast::BinaryOp::Add);

        try expectIdent(access.parent, "module");
        try expectIdent(access.child, "VAR");
    }
}

/// Test that assignment syntax requires the `set` statement.
@test fn testAssignmentRequiresSetKeyword() throws (testing::TestError) {
    let assign: ?*ast::Node = try? parseStmtStr("x = 1;");
    try testing::expect(assign == nil);

    let compoundAssign: ?*ast::Node = try? parseStmtStr("x += 1;");
    try testing::expect(compoundAssign == nil);
}

/// Test that `set` requires an assignable target.
@test fn testSetRequiresAssignableTarget() throws (testing::TestError) {
    let binTarget: ?*ast::Node = try? parseStmtStr("set x + y = 1;");
    try testing::expect(binTarget == nil);

    let condTarget: ?*ast::Node = try? parseStmtStr("set x if ok else y = 1;");
    try testing::expect(condTarget == nil);
}

/// Test parsing basic arithmetic binary operators (+, -, *, /, %).
@test fn testParseBinOpArithmetic() throws (testing::TestError) {
    let add = try! parseExprStr("a + b");
    let case ast::NodeValue::BinOp(op1) = add.value
        else throw testing::TestError::Failed;

lib/std/lang/resolver.rad +176 -176

    let mut cursor = self.types;
    while let node = cursor {
        if node.ty == ty {
            return &node.ty;
        }
        cursor = node.next;
        set cursor = node.next;
    }
    // Allocate a new type node from the arena.
    let node = try! alloc::alloc(
        &mut self.arena, @sizeOf(TypeNode), @alignOf(TypeNode)
    ) as *mut TypeNode;

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

    return &node.ty;
}

/// Allocate a nominal type descriptor and return a pointer to it.

    // placeholder entries when binding symbols.
    let entry = try! alloc::alloc(
        &mut self.arena, @sizeOf(NominalType), @alignOf(NominalType)
    ) as *mut NominalType;

    *entry = info;
    set *entry = info;

    return entry;
}

/// Allocate a function type descriptor and return a pointer to it.
fn allocFnType(self: *mut Resolver, info: FnType) -> *FnType {
    let entry = try! alloc::alloc(
        &mut self.arena, @sizeOf(FnType), @alignOf(FnType)
    ) as *mut FnType;

    *entry = info;
    set *entry = info;

    return entry;
}

/// Returns an error, if any, associated with the given node.

        &mut arena, @sizeOf(*mut Symbol), @alignOf(*mut Symbol), MAX_MODULE_SYMBOLS
    ) as *mut [*mut Symbol];

    // Initialize the root scope.
    // TODO: Set this up when declaring `PKG_SCOPE`, not here.
    *storage.pkgScope = Scope {
    set *storage.pkgScope = Scope {
        owner: nil,
        parent: nil,
        moduleId: nil,
        symbols,
        symbolsLen: 0,
    };

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

    }

    let mut moduleScopes: [?*mut Scope; module::MAX_MODULES] = undefined;
    // TODO: Simplify.
    for i in 0..moduleScopes.len {
        moduleScopes[i] = nil;
        set moduleScopes[i] = nil;
    }
    return Resolver {
        scope: storage.pkgScope,
        pkgScope: storage.pkgScope,
        loopStack: undefined,

    // Don't record more than one error per node.
    if let n = node; errorForNode(self, n) <> nil {
        return ResolveError::Failure;
    }
    let idx = self.errors.len;
    self.errors = @sliceOf(self.errors.ptr, idx + 1, self.errors.cap);
    self.errors[idx] = Error { kind, node, moduleId: self.currentMod };
    set self.errors = @sliceOf(self.errors.ptr, idx + 1, self.errors.cap);
    set self.errors[idx] = Error { kind, node, moduleId: self.currentMod };

    return ResolveError::Failure;
}

/// Like [`emitError`], but for type mismatches specifically.

    // Allocate symbols from the arena.
    let symbols = try! alloc::allocSlice(
        &mut self.arena, @sizeOf(*mut Symbol), @alignOf(*mut Symbol), capacity
    ) as *mut [*mut Symbol];

    *entry = Scope { owner, parent: nil, moduleId: nil, symbols, symbolsLen: 0 };
    self.nodeData.entries[owner.id].scope = entry;
    set *entry = Scope { owner, parent: nil, moduleId: nil, symbols, symbolsLen: 0 };
    set self.nodeData.entries[owner.id].scope = entry;

    return entry;
}

/// Enter a new local scope that is the child of the current scope.
/// This creates a parent/child relationship that means that lookups in the
/// child scope can recurse upwards.
export fn enterScope(self: *mut Resolver, owner: *ast::Node) -> *Scope {
    let scope = allocScope(self, owner, MAX_LOCAL_SYMBOLS);
    scope.parent = self.scope;
    self.scope = scope;
    set scope.parent = self.scope;
    set self.scope = scope;
    return scope;
}

/// Enter a module scope. Returns an object that can be used to exit the scope.
export fn enterModuleScope(self: *mut Resolver, owner: *ast::Node, module: *module::ModuleEntry) -> ModuleScope {
    let prevScope = self.scope;
    let prevMod = self.currentMod;
    let scope = allocScope(self, owner, MAX_MODULE_SYMBOLS);

    self.scope = scope;
    self.scope.moduleId = module.id;
    self.currentMod = module.id;
    set self.scope = scope;
    set self.scope.moduleId = module.id;
    set self.currentMod = module.id;
    // TODO: Allow any unsigned integer to index an array.
    self.moduleScopes[module.id as u32] = scope;
    set self.moduleScopes[module.id as u32] = scope;

    return ModuleScope { root: owner, entry: module, newScope: scope, prevScope, prevMod };
}

/// Enter a sub-module. Changes the current scope into that of the sub-module.

    return enterModuleScope(self, modRoot, modEntry);
}

/// Exit a module scope, given the object returned by `enterModuleScope`.
export fn exitModuleScope(self: *mut Resolver, entry: ModuleScope) {
    self.scope = entry.prevScope;
    self.currentMod = entry.prevMod;
    set self.scope = entry.prevScope;
    set self.currentMod = entry.prevMod;
}

/// Exit the most recent scope.
export fn exitScope(self: *mut Resolver) {
    let parent = self.scope.parent else {
        // TODO: This should be a panic, but one of the tests hits this
        // clause, which might be a bug in the generator.
        return;
    };
    self.scope = parent;
    set self.scope = parent;
}

/// Visit the body of a loop while tracking nesting depth.
fn visitLoop(self: *mut Resolver, body: *ast::Node) -> Type
    throws (ResolveError)
{
    assert self.loopDepth < MAX_LOOP_DEPTH, "visitLoop: loop nesting depth exceeded";
    self.loopStack[self.loopDepth] = LoopCtx { hasBreak: false };
    self.loopDepth += 1;
    set self.loopStack[self.loopDepth] = LoopCtx { hasBreak: false };
    set self.loopDepth += 1;

    let ty = try infer(self, body) catch {
        assert self.loopDepth <> 0, "visitLoop: loop depth underflow";
        self.loopDepth -= 1;
        set self.loopDepth -= 1;
        throw ResolveError::Failure;
    };
    // Pop and check if break was encountered.
    self.loopDepth -= 1;
    set self.loopDepth -= 1;

    if self.loopStack[self.loopDepth].hasBreak {
        return Type::Void;
    }
    return Type::Never;

}

/// Set the expected return type for a new function body.
fn enterFn(self: *mut Resolver, node: *ast::Node, ty: *FnType) {
    assert self.currentFn == nil, "enterFn: already in a function";
    self.currentFn = ty;
    set self.currentFn = ty;
    enterScope(self, node);
}

/// Clear the expected return type when leaving a function body.
fn exitFn(self: *mut Resolver) {
    if self.currentFn == nil {
        // TODO: This should be a panic, but one of the tests hits this
        // clause, which might be a bug in the generator.
        return;
    }
    self.currentFn = nil;
    set self.currentFn = nil;
    exitScope(self);
}

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

/// Associate a resolved symbol with an AST node.
fn setNodeSymbol(self: *mut Resolver, node: *ast::Node, symbol: *mut Symbol) {
    if let existingSym = self.nodeData.entries[node.id].sym {
        panic "setNodeSymbol: a symbol is already associated with this node";
    }
    self.nodeData.entries[node.id].sym = symbol;
    set self.nodeData.entries[node.id].sym = symbol;
}

/// Associate a resolved type with an AST node and return it.
fn setNodeType(self: *mut Resolver, node: *ast::Node, ty: Type) -> Type {
    if ty == Type::Unknown {
        // In this case, we simply don't associate a type.
        return ty;
    }
    self.nodeData.entries[node.id].ty = ty;
    set self.nodeData.entries[node.id].ty = ty;

    return ty;
}

/// Unify the types of two branches for control flow. Returns `never` only if

/// Associate a coercion plan with an AST node.
fn setNodeCoercion(self: *mut Resolver, node: *ast::Node, coercion: Coercion) -> Coercion {
    if coercion == Coercion::Identity {
        return coercion;
    }
    self.nodeData.entries[node.id].coercion = coercion;
    set self.nodeData.entries[node.id].coercion = coercion;

    return coercion;
}

/// Associate a constant value with an AST node.
fn setNodeConstValue(self: *mut Resolver, node: *ast::Node, value: ConstValue) {
    self.nodeData.entries[node.id].constValue = value;
    set self.nodeData.entries[node.id].constValue = value;
}

/// Associate a record field index with a record literal field node.
fn setRecordFieldIndex(self: *mut Resolver, node: *ast::Node, index: u32) {
    self.nodeData.entries[node.id].extra = NodeExtra::RecordField { index };
    set self.nodeData.entries[node.id].extra = NodeExtra::RecordField { index };
}

/// Associate slice range metadata with a subscript expression.
fn setSliceRangeInfo(self: *mut Resolver, node: *ast::Node, info: SliceRangeInfo) {
    self.nodeData.entries[node.id].extra = NodeExtra::SliceRange(info);
    set self.nodeData.entries[node.id].extra = NodeExtra::SliceRange(info);
}

/// Associate union variant metadata with a pattern or constructor node.
fn setVariantInfo(self: *mut Resolver, node: *ast::Node, ordinal: u32, tag: u32) {
    self.nodeData.entries[node.id].extra = NodeExtra::UnionVariant { ordinal, tag };
    set self.nodeData.entries[node.id].extra = NodeExtra::UnionVariant { ordinal, tag };
}

/// Associate trait method call metadata with a call node.
fn setTraitMethodCall(self: *mut Resolver, node: *ast::Node, traitInfo: *TraitType, methodIndex: u32) {
    self.nodeData.entries[node.id].extra = NodeExtra::TraitMethodCall { traitInfo, methodIndex };
    set self.nodeData.entries[node.id].extra = NodeExtra::TraitMethodCall { traitInfo, methodIndex };
}

/// Associate for-loop metadata with a for-loop node.
fn setForLoopInfo(self: *mut Resolver, node: *ast::Node, info: ForLoopInfo) {
    self.nodeData.entries[node.id].extra = NodeExtra::ForLoop(info);
    set self.nodeData.entries[node.id].extra = NodeExtra::ForLoop(info);
}

/// Retrieve the constant value associated with a node, if any.
export fn constValueEntry(self: *Resolver, node: *ast::Node) -> ?ConstValue {
    return self.nodeData.entries[node.id].constValue;

    return nil;
}

/// Associate match prong metadata with a match prong node.
fn setProngCatchAll(self: *mut Resolver, node: *ast::Node, catchAll: bool) {
    self.nodeData.entries[node.id].extra = NodeExtra::MatchProng { catchAll };
    set self.nodeData.entries[node.id].extra = NodeExtra::MatchProng { catchAll };
}

/// Check if a prong is catch-all.
export fn isProngCatchAll(self: *Resolver, node: *ast::Node) -> bool {
    if let case NodeExtra::MatchProng { catchAll } = self.nodeData.entries[node.id].extra {

    return false;
}

/// Set match metadata.
fn setMatchConst(self: *mut Resolver, node: *ast::Node, isConst: bool) {
    self.nodeData.entries[node.id].extra = NodeExtra::Match { isConst };
    set self.nodeData.entries[node.id].extra = NodeExtra::Match { isConst };
}

/// Check if a match has all constant patterns.
export fn isMatchConst(self: *Resolver, node: *ast::Node) -> bool {
    if let case NodeExtra::Match { isConst } = self.nodeData.entries[node.id].extra {

}

/// Allocate a new symbol, and return a reference to it.
fn allocSymbol(self: *mut Resolver, data: SymbolData, name: *[u8], node: *ast::Node, attrs: u32) -> *mut Symbol {
    let sym = try! alloc::alloc(&mut self.arena, @sizeOf(Symbol), @alignOf(Symbol)) as *mut Symbol;
    *sym = Symbol { name, data, attrs, node, moduleId: nil };
    set *sym = Symbol { name, data, attrs, node, moduleId: nil };

    return sym;
}

/// Check that a type is boolean, otherwise throw an error.

    let mut layout = getTypeLayout(ty);
    // Check for symbol-specific alignment override.
    if let sym = symbolFor(self, node) {
        if let case SymbolData::Value { alignment, .. } = sym.data {
            if alignment > 0 {
                layout.alignment = alignment;
                set layout.alignment = alignment;
            }
        }
    }
    return layout;
}

    let mut maxSize = payloadLayout.size;
    let mut maxAlign = payloadLayout.alignment;

    for errType in throwList {
        let errLayout = getTypeLayout(*errType);
        maxSize = max(maxSize, errLayout.size);
        maxAlign = max(maxAlign, errLayout.alignment);
        set maxSize = max(maxSize, errLayout.size);
        set maxAlign = max(maxAlign, errLayout.alignment);
    }
    return Layout {
        size: PTR_SIZE + maxSize,
        alignment: max(PTR_SIZE, maxAlign),
    };

    let mut maxVarAlign: u32 = 1;
    let mut isAllVoid: bool = true;

    for variant in variants {
        if variant.valueType <> Type::Void {
            isAllVoid = false;
            set isAllVoid = false;
            let payloadLayout = getTypeLayout(variant.valueType);
            maxVarSize = max(maxVarSize, payloadLayout.size);
            maxVarAlign = max(maxVarAlign, payloadLayout.alignment);
            set maxVarSize = max(maxVarSize, payloadLayout.size);
            set maxVarAlign = max(maxVarAlign, payloadLayout.alignment);
        }
    }
    let unionAlignment: u32 = max(1, maxVarAlign);
    let unionValOffset: u32 = mem::alignUp(tagSize, maxVarAlign);
    let unionLayout = Layout {

fn variantTag(variantDecl: ast::UnionDeclVariant, iota: *mut u32) -> u32 {
    let mut tag: u32 = *iota;
    if let valueNode = variantDecl.value {
        let case ast::NodeValue::Number(lit) = valueNode.value
            else panic "variantTag: expected number literal";
        tag = lit.magnitude as u32;
        set tag = lit.magnitude as u32;
    }
    *iota = tag + 1;
    set *iota = tag + 1;
    return tag;
}

/// Check if a type is a union without payloads.
export fn isVoidUnion(ty: Type) -> bool {


        if let sym = symbolFor(self, declNode) {
            if let mid = sym.moduleId {
                if (mid as u32) < self.moduleScopes.len {
                    if let ms = self.moduleScopes[mid as u32] {
                        self.scope = ms;
                        self.currentMod = mid;
                        set self.scope = ms;
                        set self.currentMod = mid;
                    }
                }
            }
        }


            case ast::NodeValue::UnionDecl(decl) => {
                try resolveUnionBody(self, declNode, decl);
            }
            else => {},
        }
        self.scope = prevScope;
        self.currentMod = prevMod;
        set self.scope = prevScope;
        set self.currentMod = prevMod;
    }
}

/// Check if all elements in a node list are assignable to the target type.
fn isListAssignable(self: *mut Resolver, targetType: Type, items: *mut [*ast::Node]) -> bool {

    if scope.symbolsLen >= scope.symbols.len {
        throw emitError(self, site, ErrorKind::SymbolOverflow);
    }
    // Propagate module ID to the symbol for fast lookup.
    if let modId = scope.moduleId {
        sym.moduleId = modId;
        set sym.moduleId = modId;
    }
    scope.symbols[scope.symbolsLen] = sym;
    scope.symbolsLen += 1;
    set scope.symbols[scope.symbolsLen] = sym;
    set scope.symbolsLen += 1;
}

/// Bind a value identifier in the current scope.
/// Returns `nil` if the identifier is a placeholder (`_`).
fn bindValueIdent(

    setNodeType(self, owner, type);
    setNodeType(self, ident, type);

    // Track number of local bindings for lowering stage.
    if let mut fnType = self.currentFn {
        fnType.localCount += 1;
        set fnType.localCount += 1;
    }
    return sym;
}

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

    loop {
        if let sym = findInScope(curr, name, predicate) {
            return sym;
        }
        if let parent = curr.parent {
            curr = parent;
            set curr = parent;
        } else {
            break;
        }
    }
    return nil;

    let mut out: *[*[u8]] = &[];

    match node.value {
        case ast::NodeValue::Ident(name) if name.len > 0 => {
            assert buf.len >= 1, "flattenPath: invalid output buffer size";
            buf[0] = name;
            out = &buf[..1];
            set buf[0] = name;
            set out = &buf[..1];
        }
        case ast::NodeValue::ScopeAccess(access) => {
            // Recursively flatten parent path.
            let parent = try flattenPath(self, access.parent, buf);
            assert parent.len < buf.len, "flattenPath: invalid output buffer size";
            let child = try nodeName(self, access.child);
            buf[parent.len] = child;
            out = &buf[..parent.len + 1];
            set buf[parent.len] = child;
            set out = &buf[..parent.len + 1];
        }
        case ast::NodeValue::Super => {
            // `super` is handled by scope adjustment in `checkSuperAccess`.
            // Return empty prefix so the path continues from the next segment.
            out = &buf[..0];
            set out = &buf[..0];
            return out;
        }
        else => {
            // Fallthrough to error.
        }

    loop {
        if let id = s.moduleId {
            return id;
        }
        if let parent = s.parent {
            s = parent;
            set s = parent;
        } else {
            return nil;
        }
    }
}

) -> *mut Symbol throws (ResolveError) {
    // Handle `super` access by adjusting scope and node.
    let mut startScope = scope;
    let mut pathNode = node;
    if let superAccess = try checkSuperAccess(self, node) {
        startScope = superAccess.scope;
        pathNode = superAccess.child;
        set startScope = superAccess.scope;
        set pathNode = superAccess.child;
    }
    // TODO: It doesn't make sense that `flattenPath` handles identifiers and scope access,
    // while this function requires a scope access.
    let mut buffer: [*[u8]; 32] = undefined;
    let path = try flattenPath(self, pathNode, &mut buffer[..]);

    let mut startScope = self.scope;
    let mut pathNode = module;

    // Handle `super` access.
    if let superAccess = try checkSuperAccess(self, module) {
        startScope = superAccess.scope;
        pathNode = superAccess.child;
        set startScope = superAccess.scope;
        set pathNode = superAccess.child;
    }
    let mut pathBuf: [*[u8]; 16] = undefined;
    let path = try flattenPath(self, pathNode, &mut pathBuf[..]);
    if path.len == 0 {
        throw emitError(self, module, ErrorKind::UnresolvedSymbol(""));

            return setNodeType(self, node, loopType);
        },
        case ast::NodeValue::Break => {
            try ensureInsideLoop(self, node);
            // Mark that the current loop has a reachable break.
            self.loopStack[self.loopDepth - 1].hasBreak = true;
            set self.loopStack[self.loopDepth - 1].hasBreak = true;

            return setNodeType(self, node, Type::Never);
        },
        case ast::NodeValue::Continue => {
            try ensureInsideLoop(self, node);

    throws (ResolveError)
{
    let mut diverges = false;
    for item in list {
        if try infer(self, item) == Type::Never {
            diverges = true;
            set diverges = true;
        }
    }
    if diverges {
        return Type::Never;
    }

    let mut mask: u32 = 0;

    for node in attrNodes {
        let case ast::NodeValue::Attribute(attr) = node.value
            else panic "resolveAttributes: invalid attribute node";
        mask |= (attr as u32);
        set mask |= (attr as u32);
    }
    return mask;
}

/// Ensure the `default` attribute is only applied to functions.

    let mut bindingTy = Type::Unknown;

    // Check type.
    if let declTy = try visitOptional(self, decl.type, Type::Unknown) {
        let _coercion = try checkAssignable(self, decl.value, declTy);
        bindingTy = declTy;
        set bindingTy = declTy;
    } else {
        bindingTy = try infer(self, decl.value);
        set bindingTy = try infer(self, decl.value);

        if not isTypeInferrable(bindingTy) {
            throw emitError(self, decl.value, ErrorKind::CannotInferType);
        }
    }

    }
    // Check alignment.
    if let a = decl.alignment {
        let case ast::NodeValue::Align { value } = a.value
            else panic "resolveLet: expected Align node";
        alignment = try checkSizeInt(self, value);
        set alignment = try checkSizeInt(self, value);
    }
    assert bindingTy <> Type::Unknown;

    // Alignment must be zero or a power of two.
    if alignment <> 0 and (alignment & (alignment - 1)) <> 0 {

    throws (ResolveError)
{
    let attrMask = resolveAttributes(self, decl.attrs);
    let mut retTy = Type::Void;
    if let retNode = decl.sig.returnType {
        retTy = try infer(self, retNode);
        set retTy = try infer(self, retNode);
    }
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut paramTypes: *mut [*Type] = &mut [];
    let mut throwList: *mut [*Type] = &mut [];
    let mut fnType = FnType {

            throw e;
        };
        throwList.append(allocType(self, throwTy), a);
    }
    exitFn(self);
    fnType.paramTypes = &paramTypes[..];
    fnType.throwList = &throwList[..];
    set fnType.paramTypes = &paramTypes[..];
    set fnType.throwList = &throwList[..];

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

        // Get field name for labeled records.
        let mut fieldName: ?*[u8] = nil;
        if labeled {
            let n = fieldNode
                else panic "resolveRecordFields: labeled record field missing name";
            fieldName = try nodeName(self, n);
            set fieldName = try nodeName(self, n);
        }
        let fieldType = typeFor(self, typeNode)
            else throw emitError(self, typeNode, ErrorKind::CannotInferType);

        // Ensure field type is fully resolved before computing layout.
        try ensureTypeResolved(self, fieldType, typeNode);

        // Compute field offset by aligning to field's alignment.
        let fieldLayout = getTypeLayout(fieldType);
        currentOffset = mem::alignUp(currentOffset, fieldLayout.alignment);
        set currentOffset = mem::alignUp(currentOffset, fieldLayout.alignment);

        result.append(RecordField { name: fieldName, fieldType, offset: currentOffset as i32 }, a);

        // Advance offset past this field.
        currentOffset += fieldLayout.size;
        set currentOffset += fieldLayout.size;

        // Track max alignment for record layout.
        maxAlignment = max(maxAlignment, fieldLayout.alignment);
        set maxAlignment = max(maxAlignment, fieldLayout.alignment);
    }
    // Compute cached layout.
    let recordLayout = Layout {
        size: mem::alignUp(currentOffset, maxAlignment),
        alignment: maxAlignment

        return;
    }
    try visitList(self, decl.derives);
    let recordType = try resolveRecordFields(self, node, decl.fields, decl.labeled);

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

/// Bind a type name.
fn bindTypeName(self: *mut Resolver, node: *ast::Node, name: *ast::Node, attrs: ?ast::Attributes) -> *mut Symbol
    throws (ResolveError)


/// Allocate a trait type descriptor and return a pointer to it.
fn allocTraitType(self: *mut Resolver, name: *[u8]) -> *mut TraitType {
    let p = try! alloc::alloc(&mut self.arena, @sizeOf(TraitType), @alignOf(TraitType));
    let entry = p as *mut TraitType;
    *entry = TraitType { name, methods: &mut [], supertraits: &mut [] };
    set *entry = TraitType { name, methods: &mut [], supertraits: &mut [] };

    return entry;
}

/// Bind a trait name in the current scope.

        for paramNode in sig.params {
            let paramTy = try infer(self, paramNode);
            paramTypes.append(allocType(self, paramTy), a);
        }
        if let ret = sig.returnType {
            retType = allocType(self, try infer(self, ret));
            set retType = allocType(self, try infer(self, ret));
        }
        // Resolve throws list.
        if sig.throwList.len > MAX_FN_THROWS {
            throw emitError(self, methodNode, ErrorKind::FnThrowOverflow(CountMismatch {
                expected: MAX_FN_THROWS,

                });
            }
        }
        let mut instanceRetTy = Type::Void;
        if let retNode = sig.returnType {
            instanceRetTy = try resolveValueType(self, retNode);
            set instanceRetTy = try resolveValueType(self, retNode);
        }
        if not typesEqual(instanceRetTy, *tm.fnType.returnType) {
            throw emitTypeMismatch(self, methodNode, TypeMismatch {
                expected: *tm.fnType.returnType,
                actual: instanceRetTy,

        setNodeSymbol(self, methodNode, sym);
        setNodeType(self, methodNode, fnTy);
        setNodeType(self, name, fnTy);

        // Store in instance entry at the matching v-table slot.
        entry.methods[tm.index] = sym;
        covered[tm.index] = true;
        set entry.methods[tm.index] = sym;
        set covered[tm.index] = true;
    }

    // Fill inherited method slots from supertrait instances.
    for superTrait in traitInfo.supertraits {
        let superInst = findInstance(self, superTrait, concreteType)
            else throw emitError(self, node, ErrorKind::MissingSupertraitInstance(superTrait.name));
        for superMethod, mi in superTrait.methods {
            let merged = findTraitMethod(traitInfo, superMethod.name)
                else panic "resolveInstanceDecl: inherited method not found";
            if not covered[merged.index] {
                entry.methods[merged.index] = superInst.methods[mi];
                covered[merged.index] = true;
                set entry.methods[merged.index] = superInst.methods[mi];
                set covered[merged.index] = true;
            }
        }
    }

    // Check that all trait methods are implemented.
    for method, i in traitInfo.methods {
        if not covered[i] {
            throw emitError(self, node, ErrorKind::MissingTraitMethod(method.name));
        }
    }
    self.instances[self.instancesLen] = entry;
    self.instancesLen += 1;
    set self.instances[self.instancesLen] = entry;
    set self.instancesLen += 1;

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

/// Resolve instance method bodies.

    }

    // Resolve return type.
    let mut returnType = Type::Void;
    if let retNode = sig.returnType {
        returnType = try resolveValueType(self, retNode);
        set returnType = try resolveValueType(self, retNode);
    }

    // Resolve throw list.
    let mut throwTypes: *mut [*Type] = &mut [];
    for throwNode in sig.throwList {

    // Compute attribute mask.
    let mut attrMask: u32 = 0;
    if let a = attrs {
        for attrNode in a.list {
            if let case ast::NodeValue::Attribute(attr) = attrNode.value {
                attrMask = attrMask | (attr as u32);
                set attrMask = attrMask | (attr as u32);
            }
        }
    }

    // Create a symbol for the method without binding it into the module scope.


    // Register in the method table.
    if self.methodsLen >= MAX_METHODS {
        throw emitError(self, node, ErrorKind::Internal);
    }
    self.methods[self.methodsLen] = MethodEntry {
    set self.methods[self.methodsLen] = MethodEntry {
        concreteType,
        concreteTypeName: typeName,
        name: methodName,
        fnType: allocFnType(self, checkFnType),
        mutable: receiverMut,
        symbol: sym,
    };
    self.methodsLen += 1;
    set self.methodsLen += 1;
}

/// Look up an instance entry by trait and concrete type.
fn findInstance(self: *Resolver, traitInfo: *TraitType, concreteType: Type) -> ?*InstanceEntry {
    for i in 0..self.instancesLen {

    let mut variants: *mut [UnionVariant] = &mut [];

    // Create a temporary nominal type to replace the placeholder.This prevents infinite recursion
    // when a variant references this union type (e.g. record payloads with `*[Self]`).
    // TODO: It would be best to have a resolving state eg. `Visiting` for this situation.
    *nominalTy = NominalType::Union(UnionType {
    set *nominalTy = NominalType::Union(UnionType {
        variants: &[],
        layout: Layout { size: 0, alignment: 0 },
        valOffset: 0,
        isAllVoid: true
    });

            else panic "resolveUnionBody: invalid union variant";
        let variantName = try nodeName(self, variantDecl.name);
        // Resolve the variant's payload type if present.
        let mut variantType = Type::Void;
        if let ty = try visitOptional(self, variantDecl.type, Type::Unknown) {
            variantType = ty;
            set variantType = ty;
        }
        // Process the variant's explicit discriminant value if present.
        try visitOptional(self, variantDecl.value, variantType);
        let tag = variantTag(variantDecl, &mut iota);
        // Create a symbol for this variant.

        }, a);
    }
    let info = computeUnionLayout(&variants[..]);

    // Update the nominal type with the resolved variants.
    *nominalTy = NominalType::Union(UnionType {
    set *nominalTy = NominalType::Union(UnionType {
        variants: &variants[..],
        layout: info.layout,
        valOffset: info.valOffset,
        isAllVoid: info.isAllVoid,
    });

    let iterableTy = try infer(self, forStmt.iterable);

    // Extract binding names for the lowerer.
    let mut bindingName: ?*[u8] = nil;
    if let case ast::NodeValue::Ident(name) = forStmt.binding.value {
        bindingName = name;
        set bindingName = name;
    }
    let mut indexName: ?*[u8] = nil;
    if let idx = forStmt.index {
        if let case ast::NodeValue::Ident(name) = idx.value {
            indexName = name;
            set indexName = name;
        }
    }
    // Extract item type and store pre-computed loop metadata for the lowerer.
    let mut itemTy: Type = undefined;
    match iterableTy {

                throw emitError(self, forStmt.iterable, ErrorKind::ExpectedIterable);
            };
            let case ast::NodeValue::Range(range) = forStmt.iterable.value else {
                throw emitError(self, forStmt.iterable, ErrorKind::ExpectedIterable);
            };
            itemTy = *valType;
            set itemTy = *valType;

            setForLoopInfo(self, node, ForLoopInfo::Range {
                valType, range, bindingName, indexName
            });
        }
        case Type::Array(arrayInfo) => {
            itemTy = *arrayInfo.item;
            set itemTy = *arrayInfo.item;
            setForLoopInfo(self, node, ForLoopInfo::Collection {
                elemType: arrayInfo.item,
                length: arrayInfo.length,
                bindingName,
                indexName,
            });
        }
        case Type::Slice { item, .. } => {
            itemTy = *item;
            set itemTy = *item;
            setForLoopInfo(self, node, ForLoopInfo::Collection {
                elemType: item, length: nil, bindingName, indexName
            });
        }
        else => throw emitError(self, forStmt.iterable, ErrorKind::ExpectedIterable),

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

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

) -> Type throws (ResolveError) {
    // Whether this prong is catch-all.
    let mut isCatchAll = false;

    if prong.guard <> nil {
        state.isConst = false;
        set state.isConst = false;
    } else {
        match prong.arm {
            case ast::ProngArm::Binding(_),
                 ast::ProngArm::Else => isCatchAll = true,
            case ast::ProngArm::Case(patterns) => isCatchAll = hasWildcardPattern(patterns),
                 ast::ProngArm::Else => set isCatchAll = true,
            case ast::ProngArm::Case(patterns) => set isCatchAll = hasWildcardPattern(patterns),
        }
    }
    if isCatchAll {
        if state.catchAll {
            throw emitError(self, prongNode, ErrorKind::DuplicateCatchAll);
        }
        state.catchAll = true;
        set state.catchAll = true;
    }
    setProngCatchAll(self, prongNode, isCatchAll);

    return try visitMatchProng(self, prongNode, prong, subjectTy, matchType, matchBy);
}

        // Only `else` without a guard is a true catch-all.
        if prong.arm == ast::ProngArm::Else and prong.guard == nil {
            if catchAll {
                throw emitError(self, prongNode, ErrorKind::DuplicateCatchAll);
            }
            catchAll = true;
            set catchAll = true;
        }

        let mut isCatchAll = false;
        if prong.guard == nil {
            match prong.arm {
                case ast::ProngArm::Else => isCatchAll = true,
                case ast::ProngArm::Case(patterns) => isCatchAll = hasWildcardPattern(patterns),
                case ast::ProngArm::Else => set isCatchAll = true,
                case ast::ProngArm::Case(patterns) => set isCatchAll = hasWildcardPattern(patterns),
                case ast::ProngArm::Binding(_) => {
                    // For optionals, a binding does *not* always match.
                }
            }
        }
        setProngCatchAll(self, prongNode, isCatchAll);
        matchType = try visitMatchProng(self, prongNode, prong, subjectTy, matchType, MatchBy::Value);
        set matchType = try visitMatchProng(self, prongNode, prong, subjectTy, matchType, MatchBy::Value);

        // Track coverage. Guarded prongs don't count as covering a case.
        if prong.guard == nil {
            if let case ast::ProngArm::Binding(_) = prong.arm {
                if hasValue {
                    throw emitError(self, prongNode, ErrorKind::DuplicateMatchPattern);
                }
                hasValue = true;
                set hasValue = true;
            } else if let case ast::ProngArm::Case(patterns) = prong.arm {
                for pat in patterns {
                    if let case ast::NodeValue::Nil = pat.value {
                        if hasNil {
                            throw emitError(self, pat, ErrorKind::DuplicateMatchPattern);
                        }
                        hasNil = true;
                        set hasNil = true;
                    }
                }
            }
        }
    }


    for prongNode in prongs {
        let case ast::NodeValue::MatchProng(prong) = prongNode.value
            else panic "resolveMatchUnion: expected match prong";

        matchType = try resolveMatchProng(self, prongNode, prong, subjectTy, &mut state, matchType, matchBy);
        set matchType = try resolveMatchProng(self, prongNode, prong, subjectTy, &mut state, matchType, matchBy);

        // Guarded prongs don't count as covering. Patterns with nested
        // refining sub-patterns (e.g. matching different inner union variants)
        // don't count as duplicates or as fully covering.
        if prong.guard == nil {

                    if let case NodeExtra::UnionVariant { ordinal: ix, .. } = self.nodeData.entries[pattern.id].extra {
                        if not hasNestedRefiningPattern(self, pattern) {
                            if covered[ix] {
                                throw emitError(self, pattern, ErrorKind::DuplicateMatchPattern);
                            }
                            covered[ix] = true;
                            coveredCount += 1;
                            set covered[ix] = true;
                            set coveredCount += 1;
                        }
                    }
                }
            }
        }


    for prongNode in prongs {
        let case ast::NodeValue::MatchProng(prong) = prongNode.value
            else panic "resolveMatchGeneric: expected match prong";

        matchType = try resolveMatchProng(
        set matchType = try resolveMatchProng(
            self, prongNode, prong, subjectTy, &mut state, matchType, MatchBy::Value
        );
        // Track boolean coverage. Guarded prongs don't count as covering.
        if let case ast::ProngArm::Case(patterns) = prong.arm {
            for p in patterns {

                    if let case ast::NodeValue::Bool(val) = p.value {
                        if (val and hasTrue) or (not val and hasFalse) {
                            throw emitError(self, p, ErrorKind::DuplicateMatchPattern);
                        }
                        if val {
                            hasTrue = true;
                            set hasTrue = true;
                        } else {
                            hasFalse = true;
                            set hasFalse = true;
                        }
                    }
                }
                // Scalar constant patterns allow the match to be lowered
                // to a switch instruction.
                if let c = constValueEntry(self, p) {
                    match c {
                        case ConstValue::Bool(_), ConstValue::Char(_), ConstValue::Int(_) =>
                            hasConstCase = true,
                            set hasConstCase = true,
                        else =>
                            state.isConst = false,
                            set state.isConst = false,
                    }
                }
            }
        }
    }

    match prong.arm {
        case ast::ProngArm::Binding(pat) => {
            // For optionals, bind the unwrapped inner type.
            let mut bindTy = subjectTy;
            if let case Type::Optional(inner) = subjectTy {
                bindTy = *inner;
                set bindTy = *inner;
            }
            try bindPatternVar(self, pat, bindTy, matchBy);
        }
        case ast::ProngArm::Case(patterns) => {
            for pattern in patterns {

    throws (ResolveError)
{
    let mut bindTy = ty;
    match matchBy {
        case MatchBy::Value => {}
        case MatchBy::Ref => bindTy = Type::Pointer { target: allocType(self, ty), mutable: false },
        case MatchBy::MutRef => bindTy = Type::Pointer { target: allocType(self, ty), mutable: true },
        case MatchBy::Ref => set bindTy = Type::Pointer { target: allocType(self, ty), mutable: false },
        case MatchBy::MutRef => set bindTy = Type::Pointer { target: allocType(self, ty), mutable: true },
    }
    match binding.value {
        case ast::NodeValue::Placeholder => {
            // Nothing to do.
        }


    // Evaluate the built-in.
    let mut value: u32 = undefined;
    match kind {
        case ast::Builtin::SizeOf => {
            value = layout.size;
            set value = layout.size;
        },
        case ast::Builtin::AlignOf => {
            value = layout.alignment;
            set value = layout.alignment;
        },
        case ast::Builtin::SliceOf => {
            panic "unreachable: @sliceOf handled above";
        }
    }


    // Check if we have a trait method call, ie. callee is a trait object.
    if let case ast::NodeValue::FieldAccess(access) = call.callee.value {
        let mut parentTy = Type::Unknown;
        if let t = typeFor(self, access.parent) {
            parentTy = t;
            set parentTy = t;
        }
        let subjectTy = autoDeref(parentTy);

        if let case Type::TraitObject { traitInfo, mutable: objMutable } = subjectTy {
            let methodName = try nodeName(self, access.child);

                // If the parent is already a mutable pointer, the receiver is fine.
                // Otherwise, check that the parent can yield a mutable borrow.
                if method.mutable {
                    let mut isMutPtr = false;
                    if let case Type::Pointer { mutable, .. } = parentTy {
                        isMutPtr = mutable;
                        set isMutPtr = mutable;
                    }
                    if not isMutPtr and not (try canBorrowMutFrom(self, access.parent)) {
                        throw emitError(self, access.parent, ErrorKind::ImmutableBinding);
                    }
                }
                // Check arguments (excluding receiver).
                try checkCallArgs(self, node, call, method.fnType, ctx);
                self.nodeData.entries[node.id].extra = NodeExtra::MethodCall { method };
                set self.nodeData.entries[node.id].extra = NodeExtra::MethodCall { method };

                return setNodeType(self, node, *method.fnType.returnType);
            }
        }
    }

    // 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);
    self.nodeData.entries[node.id].extra = NodeExtra::SliceAppend { elemType };
    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);
}


            expected: 1,
            actual: args.len as u32,
        }));
    }
    try checkAssignable(self, args[0], Type::U32);
    self.nodeData.entries[node.id].extra = NodeExtra::SliceDelete { elemType };
    set self.nodeData.entries[node.id].extra = NodeExtra::SliceDelete { elemType };

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

/// Analyze an assignment expression.

            let mut capacity: ?u32 = nil;

            match subjectTy {
                case Type::Array(a) => {
                    try validateArraySliceBounds(self, range, a.length, node);
                    item = a.item;
                    capacity = a.length;
                    set item = a.item;
                    set capacity = a.length;
                }
                case Type::Slice { item: i, mutable } => {
                    if not mutable { throw emitError(self, container, ErrorKind::ImmutableBinding); }
                    item = i;
                    set item = i;
                }
                else => throw emitError(self, container, ErrorKind::ExpectedIndexable),
            }
            // RHS is either a fill value or a source slice.
            let rhsTy = try infer(self, assign.right);

    let mut startVal: ?u32 = nil;
    let mut endVal: ?u32 = length;

    if let startNode = range.start {
        if let val = constSliceIndex(self, startNode) {
            startVal = val;
            set startVal = val;
        }
    }
    if let endNode = range.end {
        if let val = constSliceIndex(self, endNode) {
            endVal = val;
            set endVal = val;
        }
    }
    if let val = startVal; val >= length {
        throw emitError(self, site, ErrorKind::SliceRangeOutOfBounds);
    }

    throws (ResolveError)
{
    // Unwrap optional hint to get the inner record type.
    let mut innerHint = hint;
    if let case Type::Optional(inner) = hint {
        innerHint = *inner;
        set innerHint = *inner;
    }
    let mut hintInfo: ?RecordType = nil;
    if let case Type::Nominal(info) = innerHint {
        try ensureNominalResolved(self, info, node);
        if let case NominalType::Record(s) = *info {
            hintInfo = s;
            set hintInfo = s;
        }
    }
    let targetInfo = hintInfo else {
        throw emitError(self, node, ErrorKind::CannotInferType);
    };

{
    let length = items.len;
    let mut expectedTy: Type = Type::Unknown;

    if let case Type::Array(ary) = hint {
        expectedTy = *ary.item;
        set expectedTy = *ary.item;
    } else if let case Type::Optional(inner) = hint {
        if let case Type::Array(ary) = *inner {
            expectedTy = *ary.item;
            set expectedTy = *ary.item;
        }
    };
    for itemNode in items {
        let itemTy = try visit(self, itemNode, expectedTy);
        assert itemTy <> Type::Unknown;

        // Set the expected type to the first type we encounter.
        if expectedTy == Type::Unknown {
            expectedTy = itemTy;
            set expectedTy = itemTy;
        } else {
            try expectAssignable(self, expectedTy, itemTy, itemNode);
        }
    }
    if expectedTy == Type::Unknown {

fn resolveArrayRepeat(self: *mut Resolver, node: *ast::Node, lit: ast::ArrayRepeatLit, hint: Type) -> Type
    throws (ResolveError)
{
    let mut itemHint = hint;
    if let case Type::Array(ary) = hint {
        itemHint = *ary.item;
        set itemHint = *ary.item;
    } else if let case Type::Optional(inner) = hint {
        if let case Type::Array(ary) = *inner {
            itemHint = *ary.item;
            set itemHint = *ary.item;
        }
    }
    let valueTy = try visit(self, lit.item, itemHint);
    let count = try checkSizeInt(self, lit.count);
    let arrayTy = Type::Array(ArrayType {

    let mut ty: Type = undefined;

    match sym.data {
        case SymbolData::Value { type, .. } => {
            setNodeSymbol(self, node, sym);
            ty = type;
            set ty = type;
        }
        case SymbolData::Constant { type, value } => {
            // Propagate the constant value.
            if let val = value {
                setNodeConstValue(self, node, val);
            }
            setNodeSymbol(self, node, sym);
            ty = type;
            set ty = type;
        }
        case SymbolData::Type(t) => {
            setNodeSymbol(self, node, sym);
            ty = Type::Nominal(t);
            set ty = Type::Nominal(t);
        }
        case SymbolData::Variant { index, .. } => {
            let ty = typeFor(self, node)
                else throw emitError(self, node, ErrorKind::Internal);
            // For unions without payload, store the variant index as a constant.

            let mut capacity: ?u32 = nil;

            match subjectTy {
                case Type::Array(arrayInfo) => {
                    try validateArraySliceBounds(self, range, arrayInfo.length, node);
                    item = arrayInfo.item;
                    capacity = arrayInfo.length;
                    set item = arrayInfo.item;
                    set capacity = arrayInfo.length;
                }
                case Type::Slice { item: sliceItem, mutable } => {
                    if addr.mutable and not mutable {
                        throw emitError(self, addr.target, ErrorKind::ImmutableBinding);
                    }
                    item = sliceItem;
                    set item = sliceItem;
                }
                else => {
                    throw emitError(self, container, ErrorKind::ExpectedIndexable);
                }
            }

        }
    }
    // Derive a hint for the target type from the slice hint.
    let mut targetHint: Type = Type::Unknown;
    if let case Type::Slice { item, .. } = hint {
        targetHint = Type::Array(ArrayType { item, length: 0 });
        set targetHint = Type::Array(ArrayType { item, length: 0 });
    }
    let targetTy = try visit(self, addr.target, targetHint);

    // Mark local variable symbols as address-taken so the lowerer
    // allocates a stack slot eagerly.
    if let case ast::NodeValue::Ident(name) = addr.target.value {
        if let sym = findValueSymbol(self.scope, name) {
            match &mut sym.data {
                case SymbolData::Value { addressTaken, .. } => {
                    *addressTaken = true;
                    set *addressTaken = true;
                }
                else => {}
            }
        }
    }

            let mut resolvedTy = startTy;

            // Infer unsuffixed integer literals from the opposite bound.
            if startTy == Type::Int and endTy <> Type::Int {
                let _ = try checkAssignable(self, s, endTy);
                resolvedTy = endTy;
                set resolvedTy = endTy;
            } else if endTy == Type::Int and startTy <> Type::Int {
                let _ = try checkAssignable(self, e, startTy);
                resolvedTy = startTy;
                set resolvedTy = startTy;
            } else {
                let _ = try checkAssignable(self, e, startTy);
            }
            start = allocType(self, resolvedTy);
            end = allocType(self, resolvedTy);
            set start = allocType(self, resolvedTy);
            set end = allocType(self, resolvedTy);
        } else {
            start = allocType(self, startTy);
            set start = allocType(self, startTy);
        }
    } else if let e = range.end {
        end = allocType(self, try checkNumeric(self, e));
        set end = allocType(self, try checkNumeric(self, e));
    }
    return setNodeType(self, node, Type::Range { start, end });
}

/// Analyze a `try` expression and its handlers.

    if tryExpr.returnsOptional {
        // `try?` converts errors to `nil` and wraps the result in an optional.
        if let case Type::Optional(_) = resultTy {
            // Already optional, no wrapping needed.
        } else {
            tryResultTy = Type::Optional(allocType(self, resultTy));
            set tryResultTy = Type::Optional(allocType(self, resultTy));
        }
    } else if tryExpr.catches.len > 0 {
        // `try ... catch` -- one or more catch clauses.
        tryResultTy = try resolveTryCatches(self, node, tryExpr.catches, calleeInfo, resultTy, hint);
        set tryResultTy = try resolveTryCatches(self, node, tryExpr.catches, calleeInfo, resultTy, hint);
    } else if not tryExpr.shouldPanic {
        let fnInfo = self.currentFn
            else throw emitError(self, node, ErrorKind::TryRequiresThrows);
        if fnInfo.throwList.len == 0 {
            throw emitError(self, node, ErrorKind::TryRequiresThrows);

        for throwTy in calleeInfo.throwList {
            let mut found = false;

            for callerThrowTy in fnInfo.throwList {
                if callerThrowTy == throwTy {
                    found = true;
                    set found = true;
                    break;
                }
            }
            if not found {
                throw emitError(self, node, ErrorKind::TryIncompatibleError);

            let errTy = try infer(self, typeNode);
            let mut foundIdx: ?u32 = nil;

            for throwType, j in calleeInfo.throwList {
                if errTy == *throwType {
                    foundIdx = j;
                    set foundIdx = j;
                    break;
                }
            }
            let idx = foundIdx else {
                throw emitError(self, typeNode, ErrorKind::TryIncompatibleError);
            };
            if covered[idx] {
                throw emitError(self, typeNode, ErrorKind::TryCatchDuplicateType);
            }
            covered[idx] = true;
            set covered[idx] = true;

            // Bind the error variable if present.
            if let binding = clause.binding {
                enterScope(self, clauseNode);
                try bindValueIdent(self, binding, binding, errTy, false, 0, 0);
            }
        } else {
            // Catch-all clause with no type annotation or binding.
            hasCatchAll = true;
            set hasCatchAll = true;
        }
        // Resolve the catch body and check assignability.
        try visit(self, clause.body, resultTy);
        // Only typed clauses can have bindings.
        if let _ = clause.binding {

/// Returns the resulting constant value if successful.
fn foldIntBinOp(op: ast::BinaryOp, left: ConstInt, right: ConstInt) -> ?ConstValue {
    // Use the wider bit width and propagate signedness.
    let mut bits = left.bits;
    if right.bits > bits {
        bits = right.bits;
        set bits = right.bits;
    }
    let signed = left.signed or right.signed;
    let l = constIntToSigned(left);
    let r = constIntToSigned(right);


             ast::BinaryOp::Xor =>
        {
            try checkBoolean(self, binop.left);
            try checkBoolean(self, binop.right);

            resultTy = Type::Bool;
            set resultTy = Type::Bool;
        },
        case ast::BinaryOp::Eq,
             ast::BinaryOp::Ne =>
        {
            let leftTy = try infer(self, binop.left);

                    setNodeCoercion(self, binop.right, Coercion::OptionalLift(leftTy));
                }
            } else if let case Type::Optional(_) = rightTy {
                setNodeCoercion(self, binop.left, Coercion::OptionalLift(rightTy));
            }
            resultTy = Type::Bool;
            set resultTy = Type::Bool;
        },
        else => {
            // Check for pointer arithmetic before numeric check.
            if binop.op == ast::BinaryOp::Add or binop.op == ast::BinaryOp::Sub {
                let leftTy = try infer(self, binop.left);


            // Ordering comparisons return `bool`, not the operand type.
            match binop.op {
                case ast::BinaryOp::Lt, ast::BinaryOp::Gt,
                     ast::BinaryOp::Lte, ast::BinaryOp::Gte => {
                    resultTy = Type::Bool;
                    set resultTy = Type::Bool;
                } else => {
                    if leftTy == rightTy {
                        resultTy = leftTy;
                        set resultTy = leftTy;
                    } else if leftTy == Type::Int {
                        resultTy = rightTy;
                        set resultTy = rightTy;
                    } else if rightTy == Type::Int {
                        resultTy = leftTy;
                        set resultTy = leftTy;
                    } else {
                        throw emitTypeMismatch(self, binop.right, TypeMismatch {
                            expected: leftTy,
                            actual: rightTy,
                        });

{
    let mut resultTy = Type::Unknown;

    match unop.op {
        case ast::UnaryOp::Not => {
            resultTy = try checkBoolean(self, unop.value);
            set resultTy = try checkBoolean(self, unop.value);
            if let value = constValueEntry(self, unop.value) {
                if let case ConstValue::Bool(val) = value {
                    setNodeConstValue(self, node, ConstValue::Bool(not val));
                }
            }
        },
        case ast::UnaryOp::Neg => {
            // TODO: Check that we're allowed to use `-` here? Should negation
            // only be valid for signed integers?
            resultTy = try checkNumeric(self, unop.value);
            set resultTy = try checkNumeric(self, unop.value);
            if let value = constValueEntry(self, unop.value) {
                // Get the constant expression for the value, flip the sign,
                // and store that new expression on the unary op node.
                if let case ConstValue::Int(intVal) = value {
                    setNodeConstValue(

                    );
                }
            }
        },
        case ast::UnaryOp::BitNot => {
            resultTy = try checkNumeric(self, unop.value);
            set resultTy = try checkNumeric(self, unop.value);
            if let value = constValueEntry(self, unop.value) {
                if let case ConstValue::Int(intVal) = value {
                    let signed = constIntToSigned(intVal);
                    let inverted = constIntFromSigned(-(signed + 1), intVal.bits, intVal.signed);
                    setNodeConstValue(self, node, ConstValue::Int(inverted));

                let throwTy = try infer(self, tyNode);
                throwList.append(allocType(self, throwTy), a);
            }
            let mut retType = allocType(self, Type::Void);
            if let ret = t.returnType {
                retType = allocType(self, try infer(self, ret));
                set retType = allocType(self, try infer(self, ret));
            }
            let fnType = FnType {
                paramTypes: &paramTypes[..],
                returnType: retType,
                throwList: &throwList[..],

    }
}

/// Resolve all packages.
export fn resolve(self: *mut Resolver, graph: *module::ModuleGraph, packages: *[Pkg]) -> Diagnostics throws (ResolveError) {
    self.moduleGraph = graph;
    set self.moduleGraph = graph;

    // 1. Bind all package roots to enable cross-package references.
    for i in 0..packages.len {
        let pkg = &packages[i];
        // Enter a new scope for the module.

    let rootId = rootEntry.id;
    let scope = self.moduleScopes[rootId as u32]
        else panic "resolvePackage: module scope not found";

    // Set up the module scope for this package.
    self.scope = scope;
    self.currentMod = rootId;
    set self.scope = scope;
    set self.currentMod = rootId;

    let case ast::NodeValue::Block(block) = node.value
        else panic "resolvePackage: expected block for module root";

    // Module graph analysis phase: bind all module name symbols and scopes.

lib/std/lang/resolver/tests.rad +41 -41

    for i in 0..LITERALS.len {
        strings::intern(&mut STRING_POOL, LITERALS[i]);
    }
    // TODO: Use local static for this.
    // Reset the module graph for each test.
    MODULE_ARENA = ast::nodeArena(&mut MODULE_ARENA_STORAGE[..]);
    MODULE_GRAPH = module::moduleGraph(&mut MODULE_ENTRIES[..], &mut STRING_POOL, &mut MODULE_ARENA);
    set MODULE_ARENA = ast::nodeArena(&mut MODULE_ARENA_STORAGE[..]);
    set MODULE_GRAPH = module::moduleGraph(&mut MODULE_ENTRIES[..], &mut STRING_POOL, &mut MODULE_ARENA);
    let config = super::Config { buildTest: true };
    let res = super::resolver(testStorage(), config);

    return res;
}

    arena: *mut ast::NodeArena
) -> u16 throws (testing::TestError) {
    let filePath = "<test>";
    let mut modId: u16 = undefined;
    if let parent = parentId {
        modId = try module::registerChild(graph, parent, name, filePath) catch {
        set modId = try module::registerChild(graph, parent, name, filePath) catch {
            throw testing::TestError::Failed;
        };
    } else {
        modId = try module::registerRootWithName(graph, 0, name, filePath) catch {
        set modId = try module::registerRootWithName(graph, 0, name, filePath) catch {
            throw testing::TestError::Failed;
        };
    }
    let root = try parser::parse(scanner::SourceLoc::String, code, arena, &mut STRING_POOL) catch {
        panic "registerModule: parsing failed";

}

@test fn testResolveAssign() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let mut x: i32 = 0; x = 1;");
        let result = try resolveProgramStr(&mut a, "let mut x: i32 = 0; set x = 1;");
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let x: i32 = 0; x = 1;");
        let result = try resolveProgramStr(&mut a, "let x: i32 = 0; set x = 1;");
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let mut x: bool = false; x = 1;");
        let result = try resolveProgramStr(&mut a, "let mut x: bool = false; set x = 1;");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "x = 1;");
        let result = try resolveProgramStr(&mut a, "set x = 1;");
        try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("x"));
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let mut x: ?i32 = 0; x = 1;");
        let result = try resolveProgramStr(&mut a, "let mut x: ?i32 = 0; set x = 1;");
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let mut x: ?i32 = 0; x = nil;");
        let result = try resolveProgramStr(&mut a, "let mut x: ?i32 = 0; set x = nil;");
        try expectNoErrors(&result);
    }
}

@test fn testResolveAssignSubscript() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let mut xs: [u8; 2] = [0, 1]; xs[0] = 9;";
        let program = "let mut xs: [u8; 2] = [0, 1]; set xs[0] = 9;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
    {
        let mut a = testResolver();
        let program = "let mut xs: [u8; 2] = [0, 1]; let slice: *mut [u8] = &mut xs[..]; slice[0] = 1;";
        let program = "let mut xs: [u8; 2] = [0, 1]; let slice: *mut [u8] = &mut xs[..]; set slice[0] = 1;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
    {
        let mut a = testResolver();
        let program = "let mut xs: [u8; 2] = [0, 1]; let mut slice: *[u8] = &xs[..]; slice[0] = 1;";
        let program = "let mut xs: [u8; 2] = [0, 1]; let mut slice: *[u8] = &xs[..]; set slice[0] = 1;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
    {
        let mut a = testResolver();
        let program = "let xs: [u8; 2] = [0, 1]; xs[0] = 9;";
        let program = "let xs: [u8; 2] = [0, 1]; set xs[0] = 9;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
    {
        let mut a = testResolver();
        let program = "let mut xs: [u8; 2] = [0, 1]; let slice: *[u8] = &xs[..]; slice[0] = 1;";
        let program = "let mut xs: [u8; 2] = [0, 1]; let slice: *[u8] = &xs[..]; set slice[0] = 1;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
}


        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let count: i32 = undefined;");
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "let mut value: i32 = 0; value = undefined;";
        let program = "let mut value: i32 = 0; set value = undefined;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "fn f(x: i32) {} fn g() { f(undefined); }";

}

/// Test that `if let mut` produces a mutable binding.
@test fn testResolveIfLetMut() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; if let mut v = opt { v = v + 1; }";
    let program = "let opt: ?i32 = 42; if let mut v = opt { set v = v + 1; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that `if let` (without mut) rejects assignment.
@test fn testResolveIfLetImmutable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; if let v = opt { v = 1; }";
    let program = "let opt: ?i32 = 42; if let v = opt { set v = 1; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

/// Test that `let mut ... else` produces a mutable binding.
@test fn testResolveLetMutElse() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; let mut v = opt else panic; v = v + 1;";
    let program = "let opt: ?i32 = 42; let mut v = opt else panic; set v = v + 1;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that `let ... else` (without mut) rejects assignment.
@test fn testResolveLetElseImmutable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; let v = opt else panic; v = 1;";
    let program = "let opt: ?i32 = 42; let v = opt else panic; set v = 1;";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}


}

@test fn testResolveAssignDeref() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let mut x: i32 = 0; let ptr: *mut i32 = &mut x; *ptr = 42;";
        let program = "let mut x: i32 = 0; let ptr: *mut i32 = &mut x; set *ptr = 42;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "let mut x: i32 = 0; let ptr: *i32 = &x; *ptr = 42;";
        let program = "let mut x: i32 = 0; let ptr: *i32 = &x; set *ptr = 42;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    } {
        let mut a = testResolver();
        let program = "let mut x: i32 = 0; let mut ptr: *i32 = &x; *ptr = 42;";
        let program = "let mut x: i32 = 0; let mut ptr: *i32 = &x; set *ptr = 42;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    } {
        let mut a = testResolver();
        let program = "let mut x: u8 = 0; let mut ptr: *mut u8 = &mut x; *ptr = 255;";
        let program = "let mut x: u8 = 0; let mut ptr: *mut u8 = &mut x; set *ptr = 255;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}


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

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


    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export constant LIMIT: i32 = 7;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; fn main() { let p: *mut i32 = &mut consts::LIMIT; *p = 9; }", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; fn main() { let p: *mut i32 = &mut consts::LIMIT; set *p = 9; }", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}


/// Test that mutable pointer to immutable slice cannot be assigned through index.
/// This tests the case where we have `*mut *[T]`; the outer pointer is mutable but
/// the inner slice is immutable, so we shouldn't be able to mutate the elements.
@test fn testAssignThroughMutablePointerToImmutableSlice() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(slice: *[i32]) { let p: *mut *[i32] = &mut slice; p[0] = 1; }";
    let program = "fn f(slice: *[i32]) { let p: *mut *[i32] = &mut slice; set p[0] = 1; }";
    let result = try resolveProgramStr(&mut a, program);

    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

/// Test that mutable slice parameters can be assigned through index.
@test fn testAssignThroughMutableSliceParam() throws (testing::TestError) {
    {
        // Mutable slice param: direct assignment should work
        let mut a = testResolver();
        let program = "fn f(slice: *mut [i32]) { 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]) { 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 if the record binding is mutable.
@test fn testMutableAssignToMutableRecordBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S { x: i32 } fn f() { let mut s = S { x: 1 }; s.x = 2; }";
    let program = "record S { x: i32 } fn f() { let mut s = S { x: 1 }; set s.x = 2; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that record fields cannot be assigned if the record binding is immutable.
@test fn testMutableAssignToImmutableRecordBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S { x: i32 } fn f() { let s = S { x: 1 }; s.x = 2; }";
    let program = "record S { x: i32 } fn f() { let s = S { x: 1 }; set s.x = 2; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

/// Test that record fields can be assigned through a mutable pointer.
@test fn testMutableAssignToMutablePointerToRecord() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S { x: i32 } fn f(p: *mut S) { 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.
@test fn testMutableAssignToImmutablePointerToRecord() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S { x: i32 } fn f(p: *S) { p.x = 2; }";
    let program = "record S { x: i32 } fn f(p: *S) { set p.x = 2; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

// Opaque pointer tests.

/// You can assign any pointer (*T) to an opaque pointer (*opaque) without a cast.
@test fn testOpaquePointerAutoCoercion() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn f(x: i32) { let mut ptr: *i32 = &x; let o: *opaque = ptr; ptr = o as *i32; }");
    let result = try resolveProgramStr(&mut a, "fn f(x: i32) { let mut ptr: *i32 = &x; let o: *opaque = ptr; set ptr = o as *i32; }");
    try expectNoErrors(&result);
}

/// You cannot assign an opaque pointer to a non-opaque pointer without a cast.
@test fn testOpaquePointerNoReverseCoercion() throws (testing::TestError) {


/// Trait declares immutable receiver (*Trait) but instance uses mutable (*mut Type).
/// The instance method could mutate through what was originally an immutable pointer.
@test fn testResolveInstanceMutReceiverOnImmutableTrait() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Counter { value: i32 } trait Reader { fn (*Reader) read() -> i32; } instance Reader for Counter { fn (c: *mut Counter) read() -> i32 { c.value = c.value + 1; return c.value; } }";
    let program = "record Counter { value: i32 } trait Reader { fn (*Reader) read() -> i32; } instance Reader for Counter { fn (c: *mut Counter) read() -> i32 { set c.value = c.value + 1; return c.value; } }";
    let result = try resolveProgramStr(&mut a, program);
    // Should reject: instance declares *mut receiver but trait only requires immutable.
    try expectErrorKind(&result, super::ErrorKind::ReceiverMutabilityMismatch);
}

/// Instance method declares different parameter types than the trait.
/// The resolver should reject the mismatch rather than silently using the trait's types.
@test fn testResolveInstanceParamTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Acc { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Acc { fn (a: *mut Acc) add(n: u8) -> i32 { a.value = a.value + n as i32; return a.value; } }";
    let program = "record Acc { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Acc { fn (a: *mut Acc) add(n: u8) -> i32 { set a.value = a.value + n as i32; return a.value; } }";
    let result = try resolveProgramStr(&mut a, program);
    // Should reject: instance param type u8 doesn't match trait param type i32.
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Duplicate instance declarations for the same (trait, type) pair should be rejected.
@test fn testResolveInstanceDuplicateRejected() throws (testing::TestError) {
    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 { c.value = c.value + n; return c.value; } } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { c.value = c.value + n + 100; return c.value; } }";
    let program = "record Counter { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { set c.value = c.value + n; return c.value; } } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { set c.value = c.value + n + 100; return c.value; } }";
    let result = try resolveProgramStr(&mut a, program);
    // Should reject: duplicate instance for (Adder, Counter).
    try expectErrorKind(&result, super::ErrorKind::DuplicateInstance);
}


@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 { c.value = c.value + n; return c.value; } }", &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 result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

    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 { c.value = c.value + n; return c.value; } }", &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 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 { 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.

}

/// 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() { 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.

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

    return s.source[s.cursor + 1];
}

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

/// Consume the expected character if it matches the current position.
fn consume(s: *mut Scanner, expected: u8) -> bool {

        let mid = left + ((right - left) / 2);
        let kw = KEYWORDS[mid];
        let cmp = mem::cmp(src, kw.name);

        match cmp {
            case -1 => right = mid,
            case 1 => left = mid + 1,
            case -1 => set right = mid,
            case 1 => set left = mid + 1,
            else => return kw.tok,
        }
    }
    return TokenKind::Ident;
}

}

/// Scan the next token.
export fn next(s: *mut Scanner) -> Token {
    skipWhitespace(s);  // Skip any whitespace between tokens.
    s.token = s.cursor; // Token starts at current position.
    set s.token = s.cursor; // Token starts at current position.

    if isEof(s) {
        return tok(s, TokenKind::Eof);
    }
    let c: u8 = advance(s);

    if offset >= source.len {
        return nil;
    }
    for ch in &source[..offset] {
        if ch == '\n' {
            c = 1;
            l += 1;
            set c = 1;
            set l += 1;
        } else {
            c += 1;
            set c += 1;
        }
    }
    return Location { source: sourceLoc, line: l, col: c };
}

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

    let mut t: super::Token = super::next(&mut s);
    try testing::expect(t.kind == super::TokenKind::String);
    try testing::expect(t.source.len == 14); // Includes quotes.
    try testing::expect(mem::eq(t.source, "\"Hello World!\""));

    t = super::next(&mut s);
    set t = super::next(&mut s);
    try testing::expect(t.kind == super::TokenKind::String);
    try testing::expect(t.source.len == 4);
    try testing::expect(mem::eq(t.source, "\"\\\"\""));
}


        try testing::expect(loc.line == 1);
        try testing::expect(loc.col == 1);
    } else {
        try testing::expect(false);
    }
    tok = super::next(&mut s);
    set tok = super::next(&mut s);
    try testing::expect(tok.kind == super::TokenKind::Ident);
    try testing::expect(tok.source.len == 3);

    if let loc = super::getLocation(s.sourceLoc, s.source, tok.offset) {
        try testing::expect(loc.line == 2);
        try testing::expect(loc.col == 3);
    } else {
        try testing::expect(false);
    }
    tok = super::next(&mut s);
    set tok = super::next(&mut s);
    try testing::expect(tok.kind == super::TokenKind::Ident);
    try testing::expect(tok.source.len == 3);

    if let loc = super::getLocation(s.sourceLoc, s.source, tok.offset) {
        try testing::expect(loc.line == 3);

    );
    let mut tok: super::Token = super::next(&mut s);
    try testing::expect(tok.kind == super::TokenKind::Ident);
    try testing::expect(tok.source.len == 3);

    tok = super::next(&mut s);
    set tok = super::next(&mut s);
    try testing::expect(tok.kind == super::TokenKind::Ident);
    try testing::expect(tok.source.len == 6);

    tok = super::next(&mut s);
    set tok = super::next(&mut s);
    try testing::expect(tok.kind == super::TokenKind::Ident);
    try testing::expect(tok.source.len == 7);
}

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

    let mut tok: super::Token = super::next(&mut s);
    try testing::expect(tok.kind == super::TokenKind::Number);
    try testing::expect(mem::eq(tok.source, "9841029"));
    try testing::expect(tok.source.len == 7);

    tok = super::next(&mut s);
    set tok = super::next(&mut s);
    try testing::expect(tok.kind == super::TokenKind::Number);
    try testing::expect(tok.source.len == 5);

    tok = super::next(&mut s);
    set tok = super::next(&mut s);
    try testing::expect(tok.kind == super::TokenKind::Number);
    try testing::expect(mem::eq(tok.source, "-128"));
    try testing::expect(tok.source.len == 4);

    tok = super::next(&mut s);
    set tok = super::next(&mut s);
    try testing::expect(tok.kind == super::TokenKind::Number);
    try testing::expect(mem::eq(tok.source, "+0x2A"));
    try testing::expect(tok.source.len == 5);

    tok = super::next(&mut s);
    set tok = super::next(&mut s);
    try testing::expect(tok.kind == super::TokenKind::Number);
    try testing::expect(mem::eq(tok.source, "+0b11"));
    try testing::expect(tok.source.len == 5);
}


    );
    let mut tok: super::Token = super::next(&mut s);
    try testing::expect(tok.kind == super::TokenKind::Invalid);
    try testing::expect(tok.offset == 0);

    tok = super::next(&mut s);
    set tok = super::next(&mut s);
    try testing::expect(tok.kind == super::TokenKind::Invalid);
    try testing::expect(tok.offset == 1);

    tok = super::next(&mut s);
    set tok = super::next(&mut s);
    try testing::expect(tok.kind == super::TokenKind::Invalid);
    try testing::expect(tok.offset == 2);
}

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

lib/std/lang/sexpr.rad +4 -4

    if items.len == 0 {
        return &[];
    }
    let buf = try! allocExprs(a, items.len);
    for item, i in items {
        buf[i] = item;
        set buf[i] = item;
    }
    return buf;
}

/// Shorthand for creating a symbol.

        case Output::Stdout => io::print(s),
        case Output::Buffer { buf, pos } => {
            let remaining = buf.len - *pos;
            let toWrite = remaining if s.len > remaining else s.len;
            for i in 0..toWrite {
                buf[*pos] = s[i];
                *pos += 1;
                set buf[*pos] = s[i];
                set *pos += 1;
            }
        }
    }
}


            } else {
                let mut first = head.len == 0;
                for i in 0..tail.len {
                    if tail[i] <> Expr::Null {
                        if first {
                            first = false;
                            set first = false;
                        } else {
                            write(out, " ");
                        }
                        printTo(tail[i], depth, out);
                    }

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

        let entry = sp.table[idx];
        if entry.len > 0 {
            if mem::eq(entry, str) {
                return Lookup::Found(entry);
            }
            idx = (idx + 1) & (TABLE_SIZE - 1);
            set idx = (idx + 1) & (TABLE_SIZE - 1);
        } else {
            return Lookup::Empty(idx);
        }
    }
}

export fn intern(sp: *mut Pool, str: *[u8]) -> *[u8] {
    match lookup(sp, str) {
        case Lookup::Found(entry) => return entry,
        case Lookup::Empty(idx) => {
            assert sp.count < TABLE_SIZE / 2, "intern: string pool is full";
            sp.table[idx] = str;
            sp.count += 1;
            set sp.table[idx] = str;
            set sp.count += 1;

            return str;
        }
    }
}

lib/std/mem.rad +3 -3

export fn copy(into: *mut [u8], from: *[u8]) -> u32 throws (MemoryError) {
    if into.len < from.len {
        throw MemoryError::BufferTooSmall;
    }
    for x, i in from {
        into[i] = x;
        set into[i] = x;
    }
    return from.len;
}

/// Strip a byte-level prefix from the input, and return the suffix.

/// Count number of set bits in a 32-bit value.
export fn popCount(x: u32) -> i32 {
    let mut n = x;
    let mut count: i32 = 0;
    while n <> 0 {
        count += (n & 1) as i32;
        n >>= 1;
        set count += (n & 1) as i32;
        set n >>= 1;
    }
    return count;
}

/// Check whether two byte slices have the same length and contents.

lib/std/sys/unix.rad +2 -2

            return n;
        }
        if n == 0 {
            break;
        }
        total += n as u32;
        set total += n as u32;
    }
    return total as i64;
}

/// Writes to a file descriptor from the provided buffer.

        let n = write(fd, chunk);
        if n <= 0 {
            close(fd);
            return false;
        }
        written += n as u32;
        set written += n as u32;
    }
    close(fd);

    return true;
}

lib/std/testing.rad +3 -3

    io::print(name);
    io::print(" ... ");

    let mut success = true;
    try testFn() catch {
        success = false;
        set success = false;
    };
    if success {
        io::printLn("ok");
        ctx.passed += 1;
        set ctx.passed += 1;
    } else {
        io::printLn("FAILED");
        ctx.failed += 1;
        set ctx.failed += 1;
    }
}

fn printTestSummary(ctx: *Ctx) {
    if (ctx.failed > 0) {

lib/std/tests.rad +1 -1

    let mut xs: [u8; 2] = [1, 2];
    let ys: [u8; 3] = [4, 5, 6];

    let mut threw = false;
    try mem::copy(&mut xs[..], &ys[..]) catch {
        threw = true;
        set threw = true;
    };
    try testing::expect(threw);
}

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

lib/std/vec.rad +4 -4

    return vec.data.len / vec.stride;
}

/// Reset the vector to empty (does not clear memory).
export fn reset(vec: *mut RawVec) {
    vec.len = 0;
    set vec.len = 0;
}

/// Get a pointer to the element at the given index.
///
/// Returns nil if index is out of bounds.

    let off: u32 = vec.len * vec.stride;
    let dst: *mut u8 = &mut vec.data[off];
    let src: *u8 = elem as *u8;

    copyBytes(dst, src, vec.stride);
    vec.len += 1;
    set vec.len += 1;

    return true;
}

/// Pop an element from the end of the vector.

/// Returns false if the vector is empty.
export fn pop(vec: *mut RawVec, out: *mut opaque) -> bool {
    if vec.len == 0 {
        return false;
    }
    vec.len -= 1;
    set vec.len -= 1;

    let off: u32 = vec.len * vec.stride;
    let src: *u8 = &vec.data[off];
    let dst: *mut u8 = out as *mut u8;


}

/// Copy bytes from source to destination.
fn copyBytes(dst: *mut u8, src: *u8, count: u32) {
    for i in 0..count {
        *(dst + i) = *(src + i);
        set *(dst + i) = *(src + i);
    }
}

test/runner.rad +11 -11

    let mut end: u32 = 0;
    let mut i: u32 = 0;

    while i < line.len and line[i] <> ';' {
        if line[i] <> ' ' and line[i] <> '\t' {
            end = i + 1;
            set end = i + 1;
        }
        i += 1;
        set i += 1;
    }
    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] {
    let start = *offset;
    let mut i = start;

    while i < s.len and s[i] <> '\n' {
        i += 1;
        set i += 1;
    }
    let line = &s[start..i];
    if i < s.len {
        *offset = i + 1;
        set *offset = i + 1;
    } else {
        *offset = i;
        set *offset = i;
    }
    return line;
}

/// Compare two strings ignoring comments, line by line.

    let mut bi: u32 = 0;

    while ai < a.len or bi < b.len {
        let mut aLine = "";
        while ai < a.len and aLine.len == 0 {
            aLine = stripLine(nextLine(a, &mut ai));
            set aLine = stripLine(nextLine(a, &mut ai));
        }
        let mut bLine = "";
        while bi < b.len and bLine.len == 0 {
            bLine = stripLine(nextLine(b, &mut bi));
            set bLine = stripLine(nextLine(b, &mut bi));
        }
        if not mem::eq(aLine, bLine) {
            return false;
        }
    }

    try mem::copy(buf, sourcePath) catch {
        return nil;
    };
    // TODO: Rewrite this once we fix the compiler bug and add support for
    // additions in ranges.
    buf[len - 3] = 'r';
    buf[len - 2] = 'i';
    buf[len - 1] = 'l';
    buf[len] = 0;
    set buf[len - 3] = 'r';
    set buf[len - 2] = 'i';
    set buf[len - 1] = 'l';
    set buf[len] = 0;

    return &buf[..len];
}

/// Run a single IL snapshot test case. Returns `true` on success.

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

fn testMutateReturnedAggregate() -> i32 {
    let before: u32 = 42;
    let mut p: Pair = makePair(10, 20);
    let after: u32 = 99;

    p.a = 100;
    p.b = 200;
    set p.a = 100;
    set p.b = 200;

    assert before == 42;
    assert after == 99;
    assert p.a == 100;
    assert p.b == 200;

fn testAggregateReturnInLoop() -> i32 {
    let mut total: u32 = 0;
    let mut idx: u32 = 0;
    while idx < 5 {
        let p: Pair = makePair(idx, idx + 10);
        total += p.a + p.b;
        idx += 1;
        set total += p.a + p.b;
        set idx += 1;
    }
    // total = sum(i + i+10 for i in 0..5) = sum(2i+10) = 2*(0+1+2+3+4) + 50 = 20 + 50 = 70
    assert total == 70;
    return 0;
}

test/tests/arith.assignment.rad +9 -9

4	4		let mut b: i32 = 3;
5	5		let mut c: i32 = 0;
6	6		let mut d: i32 = 0;
7	7
8	8		// Test addition.
9		-	c = a + b; // c = 9
	9	+	set c = a + b; // c = 9
10	10
11	11		// Test subtraction.
12		-	c -= b; // c = 6
	12	+	set c -= b; // c = 6
13	13
14	14		// Test multiplication.
15		-	c *= b; // c = 18
	15	+	set c *= b; // c = 18
16	16
17	17		// Test division.
18		-	c /= b; // c = 6
	18	+	set c /= b; // c = 6
19	19
20	20		// Test mixed operations.
21		-	d = a * b + c / b; // d = 18 + 2 = 20
22		-	d += a * b / a; // d = 20 + 3 = 23
23		-	d += (b * a - c); // d = 23 + (18 - 6) = 35
24		-	d += (c - a / b); // d = 35 + (6 - 2) = 39
25		-	d += 3; // d = 42
	21	+	set d = a * b + c / b; // d = 18 + 2 = 20
	22	+	set d += a * b / a; // d = 20 + 3 = 23
	23	+	set d += (b * a - c); // d = 23 + (18 - 6) = 35
	24	+	set d += (c - a / b); // d = 35 + (6 - 2) = 39
	25	+	set d += 3; // d = 42
26	26
27	27		return (d) - 42;
28	28		}

test/tests/array.assign.rad +1 -1

3	3
4	4		@default fn main() -> i32 {
5	5		let mut a: [i32; 5] = [1, 2, 3, 4, 5];
6	6		let mut b: [i32; 5] = [8, 9, 7, 6, 0];
7	7
8		-	b = a;
	8	+	set b = a;
9	9
10	10		return b[0] + b[3] - b[2];
11	11		}

test/tests/array.index.assign.rad +10 -10

//! Test array index assignment and reading.

@default fn main() -> i32 {
    let mut arr: [i32; 5] = [1, 2, 3, 4, 5];

    arr[0] = 10;
    arr[1] = 20;
    arr[2] = 30;
    arr[3] = 40;
    arr[4] = 50;
    set arr[0] = 10;
    set arr[1] = 20;
    set arr[2] = 30;
    set arr[3] = 40;
    set arr[4] = 50;

    let mut sum: i32 = 0;

    sum += arr[0];
    sum += arr[1];
    sum += arr[2];
    sum += arr[3];
    sum -= arr[4];
    set sum += arr[0];
    set sum += arr[1];
    set sum += arr[2];
    set sum += arr[3];
    set sum -= arr[4];

    assert sum == 50;
    return 0;
}

test/tests/array.index.rad +4 -4


@default fn main() -> i32 {
    let mut arr: [i32; 4] = [10, 20, 30, 40];
    let mut sum: i32 = 0;

    sum += arr[0];
    sum += arr[1];
    sum += arr[2];
    sum += arr[3];
    set sum += arr[0];
    set sum += arr[1];
    set sum += arr[2];
    set sum += arr[3];

    return (sum) - 100;
}

test/tests/array.length.rad +2 -2

    let mut ary: [i32; 7] = [1, 2, 3, 4, 5, 6, 7];
    let mut sum: i32 = 0;
    let mut i: u32 = 0;

    while (i < ary.len) {
        sum += ary[i];
        i += 1;
        set sum += ary[i];
        set i += 1;
    }
    return (sum) - 28;
}

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


fn sumMatrix(mat: [[i32; 3]; 2]) -> i32 {
    let mut sum: i32 = 0;
    for vec in mat {
        for x in vec {
            sum += x;
            set sum += x;
        }
    }
    return sum;
}

fn sumMatrixTransposed(mat: [[i32; 2]; 3]) -> i32 {
    let mut sum: i32 = 0;
    for vec in (mat) {
        for x in (vec) {
            sum += x;
            set sum += x;
        }
    }
    return sum;
}


    let mut i: u32 = 0;

    while (i < matrix.len) {
        let mut j: u32 = 0;
        while (j < matrix[i].len) {
            result[j][i] = matrix[i][j];
            j += 1;
            set result[j][i] = matrix[i][j];
            set j += 1;
        }
        i += 1;
        set i += 1;
    }
    return result;
}

@default fn main() -> i32 {

test/tests/array.nested.assign.rad +2 -2

4	4		@default fn main() -> i32 {
5	5		let mut m: [[i32; 3]; 2] = [
6	6		[1, 2, 3],
7	7		[4, 5, 6]
8	8		];
9		-	m[1][1] = 7;
10		-	m[0][2] = 4;
	9	+	set m[1][1] = 7;
	10	+	set m[0][2] = 4;
11	11
12	12		return
13	13		m[0][0] +
14	14		m[0][1] +
15	15		m[0][2] +

test/tests/array.record.elements.rad +8 -8


fn calculateDistance(p1: Point, p2: Point) -> i32 {
    // Simple Manhattan distance
    let mut dx: i32 = p2.x - p1.x;
    if (dx < 0) {
        dx = -dx;
        set dx = -dx;
    }
    let mut dy: i32 = p2.y - p1.y;
    if (dy < 0) {
        dy = -dy;
        set dy = -dy;
    }
    return dx + dy;
}

fn sumPoints(points: [Point; 4]) -> i32 {
    let mut sum: i32 = 0;
    let mut i: u32 = 0;

    while (i < 4) {
        sum += points[i].x + points[i].y;
        i += 1;
        set sum += points[i].x + points[i].y;
        set i += 1;
    }
    return sum;
}

fn shiftPoints(points: [Point; 4], dx: i32, dy: i32) -> [Point; 4] {

        Point { x: 0, y: 0 },
        Point { x: 0, y: 0 }
    ];
    let mut i: u32 = 0;
    while (i < 4) {
        result[i] = Point {
        set result[i] = Point {
            x: points[i].x + dx,
            y: points[i].y + dy
        };
        i += 1;
        set i += 1;
    }
    return result;
}

@default fn main() -> i32 {

    let mut shifted: [Point; 4] = shiftPoints(points, 1, 1);
    // Calculate distance between original and shifted array elements.
    let mut distance: i32 = 0;
    let mut i: u32 = 0;
    while (i < points.len) {
        distance += calculateDistance(points[i], shifted[i]);
        i += 1;
        set distance += calculateDistance(points[i], shifted[i]);
        set i += 1;
    }
    return total + distance + shifted[3].x - points[0].y;
}

test/tests/assign.loop.rad +2 -2

/// Assignment in a loop, accumulating a value.
fn assignLoop(n: i32) -> i32 {
    let mut sum: i32 = 0;
    let mut i: i32 = 0;
    while i < n {
        sum += i;
        i += 1;
        set sum += i;
        set i += 1;
    }
    return sum;
}

test/tests/assign.multi.var.rad +3 -3

/// Multiple variables with interleaved assignments.
fn assignMultiVar() -> i32 {
    let mut a: i32 = 1;
    let mut b: i32 = 2;
    a = 10;
    b = 20;
    a += b;
    set a = 10;
    set b = 20;
    set a += b;
    return a;
}

test/tests/assign.mutable.rad +46 -46

/// Basic variable aliasing and mutation.
fn testBasicAliasing() -> i32 {
    let mut x: i32 = 10;
    let mut y: i32 = x;  // y aliases x's value

    x = 20;          // Modify x
    y += 5;       // Modify y independently
    set x = 20;          // Modify x
    set y += 5;       // Modify y independently

    return x + y;    // Should be 20 + 15 = 35
}

/// Struct aliasing and field mutation.
fn testStructAliasing() -> i32 {
    let mut p1: Person = Person { age: 25, score: 100 };
    let mut p2: Person = p1;     // Copy record

    p1.age = 30;             // Modify original
    p2.score = 0;            // Modify copy
    set p1.age = 30;             // Modify original
    set p2.score = 0;            // Modify copy

    return p1.age + p1.score + p2.age + p2.score; // 30+100+25+0 = 155
}

/// Array aliasing and element mutation.
fn testArrayAliasing() -> i32 {
    let mut arr1: [i32; 3] = [1, 2, 3];
    let mut arr2: [i32; 3] = arr1;  // Copy array
    arr1[0] = 10;               // Modify original
    arr2[1] = 20;               // Modify copy
    set arr1[0] = 10;               // Modify original
    set arr2[1] = 20;               // Modify copy
    // Arrays should be independent
    return arr1[0] + arr1[1] + arr2[0] + arr2[1]; // 10+2+1+20 = 33
}

/// Test 4: Nested record with array mutation.

        values: [1, 2, 3],
        count: 3
    };
    let mut container2: Container = container1;  // Copy entire record

    container1.values[0] = 50;              // Modify nested array in original
    container1.count = 5;                   // Modify field in original
    set container1.values[0] = 50;              // Modify nested array in original
    set container1.count = 5;                   // Modify field in original

    container2.values[2] = 60;              // Modify nested array in copy
    container2.count = 7;                   // Modify field in copy
    set container2.values[2] = 60;              // Modify nested array in copy
    set container2.count = 7;                   // Modify field in copy

    return container1.values[0] + container1.count +
           container2.values[2] + container2.count; // 50+5+60+7 = 122
}

/// Variable overwriting with different types/scopes.
fn testVariableOverwriting() -> i32 {
    let mut result: i32 = 0;
    let mut temp: i32 = 10;
    result = temp;      // First assignment
    set result = temp;      // First assignment

    temp = 20;          // Overwrite temp
    result += temp; // result = 10 + 20 = 30
    set temp = 20;          // Overwrite temp
    set result += temp; // result = 10 + 20 = 30

    // Create new scope with same variable name
    if true {
        let mut temp: i32 = 50;   // Shadow outer temp
        result += temp; // result = 30 + 50 = 80
        temp = 60;        // Modify inner temp
        result += temp; // result = 80 + 60 = 140
        set result += temp; // result = 30 + 50 = 80
        set temp = 60;        // Modify inner temp
        set result += temp; // result = 80 + 60 = 140
    }
    result += temp;   // Should use outer temp (20)
    set result += temp;   // Should use outer temp (20)

    return result;            // 140 + 20 = 160
}

/// Array of structs with aliasing.

        Person { age: 10, score: 20 },
        Person { age: 15, score: 25 }
    ];
    let mut backup: [Person; 2] = people;  // Copy array of structs

    people[0].age = 12;        // Modify original
    people[1].score = 30;      // Modify original
    set people[0].age = 12;        // Modify original
    set people[1].score = 30;      // Modify original

    backup[0].score = 22;      // Modify copy
    backup[1].age = 18;        // Modify copy
    set backup[0].score = 22;      // Modify copy
    set backup[1].age = 18;        // Modify copy

    return people[0].age + people[0].score + people[1].age + people[1].score +
           backup[0].age + backup[0].score + backup[1].age + backup[1].score;
}


105	105		fn testMutationChain() -> i32 {
106	106		let mut a: i32 = 1;
107	107		let mut b: i32 = 2;
108	108		let mut c: i32 = 3;
109	109
110		-	a = b; // a = 2
111		-	b = c; // b = 3
112		-	c = a + b; // c = 2 + 3 = 5
113		-	a = c - b; // a = 5 - 3 = 2
114		-	b = a * c; // b = 2 * 5 = 10
	110	+	set a = b; // a = 2
	111	+	set b = c; // b = 3
	112	+	set c = a + b; // c = 2 + 3 = 5
	113	+	set a = c - b; // a = 5 - 3 = 2
	114	+	set b = a * c; // b = 2 * 5 = 10
115	115
116	116		return a + b + c; // 2 + 10 + 5 = 17
117	117		}
118	118
119	119		/// Struct field reassignment with aliasing.

    let mut original: Person = Person { age: 30, score: 40 };
    let mut copied: Person = original;

    // Swap fields in original
    let mut temp: i32 = original.age;
    original.age = original.score;
    original.score = temp;
    set original.age = original.score;
    set original.score = temp;

    // Different swap in copy
    temp = copied.score;
    copied.score = copied.age;
    copied.age = temp;
    set temp = copied.score;
    set copied.score = copied.age;
    set copied.age = temp;

    return original.age + original.score + copied.age + copied.score;
    // 40+30 + 40+30 = 140
}


    let mut indices: [u32; 3] = [0, 1, 2];
    let mut values: [i32; 3] = [10, 20, 30];
    let mut backup: [i32; 3] = values;

    // Use indices to modify values
    values[indices[0]] = 25;     // values[0] = 25
    values[indices[1]] = 35;     // values[1] = 35
    set values[indices[0]] = 25;     // values[0] = 25
    set values[indices[1]] = 35;     // values[1] = 35

    // Modify indices
    indices[0] = 2;
    indices[2] = 0;
    set indices[0] = 2;
    set indices[2] = 0;

    // Use new indices on backup
    backup[indices[0]] = 40;   // backup[2] = 40
    backup[indices[2]] = 45;   // backup[0] = 45
    set backup[indices[0]] = 40;   // backup[2] = 40
    set backup[indices[2]] = 45;   // backup[0] = 45

    return values[0] + values[1] + values[2] +
           backup[0] + backup[1] + backup[2];
    // 25+35+30 + 45+20+40 = 195
}

    let mut level2: Person = level1;
    let mut level3: Person = level2;
    let mut level4: Person = level3;

    // Modify each level
    level1.age = 11;
    level2.age = 12;
    level3.age = 13;
    level4.age = 14;

    level1.score = 21;
    level2.score = 22;
    level3.score = 23;
    level4.score = 24;
    set level1.age = 11;
    set level2.age = 12;
    set level3.age = 13;
    set level4.age = 14;

    set level1.score = 21;
    set level2.score = 22;
    set level3.score = 23;
    set level4.score = 24;

    return (level1.age + level1.score) +
           (level2.age + level2.score) +
           (level3.age + level3.score) +
           (level4.age + level4.score);

test/tests/assign.param.rad +2 -2

/// Assignment overwriting a parameter value.
fn assignParam(x: i32) -> i32 {
    let mut y: i32 = x;
    y += 1;
    y *= 2;
    set y += 1;
    set y *= 2;
    return y;
}

test/tests/assign.rad +3 -3

1	1		//! returns: 0
2	2		@default fn main() -> i32 {
3	3		let mut i: i32 = 36;
4		-	i += 1; // 37
5		-	i += 2; // 39
6		-	i += 3; // 42
	4	+	set i += 1; // 37
	5	+	set i += 2; // 39
	6	+	set i += 3; // 42
7	7
8	8		return i - 42;
9	9		}

test/tests/assign.self.ref.rad +2 -2

/// Assignment where the new value depends on the old value.
fn assignSelfRef() -> i32 {
    let mut x: i32 = 1;
    x += x;
    x *= x;
    set x += x;
    set x *= x;
    return x;
}

test/tests/assign.sequential.rad +2 -2

/// Sequential assignments where the final value is returned.
fn assignSequential() -> i32 {
    let mut x: i32 = 1;
    x = 2;
    x = 3;
    set x = 2;
    set x = 3;
    return x;
}

test/tests/assign.shadow.mutable.rad +7 -7

//! returns: 0

fn shadowedMutation() -> i32 {
    let mut result: i32 = 0;
    let mut temp: i32 = 10;
    result = temp;
    set result = temp;

    temp = 20;
    result += temp;
    set temp = 20;
    set result += temp;

    if true {
        let mut temp: i32 = 50;
        result += temp;
        temp = 60;
        result += temp;
        set result += temp;
        set temp = 60;
        set result += temp;
    }
    // Must refer to outer `temp` (20), not inner shadowed `temp` (60).
    result += temp;
    set result += temp;

    return result;
}

@default fn main() -> i32 {

test/tests/assign.use.intermediate.rad +1 -1

/// Sequential assignments with intermediate value used in computation.
fn assignUseIntermediate() -> i32 {
    let mut x: i32 = 1;
    let y: i32 = x + 1;
    x = 5;
    set x = 5;
    return x + y;
}

test/tests/average.rad +1 -1

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

    for i in numbers {
        sum += i;
        set sum += i;
    }
    return sum / numbers.len;
}

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 {
    *counter += 1;
    set *counter += 1;
    return ret;
}

@default fn main() -> i32 {
    // Test 'and' short-circuits when first operand is false.

test/tests/builtin.sliceof.mut.rad +8 -8


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

    // Double each element via the slice
    slice[0] *= 2;
    slice[1] *= 2;
    slice[2] *= 2;
    slice[3] *= 2;
    set slice[0] *= 2;
    set slice[1] *= 2;
    set slice[2] *= 2;
    set slice[3] *= 2;

    // Sum the modified elements
    let mut sum: i32 = 0;
    sum += slice[0];
    sum += slice[1];
    sum += slice[2];
    sum += slice[3];
    set sum += slice[0];
    set sum += slice[1];
    set sum += slice[2];
    set sum += slice[3];

    return (sum) - 200;
}

test/tests/builtin.sliceof.rad +4 -4

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

    // Access elements via the slice and sum them
    let mut sum: i32 = 0;
    sum += slice[0];
    sum += slice[1];
    sum += slice[2];
    sum += slice[3];
    set sum += slice[0];
    set sum += slice[1];
    set sum += slice[2];
    set sum += slice[3];

    return sum;
}

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

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

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

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

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

test/tests/call.clobber.rad +1 -1

//! returns: 0
//! Test that values live across function calls are not clobbered.
fn modify(counter: *mut i32, ret: bool) -> bool {
    *counter += 1;
    set *counter += 1;
    return ret;
}

@default fn main() -> i32 {
    let mut x: i32 = 0;

test/tests/casting.numbers.rad +2 -2

//! Test integer casting: zero-extension, sign-extension, truncation.

fn zeroExtension() -> bool {
    let x: u8 = 9;
    let mut y: i32 = 42424242;
    y = x as i32;
    set y = x as i32;
    let z: u8 = y as u8;

    return y == 9 and z == 9;
}

fn casting() -> bool {
    let x: u8 = 5;
    let y: i16 = 10;
    let mut z: i32 = y as i32;

    z = 11 as i32 + z;
    set z = 11 as i32 + z;

    return ((x as i32) + z) == 26;
}

fn signedCasting() -> bool {

test/tests/compound.assign.field.rad +3 -3

6	6		}
7	7
8	8		@default fn main() -> i32 {
9	9		let mut p = Point { x: 10, y: 20 };
10	10
11		-	p.x += 5;
	11	+	set p.x += 5;
12	12		assert p.x == 15;
13	13
14		-	p.y -= 3;
	14	+	set p.y -= 3;
15	15		assert p.y == 17;
16	16
17		-	p.x *= 2;
	17	+	set p.x *= 2;
18	18		assert p.x == 30;
19	19
20	20		return 0;
21	21		}

test/tests/compound.assign.rad +15 -15

/// Test compound assignment operators (+=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=).
@default fn main() -> i32 {
    let mut a: i32 = 10;

    // Test +=
    a += 5;
    set a += 5;
    assert a == 15;

    // Test -=
    a -= 3;
    set a -= 3;
    assert a == 12;

    // Test *=
    a *= 2;
    set a *= 2;
    assert a == 24;

    // Test /=
    a /= 4;
    set a /= 4;
    assert a == 6;

    // Test %=
    a %= 4;
    set a %= 4;
    assert a == 2;

    // Test &=
    let mut b: i32 = 0xFF;
    b &= 0x0F;
    set b &= 0x0F;
    assert b == 0x0F;

    // Test |=
    b |= 0xF0;
    set b |= 0xF0;
    assert b == 0xFF;

    // Test ^=
    b ^= 0x0F;
    set b ^= 0x0F;
    assert b == 0xF0;

    // Test <<=
    let mut c: i32 = 1;
    c <<= 4;
    set c <<= 4;
    assert c == 16;

    // Test >>=
    c >>= 2;
    set c >>= 2;
    assert c == 4;

    // Test compound assignment with array subscript.
    let mut arr: [i32; 3] = [10, 20, 30];
    arr[1] += 5;
    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;
    *p += 50;
    set *p += 50;
    assert val == 150;

    // Test chained compound assignments.
    let mut x: i32 = 1;
    x += 2;
    x *= 3;
    x -= 1;
    set x += 2;
    set x *= 3;
    set x -= 1;
    assert x == 8;

    return 0;
}

test/tests/cond.assign.merge.basic.rad +2 -2

/// Return a value assigned from either branch of a conditional.
fn condAssignMergeBasic(flag: bool) -> i32 {
    let mut x: i32 = 0;
    if flag {
        x = 1;
        set x = 1;
    } else {
        x = 2;
        set x = 2;
    }
    return x;
}

test/tests/cond.assign.merge.rad +2 -2

/// Returns a value assigned from either branch of a conditional.
fn condAssignMerge(x: i32) -> i32 {
    let mut y: i32 = 0;
    if x > 0 {
        y = 1;
        set y = 1;
    } else {
        y = 2;
        set y = 2;
    }
    return y;
}

test/tests/cond.assign.rad +7 -7

6	6		@default fn main() -> i32 {
7	7		// Simple `if-else` with variable assignment.
8	8		let t: bool = true;
9	9		let mut x: i32 = 0;
10	10		if t {
11		-	x = 1;
	11	+	set x = 1;
12	12		} else {
13		-	x = 2;
	13	+	set x = 2;
14	14		}
15	15		assert x == 1;
16	16
17	17		// `if-else` with `false` condition.
18	18		let f: bool = false;
19	19		if f {
20		-	x = 10;
	20	+	set x = 10;
21	21		} else {
22		-	x = 20;
	22	+	set x = 20;
23	23		}
24	24		assert x == 20;
25	25
26	26		// `if-else` chain.
27	27		let a: i32 = 5;
28	28		if a == 3 {
29		-	x = 100;
	29	+	set x = 100;
30	30		} else if a == 5 {
31		-	x = 200;
	31	+	set x = 200;
32	32		} else {
33		-	x = 300;
	33	+	set x = 300;
34	34		}
35	35		assert x == 200;
36	36		return 0;
37	37		}

test/tests/cond.for.else.break.rad +2 -2

@default fn main() -> i32 {
    let mut i: i32 = 0;
    let xs: [i32; 7] = [1, 2, 3, 4, 5, 6, 7];

    for x in (xs) {
        i += x;
        set i += x;
        if (i >= 10) {
            break; // This should skip the else clause.
        }
    } else {
        i += 100; // This should NOT run because we break.
        set i += 100; // This should NOT run because we break.
    }
    return (i) - 10;
}

test/tests/cond.for.indexed.rad +1 -1

@default fn main() -> u32 {
    let arr: [u32; 3] = [10, 20, 30];
    let mut sum: u32 = 0;

    for value, index in arr {
        sum += value + index;
        set sum += value + index;
    }
    return (sum) - 63;
    //  (10+0) + (20+1) + (30+2) = 10 + 21 + 32 = 63
}

test/tests/cond.for.rad +1 -1

3	3		@default fn main() -> i32 {
4	4		let mut i: i32 = 0;
5	5		let xs: [i32; 7] = [1, 2, 3, 4, 5, 6, 7];
6	6
7	7		for x in (xs) {
8		-	i += x;
	8	+	set i += x;
9	9		}
10	10		return (i) - 28;
11	11		}

test/tests/cond.for.range.indexed.rad +2 -2

6	6		// Test range iteration with index.
7	7		// val: 5, 6, 7, 8
8	8		// idx: 0, 1, 2, 3
9	9		// sum: (5+0) + (6+1) + (7+2) + (8+3) = 5 + 7 + 9 + 11 = 32
10	10		for val, idx in 5..9 {
11		-	sum += val + idx as i32;
	11	+	set sum += val + idx as i32;
12	12		}
13	13
14	14		// Test that value starts from a non-zero offset while index starts at 0.
15	15		// val: 10, 11
16	16		// idx: 0, 1
17	17		// sum: 32 + (10-0) + (11-1) = 32 + 10 + 10 = 52
18	18		for v, i in 10..12 {
19		-	sum += v - i as i32;
	19	+	set sum += v - i as i32;
20	20		}
21	21
22	22		return (sum) - 52;
23	23		}

test/tests/cond.for.range.rad +1 -1

3	3		@default fn main() -> i32 {
4	4		let xs: [i32; 4] = [3, 4, 5, 6];
5	5		let mut sum: i32 = 0;
6	6
7	7		for i in 0..xs.len {
8		-	sum += xs[i];
	8	+	set sum += xs[i];
9	9		}
10	10		return (sum) - 18;
11	11		}

test/tests/cond.for.unsigned.range.rad +3 -3

    let start: u32 = 2147483647;
    let end: u32 = 2147483648;
    let mut count: i32 = 0;

    for i in start..end {
        count += 1;
        set count += 1;
    }
    assert count == 1;

    // Unsigned range above signed boundary.
    let start2: u32 = 2147483648;
    let end2: u32 = 2147483651;
    let mut count2: i32 = 0;

    for i in start2..end2 {
        count2 += 1;
        set count2 += 1;
    }
    assert count2 == 3;

    // Signed range still uses signed ordering.
    let mut sum: i32 = 0;
    for i in -2..2 {
        sum += i;
        set sum += i;
    }
    assert sum == -2;

    return 0;
}

test/tests/cond.forever.break.continue.rad +1 -1

@default fn main() -> i32 {
    let mut i: i32 = 0;

    loop {
        if (i < 42) {
            i += 1;
            set i += 1;
            continue;
        }
        break;
    }
    return (i) - 42;

test/tests/cond.forever.break.rad +2 -2

5	5		loop {
6	6		loop {
7	7		if (i > 39) {
8	8		break;
9	9		}
10		-	i += 1;
	10	+	set i += 1;
11	11		}
12		-	i += 2;
	12	+	set i += 2;
13	13		break;
14	14		}
15	15		return (i) - 42;
16	16		}

test/tests/cond.if.else.rad +1 -1

3	3		let mut i: i32 = 41;
4	4
5	5		if (i == 42) {
6	6		return (1) - 42;
7	7		} else {
8		-	i += 1;
	8	+	set i += 1;
9	9		}
10	10
11	11		if (i == 42) {
12	12		return (42) - 42;
13	13		} else {

test/tests/cond.if.elseif.rad +2 -2

5	5		if (i == 42) {
6	6		return (1) - 42;
7	7		} else if (i == 41) {
8	8		return (1) - 42;
9	9		} else if (i == 40) {
10		-	i += 2;
	10	+	set i += 2;
11	11		} else {
12		-	i += 1;
	12	+	set i += 1;
13	13		}
14	14
15	15		if (i == 42) {
16	16		return (42) - 42;
17	17		} else if (i == 41) {

test/tests/cond.if.noelse.rad +1 -1

2	2
3	3		@default fn main() -> i32 {
4	4		let mut x: i32 = 10;
5	5
6	6		if (x == 11) {
7		-	x = 20;
	7	+	set x = 20;
8	8		}
9	9
10	10		return (x) - 10;
11	11		}

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

//! `if let mut` binding with mutation of the bound variable.
fn ifLetMut(p: ?i32) -> i32 {
    if let mut x = p {
        x = x + 1;
        set x = x + 1;
        return x;
    } else {
        return 0;
    }
}

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

//! `let mut ... else` binding with mutation of the bound variable.
fn letMutElse(p: ?i32) -> i32 {
    let mut x = p else {
        return 0;
    };
    x = x + 1;
    set x = x + 1;
    return x;
}

test/tests/cond.match.fallthrough.rad +1 -1

    let mut x: i32 = 1;

    match (x) {
        case 1 => {
            // This case matches, changes x to 2 and should jump to end.
            x = 2;
            set x = 2;
        },
        case 2 => { return (2) - 42; },
        else => { return (0) - 42; }
    }
    return (42) - 42;

test/tests/cond.match.guard.rad +4 -4


fn checkStmt(value: OptionNum) -> i32 {
    let mut result: i32 = -100;
    match value {
        case OptionNum::Some(payload) if payload == 5 => {
            result = payload;
            set result = payload;
        }
        case OptionNum::Some(payload) => {
            result = -payload;
            set result = -payload;
        }
        case OptionNum::Other(payload) if payload == 7 => {
            result = payload * 2;
            set result = payload * 2;
        }
        else => {
            result = 0;
            set result = 0;
        }
    }
    return result;
}


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

fn getPath(node: *Node, buf: *mut [*[u8]]) -> *[*[u8]] {
    let mut out: *[*[u8]] = &[];

    match node.kind {
        case Kind::Name(name) if name.len > 0 => {
            buf[0] = name;
            out = &buf[..1];
            set buf[0] = name;
            set out = &buf[..1];
        }
        case Kind::Pair { a, b } => {
            out = &buf[..1];
            set out = &buf[..1];
        }
        else => {}
    }
    return out;
}

test/tests/cond.while.else.break.rad +2 -2


@default fn main() -> i32 {
    let mut i: i32 = 0;

    while (i < 100) {
        i += 1;
        set i += 1;
        if (i == 42) {
            break; // This should skip the else clause.
        }
    } else {
        i += 100; // This should NOT run because we break.
        set i += 100; // This should NOT run because we break.
    }
    return (i) - 42;
}

test/tests/cond.while.rad +1 -1

//! returns: 0
@default fn main() -> i32 {
    let mut i: i32 = 0;

    while (i < 42) {
        i += 1;
        set i += 1;
    }
    return (i) - 42;
}

test/tests/const.array.copy.mutate.rad +2 -2

constant SEED: [i32; 4] = [1, 2, 3, 4];

fn crunch() -> i32 {
    let mut working: [i32; 4] = SEED;

    working[0] += 5;
    working[3] = working[1] + working[2];
    set working[0] += 5;
    set working[3] = working[1] + working[2];

    return working[0] + working[3];
}

@default fn main() -> i32 {

test/tests/const.array.rad +1 -1

constant NUMBERS: [i32; 4] = [1, 2, 3, 4];

@default fn main() -> i32 {
    let mut sum: i32 = 0;
    for n in (NUMBERS) {
        sum += n;
        set sum += n;
    }
    return (sum) - 10;
}

test/tests/const.record.array.rad +1 -1


fn sumPoints(points: [Point; 3]) -> i32 {
    let mut sum: i32 = 0;

    for p in (points) {
        sum += p.x + p.y;
        set sum += p.x + p.y;
    }
    return sum;
}

// Array of structs as a function parameter

test/tests/const.record.array.simple.rad +3 -3

15	15
16	16		@default fn main() -> i32 {
17	17		let mut sum: i32 = 0;
18	18
19	19		// Add all points' x and y values
20		-	sum += POINTS[0].x + POINTS[0].y; // 1 + 2 = 3
21		-	sum += POINTS[1].x + POINTS[1].y; // 3 + 4 = 7
22		-	sum += POINTS[2].x + POINTS[2].y; // 5 + 6 = 11
	20	+	set sum += POINTS[0].x + POINTS[0].y; // 1 + 2 = 3
	21	+	set sum += POINTS[1].x + POINTS[1].y; // 3 + 4 = 7
	22	+	set sum += POINTS[2].x + POINTS[2].y; // 5 + 6 = 11
23	23
24	24		return (sum) - 21; // 3 + 7 + 11 = 21
25	25		}

test/tests/const.record.mutcopy.rad +1 -1


/// Returns a scratch register, avoiding the one already used by `rs`.
fn test(rs: Reg) -> Reg {
    let mut scratch = SCRATCH1;
    if rs.n == SCRATCH1.n {
        scratch = SCRATCH2;
        set scratch = SCRATCH2;
    }
    return scratch;
}

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

}

fn node(nodes: *mut Node, count: *mut u32, value: NodeValue) -> *Node {
    let index = *count;
    let slot = nodes + index;
    *slot = Node { value };
    *count = index + 1;
    set *slot = Node { value };
    set *count = index + 1;
    return slot;
}

fn nodeTypeInt(nodes: *mut Node, count: *mut u32, width: u8, sign: Signedness) -> *Node {
    return node(nodes, count, NodeValue::TypeSig(

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

    t: 0x1234560F,
};
static ANALYZER: Analyzer = undefined;

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

fn mkEntry() -> Entry {
    return DEFAULT_ENTRY;
}

    }
    return mkEntry();
}

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

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

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

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


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

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

    return target;
}

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

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

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

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

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

    assert val2 == 21;

    // Catch block that discards error
    let mut flag: u32 = 0;
    try returnsErr() catch {};
    flag = 1;
    set flag = 1;
    assert flag == 1;

    // Catch block with return in function
    let val3: u32 = returnsEarly();
    assert val3 == 42;

test/tests/error.multi.basic.rad +3 -3


@default fn main() -> i32 {
    // Test throwing ErrA.
    let mut caught: i32 = 0;
    try failA() catch {
        caught = 1;
        set caught = 1;
    };
    assert caught == 1;

    // Test throwing ErrB.
    caught = 0;
    set caught = 0;
    try failB() catch {
        caught = 2;
        set caught = 2;
    };
    assert caught == 2;

    // Test success path.
    let val = try succeed() catch {

test/tests/error.multi.catch.rad +5 -5


@default fn main() -> i32 {
    // Catch ErrA without binding.
    let mut handled: i32 = 0;
    try failA() catch {
        handled = 1;
        set handled = 1;
    };
    assert handled == 1;

    // Catch ErrB without binding.
    handled = 0;
    set handled = 0;
    try failB() catch {
        handled = 2;
        set handled = 2;
    };
    assert handled == 2;

    // Success path should not trigger catch.
    handled = 0;
    set handled = 0;
    let val = try succeed() catch {
        handled = 99;
        set handled = 99;
    };
    assert handled == 0;
    assert val == 99;
    return 0;
}

test/tests/error.multi.catch.typed.binding.rad +3 -3

    let mut got: i32 = 0;
    try failA(100) catch e as ErrA {
        let case ErrA::A(v) = e else {
            return 1;
        };
        got = v;
        set got = v;
    } catch e as ErrB {
        return 2;
    };
    assert got == 100;

    // Extract ErrB payload.
    got = 0;
    set got = 0;
    try failB(200) catch e as ErrA {
        return 4;
    } catch e as ErrB {
        let case ErrB::B(v) = e else {
            return 5;
        };
        got = v;
        set got = v;
    };
    assert got == 200;
    return 0;
}

test/tests/error.multi.catch.typed.catchall.rad +4 -4

    let mut result: i32 = 0;
    try failA() catch e as ErrA {
        let case ErrA::A(v) = e else {
            return 10;
        };
        result = v;
        set result = v;
    } catch {
        return 1;
    };
    assert result == 10;

    // ErrB should fall into catch-all.
    let mut caughtAll: i32 = 0;
    try failB() catch e as ErrA {
        return 3;
    } catch {
        caughtAll = 1;
        set caughtAll = 1;
    };
    assert caughtAll == 1;

    // ErrC should also fall into catch-all.
    caughtAll = 0;
    set caughtAll = 0;
    try failC() catch e as ErrA {
        return 5;
    } catch {
        caughtAll = 1;
        set caughtAll = 1;
    };
    assert caughtAll == 1;
    return 0;
}

test/tests/error.multi.catch.typed.rad +3 -3

    let mut result: i32 = 0;
    let val1 = try failA() catch e as ErrA {
        let case ErrA::A(v) = e else {
            return 10;
        };
        result = v;
        set result = v;
        0
    } catch e as ErrB {
        return 1;
    };
    assert result == 10;

    // Catch ErrB specifically with typed binding.
    result = 0;
    set result = 0;
    let val2 = try failB() catch e as ErrA {
        return 3;
    } catch e as ErrB {
        let case ErrB::B(v) = e else {
            return 11;
        };
        result = v;
        set result = v;
        0
    };
    assert result == 20;

    // Success path should skip all catches.

test/tests/error.multi.propagate.multi.rad +5 -5


@default fn main() -> i32 {
    // Propagate ErrA through outer.
    let mut result: i32 = 0;
    try outer(1) catch e as ErrA {
        result = 10;
        set result = 10;
    } catch e as ErrB {
        result = 20;
        set result = 20;
    };
    assert result == 10;

    // Propagate ErrB through outer.
    result = 0;
    set result = 0;
    try outer(2) catch e as ErrA {
        result = 10;
        set result = 10;
    } catch e as ErrB {
        result = 20;
        set result = 20;
    };
    assert result == 20;

    // Success path.
    let val = try outer(0) catch e as ErrA {

test/tests/error.multi.propagate.rad +3 -3


@default fn main() -> i32 {
    // Propagate ErrA through middle.
    let mut caught: i32 = 0;
    try middle(1) catch {
        caught = 1;
        set caught = 1;
    };
    assert caught == 1;

    // Propagate ErrB through middle.
    caught = 0;
    set caught = 0;
    try middle(2) catch {
        caught = 2;
        set caught = 2;
    };
    assert caught == 2;

    // Success path.
    let val = try middle(0) catch {

test/tests/error.try.catch.binding.rad +7 -7

@default fn main() -> u32 {
    // Test catching and using the error value.
    let mut caught: u32 = 0;
    try failWithBoom() catch e {
        if (e == TestError::Boom) {
            caught = 1;
            set caught = 1;
        } else {
            caught = 2;
            set caught = 2;
        }
    };
    assert caught == 1;

    // Test catching a different error variant.
    caught = 0;
    set caught = 0;
    try failWithBust() catch e {
        if (e == TestError::Bust) {
            caught = 10;
            set caught = 10;
        } else {
            caught = 20;
            set caught = 20;
        }
    };
    assert caught == 10;

    // Test that success path doesn't execute catch block.
    caught = 0;
    set caught = 0;
    try succeed() catch e {
        caught = 99;
        set caught = 99;
    };
    assert caught == 0;

    // Test catch block that returns early from function.
    let early: u32 = testCatchReturn();

test/tests/error.try.optional.rad +2 -2


    // Test 7: try? in while-let loop
    let mut count: u32 = 0;
    let mut iter: u32 = 0;
    while let value = try? maybeValue(iter) {
        count += value;
        iter += 1;
        set count += value;
        set iter += 1;
    }
    assert count == 6;

    return 0;
}

test/tests/error.try.rad +13 -13


fn shortCircuit(flag: bool) -> u32 throws (TestError) {
    let mut counter: u32 = 1;

    if flag {
        counter += try returnsErr(2);
        set counter += try returnsErr(2);
    } else {
        try returnsErr(0);
        counter += 100;
        set counter += 100;
    }
    return counter;
}

fn aggregateTwo() -> u32 throws (TestError) {


fn catchReturn(flag: *mut u32, fail: bool) -> bool {
    let value: u32 = try maybeReturn(fail) catch {
        return true;
    };
    *flag = value;
    set *flag = value;
    return false;
}

fn accumulateSteps(failMid: bool) -> u32 throws (TestError) {
    let mut total: u32 = 0;
    let mut idx: u32 = 0;
    while idx < 3 {
        if failMid {
            if idx == 1 {
                total += try returnsErr(0);
                set total += try returnsErr(0);
            } else {
                total += try returnsErr(2);
                set total += try returnsErr(2);
            }
        } else {
            total += try returnsErr(2);
            set total += try returnsErr(2);
        }
        idx += 1;
        set idx += 1;
    }
    return total;
}

fn structSuccess(state: *mut ResultSink) -> u32 throws (TestError) {
    let value: u32 = try returnsOk();
    state.last = value;
    state.count += 1;
    set state.last = value;
    set state.count += 1;
    return value;
}

fn structFailure(state: *mut ResultSink) -> u32 throws (TestError) {
    try returnsErr(1);
    state.last = 999;
    set state.last = 999;
    return 999;
}

@default fn main() -> i32 {
    let mut sumFlag: u32 = 0;
    let total: u32 = try! sumThree();
    assert total == 39;
    sumFlag = total;
    set sumFlag = total;

    let mut scOkFlag: u32 = 0;
    let scVal: u32 = try! shortCircuit(true);
    assert scVal == 10;
    scOkFlag = scVal;
    set scOkFlag = scVal;

    let mut scErrFlag: u32 = 0;
    try shortCircuit(false) catch {};
    assert scErrFlag == 0;


    try structFailure(&mut sink) catch {};
    assert sink.count == 2;

    let mut voidOkFlag: u32 = 0;
    try! returnsOkVoid();
    voidOkFlag = 77;
    set voidOkFlag = 77;
    assert voidOkFlag == 77;

    let mut voidErrFlag: u32 = 0;
    try returnsErrVoid() catch {};
    assert voidErrFlag == 0;

test/tests/fn.callback.nested.rad +1 -1

    return current;
}

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

fn withReg(val: Val, callback: fn(Reg, *mut opaque), ctx: *mut opaque) {
    if let case Val::Reg(r) = val {
        callback(r, ctx);

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

            else continue;
        if name.len == target.len {
            let mut eq = true;
            for j in 0..name.len {
                if name[j] <> target[j] {
                    eq = false;
                    set eq = false;
                }
            }
            if eq {
                return fields[i].value;
            }

    return nil;
}

@default fn main() -> i32 {
    let mut fields: [Field; 4] = undefined;
    fields[0] = Field { name: nil, value: 10 };
    fields[1] = Field { name: "foo", value: 20 };
    fields[2] = Field { name: nil, value: 30 };
    fields[3] = Field { name: "bar", value: 40 };
    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 {
        return 1;
    };
    assert v1 == 20;

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

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

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

    return ary[4091] as i32;
}

@default fn main() -> i32 {

test/tests/if-let-mut.rad +4 -4


fn testIfLetMut() -> i32 {
    let opt = getOptional(10);

    if let mut v = opt {
        v = v + 5;
        set v = v + 5;
        if v <> 15 {
            return 1;
        }
    } else {
        return 2;


fn testIfLetMutNil() -> i32 {
    let opt = getOptional(0);

    if let mut v = opt {
        v = v + 1;
        set v = v + 1;
        return 3;
    }
    return 0;
}


    let opt = getOptional(42);

    let mut v = opt else {
        return 4;
    };
    v = v + 8;
    set v = v + 8;
    if v <> 50 {
        return 5;
    }
    return 0;
}

    let opt = getOptional(0);

    let mut v = opt else {
        return 0;
    };
    v = v + 1;
    set v = v + 1;
    return 6;
}

@default fn main() -> i32 {
    let r1 = testIfLetMut();

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

/// 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 {
    let mut b: Big = undefined;
    b.tag = 42;
    set b.tag = 42;
    assert b.tag == 42;
    b.tag = 99;
    set b.tag = 99;
    assert b.tag == 99;
    return 0;
}

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

    let mut dst: Big = src;

    assert dst.a[0] == 10;
    assert dst.a[1000] == 20;

48	48		}
49	49
50	50		/// Mutate a copy to ensure the blit produced an independent copy.
51	51		fn copyIndependence() -> i32 {
52	52		let mut a: Big = undefined;
53		-	a.a[0] = 1;
54		-	a.a[2199] = 2;
55		-	a.tag = 100;
	53	+	set a.a[0] = 1;
	54	+	set a.a[2199] = 2;
	55	+	set a.tag = 100;
56	56
57	57		let mut b: Big = a;
58		-	b.a[0] = 99;
59		-	b.tag = 200;
	58	+	set b.a[0] = 99;
	59	+	set b.tag = 200;
60	60
61	61		assert a.a[0] == 1;
62	62		assert a.tag == 100;
63	63		assert b.a[0] == 99;
64	64		assert b.a[2199] == 2;

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

}

static outer: Outer = undefined;

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

    let ptr: *Inner = &outer.inner;

    assert (*ptr).value == 42;
    return 0;

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

static container: Container = undefined;

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

    container.opt = sourceOpt;
    set container.opt = sourceOpt;

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

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

}

static container: Container = undefined;

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

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

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


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

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

    outer.inner = source;
    set outer.inner = source;

    assert outer.inner.value == 42;
    return 0;
}

test/tests/local.mut.rad +1 -1

fn localMut() -> i32 {
    let mut x: i32 = 5;
    x = 10;
    set x = 10;
    return x;
}

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

2	2		let mut i: i32 = 0;
3	3		loop {
4	4		if i >= n {
5	5		break;
6	6		}
7		-	i += 1;
	7	+	set i += 1;
8	8		}
9	9		return i;
10	10		}

test/tests/loop.complex.flow.rad +3 -3

        let val = i - 2;  // -2, -1, 0, 1, 2, 3
        let result = maybeAdd(sum, val);

        match result {
            case Result::Ok(v) => {
                sum = v;
                set sum = v;
            },
            case Result::Err(e) => {
                errCount += 1;
                set errCount += 1;
            },
        }
        i += 1;
        set i += 1;
    }

    // val sequence: -2, -1, 0, 1, 2, 3
    // Err for val <= 0: errCount = 3 (for -2, -1, 0)
    // Ok for val > 0: sum = 0 + 1 + 2 + 3 = 6

test/tests/loop.continue.rad +2 -2

fn loopContinue(n: i32) -> i32 {
    let mut i: i32 = 0;
    let mut sum: i32 = 0;
    while i < n {
        i += 1;
        set i += 1;
        if i == 3 {
            continue;
        }
        sum += i;
        set sum += i;
    }
    return sum;
}

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

/// Iterates over an array with index binding and sums elements.
fn forArrayIndexed(arr: [i32; 3]) -> i32 {
    let mut sum: i32 = 0;
    for elem, idx in arr {
        sum += elem + idx as i32;
        set sum += elem + idx as i32;
    }
    return sum;
}

test/tests/loop.for.continue.rad +2 -2

    let mut sum: u32 = 0;
    for i in 0..n {
        if i == 2 {
            continue;
        }
        sum += i;
        set sum += i;
    }
    return sum;
}

fn forContinueArray(arr: [i32; 4]) -> i32 {
    let mut sum: i32 = 0;
    for elem in arr {
        if elem == 0 {
            continue;
        }
        sum += elem;
        set sum += elem;
    }
    return sum;
}

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

fn loopForIndexed(n: i32) -> i32 {
    let mut sum: i32 = 0;
    for val, idx in 0..n {
        sum += val + idx as i32;
        set sum += val + idx as i32;
    }
    return sum;
}

test/tests/loop.for.placeholder.rad +2 -2

// Test for loop with placeholder binding

fn forPlaceholder(n: u32) -> u32 {
    let mut count: u32 = 0;
    for _ in 0..n {
        count += 1;
        set count += 1;
    }
    return count;
}

fn forPlaceholderArray(arr: [i32; 4]) -> i32 {
    let mut count: i32 = 0;
    for _ in arr {
        count += 1;
        set count += 1;
    }
    return count;
}

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

fn loopFor(n: i32) -> i32 {
    let mut sum: i32 = 0;
    for i in 0..n {
        sum += i;
        set sum += i;
    }
    return sum;
}

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

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

test/tests/loop.for.unsigned.range.rad +2 -2

fn loopForUnsignedRange(start: u32, end: u32) -> u32 {
    let mut count: u32 = 0;
    for _ in start..end {
        count += 1;
        set count += 1;
    }
    return count;
}

fn loopForSignedRange(start: i32, end: i32) -> i32 {
    let mut count: i32 = 0;
    for _ in start..end {
        count += 1;
        set count += 1;
    }
    return count;
}

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


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

test/tests/loop.nested.break.rad +3 -3

    let mut i: i32 = 0;

    loop {
        let mut j: i32 = 0;
        loop {
            result += 1;
            j += 1;
            set result += 1;
            set j += 1;
            if j >= n {
                break;
            }
        }
        i += 1;
        set i += 1;
        if i >= n {
            break;
        }
    }
    return result;

test/tests/loop.nested.continue.rad +3 -3

fn nestedContinue(n: i32) -> i32 {
    let mut result: i32 = 0;
    let mut i: i32 = 0;

    while i < n {
        i += 1;
        set i += 1;
        if i == 2 {
            continue;
        }
        let mut j: i32 = 0;
        while j < n {
            j += 1;
            set j += 1;
            if j == 1 {
                continue;
            }
            result += 1;
            set result += 1;
        }
    }
    return result;
}

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

1	1		fn loopReturn() -> i32 {
2	2		let mut i: i32 = 0;
3	3		loop {
4		-	i += 1;
	4	+	set i += 1;
5	5		if i == 10 {
6	6		return i;
7	7		}
8	8		}
9	9		}

test/tests/loop.sealblock.rad +4 -4

@default fn main() -> i32 {
    // Simple loop with mutable variable.
    let mut sum: i32 = 0;
    let mut i: i32 = 0;
    while i < 5 {
        sum += i;
        i += 1;
        set sum += i;
        set i += 1;
    }
    // sum = 0 + 1 + 2 + 3 + 4 = 10
    assert sum == 10;

    // For loop with mutable variable.
    let mut count: i32 = 0;
    for j in 0..4 {
        count += 1;
        set count += 1;
    }
    assert count == 4;

    // Nested pattern: mutable var with function call in loop.
    let mut total: i32 = 0;
    for k in 0..3 {
        total += addOne(k);
        set total += addOne(k);
    }
    // total = 1 + 2 + 3 = 6
    assert total == 6;

    return 0;

test/tests/loop.while.nested.shortcircuit.rad +3 -3

    let mut outer: i32 = 0;
    let mut total: i32 = 0;
    while outer < n {
        let mut inner: i32 = outer;
        while inner > 0 and inner < 100 {
            inner -= 1;
            set inner -= 1;
        }
        total += outer;
        outer += 1;
        set total += outer;
        set outer += 1;
    }
    return total;
}

test/tests/loop.while.rad +2 -2

fn loopWhile(n: i32) -> i32 {
    let mut i: i32 = 0;
    let mut sum: i32 = 0;
    while i < n {
        sum += i;
        i += 1;
        set sum += i;
        set i += 1;
    }
    return sum;
}

test/tests/loop.whilelet.case.rad +2 -2

// Returns the number of loop iterations when the input starts at zero.
fn whileLetCase(x: i32) -> i32 {
    let mut cur: i32 = x;
    let mut steps: i32 = 0;
    while let case 0 = cur {
        cur = 1;
        steps += 1;
        set cur = 1;
        set steps += 1;
    }
    return steps;
}

test/tests/loop.whilelet.guard.rad +2 -2

// Loops while the input matches case 0 and passes the guard.
fn whileLetCaseGuard(x: i32) -> i32 {
    let mut cur: i32 = x;
    let mut steps: i32 = 0;
    while let case 0 = cur; steps < 3 {
        cur = 0;
        steps += 1;
        set cur = 0;
        set steps += 1;
    }
    return steps;
}

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

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

test/tests/loop.whilelet.union.rad +2 -2

/// Sum values from a linked iteration using while-let case with binding.
fn sumWhileLet(x: Option) -> u32 {
    let mut opt = x;
    let mut sum: u32 = 0;
    while let case Option::Some(val) = opt {
        sum += val;
        opt = Option::None;
        set sum += val;
        set opt = Option::None;
    }
    return sum;
}

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


// Returns 1 when the input matches, otherwise returns 0.
fn matchNoElse(x: i32) -> i32 {
    let mut y: i32 = 0;
    match x {
       case 1 => y = 1,
       case 1 => set y = 1,
       else => {},
    }
    return y;
}

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

    No { items: U32List },
    Yes,
}

fn pushItem(list: *mut U32List, value: u32) {
    list.data[list.len] = value;
    list.len += 1;
    set list.data[list.len] = value;
    set list.len += 1;
}

fn addToUnsealedBlock(state: *mut Sealed, value: u32) -> bool {
    match state {
        case Sealed::No { items } => {

    }
}

@default fn main() -> i32 {
    let mut buf: [u32; 8] = undefined;
    buf[0] = 0;
    set buf[0] = 0;
    let mut state = Sealed::No { items: U32List { data: &mut buf[0..8], len: 0 } };

    assert addToUnsealedBlock(&mut state, 42);
    assert addToUnsealedBlock(&mut state, 99);


test/tests/match.mutref.union.rad +1 -1


fn process(d: *mut Data) -> u32 {
    match &mut d.state {
        case State::A { count } => {
            let c = *count;
            *count = c + 1;
            set *count = c + 1;
            return c;
        },
        case State::B => {
            return 0;
        },

test/tests/match.nested.whilelet.rad +6 -6

/// While-let with nested record destructuring.
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) {
        sum = sum + a + b;
        i = i + 1;
        set sum = sum + a + b;
        set i = i + 1;
    }
    return sum;
}

/// While-let with nested record and guard.
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 {
        sum = sum + a + b;
        i = i + 1;
        set sum = sum + a + b;
        set i = i + 1;
    }
    return sum;
}

union Dir { North, South }

/// While-let with nested union variant pattern.
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) {
        sum = sum + speed;
        i = i + 1;
        set sum = sum + speed;
        set i = i + 1;
    }
    return sum;
}

@default fn main() -> i32 {

test/tests/match.value.copy.rad +3 -3


    let case Data::Some { pair } = b.data else {
        return 1;
    };
    // Overwrite the source - binding should be unaffected.
    b.data = Data::None;
    set b.data = Data::None;

    assert pair.a == 10;
    assert pair.b == 20;
    return 0;
}

    let mut b = Box {
        data: Data::Some { pair: Pair { a: 30, b: 40 } },
    };

    if let case Data::Some { pair } = b.data {
        b.data = Data::None;
        set b.data = Data::None;
        assert pair.a == 30;
        assert pair.b == 40;
    } else {
        return 4;
    }

        data: Data::Some { pair: Pair { a: 50, b: 60 } },
    };

    match b.data {
        case Data::Some { pair } => {
            b.data = Data::None;
            set b.data = Data::None;
            assert pair.a == 50;
            assert pair.b == 60;
        }
        case Data::None => {
            return 7;

test/tests/memzero.result.bug.rad +2 -2

    // Place the return slot and a guard back-to-back on the stack.
    let mut guard: u32 = 0;

    // Success return should write only the small payload.
    try fallible(false) catch {
        guard = 0xDEAD;
        set guard = 0xDEAD;
    };
    guard = 0xDEADBEEF;
    set guard = 0xDEADBEEF;

    if guard <> 0xDEADBEEF {
        return 1; // Guard was clobbered by an overzealous memzero.
    }
    return 0;

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

}

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

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

    if f.guard1 == 0xDEAD and f.guard2 == 0xDEADBEEF {
        return 0;
    } else {
        return 1;

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

9	9		fn (p: *Point) sum() -> i32 {
10	10		return p.x + p.y;
11	11		}
12	12
13	13		fn (p: *mut Point) translate(dx: i32, dy: i32) {
14		-	p.x = p.x + dx;
15		-	p.y = p.y + dy;
	14	+	set p.x = p.x + dx;
	15	+	set p.y = p.y + dy;
16	16		}
17	17
18	18		@default fn main() -> i32 {
19	19		let mut pt = Point { x: 3, y: 4 };
20	20

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

    x: i32,
    y: i32,
}

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

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

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

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

13	13		fn (v: Vec2) dot(other: Vec2) -> i32 {
14	14		return v.x * other.x + v.y * other.y;
15	15		}
16	16
17	17		fn (v: mut Vec2) add(other: Vec2) {
18		-	v.x = v.x + other.x;
19		-	v.y = v.y + other.y;
	18	+	set v.x = v.x + other.x;
	19	+	set v.y = v.y + other.y;
20	20		}
21	21
22	22		fn (v: *mut Vec2) scale(factor: i32) {
23		-	v.x = v.x * factor;
24		-	v.y = v.y * factor;
	23	+	set v.x = v.x * factor;
	24	+	set v.y = v.y * factor;
25	25		}
26	26
27	27		@default fn main() -> i32 {
28	28		let mut a = Vec2 { x: 3, y: 4 };
29	29		let b = Vec2 { x: 1, y: 2 };

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

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

fn (c: *mut Counter) inc() {
    c.value = c.value + 1;
    set c.value = c.value + 1;
}

@default fn main() -> i32 {
    let mut c = Counter { value: 0 };


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


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

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

    assert parser.remaining() == 0;

    // Advance past end -- should throw.
    let mut threw = false;
    try parser.advance() catch {
        threw = true;
        set threw = true;
    };
    assert threw;

    return 0;
}

test/tests/multi.throw.catch.typed.rad +2 -2

}

fn caller(flag: i32) -> i32 {
    let mut r: i32 = 0;
    try fallible(flag) catch e as ErrA {
        r = 1;
        set r = 1;
    } catch e as ErrB {
        r = 2;
        set r = 2;
    };
    return r;
}

test/tests/mutref.call.result.rad added +20 -0

1	+	//! returns: 0
2	+	//! Mutable borrow through a field access on a call result.
3	+
4	+	record Box {
5	+	x: i32,
6	+	}
7	+
8	+	fn idBox(b: mut Box) -> mut Box {
9	+	return b;
10	+	}
11	+
12	+	@default fn main() -> i32 {
13	+	let mut b = Box { x: 1 };
14	+
15	+	let px: *mut i32 = &mut idBox(&mut b).x;
16	+	set *px = 9;
17	+
18	+	assert b.x == 9;
19	+	return 0;
20	+	}

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

//! 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) {
    *ptr = val;
    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 {
    let mut val: u32 = 42;
    let mut i: u32 = 0;
    while i < n {
        store(&mut val, val + 1);
        i += 1;
        set i += 1;
    }
    return val;
}

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

/// Multiple address-taken variables in the same loop.

    let mut b: u32 = 100;
    let mut i: u32 = 0;
    while i < 3 {
        store(&mut a, a + 1);
        store(&mut b, b - 1);
        i += 1;
        set i += 1;
    }
    return a + b;
}

@default fn main() -> i32 {

test/tests/mutref.loop.rad +2 -2

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

fn test() -> i32 {
    let mut maxReg: u32 = 0;
    let mut i: u32 = 0;
    while i < 3 {
        callback(i, &mut maxReg as *mut opaque);
        i += 1;
        set i += 1;
    }
    return maxReg as i32;
}

test/tests/mutref.scalar.rad +1 -1

fn modify(counter: *mut i32, ret: bool) -> bool {
    *counter += 1;
    set *counter += 1;
    return ret;
}

fn test() -> i32 {
    let mut x: i32 = 0;

test/tests/opt.assignment.bug.rad +4 -4

/// Test assigning via if-let pattern.
fn testIfLetPattern() -> bool {
    let mut result: ?i32 = nil;

    if let val = returnOptional(true) {
        result = val;
        set result = val;
    }
    if let r = result {
        return r == 99;
    }
    return false;


/// Test direct assignment from function.
fn testDirectAssignment() -> bool {
    let mut result: ?i32 = nil;

    result = returnOptional(true);
    set result = returnOptional(true);

    if let r = result {
        return r == 99;
    }
    return false;

/// Test if-let pattern with nil return.
fn testIfLetPatternNil() -> bool {
    let mut result: ?i32 = nil;

    if let val = returnOptional(false) {
        result = val;
        set result = val;
    }
    if let r = result {
        return false;
    }
    return true;


/// Test direct assignment with nil return.
fn testDirectAssignmentNil() -> bool {
    let mut result: ?i32 = nil;

    result = returnOptional(false);
    set result = returnOptional(false);

    if let r = result {
        return false;
    }
    return true;

test/tests/opt.bug.test.rad +2 -2

fn testManualPattern() -> bool {
    let mut result: ?i32 = nil;
    let opt: ?i32 = 42;

    if let val = opt {
        result = inner(val);
        set result = inner(val);
    }

    if let r = result {
        return r == 43;
    }

fn testManualPatternNil() -> bool {
    let mut result: ?i32 = nil;
    let opt: ?i32 = nil;

    if let val = opt {
        result = inner(val);
        set result = inner(val);
    }

    if let r = result {
        return false; // Should be nil
    }

test/tests/opt.if.let.complex.rad +5 -5

fn testMultipleNilAssignments() -> bool {
    let mut opt: ?i32 = 42;

    if let x = opt {
        if x == 42 {
            opt = nil;
            set opt = nil;
            if let y = opt {
                return false; // Should not reach here after nil assignment
            } else {
                opt = 100;
                set opt = 100;
                if let z = opt {
                    return z == 100;
                } else {
                    return false;
                }


    if let x = opt {
        return false;
    }

    opt = 10;
    set opt = 10;
    if let x = opt; x == 10 {
        opt = 20;
        set opt = 20;
        if let y = opt; y == 20 {
            opt = nil;
            set opt = nil;
            if let z = opt {
                return false;
            } else {
                return true;
            }

test/tests/opt.record.eq.rad +3 -3

    let mut optA: ?Outer = nil;
    let mut optB: ?Outer = nil;
    let mut optDiff: ?Outer = nil;
    let mut optNil: ?Outer = nil;

    optA = outerA;
    optB = outerB;
    optDiff = outerC;
    set optA = outerA;
    set optB = outerB;
    set optDiff = outerC;

    if optA <> optB {
        return false;
    }
    if optA == optDiff {

test/tests/opt.record.rad +3 -3

    return 0;
}

@default fn main() -> i32 {
    let mut v: ?Vector = nil;
    v = Vector { x: 3, y: 4, z: 5 };
    set v = Vector { x: 3, y: 4, z: 5 };

    let mut total: i32 = 0;

    if let w = v {
        total = w.x + w.y + w.z;
        set total = w.x + w.y + w.z;
    } else {
        return 0;
    }

    let wrapper = Wrapper { opt: 7 };
    if let value = wrapper.opt {
        total += value;
        set total += value;
    } else {
        return 0;
    }

    let call = takeOptional(9);

test/tests/opt.type.rad +3 -3

@default fn main() -> i32 {
    let optSome: ?i32 = 42;
    let optNone: ?i32 = nil;

    let mut optMaybe: ?i32 = nil;
    optMaybe = optSome;
    optMaybe = 42;
    optMaybe = nil;
    set optMaybe = optSome;
    set optMaybe = 42;
    set optMaybe = nil;

    return 0;
}

test/tests/opt.while.let.complex.rad +2 -2

@default fn main() -> i32 {
    let mut cur: u32 = 7;
    let mut sum: u32 = 0;

    while let x = decr(cur); x > 1 {
        sum += x;
        cur = x;
        set sum += x;
        set cur = x;
    }

    // sum should be 6 + 5 + 4 + 3 + 2 = 20
    assert sum == 20;
    return 0;

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


    // Test 4: for loop with placeholder for value
    let arr: [i32; 3] = [1, 2, 3];
    let mut count: i32 = 0;
    for _ in &arr[..] {
        count += 1;
        set count += 1;
    }
    assert count == 3;
    return 0;
}

test/tests/pointer.copy.edge.case.rad +5 -5

    count: u32,
}

fn makeNode(p: *mut Parser, kind: NodeKind) -> *mut Node {
    let idx: u32 = p.count;
    p.nodes[idx] = Node {
    set p.nodes[idx] = Node {
        span: Span { length: 0 },
        kind,
    };
    p.count = idx + 1;
    set p.count = idx + 1;
    return &mut p.nodes[idx];
}

fn setLen(n: *mut Node, len: u32) {
    n.span.length = len;
    set n.span.length = len;
}

@default fn main() -> i32 {
    let mut parser: Parser = Parser {
        nodes: [Node {

            kind: NodeKind::Placeholder,
        }; 1],
        count: 0,
    };

    parser.count = 0;
    parser.nodes[0] = Node {
    set parser.count = 0;
    set parser.nodes[0] = Node {
        span: Span { length: 0 },
        kind: NodeKind::Placeholder,
    };

    let node: *mut Node = makeNode(&mut parser, NodeKind::Bool(true));

test/tests/pointer.slice.store.rad +5 -5

static STORAGE: [Entry; 2] = undefined;
static TABLE: Table = undefined;
static HOLDER: PtrBox = undefined;

@default fn main() -> i32 {
    TABLE.entries = &mut STORAGE[..];
    TABLE.len     = 0;
    set TABLE.entries = &mut STORAGE[..];
    set TABLE.len     = 0;

    HOLDER.ptr = &mut TABLE.entries;
    set HOLDER.ptr = &mut TABLE.entries;

    HOLDER.ptr[0] = Entry { a: 1, b: 2, c: 3, d: 4, e: 5 };
    set HOLDER.ptr[0] = Entry { a: 1, b: 2, c: 3, d: 4, e: 5 };

    assert TABLE.entries.len == 2 and TABLE.entries.ptr == &STORAGE[0];
    assert STORAGE[0].a == 1 and STORAGE[0].e == 5;

    HOLDER.ptr[1] = Entry { a: 10, b: 20, c: 30, d: 40, e: 50 };
    set HOLDER.ptr[1] = Entry { a: 10, b: 20, c: 30, d: 40, e: 50 };

    assert TABLE.entries.len == 2 and TABLE.entries.ptr == &STORAGE[0];
    assert STORAGE[1].c == 30 and STORAGE[1].d == 40;
    return 0;
}

test/tests/prog.ackermann.rad +16 -16

    if m == 3 {
        // 2^(n+3) - 3
        let mut power: i32 = 1;
        let mut i: u32 = 0;
        while i < n + 3 {
            power *= 2;
            i += 1;
            set power *= 2;
            set i += 1;
        }
        return power - 3;
    }
    // For m >= 4, fall back to recursion (only safe for very small n).
    if n == 0 {

/// Power of 2 helper.
fn pow2(exp: u32) -> i32 {
    let mut result: i32 = 1;
    let mut i: u32 = 0;
    while i < exp {
        result *= 2;
        i += 1;
        set result *= 2;
        set i += 1;
    }
    return result;
}

/// Test known small values using the recursive implementation.

    // Verify m=0 row.
    let mut n: u32 = 0;
    while n < 50 {
        let expected: i32 = n as i32 + 1;
        assert ackMemo(0, n) == expected;
        n += 1;
        set n += 1;
    }

    // Verify m=1 row.
    n = 0;
    set n = 0;
    while n < 50 {
        let expected: i32 = n as i32 + 2;
        assert ackMemo(1, n) == expected;
        n += 1;
        set n += 1;
    }

    // Verify m=2 row.
    n = 0;
    set n = 0;
    while n < 50 {
        let expected: i32 = (2 * n + 3) as i32;
        assert ackMemo(2, n) == expected;
        n += 1;
        set n += 1;
    }

    // Verify m=3 row for small n.
    // A(3,0)=5, A(3,1)=13, A(3,2)=29, A(3,3)=61, A(3,4)=125
    assert ackMemo(3, 0) == 5;

    while m <= 3 {
        let mut n: u32 = 0;
        // Limit n to keep recursion tractable.
        let mut limit: u32 = 4;
        if m <= 2 {
            limit = 8;
            set limit = 8;
        }
        while n <= limit {
            let r: i32 = ack(m, n);
            let memoR: i32 = ackMemo(m, n);
            if r <> memoR {
                return (m * 20 + n) as i32 + 1;
            }
            n += 1;
            set n += 1;
        }
        m += 1;
        set m += 1;
    }
    return 0;
}

/// Test the Ackermann inverse property: A(m, n) > n for all m, n.

            let val: i32 = ackMemo(m, n);
            assert val > n as i32;
            // A(m, n) < A(m, n+1) (strictly increasing in n).
            let valNext: i32 = ackMemo(m, n + 1);
            assert valNext > val;
            n += 1;
            set n += 1;
        }
        m += 1;
        set m += 1;
    }

    // A(m, n) < A(m+1, n) (strictly increasing in m).
    let mut m2: u32 = 0;
    while m2 < 3 {
        let mut n2: u32 = 0;
        while n2 < 10 {
            let lower: i32 = ackMemo(m2, n2);
            let upper: i32 = ackMemo(m2 + 1, n2);
            assert upper > lower;
            n2 += 1;
            set n2 += 1;
        }
        m2 += 1;
        set m2 += 1;
    }

    return 0;
}


test/tests/prog.bignum.rad +62 -62

/// 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) {
    dst[0] = val;
    set dst[0] = val;
    let mut i: u32 = 1;
    while i < LIMBS {
        dst[i] = 0;
        i += 1;
        set dst[i] = 0;
        set i += 1;
    }
}

/// Set a big number to zero.
fn bnZero(dst: *mut [u32]) {
    let mut i: u32 = 0;
    while i < LIMBS {
        dst[i] = 0;
        i += 1;
        set dst[i] = 0;
        set i += 1;
    }
}

/// Copy src to dst.
fn bnCopy(dst: *mut [u32], src: *[u32]) {
    let mut i: u32 = 0;
    while i < LIMBS {
        dst[i] = src[i];
        i += 1;
        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 {

            return -1;
        }
        if i == 0 {
            break;
        }
        i -= 1;
        set i -= 1;
    }
    return 0;
}

/// Add two big numbers: dst = a + b. Returns carry (0 or 1).

    let mut i: u32 = 0;
    while i < LIMBS {
        let sumLo: u32 = a[i] + b[i];
        let mut carry1: u32 = 0;
        if sumLo < a[i] {
            carry1 = 1;
            set carry1 = 1;
        }
        let sum: u32 = sumLo + carry;
        let mut carry2: u32 = 0;
        if sum < sumLo {
            carry2 = 1;
            set carry2 = 1;
        }
        dst[i] = sum;
        carry = carry1 + carry2;
        i += 1;
        set dst[i] = sum;
        set carry = carry1 + carry2;
        set i += 1;
    }
    return carry;
}

/// Subtract two big numbers: dst = a - b. Returns borrow (0 or 1).

    let mut i: u32 = 0;
    while i < LIMBS {
        let diff: u32 = a[i] - b[i];
        let mut borrow1: u32 = 0;
        if diff > a[i] {
            borrow1 = 1;
            set borrow1 = 1;
        }
        let result: u32 = diff - borrow;
        let mut borrow2: u32 = 0;
        if result > diff {
            borrow2 = 1;
            set borrow2 = 1;
        }
        dst[i] = result;
        borrow = borrow1 + borrow2;
        i += 1;
        set dst[i] = result;
        set borrow = borrow1 + borrow2;
        set i += 1;
    }
    return borrow;
}

/// Multiply two LIMBS-word numbers, producing a 2*LIMBS-word result in wide.
fn bnMul(wide: *mut [u32], a: *[u32], b: *[u32]) {
    let mut i: u32 = 0;
    while i < LIMBS * 2 {
        wide[i] = 0;
        i += 1;
        set wide[i] = 0;
        set i += 1;
    }

    i = 0;
    set i = 0;
    while i < LIMBS {
        let mut carry: u32 = 0;
        let mut j: u32 = 0;
        while j < LIMBS {
            let al: u32 = a[i] & 0xFFFF;

            let hh: u32 = ah * bh;

            let mid: u32 = lh + hl;
            let mut midCarry: u32 = 0;
            if mid < lh {
                midCarry = 1;
                set midCarry = 1;
            }

            let lo: u32 = ll + (mid << 16);
            let mut loCarry: u32 = 0;
            if lo < ll {
                loCarry = 1;
                set loCarry = 1;
            }
            let hi: u32 = hh + (mid >> 16) + (midCarry << 16) + loCarry;

            let sum1: u32 = wide[i + j] + lo;
            let mut c1: u32 = 0;
            if sum1 < wide[i + j] {
                c1 = 1;
                set c1 = 1;
            }
            let sum2: u32 = sum1 + carry;
            let mut c2: u32 = 0;
            if sum2 < sum1 {
                c2 = 1;
                set c2 = 1;
            }
            wide[i + j] = sum2;
            carry = hi + c1 + c2;
            set wide[i + j] = sum2;
            set carry = hi + c1 + c2;

            j += 1;
            set j += 1;
        }
        wide[i + LIMBS] += carry;
        i += 1;
        set wide[i + LIMBS] += carry;
        set i += 1;
    }
}

/// Left shift a big number by 1 bit.
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;
        dst[i] = (src[i] << 1) | carry;
        carry = newCarry;
        i += 1;
        set dst[i] = (src[i] << 1) | carry;
        set carry = newCarry;
        set i += 1;
    }
}

/// Right shift a big number by 1 bit.
fn bnShr1(dst: *mut [u32], src: *[u32]) {
    let mut carry: u32 = 0;
    let mut i: u32 = LIMBS;
    while i > 0 {
        i -= 1;
        set i -= 1;
        let newCarry: u32 = src[i] & 1;
        dst[i] = (src[i] >> 1) | (carry << 31);
        carry = newCarry;
        set dst[i] = (src[i] >> 1) | (carry << 31);
        set carry = newCarry;
    }
}

/// Test basic addition.
fn testAdd() -> i32 {

206	206		let mut a: [u32; 4] = [0; 4];
207	207		let mut b: [u32; 4] = [0; 4];
208	208		let mut c: [u32; 4] = [0; 4];
209	209
210	210		bnZero(&mut a[..]);
211		-	a[1] = 1;
	211	+	set a[1] = 1;
212	212		bnFromU32(&mut b[..], 1);
213	213		let borrow: u32 = bnSub(&mut c[..], &a[..], &b[..]);
214	214
215	215		assert borrow == 0;
216	216		assert c[0] == 0xFFFFFFFF;

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

    a[0] = 0x12345678;
    a[1] = 0xABCDEF01;
    a[2] = 0x9876FEDC;
    a[3] = 0x01020304;
    set a[0] = 0x12345678;
    set a[1] = 0xABCDEF01;
    set a[2] = 0x9876FEDC;
    set a[3] = 0x01020304;

    b[0] = 0xFEDCBA98;
    b[1] = 0x76543210;
    b[2] = 0x11223344;
    b[3] = 0x00AABB00;
    set b[0] = 0xFEDCBA98;
    set b[1] = 0x76543210;
    set b[2] = 0x11223344;
    set b[3] = 0x00AABB00;

    bnAdd(&mut c[..], &a[..], &b[..]);
    bnSub(&mut d[..], &c[..], &b[..]);

    assert bnCmp(&d[..], &a[..]) == 0;

296	296		fn testLargeMultiply() -> i32 {
297	297		let mut a: [u32; 4] = [0; 4];
298	298		let mut b: [u32; 4] = [0; 4];
299	299		let mut wide: [u32; 8] = [0; 8];
300	300
301		-	a[0] = 0xFFFFFFFF;
302		-	a[1] = 0xFFFFFFFF;
303		-	a[2] = 0;
304		-	a[3] = 0;
	301	+	set a[0] = 0xFFFFFFFF;
	302	+	set a[1] = 0xFFFFFFFF;
	303	+	set a[2] = 0;
	304	+	set a[3] = 0;
305	305
306	306		bnFromU32(&mut b[..], 1);
307	307		bnMul(&mut wide[..], &a[..], &b[..]);
308	308		assert wide[0] == 0xFFFFFFFF;
309	309		assert wide[1] == 0xFFFFFFFF;
310	310		assert wide[2] == 0;
311	311
312	312		bnZero(&mut a[..]);
313		-	a[1] = 1;
	313	+	set a[1] = 1;
314	314		bnZero(&mut b[..]);
315		-	b[1] = 1;
	315	+	set b[1] = 1;
316	316		bnMul(&mut wide[..], &a[..], &b[..]);
317	317		assert wide[0] == 0;
318	318		assert wide[1] == 0;
319	319		assert wide[2] == 1;
320	320		assert wide[3] == 0;

326	326		fn testFibonacci() -> i32 {
327	327		let mut fibA: [u32; 4] = [0; 4];
328	328		let mut fibB: [u32; 4] = [0; 4];
329	329		let mut fibC: [u32; 4] = [0; 4];
330	330
331		-	fibA[0] = 0;
332		-	fibB[0] = 1;
	331	+	set fibA[0] = 0;
	332	+	set fibB[0] = 1;
333	333
334	334		let mut i: u32 = 2;
335	335		while i <= 48 {
336	336		bnAdd(&mut fibC[..], &fibA[..], &fibB[..]);
337	337		bnCopy(&mut fibA[..], &fibB[..]);
338	338		bnCopy(&mut fibB[..], &fibC[..]);
339		-	i += 1;
	339	+	set i += 1;
340	340		}
341	341
342	342		assert fibB[0] == 0x1E8D0A40;
343	343		assert fibB[1] == 0x01;
344	344
345	345		let mut fa: [u32; 4] = [0; 4];
346	346		let mut fb: [u32; 4] = [0; 4];
347	347		let mut fc: [u32; 4] = [0; 4];
348		-	fa[0] = 0;
349		-	fb[0] = 1;
350		-	i = 2;
	348	+	set fa[0] = 0;
	349	+	set fb[0] = 1;
	350	+	set i = 2;
351	351		while i <= 47 {
352	352		bnAdd(&mut fc[..], &fa[..], &fb[..]);
353	353		bnCopy(&mut fa[..], &fb[..]);
354	354		bnCopy(&mut fb[..], &fc[..]);
355		-	i += 1;
	355	+	set i += 1;
356	356		}
357	357		bnAdd(&mut fc[..], &fa[..], &fb[..]);
358	358		assert bnCmp(&fc[..], &fibB[..]) == 0;
359	359
360	360		return 0;

372	372		assert bnCmp(&b[..], &a[..]) == 1;
373	373		assert bnCmp(&a[..], &a[..]) == 0;
374	374
375	375		bnZero(&mut a[..]);
376	376		bnZero(&mut b[..]);
377		-	a[3] = 1;
378		-	b[0] = 0xFFFFFFFF;
379		-	b[1] = 0xFFFFFFFF;
380		-	b[2] = 0xFFFFFFFF;
	377	+	set a[3] = 1;
	378	+	set b[0] = 0xFFFFFFFF;
	379	+	set b[1] = 0xFFFFFFFF;
	380	+	set b[2] = 0xFFFFFFFF;
381	381		assert bnCmp(&a[..], &b[..]) == 1;
382	382
383	383		return 0;
384	384		}
385	385

test/tests/prog.binsearch.rad +2 -2

        let val: i32 = data[mid as u32];

        if val == target {
            return mid as u32;
        } else if val < target {
            lo = mid + 1;
            set lo = mid + 1;
        } else {
            hi = mid - 1;
            set hi = mid - 1;
        }
    }
    return nil;
}


test/tests/prog.bubblesort.rad +7 -7

        let mut swapped: bool = false;
        let mut i: u32 = 0;
        while i < n - 1 {
            if data[i] > data[i + 1] {
                let tmp: i32 = data[i];
                data[i] = data[i + 1];
                data[i + 1] = tmp;
                swapped = true;
                set data[i] = data[i + 1];
                set data[i + 1] = tmp;
                set swapped = true;
            }
            i += 1;
            set i += 1;
        }
        if not swapped {
            // Already sorted, early exit.
            return;
        }
        n -= 1;
        set n -= 1;
    }
}

/// Verify the array is sorted in ascending order.
fn isSorted(data: *[i32]) -> bool {

        if let p = prev {
            if p > val {
                return false;
            }
        }
        prev = val;
        set prev = val;
    }
    return true;
}

/// Compute the sum of all elements.
fn sum(data: *[i32]) -> i32 {
    let mut total: i32 = 0;
    for val in data {
        total += val;
        set total += val;
    }
    return total;
}

/// Verify specific positions in the sorted output.

test/tests/prog.cordic.rad +13 -13

38	38		while i < ITERATIONS {
39	39		let dx: i32 = x >> i as i32;
40	40		let dy: i32 = y >> i as i32;
41	41
42	42		if z >= 0 {
43		-	x -= dy;
44		-	y += dx;
45		-	z -= atanTable[i];
	43	+	set x -= dy;
	44	+	set y += dx;
	45	+	set z -= atanTable[i];
46	46		} else {
47		-	x += dy;
48		-	y -= dx;
49		-	z += atanTable[i];
	47	+	set x += dy;
	48	+	set y -= dx;
	49	+	set z += atanTable[i];
50	50		}
51		-	i += 1;
	51	+	set i += 1;
52	52		}
53	53
54	54		return CosSin { cos: x, sin: y };
55	55		}
56	56

58	58		fn cosSin(angle: i32, atanTable: *[i32]) -> CosSin {
59	59		let mut a: i32 = angle;
60	60
61	61		// Reduce to [-pi, pi].
62	62		while a > PI {
63		-	a -= 2 * PI;
	63	+	set a -= 2 * PI;
64	64		}
65	65		while a < 0 - PI {
66		-	a += 2 * PI;
	66	+	set a += 2 * PI;
67	67		}
68	68
69	69		// If in [pi/2, pi], use cos(a) = -cos(pi-a), sin(a) = sin(pi-a).
70	70		if a > HALF_PI {
71	71		let r: CosSin = cordicRotate(PI - a, atanTable);

92	92		fn fpmul(a: i32, b: i32) -> i32 {
93	93		// Determine sign and work with magnitudes.
94	94		let neg: bool = (a < 0) <> (b < 0);
95	95		let mut ua: u32 = a as u32;
96	96		if a < 0 {
97		-	ua = (0 - a) as u32;
	97	+	set ua = (0 - a) as u32;
98	98		}
99	99		let mut ub: u32 = b as u32;
100	100		if b < 0 {
101		-	ub = (0 - b) as u32;
	101	+	set ub = (0 - b) as u32;
102	102		}
103	103
104	104		// Split into 16-bit halves: ua = ah:al, ub = bh:bl.
105	105		let al: u32 = ua & 0xFFFF;
106	106		let ah: u32 = ua >> 16;

        let sum: i32 = sin2 + cos2;
        let err: i32 = abs(sum - SCALE);

        // Allow ~2% error due to fixed-point precision.
        assert err <= 1311;
        i += step;
        set i += step;
    }
    return 0;
}

/// Test symmetry: sin(-x) = -sin(x), cos(-x) = cos(x).


        // cos(-x) should equal cos(x).
        assert abs(rPos.cos - rNeg.cos) <= 655;
        // sin(-x) should equal -sin(x).
        assert abs(rPos.sin + rNeg.sin) <= 655;
        i += 1;
        set i += 1;
    }
    return 0;
}

/// Test specific known value: cos(pi/3) = 0.5, sin(pi/3) = 0.866.

test/tests/prog.crc32.rad +9 -9

    while i < 256 {
        let mut crc: u32 = i;
        let mut j: u32 = 0;
        while j < 8 {
            if crc & 1 == 1 {
                crc = (crc >> 1) ^ 0xEDB88320;
                set crc = (crc >> 1) ^ 0xEDB88320;
            } else {
                crc >>= 1;
                set crc >>= 1;
            }
            j += 1;
            set j += 1;
        }
        table[i] = crc;
        i += 1;
        set table[i] = crc;
        set i += 1;
    }
}

/// Compute CRC-32 of a byte slice.
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;
        crc = (crc >> 8) ^ table[index];
        i += 1;
        set crc = (crc >> 8) ^ table[index];
        set i += 1;
    }
    return crc ^ 0xFFFFFFFF;
}

/// Test the lookup table has been built correctly.

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 {
        buf[i] = i as u8;
        i += 1;
        set buf[i] = i as u8;
        set i += 1;
    }
    let crcFull = crc32(table, &buf[..]);

    // CRC should be non-zero and deterministic.
    assert crcFull <> 0;

test/tests/prog.dijkstra.rad +39 -39

    heapSize: u32,
}

fn heapSwap(g: *mut Graph, i: u32, j: u32) {
    let tmp: HeapEntry = g.heap[i];
    g.heap[i] = g.heap[j];
    g.heap[j] = tmp;
    set g.heap[i] = g.heap[j];
    set g.heap[j] = tmp;
}

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);
            i = parent;
            set i = parent;
        } else {
            return;
        }
    }
}

        let left: u32 = 2 * i + 1;
        let right: u32 = 2 * i + 2;
        let mut smallest: u32 = i;

        if left < g.heapSize and g.heap[left].dist < g.heap[smallest].dist {
            smallest = left;
            set smallest = left;
        }
        if right < g.heapSize and g.heap[right].dist < g.heap[smallest].dist {
            smallest = right;
            set smallest = right;
        }
        if smallest == i {
            return;
        }
        heapSwap(g, i, smallest);
        i = smallest;
        set i = smallest;
    }
}

fn heapPush(g: *mut Graph, dist: u32, node: u32) {
    g.heap[g.heapSize] = HeapEntry { dist, node };
    g.heapSize += 1;
    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 {
    if g.heapSize == 0 {
        return nil;
    }
    let result: HeapEntry = g.heap[0];
    g.heapSize -= 1;
    g.heap[0] = g.heap[g.heapSize];
    set g.heapSize -= 1;
    set g.heap[0] = g.heap[g.heapSize];
    if g.heapSize > 0 {
        siftDown(g, 0);
    }
    return result;
}

fn addEdge(g: *mut Graph, from: u32, to: u32, weight: u32) {
    g.adj[from][to] = weight;
    set g.adj[from][to] = weight;
}

fn addBidiEdge(g: *mut Graph, from: u32, to: u32, weight: u32) {
    g.adj[from][to] = weight;
    g.adj[to][from] = weight;
    set g.adj[from][to] = weight;
    set g.adj[to][from] = weight;
}

fn resetGraph(g: *mut Graph, n: u32) {
    g.numNodes = n;
    set g.numNodes = n;
    let mut i: u32 = 0;
    while i < MAX_NODES {
        let mut j: u32 = 0;
        while j < MAX_NODES {
            g.adj[i][j] = INF;
            j += 1;
            set g.adj[i][j] = INF;
            set j += 1;
        }
        g.dist[i] = INF;
        g.prev[i] = -1;
        g.visited[i] = false;
        i += 1;
        set g.dist[i] = INF;
        set g.prev[i] = -1;
        set g.visited[i] = false;
        set i += 1;
    }
    g.heapSize = 0;
    set g.heapSize = 0;
}

/// Get the predecessor as an optional; -1 means no predecessor.
fn getPrev(g: *Graph, node: u32) -> ?u32 {
    let p = g.prev[node];

    }
    return p as u32;
}

fn dijkstra(g: *mut Graph, source: u32) {
    g.dist[source] = 0;
    set g.dist[source] = 0;
    heapPush(g, 0, source);

    while let entry = heapPop(g) {
        let u: u32 = entry.node;

        if g.visited[u] {
            continue;
        }
        g.visited[u] = true;
        set g.visited[u] = true;

        let mut v: u32 = 0;
        while v < g.numNodes {
            if g.adj[u][v] <> INF and not g.visited[v] {
                let newDist: u32 = g.dist[u] + g.adj[u][v];
                if newDist < g.dist[v] {
                    g.dist[v] = newDist;
                    g.prev[v] = u as i32;
                    set g.dist[v] = newDist;
                    set g.prev[v] = u as i32;
                    heapPush(g, newDist, v);
                }
            }
            v += 1;
            set v += 1;
        }
    }
}

/// Reconstruct the shortest path from source to target.
fn reconstructPath(g: *Graph, target: u32, path: *mut [u32]) -> u32 {
    let mut len: u32 = 0;

    path[len] = target;
    len += 1;
    set path[len] = target;
    set len += 1;

    let mut cur: ?u32 = getPrev(g, target);
    while let node = cur {
        path[len] = node;
        len += 1;
        cur = getPrev(g, node);
        set path[len] = node;
        set len += 1;
        set cur = getPrev(g, node);
    }

    // Reverse the path.
    let mut a: u32 = 0;
    let mut b: u32 = len - 1;
    while a < b {
        let tmp: u32 = path[a];
        path[a] = path[b];
        path[b] = tmp;
        a += 1;
        b -= 1;
        set path[a] = path[b];
        set path[b] = tmp;
        set a += 1;
        set b -= 1;
    }
    return len;
}

fn testLinear(g: *mut Graph) -> i32 {

244	244		let mut j: u32 = 0;
245	245		while j < 8 {
246	246		if i <> j {
247	247		let mut diff: u32 = j - i;
248	248		if i > j {
249		-	diff = i - j;
	249	+	set diff = i - j;
250	250		}
251	251		addEdge(g, i, j, diff * 3 + 1);
252	252		}
253		-	j += 1;
	253	+	set j += 1;
254	254		}
255		-	i += 1;
	255	+	set i += 1;
256	256		}
257	257
258	258		dijkstra(g, 0);
259	259
260	260		let mut k: u32 = 1;
261	261		while k < 8 {
262	262		let expected: u32 = k * 3 + 1;
263	263		if g.dist[k] <> expected {
264	264		return k as i32;
265	265		}
266		-	k += 1;
	266	+	set k += 1;
267	267		}
268	268
269	269		return 0;
270	270		}
271	271

test/tests/prog.eval.rad +4 -4

}

/// Allocate a new node, returning its index.
fn newNode(pool: *mut Pool, expr: Expr) -> u32 {
    let idx = pool.count;
    pool.nodes[idx] = expr;
    pool.count += 1;
    set pool.nodes[idx] = expr;
    set pool.count += 1;
    return idx;
}

/// Convenience constructors.
fn num(pool: *mut Pool, n: i32) -> u32 {

    }
}

/// Reset the node pool.
fn reset(pool: *mut Pool) {
    pool.count = 0;
    set pool.count = 0;
}

/// Test 1: Simple addition: 3 + 4 = 7
fn testSimpleAdd(pool: *mut Pool) -> i32 {
    reset(pool);

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 {
        root = add(pool, root, num(pool, v));
        set root = add(pool, root, num(pool, v));
    }
    assert try! eval(&pool.nodes[..], root) == 36;
    assert countNodes(&pool.nodes[..], root) == 15;
    return 0;
}

test/tests/prog.hanoi.rad +7 -7

}

/// Record a move.
fn recordMove(ml: *mut MoveLog, disk: u32, from: u32, to: u32) {
    if ml.count < MAX_MOVES {
        ml.moves[ml.count] = Move { disk, from, to };
        ml.count += 1;
        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.

        // Check that the top disk is larger than the one being placed.
        if pegs.stacks[peg][t - 1] < disk {
            return false;
        }
    }
    pegs.stacks[peg][t] = disk;
    pegs.top[peg] = t + 1;
    set pegs.stacks[peg][t] = disk;
    set pegs.top[peg] = t + 1;
    return true;
}

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;
    }
    pegs.top[peg] = t - 1;
    set pegs.top[peg] = t - 1;
    return pegs.stacks[peg][t - 1];
}

/// Simulate the peg state to verify correctness.
/// Replay all moves and check:

    while d >= 1 {
        assert pegPush(&mut pegs, 0, d);
        if d == 0 {
            break;
        }
        d -= 1;
        set d -= 1;
    }

    // Replay all moves.
    let mut i: u32 = 0;
    while i < ml.count {
        let m = ml.moves[i];
        let disk = pegPop(&mut pegs, m.from);
        assert disk == m.disk;
        assert pegPush(&mut pegs, m.to, disk);
        i += 1;
        set i += 1;
    }

    // All disks should be on peg 1.
    assert pegs.top[0] == 0;
    assert pegs.top[1] == NUM_DISKS;

test/tests/prog.huffman.rad +39 -39

    bitCount: u32,
}

fn newLeaf(s: *mut HuffState, freq: u32, symbol: u32) -> u32 {
    let idx: u32 = s.nodeCount;
    s.nodes[idx] = HNode { freq, kind: HNodeKind::Leaf(symbol), left: NIL, right: NIL };
    s.nodeCount += 1;
    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 {
    let idx: u32 = s.nodeCount;
    s.nodes[idx] = HNode { freq, kind: HNodeKind::Interior, left, right };
    s.nodeCount += 1;
    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 {

    }
}

fn heapSwap(s: *mut HuffState, i: u32, j: u32) {
    let tmp: u32 = s.heap[i];
    s.heap[i] = s.heap[j];
    s.heap[j] = tmp;
    set s.heap[i] = s.heap[j];
    set s.heap[j] = tmp;
}

fn heapFreq(s: *HuffState, i: u32) -> u32 {
    return s.nodes[s.heap[i]].freq;
}

    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);
            i = parent;
            set i = parent;
        } else {
            return;
        }
    }
}

        let left: u32 = 2 * i + 1;
        let right: u32 = 2 * i + 2;
        let mut smallest: u32 = i;

        if left < s.heapSize and heapFreq(s, left) < heapFreq(s, smallest) {
            smallest = left;
            set smallest = left;
        }
        if right < s.heapSize and heapFreq(s, right) < heapFreq(s, smallest) {
            smallest = right;
            set smallest = right;
        }
        if smallest == i {
            return;
        }
        heapSwap(s, i, smallest);
        i = smallest;
        set i = smallest;
    }
}

fn heapPush(s: *mut HuffState, nodeIdx: u32) {
    s.heap[s.heapSize] = nodeIdx;
    s.heapSize += 1;
    set s.heap[s.heapSize] = nodeIdx;
    set s.heapSize += 1;
    siftUp(s, s.heapSize - 1);
}

fn heapPop(s: *mut HuffState) -> u32 {
    let result: u32 = s.heap[0];
    s.heapSize -= 1;
    s.heap[0] = s.heap[s.heapSize];
    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 {
    s.nodeCount = 0;
    s.heapSize = 0;
    set s.nodeCount = 0;
    set s.heapSize = 0;

    for freq, sym in freqs {
        if freq > 0 {
            let idx: u32 = newLeaf(s, freq, sym);
            heapPush(s, idx);

}

fn generateCodes(s: *mut HuffState, nodeIdx: u32, code: u32, depth: u32) {
    match s.nodes[nodeIdx].kind {
        case HNodeKind::Leaf(sym) => {
            s.codeBits[sym] = code;
            s.codeLen[sym] = depth;
            set s.codeBits[sym] = code;
            set s.codeLen[sym] = depth;
        }
        case HNodeKind::Interior => {
            if s.nodes[nodeIdx].left <> NIL {
                generateCodes(s, s.nodes[nodeIdx].left, code << 1, depth + 1);
            }


fn writeBit(s: *mut HuffState, bit: u32) {
    let byteIdx: u32 = s.bitCount / 8;
    let bitIdx: u32 = 7 - (s.bitCount % 8);
    if bit == 1 {
        s.bitstream[byteIdx] |= (1 as u8 << bitIdx as u8);
        set s.bitstream[byteIdx] |= (1 as u8 << bitIdx as u8);
    }
    s.bitCount += 1;
    set s.bitCount += 1;
}

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]) {
    s.bitCount = 0;
    set s.bitCount = 0;
    let mut i: u32 = 0;
    while i < MAX_BITS {
        s.bitstream[i] = 0;
        i += 1;
        set s.bitstream[i] = 0;
        set i += 1;
    }

    for sym in msg {
        let bits: u32 = s.codeBits[sym];
        let len: u32 = s.codeLen[sym];
        let mut b: u32 = 0;
        while b < len {
            let bit: u32 = (bits >> (len - 1 - b)) & 1;
            writeBit(s, bit);
            b += 1;
            set b += 1;
        }
    }
}

fn decode(s: *HuffState, root: u32, numSymbols: u32, out: *mut [u32]) -> u32 {

    while decoded < numSymbols {
        let mut cur: u32 = root;
        // Walk the tree until we find a leaf.
        while nodeSymbol(&s.nodes[cur]) == nil {
            let bit: u32 = readBit(s, bitPos);
            bitPos += 1;
            set bitPos += 1;
            if bit == 0 {
                cur = s.nodes[cur].left;
                set cur = s.nodes[cur].left;
            } else {
                cur = s.nodes[cur].right;
                set cur = s.nodes[cur].right;
            }
        }
        let sym = nodeSymbol(&s.nodes[cur]) else {
            return decoded;
        };
        out[decoded] = sym;
        decoded += 1;
        set out[decoded] = sym;
        set decoded += 1;
    }
    return decoded;
}

fn resetCodes(s: *mut HuffState) {
    let mut i: u32 = 0;
    while i < MAX_SYMBOLS {
        s.codeBits[i] = 0;
        s.codeLen[i] = 0;
        i += 1;
        set s.codeBits[i] = 0;
        set s.codeLen[i] = 0;
        set i += 1;
    }
}

fn testBasic(s: *mut HuffState) -> i32 {
    let freqs: [u32; 5] = [5, 9, 12, 13, 16];


    // All symbols should have non-zero code lengths.
    let mut i: u32 = 0;
    while i < 5 {
        assert s.codeLen[i] <> 0;
        i += 1;
        set i += 1;
    }

    // No two symbols at the same depth should have the same code.
    let mut a: u32 = 0;
    while a < 5 {
        let mut b: u32 = a + 1;
        while b < 5 {
            if s.codeLen[a] == s.codeLen[b] {
                assert s.codeBits[a] <> s.codeBits[b];
            }
            b += 1;
            set b += 1;
        }
        a += 1;
        set a += 1;
    }

    return 0;
}


    let mut shortestLen: u32 = 100;
    let mut shortestSym: u32 = 0;
    let mut i: u32 = 0;
    while i < 6 {
        if s.codeLen[i] > 0 and s.codeLen[i] < shortestLen {
            shortestLen = s.codeLen[i];
            shortestSym = i;
            set shortestLen = s.codeLen[i];
            set shortestSym = i;
        }
        i += 1;
        set i += 1;
    }
    assert shortestSym == 0;

    let msg: [u32; 12] = [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 2];
    encode(s, &msg[..]);


    // All 8 symbols should have code length 3 (8 = 2^3).
    let mut i: u32 = 0;
    while i < 8 {
        assert s.codeLen[i] == 3;
        i += 1;
        set i += 1;
    }

    let msg: [u32; 8] = [0, 1, 2, 3, 4, 5, 6, 7];
    encode(s, &msg[..]);


test/tests/prog.hybridsort.rad +12 -12

//! both produce identical sorted output.

/// Copy `src` into `dst`.
fn copy(dst: *mut [i32], src: *[i32]) {
    for val, i in src {
        dst[i] = val;
        set dst[i] = val;
    }
}

/// Insertion sort on the given array.
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 {
            data[(j + 1) as u32] = data[j as u32];
            j -= 1;
            set data[(j + 1) as u32] = data[j as u32];
            set j -= 1;
        }
        data[(j + 1) as u32] = key;
        i += 1;
        set data[(j + 1) as u32] = key;
        set i += 1;
    }
}

/// Selection sort on the given array.
fn selectionSort(data: *mut [i32]) {

    while i < data.len - 1 {
        let mut minIdx: u32 = i;
        let mut j: u32 = i + 1;
        while j < data.len {
            if data[j] < data[minIdx] {
                minIdx = j;
                set minIdx = j;
            }
            j += 1;
            set j += 1;
        }
        if minIdx <> i {
            let tmp = data[i];
            data[i] = data[minIdx];
            data[minIdx] = tmp;
            set data[i] = data[minIdx];
            set data[minIdx] = tmp;
        }
        i += 1;
        set i += 1;
    }
}

/// Check that an array is sorted in ascending order.
fn isSorted(data: *[i32]) -> bool {

        if let p = prev {
            if p > val {
                return false;
            }
        }
        prev = val;
        set prev = val;
    }
    return true;
}

/// Compute sum of all elements.
fn sum(data: *[i32]) -> i32 {
    let mut total: i32 = 0;
    for val in data {
        total += val;
        set total += val;
    }
    return total;
}

/// Compare two arrays element by element.

test/tests/prog.linkedlist.rad +20 -20

}

/// Allocate a node from the pool. Returns its index.
fn alloc(list: *mut List, value: i32) -> u32 {
    let idx = list.free;
    list.free += 1;
    list.pool[idx] = Node { value, next: nil };
    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) {
    let idx = alloc(list, value);
    list.pool[idx].next = list.head;
    list.head = idx;
    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 {
    let idx = list.head else {
        return nil;
    };
    let value = list.pool[idx].value;
    list.head = list.pool[idx].next;
    set list.head = list.pool[idx].next;
    return value;
}

/// Get the length of the list.
fn length(list: *List) -> u32 {
    let mut count: u32 = 0;
    let mut cur = list.head;
    while let idx = cur {
        count += 1;
        cur = list.pool[idx].next;
        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.

    let mut cur = list.head;
    while let idx = cur {
        if list.pool[idx].value == value {
            return idx;
        }
        cur = list.pool[idx].next;
        set cur = list.pool[idx].next;
    }
    return nil;
}

/// Get the value at a given index (0-based from head).

    let mut i: u32 = 0;
    while let idx = cur {
        if i == index {
            return list.pool[idx].value;
        }
        cur = list.pool[idx].next;
        i += 1;
        set cur = list.pool[idx].next;
        set i += 1;
    }
    return nil;
}

/// Reverse the linked list in-place.
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;
        list.pool[idx].next = prev;
        prev = idx;
        cur = next;
        set list.pool[idx].next = prev;
        set prev = idx;
        set cur = next;
    }
    list.head = prev;
    set list.head = prev;
}

/// Compute the sum of all values in the list.
fn sum(list: *List) -> i32 {
    let mut total: i32 = 0;
    let mut cur = list.head;
    while let idx = cur {
        total += list.pool[idx].value;
        cur = list.pool[idx].next;
        set total += list.pool[idx].value;
        set cur = list.pool[idx].next;
    }
    return total;
}

/// Reset the list to empty.
fn reset(list: *mut List) {
    list.head = nil;
    list.free = 0;
    set list.head = nil;
    set list.free = 0;
}

/// Test basic push and length.
fn testPushLength(list: *mut List) -> i32 {
    push(list, 10);

200	200
201	201		// Push 32 elements.
202	202		let mut i: u32 = 0;
203	203		while i < 32 {
204	204		push(list, i as i32 * 3);
205		-	i += 1;
	205	+	set i += 1;
206	206		}
207	207
208	208		assert length(list) == 32;
209	209
210	210		// Sum should be 3 * (0 + 1 + ... + 31) = 3 * 496 = 1488

        let v = pop(list) else {
            return 6;
        };
        let expected = j as i32 * 3;
        assert v == expected;
        j += 1;
        set j += 1;
    }

    assert length(list) == 0;

    // Pop from empty list should return nil.

test/tests/prog.lzw.rad +38 -38

    decLen: u32,
    temp: *mut [u8],
}

fn initEncDict(s: *mut LzwState) {
    s.encDictSize = INIT_DICT;
    set s.encDictSize = INIT_DICT;
    let mut i: u32 = 0;
    while i < 256 {
        s.encDict[i] = DictEntry { prefix: 0xFFFF, suffix: i as u8 };
        i += 1;
        set s.encDict[i] = DictEntry { prefix: 0xFFFF, suffix: i as u8 };
        set i += 1;
    }
}

fn initDecDict(s: *mut LzwState) {
    s.decDictSize = INIT_DICT;
    set s.decDictSize = INIT_DICT;
    let mut i: u32 = 0;
    while i < 256 {
        s.decDict[i] = DictEntry { prefix: 0xFFFF, suffix: i as u8 };
        i += 1;
        set s.decDict[i] = DictEntry { prefix: 0xFFFF, suffix: i as u8 };
        set i += 1;
    }
}

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;
        }
        i += 1;
        set i += 1;
    }
    return 0xFFFFFFFF;
}

fn dictAdd(s: *mut LzwState, prefix: u32, suffix: u8) {
    if s.encDictSize < MAX_DICT {
        s.encDict[s.encDictSize] = DictEntry { prefix, suffix };
        s.encDictSize += 1;
        set s.encDict[s.encDictSize] = DictEntry { prefix, suffix };
        set s.encDictSize += 1;
    }
}

fn emitCode(s: *mut LzwState, code: u32) {
    s.encoded[s.encLen] = code;
    s.encLen += 1;
    set s.encoded[s.encLen] = code;
    set s.encLen += 1;
}

fn encode(s: *mut LzwState, data: *[u8]) {
    initEncDict(s);
    s.encLen = 0;
    set s.encLen = 0;

    if data.len == 0 {
        emitCode(s, EOI_CODE);
        return;
    }


    while i < data.len {
        let c: u8 = data[i];
        let wc: u32 = dictLookup(s, w, c);
        if wc <> 0xFFFFFFFF {
            w = wc;
            set w = wc;
        } else {
            emitCode(s, w);
            dictAdd(s, w, c);
            w = c as u32;
            set w = c as u32;
        }
        i += 1;
        set i += 1;
    }
    emitCode(s, w);
    emitCode(s, EOI_CODE);
}

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 {
        s.temp[len] = s.decDict[c].suffix;
        len += 1;
        c = s.decDict[c].prefix;
        set s.temp[len] = s.decDict[c].suffix;
        set len += 1;
        set c = s.decDict[c].prefix;
    }
    let mut a: u32 = 0;
    let mut b: u32 = len - 1;
    while a < b {
        let tmp: u8 = s.temp[a];
        s.temp[a] = s.temp[b];
        s.temp[b] = tmp;
        a += 1;
        b -= 1;
        set s.temp[a] = s.temp[b];
        set s.temp[b] = tmp;
        set a += 1;
        set b -= 1;
    }
    return len;
}

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 {
        c = s.decDict[c].prefix;
        set c = s.decDict[c].prefix;
    }
    return s.decDict[c].suffix;
}

fn decDictAdd(s: *mut LzwState, prefix: u32, suffix: u8) {
    if s.decDictSize < MAX_DICT {
        s.decDict[s.decDictSize] = DictEntry { prefix, suffix };
        s.decDictSize += 1;
        set s.decDict[s.decDictSize] = DictEntry { prefix, suffix };
        set s.decDictSize += 1;
    }
}

fn outputByte(s: *mut LzwState, b: u8) {
    s.decoded[s.decLen] = b;
    s.decLen += 1;
    set s.decoded[s.decLen] = b;
    set s.decLen += 1;
}

fn decode(s: *mut LzwState) {
    initDecDict(s);
    s.decLen = 0;
    set s.decLen = 0;

    if s.encLen == 0 {
        return;
    }

    let mut pos: u32 = 0;
    let mut code: u32 = s.encoded[pos];
    pos += 1;
    set pos += 1;

    if code == EOI_CODE {
        return;
    }

    outputByte(s, code as u8);
    let mut prevCode: u32 = code;

    while pos < s.encLen {
        code = s.encoded[pos];
        pos += 1;
        set code = s.encoded[pos];
        set pos += 1;

        if code == EOI_CODE {
            return;
        }

        if code < s.decDictSize {
            let len: u32 = decodeString(s, code);
            let mut i: u32 = 0;
            while i < len {
                outputByte(s, s.temp[i]);
                i += 1;
                set i += 1;
            }
            decDictAdd(s, prevCode, s.temp[0]);
        } else {
            let fb: u8 = firstByte(s, prevCode);
            let len: u32 = decodeString(s, prevCode);
            let mut i: u32 = 0;
            while i < len {
                outputByte(s, s.temp[i]);
                i += 1;
                set i += 1;
            }
            outputByte(s, fb);
            decDictAdd(s, prevCode, fb);
        }
        prevCode = code;
        set prevCode = code;
    }
}

fn testSimple(s: *mut LzwState) -> i32 {
    let data: *[u8] = "ABABABABAB";

    decode(s);
    assert s.decLen == 10;
    let mut i: u32 = 0;
    while i < 10 {
        assert s.decoded[i] == data[i];
        i += 1;
        set i += 1;
    }
    return 0;
}

fn testDistinct(s: *mut LzwState) -> i32 {

    decode(s);
    assert s.decLen == 16;
    let mut i: u32 = 0;
    while i < 16 {
        assert s.decoded[i] == data[i];
        i += 1;
        set i += 1;
    }
    return 0;
}

fn testRepetitive(s: *mut LzwState) -> i32 {

    decode(s);
    assert s.decLen == 64;
    let mut i: u32 = 0;
    while i < 64 {
        assert s.decoded[i] == 65;
        i += 1;
        set i += 1;
    }
    return 0;
}

fn testMixed(s: *mut LzwState) -> i32 {

    decode(s);
    assert s.decLen == 24;
    let mut i: u32 = 0;
    while i < 24 {
        assert s.decoded[i] == data[i];
        i += 1;
        set i += 1;
    }

    assert s.encLen - 1 < 24;

    return 0;

test/tests/prog.matmul.rad +12 -12

        let mut j: u32 = 0;
        while j < N {
            let mut sum: i32 = 0;
            let mut k: u32 = 0;
            while k < N {
                sum += a.rows[i][k] * b.rows[k][j];
                k += 1;
                set sum += a.rows[i][k] * b.rows[k][j];
                set k += 1;
            }
            c.rows[i][j] = sum;
            j += 1;
            set c.rows[i][j] = sum;
            set j += 1;
        }
        i += 1;
        set i += 1;
    }
}

/// Verify c matches expected.
fn verifyResult(c: *Mat4, expected: *Mat4) -> i32 {

        let mut j: u32 = 0;
        while j < N {
            if c.rows[i][j] <> expected.rows[i][j] {
                return (i * N + j) as i32 + 1;
            }
            j += 1;
            set j += 1;
        }
        i += 1;
        set i += 1;
    }
    return 0;
}

/// Compute the trace (sum of diagonal) of a matrix.
fn trace(m: *Mat4) -> i32 {
    let mut sum: i32 = 0;
    let mut i: u32 = 0;
    while i < N {
        sum += m.rows[i][i];
        i += 1;
        set sum += m.rows[i][i];
        set i += 1;
    }
    return sum;
}

/// Zero out a matrix.
fn zero(m: *mut Mat4) {
    let mut i: u32 = 0;
    while i < N {
        let mut j: u32 = 0;
        while j < N {
            m.rows[i][j] = 0;
            j += 1;
            set m.rows[i][j] = 0;
            set j += 1;
        }
        i += 1;
        set i += 1;
    }
}

/// Multiply matrices multiple times to test repeated computation.
fn testRepeatedMultiply(c: *mut Mat4, a: *Mat4, b: *Mat4) -> i32 {

test/tests/prog.mersenne.rad +41 -41

    mt: *mut [u32],
    mti: u32,
}

fn mtInit(s: *mut MtState, seed: u32) {
    s.mt[0] = seed;
    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);


28	28		let ll: u32 = clo * lo;
29	29		let lh: u32 = clo * hi;
30	30		let hl: u32 = chi * lo;
31	31
32	32		let result: u32 = ll + ((lh + hl) << 16) + i;
33		-	s.mt[i] = result;
34		-	i += 1;
	33	+	set s.mt[i] = result;
	34	+	set i += 1;
35	35		}
36		-	s.mti = N;
	36	+	set s.mti = N;
37	37		}
38	38
39	39		fn generateNumbers(s: *mut MtState) {
40	40		let mut i: u32 = 0;
41	41
42	42		while i < N - M {
43	43		let y: u32 = (s.mt[i] & UPPER_MASK) \| (s.mt[i + 1] & LOWER_MASK);
44	44		let mut mag: u32 = 0;
45	45		if y & 1 == 1 {
46		-	mag = MATRIX_A;
	46	+	set mag = MATRIX_A;
47	47		}
48		-	s.mt[i] = s.mt[i + M] ^ (y >> 1) ^ mag;
49		-	i += 1;
	48	+	set s.mt[i] = s.mt[i + M] ^ (y >> 1) ^ mag;
	49	+	set i += 1;
50	50		}
51	51
52	52		while i < N - 1 {
53	53		let y: u32 = (s.mt[i] & UPPER_MASK) \| (s.mt[i + 1] & LOWER_MASK);
54	54		let mut mag: u32 = 0;
55	55		if y & 1 == 1 {
56		-	mag = MATRIX_A;
	56	+	set mag = MATRIX_A;
57	57		}
58		-	s.mt[i] = s.mt[i + M - N] ^ (y >> 1) ^ mag;
59		-	i += 1;
	58	+	set s.mt[i] = s.mt[i + M - N] ^ (y >> 1) ^ mag;
	59	+	set i += 1;
60	60		}
61	61
62	62		let y: u32 = (s.mt[N - 1] & UPPER_MASK) \| (s.mt[0] & LOWER_MASK);
63	63		let mut mag: u32 = 0;
64	64		if y & 1 == 1 {
65		-	mag = MATRIX_A;
	65	+	set mag = MATRIX_A;
66	66		}
67		-	s.mt[N - 1] = s.mt[M - 1] ^ (y >> 1) ^ mag;
	67	+	set s.mt[N - 1] = s.mt[M - 1] ^ (y >> 1) ^ mag;
68	68
69		-	s.mti = 0;
	69	+	set s.mti = 0;
70	70		}
71	71
72	72		fn mtNext(s: *mut MtState) -> u32 {
73	73		if s.mti >= N {
74	74		generateNumbers(s);
75	75		}
76	76
77	77		let mut y: u32 = s.mt[s.mti];
78		-	s.mti += 1;
	78	+	set s.mti += 1;
79	79
80		-	y ^= (y >> 11);
81		-	y ^= ((y << 7) & 0x9D2C5680);
82		-	y ^= ((y << 15) & 0xEFC60000);
83		-	y ^= (y >> 18);
	80	+	set y ^= (y >> 11);
	81	+	set y ^= ((y << 7) & 0x9D2C5680);
	82	+	set y ^= ((y << 15) & 0xEFC60000);
	83	+	set y ^= (y >> 18);
84	84
85	85		return y;
86	86		}
87	87
88	88		fn testKnownSequence(s: *mut MtState) -> i32 {

110	110		mtInit(s, 42);
111	111
112	112		let mut first: [u32; 10] = [0; 10];
113	113		let mut i: u32 = 0;
114	114		while i < 10 {
115		-	first[i] = mtNext(s);
116		-	i += 1;
	115	+	set first[i] = mtNext(s);
	116	+	set i += 1;
117	117		}
118	118
119	119		mtInit(s, 42);
120	120
121		-	i = 0;
	121	+	set i = 0;
122	122		while i < 10 {
123	123		let v: u32 = mtNext(s);
124	124		if v <> first[i] { return i as i32 + 1; }
125		-	i += 1;
	125	+	set i += 1;
126	126		}
127	127
128	128		return 0;
129	129		}
130	130


    let mut i: u32 = 0;
    while i < NUM_SAMPLES {
        let val: u32 = mtNext(s);
        let bin: u32 = val >> 28;
        bins[bin] += 1;
        i += 1;
        set bins[bin] += 1;
        set i += 1;
    }

    let mut chi2Scaled: u32 = 0;
    let mut b: u32 = 0;
    while b < NUM_BINS {
        let obs: i32 = bins[b] as i32;
        let exp: i32 = EXPECTED as i32;
        let diff: i32 = obs - exp;
        chi2Scaled += (diff * diff) as u32;
        b += 1;
        set chi2Scaled += (diff * diff) as u32;
        set b += 1;
    }

    assert chi2Scaled <= 5000;

    b = 0;
    set b = 0;
    while b < NUM_BINS {
        assert bins[b] <> 0;
        b += 1;
        set b += 1;
    }

    b = 0;
    set b = 0;
    while b < NUM_BINS {
        assert bins[b] <= NUM_SAMPLES / 2;
        b += 1;
        set b += 1;
    }

    return 0;
}


    mtInit(s, 7);

    let mut last: u32 = 0;
    let mut i: u32 = 0;
    while i < 700 {
        last = mtNext(s);
        i += 1;
        set last = mtNext(s);
        set i += 1;
    }

    mtInit(s, 7);
    let mut last2: u32 = 0;
    i = 0;
    set i = 0;
    while i < 700 {
        last2 = mtNext(s);
        i += 1;
        set last2 = mtNext(s);
        set i += 1;
    }

    assert last == last2;

    let mut more: u32 = 0;
    i = 0;
    set i = 0;
    while i < 700 {
        more = mtNext(s);
        i += 1;
        set more = mtNext(s);
        set i += 1;
    }
    assert more <> 0;

    return 0;
}

    let mut andAll: u32 = 0xFFFFFFFF;

    let mut i: u32 = 0;
    while i < 200 {
        let v: u32 = mtNext(s);
        orAll |= v;
        andAll &= v;
        i += 1;
        set orAll |= v;
        set andAll &= v;
        set i += 1;
    }

    assert orAll == 0xFFFFFFFF;
    assert andAll <> 0xFFFFFFFF;
    assert andAll == 0;

test/tests/prog.nqueens.rad +15 -15

        let rowDiff: i32 = row as i32 - i as i32;
        let colDiff: i32 = col as i32 - qcol;
        if colDiff == rowDiff or colDiff == 0 - rowDiff {
            return false;
        }
        i += 1;
        set i += 1;
    }
    return true;
}

fn solve(b: *mut Board, row: u32) {
    if row == b.boardSize {
        b.solutionCount += 1;
        set b.solutionCount += 1;
        return;
    }
    let mut col: u32 = 0;
    while col < b.boardSize {
        if isSafe(b, row, col) {
            b.queens[row] = col as i32;
            set b.queens[row] = col as i32;
            solve(b, row + 1);
            b.queens[row] = -1;
            set b.queens[row] = -1;
        }
        col += 1;
        set col += 1;
    }
}

fn resetBoard(b: *mut Board) {
    let mut i: u32 = 0;
    while i < MAX_N {
        b.queens[i] = -1;
        i += 1;
        set b.queens[i] = -1;
        set i += 1;
    }
    b.solutionCount = 0;
    set b.solutionCount = 0;
}

fn solveNQueens(b: *mut Board, n: u32) -> u32 {
    resetBoard(b);
    b.boardSize = n;
    set b.boardSize = n;
    solve(b, 0);
    return b.solutionCount;
}

fn testAllSizes(b: *mut Board) -> i32 {

    while n <= 8 {
        let count: u32 = solveNQueens(b, n);
        if count <> expected[n] {
            return n as i32;
        }
        n += 1;
        set n += 1;
    }
    return 0;
}

fn testKnownSolution() -> i32 {

        while j < 8 {
            assert solution[i] <> solution[j];
            let rowDiff: i32 = j as i32 - i as i32;
            let colDiff: i32 = solution[j] - solution[i];
            assert colDiff <> rowDiff and colDiff <> 0 - rowDiff;
            j += 1;
            set j += 1;
        }
        i += 1;
        set i += 1;
    }

    let mut used: [bool; 8] = [false; 8];
    let mut k: u32 = 0;
    while k < 8 {
        let col: u32 = solution[k] as u32;
        if used[col] {
            return 3;
        }
        used[col] = true;
        k += 1;
        set used[col] = true;
        set k += 1;
    }

    return 0;
}


    let expected: [u32; 9] = [0, 1, 0, 0, 2, 10, 4, 40, 92];

    let mut n: u32 = 4;
    while n <= 8 {
        assert expected[n] <> 0;
        n += 1;
        set n += 1;
    }

    assert expected[2] == 0;
    assert expected[3] == 0;
    assert expected[7] > expected[6];

test/tests/prog.rbtree.rad +62 -62

    inorderCount: u32,
}

fn allocNode(t: *mut RBTree, key: i32) -> u32 {
    let idx: u32 = t.poolNext;
    t.poolNext += 1;
    t.pool[idx] = RBNode { key, color: RED, left: NIL, right: NIL, parent: NIL };
    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) {
    let y: u32 = t.pool[x].right;
    t.pool[x].right = t.pool[y].left;
    set t.pool[x].right = t.pool[y].left;
    if t.pool[y].left <> NIL {
        t.pool[t.pool[y].left].parent = x;
        set t.pool[t.pool[y].left].parent = x;
    }
    t.pool[y].parent = t.pool[x].parent;
    set t.pool[y].parent = t.pool[x].parent;
    if t.pool[x].parent == NIL {
        t.root = y;
        set t.root = y;
    } else if x == t.pool[t.pool[x].parent].left {
        t.pool[t.pool[x].parent].left = y;
        set t.pool[t.pool[x].parent].left = y;
    } else {
        t.pool[t.pool[x].parent].right = y;
        set t.pool[t.pool[x].parent].right = y;
    }
    t.pool[y].left = x;
    t.pool[x].parent = y;
    set t.pool[y].left = x;
    set t.pool[x].parent = y;
}

fn rotateRight(t: *mut RBTree, x: u32) {
    let y: u32 = t.pool[x].left;
    t.pool[x].left = t.pool[y].right;
    set t.pool[x].left = t.pool[y].right;
    if t.pool[y].right <> NIL {
        t.pool[t.pool[y].right].parent = x;
        set t.pool[t.pool[y].right].parent = x;
    }
    t.pool[y].parent = t.pool[x].parent;
    set t.pool[y].parent = t.pool[x].parent;
    if t.pool[x].parent == NIL {
        t.root = y;
        set t.root = y;
    } else if x == t.pool[t.pool[x].parent].right {
        t.pool[t.pool[x].parent].right = y;
        set t.pool[t.pool[x].parent].right = y;
    } else {
        t.pool[t.pool[x].parent].left = y;
        set t.pool[t.pool[x].parent].left = y;
    }
    t.pool[y].right = x;
    t.pool[x].parent = y;
    set t.pool[y].right = x;
    set t.pool[x].parent = y;
}

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 {
                t.pool[t.pool[z].parent].color = BLACK;
                t.pool[y].color = BLACK;
                t.pool[t.pool[t.pool[z].parent].parent].color = RED;
                z = t.pool[t.pool[z].parent].parent;
                set t.pool[t.pool[z].parent].color = BLACK;
                set t.pool[y].color = BLACK;
                set t.pool[t.pool[t.pool[z].parent].parent].color = RED;
                set z = t.pool[t.pool[z].parent].parent;
            } else {
                if z == t.pool[t.pool[z].parent].right {
                    z = t.pool[z].parent;
                    set z = t.pool[z].parent;
                    rotateLeft(t, z);
                }
                t.pool[t.pool[z].parent].color = BLACK;
                t.pool[t.pool[t.pool[z].parent].parent].color = RED;
                set t.pool[t.pool[z].parent].color = BLACK;
                set t.pool[t.pool[t.pool[z].parent].parent].color = RED;
                rotateRight(t, t.pool[t.pool[z].parent].parent);
            }
        } else {
            let y: u32 = t.pool[t.pool[t.pool[z].parent].parent].left;
            if t.pool[y].color == RED {
                t.pool[t.pool[z].parent].color = BLACK;
                t.pool[y].color = BLACK;
                t.pool[t.pool[t.pool[z].parent].parent].color = RED;
                z = t.pool[t.pool[z].parent].parent;
                set t.pool[t.pool[z].parent].color = BLACK;
                set t.pool[y].color = BLACK;
                set t.pool[t.pool[t.pool[z].parent].parent].color = RED;
                set z = t.pool[t.pool[z].parent].parent;
            } else {
                if z == t.pool[t.pool[z].parent].left {
                    z = t.pool[z].parent;
                    set z = t.pool[z].parent;
                    rotateRight(t, z);
                }
                t.pool[t.pool[z].parent].color = BLACK;
                t.pool[t.pool[t.pool[z].parent].parent].color = RED;
                set t.pool[t.pool[z].parent].color = BLACK;
                set t.pool[t.pool[t.pool[z].parent].parent].color = RED;
                rotateLeft(t, t.pool[t.pool[z].parent].parent);
            }
        }
    }
    t.pool[t.root].color = BLACK;
    set t.pool[t.root].color = BLACK;
}

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 {
        y = x;
        set y = x;
        if key < t.pool[x].key {
            x = t.pool[x].left;
            set x = t.pool[x].left;
        } else {
            x = t.pool[x].right;
            set x = t.pool[x].right;
        }
    }

    t.pool[z].parent = y;
    set t.pool[z].parent = y;
    if y == NIL {
        t.root = z;
        set t.root = z;
    } else if key < t.pool[y].key {
        t.pool[y].left = z;
        set t.pool[y].left = z;
    } else {
        t.pool[y].right = z;
        set t.pool[y].right = z;
    }

    insertFixup(t, z);
}


    let mut x: u32 = t.root;
    while x <> NIL {
        if key == t.pool[x].key {
            return true;
        } else if key < t.pool[x].key {
            x = t.pool[x].left;
            set x = t.pool[x].left;
        } else {
            x = t.pool[x].right;
            set x = t.pool[x].right;
        }
    }
    return false;
}

fn inorderWalk(t: *mut RBTree, x: u32) {
    if x == NIL {
        return;
    }
    inorderWalk(t, t.pool[x].left);
    t.inorder[t.inorderCount] = t.pool[x].key;
    t.inorderCount += 1;
    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 {
    if x == NIL {

}

fn resetTree(t: *mut RBTree) {
    let mut i: u32 = 0;
    while i < POOL_SIZE {
        t.pool[i] = RBNode { key: 0, color: BLACK, left: NIL, right: NIL, parent: NIL };
        i += 1;
        set t.pool[i] = RBNode { key: 0, color: BLACK, left: NIL, right: NIL, parent: NIL };
        set i += 1;
    }
    t.poolNext = 1;
    t.root = NIL;
    t.inorderCount = 0;
    set t.poolNext = 1;
    set t.root = NIL;
    set t.inorderCount = 0;
}

fn testAscending(t: *mut RBTree) -> i32 {
    resetTree(t);

    let mut i: i32 = 0;
    while i < 32 {
        insert(t, i);
        i += 1;
        set i += 1;
    }

    assert countNodes(t, t.root) == 32;
    assert t.pool[t.root].color == BLACK;

    let bh: i32 = blackHeight(t, t.root);
    assert bh <> -1;

    assert noRedRed(t, t.root);

    t.inorderCount = 0;
    set t.inorderCount = 0;
    inorderWalk(t, t.root);
    assert t.inorderCount == 32;
    let mut j: u32 = 0;
    while j < 32 {
        assert t.inorder[j] == j as i32;
        j += 1;
        set j += 1;
    }

    return 0;
}


    while i >= 0 {
        insert(t, i);
        if i == 0 {
            break;
        }
        i -= 1;
        set i -= 1;
    }

    assert countNodes(t, t.root) == 32;
    assert blackHeight(t, t.root) <> -1;
    assert noRedRed(t, t.root);

    t.inorderCount = 0;
    set t.inorderCount = 0;
    inorderWalk(t, t.root);
    let mut j: u32 = 0;
    while j < 32 {
        assert t.inorder[j] == j as i32;
        j += 1;
        set j += 1;
    }

    return 0;
}


    let mut inserted: [bool; 48] = [false; 48];
    let mut seed: u32 = 42;
    let mut count: u32 = 0;

    while count < 48 {
        seed = (seed * 1103515245 + 12345) & 0x7FFFFFFF;
        set seed = (seed * 1103515245 + 12345) & 0x7FFFFFFF;
        let val: u32 = seed % 48;
        if not inserted[val] {
            insert(t, val as i32);
            inserted[val] = true;
            count += 1;
            set inserted[val] = true;
            set count += 1;
        }
    }

    assert countNodes(t, t.root) == 48;
    assert blackHeight(t, t.root) <> -1;
    assert noRedRed(t, t.root);

    let mut i: i32 = 0;
    while i < 48 {
        assert search(t, i);
        i += 1;
        set i += 1;
    }

    assert not search(t, -1);
    assert not search(t, 48);
    assert not search(t, 100);

    t.inorderCount = 0;
    set t.inorderCount = 0;
    inorderWalk(t, t.root);
    assert t.inorderCount == 48;
    let mut j: u32 = 0;
    while j < 48 {
        assert t.inorder[j] == j as i32;
        j += 1;
        set j += 1;
    }

    return 0;
}


    resetTree(t);

    let mut i: i32 = 0;
    while i < 63 {
        insert(t, i);
        i += 1;
        set i += 1;
    }

    let bh: i32 = blackHeight(t, t.root);
    assert bh >= 3;
    assert bh <= 7;

test/tests/prog.regex.rad +42 -42

    fragTop: u32,
}

fn newState(nfa: *mut NfaState) -> u32 {
    let s: u32 = nfa.stateCount;
    nfa.stateFirst[s] = NIL;
    nfa.stateCount += 1;
    set nfa.stateFirst[s] = NIL;
    set nfa.stateCount += 1;
    return s;
}

fn addTrans(nfa: *mut NfaState, from: u32, kind: u32, ch: u8, to: u32) {
    let idx: u32 = nfa.transCount;
    nfa.trans[idx] = Trans { kind, ch, to };
    nfa.transNext[idx] = nfa.stateFirst[from];
    nfa.stateFirst[from] = idx;
    nfa.transCount += 1;
    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) {
    nfa.fragStack[nfa.fragTop] = f;
    nfa.fragTop += 1;
    set nfa.fragStack[nfa.fragTop] = f;
    set nfa.fragTop += 1;
}

fn popFrag(nfa: *mut NfaState) -> Frag {
    nfa.fragTop -= 1;
    set nfa.fragTop -= 1;
    return nfa.fragStack[nfa.fragTop];
}

fn setEmpty(s: *mut [u32]) {
    s[0] = 0;
    s[1] = 0;
    s[2] = 0;
    s[3] = 0;
    set s[0] = 0;
    set s[1] = 0;
    set s[2] = 0;
    set s[3] = 0;
}

fn setAdd(s: *mut [u32], bit: u32) {
    let word: u32 = bit / 32;
    let pos: u32 = bit % 32;
    s[word] |= (1 << pos);
    set s[word] |= (1 << pos);
}

fn setHas(s: *[u32], bit: u32) -> bool {
    let word: u32 = bit / 32;
    let pos: u32 = bit % 32;

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]) {
    dst[0] = src[0];
    dst[1] = src[1];
    dst[2] = src[2];
    dst[3] = src[3];
    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]) {
    setCopy(nfa.closure, states);

    let mut changed: bool = true;
    while changed {
        changed = false;
        set changed = false;
        let mut s: u32 = 0;
        while s < nfa.stateCount {
            if setHas(nfa.closure, s) {
                let mut t: u32 = nfa.stateFirst[s];
                while t <> NIL {
                    if nfa.trans[t].kind == TRANS_EPSILON {
                        if not setHas(nfa.closure, nfa.trans[t].to) {
                            setAdd(nfa.closure, nfa.trans[t].to);
                            changed = true;
                            set changed = true;
                        }
                    }
                    t = nfa.transNext[t];
                    set t = nfa.transNext[t];
                }
            }
            s += 1;
            set s += 1;
        }
    }

    setCopy(states, nfa.closure);
}

fn resetNFA(nfa: *mut NfaState) {
    nfa.stateCount = 0;
    nfa.transCount = 0;
    nfa.fragTop = 0;
    set nfa.stateCount = 0;
    set nfa.transCount = 0;
    set nfa.fragTop = 0;
    let mut i: u32 = 0;
    while i < MAX_STATES {
        nfa.stateFirst[i] = NIL;
        i += 1;
        set nfa.stateFirst[i] = NIL;
        set i += 1;
    }
    i = 0;
    set i = 0;
    while i < MAX_TRANSITIONS {
        nfa.transNext[i] = NIL;
        i += 1;
        set nfa.transNext[i] = NIL;
        set i += 1;
    }
}

fn compile(nfa: *mut NfaState, pattern: *[u8]) -> u32 {
    resetNFA(nfa);

                addTrans(nfa, s, TRANS_EPSILON, 0, body);
                addTrans(nfa, s, TRANS_EPSILON, 0, e);
                addTrans(nfa, body, TRANS_EPSILON, 0, e);

                pushFrag(nfa, Frag { start: s, endState: e });
                i += 2;
                set i += 2;
                continue;
            }
            if nextCh == 43 {
                let s: u32 = newState(nfa);
                let m: u32 = newState(nfa);

                    addTrans(nfa, m, TRANS_CHAR, ch, m);
                }
                addTrans(nfa, m, TRANS_EPSILON, 0, e);

                pushFrag(nfa, Frag { start: s, endState: e });
                i += 2;
                set i += 2;
                continue;
            }
            if nextCh == 63 {
                let s: u32 = newState(nfa);
                let m: u32 = newState(nfa);

                }
                addTrans(nfa, s, TRANS_EPSILON, 0, e);
                addTrans(nfa, m, TRANS_EPSILON, 0, e);

                pushFrag(nfa, Frag { start: s, endState: e });
                i += 2;
                set i += 2;
                continue;
            }
        }

        let s: u32 = newState(nfa);

            addTrans(nfa, s, TRANS_DOT, 0, e);
        } else {
            addTrans(nfa, s, TRANS_CHAR, ch, e);
        }
        pushFrag(nfa, Frag { start: s, endState: e });
        i += 1;
        set i += 1;
    }

    if nfa.fragTop == 0 {
        let s: u32 = newState(nfa);
        nfa.acceptState = s;
        set nfa.acceptState = s;
        return s;
    }

    let numFrags: u32 = nfa.fragTop;
    let mut frags: [Frag; 64] = [Frag { start: 0, endState: 0 }; 64];
    let mut k: u32 = 0;
    while k < numFrags {
        frags[numFrags - 1 - k] = popFrag(nfa);
        k += 1;
        set frags[numFrags - 1 - k] = popFrag(nfa);
        set k += 1;
    }

    let mut j: u32 = 0;
    while j < numFrags - 1 {
        addTrans(nfa, frags[j].endState, TRANS_EPSILON, 0, frags[j + 1].start);
        j += 1;
        set j += 1;
    }

    nfa.acceptState = frags[numFrags - 1].endState;
    set nfa.acceptState = frags[numFrags - 1].endState;
    return frags[0].start;
}

fn nfaMatches(nfa: *mut NfaState, start: u32, input: *[u8]) -> bool {
    setEmpty(nfa.current);

                    if nfa.trans[t].kind == TRANS_CHAR and nfa.trans[t].ch == ch {
                        setAdd(nfa.nextSet, nfa.trans[t].to);
                    } else if nfa.trans[t].kind == TRANS_DOT {
                        setAdd(nfa.nextSet, nfa.trans[t].to);
                    }
                    t = nfa.transNext[t];
                    set t = nfa.transNext[t];
                }
            }
            s += 1;
            set s += 1;
        }

        epsilonClosure(nfa, nfa.nextSet);
        setCopy(nfa.current, nfa.nextSet);

        if setIsEmpty(nfa.current) {
            return false;
        }
        i += 1;
        set i += 1;
    }

    return setHas(nfa.current, nfa.acceptState);
}


test/tests/prog.sha256.rad +35 -35

/// Prepare the message schedule from a 16-word (512-bit) block.
fn prepareSchedule(s: *mut Sha256, block: *[u32]) {
    // Copy the first 16 words directly.
    let mut i: u32 = 0;
    while i < 16 {
        s.w[i] = block[i];
        i += 1;
        set s.w[i] = block[i];
        set i += 1;
    }
    // Extend to 64 words.
    while i < 64 {
        s.w[i] = ssig1(s.w[i - 2]) + s.w[i - 7] + ssig0(s.w[i - 15]) + s.w[i - 16];
        i += 1;
        set s.w[i] = ssig1(s.w[i - 2]) + s.w[i - 7] + ssig0(s.w[i - 15]) + s.w[i - 16];
        set i += 1;
    }
}

/// Run the 64-round compression function.
fn compress(s: *mut Sha256, k: *[u32]) {

79	79
80	80		let mut i: u32 = 0;
81	81		while i < 64 {
82	82		let t1 = hh + bsig1(e) + ch(e, f, g) + k[i] + s.w[i];
83	83		let t2 = bsig0(a) + maj(a, b, c);
84		-	hh = g;
85		-	g = f;
86		-	f = e;
87		-	e = d + t1;
88		-	d = c;
89		-	c = b;
90		-	b = a;
91		-	a = t1 + t2;
92		-	i += 1;
	84	+	set hh = g;
	85	+	set g = f;
	86	+	set f = e;
	87	+	set e = d + t1;
	88	+	set d = c;
	89	+	set c = b;
	90	+	set b = a;
	91	+	set a = t1 + t2;
	92	+	set i += 1;
93	93		}
94	94
95		-	s.h[0] += a;
96		-	s.h[1] += b;
97		-	s.h[2] += c;
98		-	s.h[3] += d;
99		-	s.h[4] += e;
100		-	s.h[5] += f;
101		-	s.h[6] += g;
102		-	s.h[7] += hh;
	95	+	set s.h[0] += a;
	96	+	set s.h[1] += b;
	97	+	set s.h[2] += c;
	98	+	set s.h[3] += d;
	99	+	set s.h[4] += e;
	100	+	set s.h[5] += f;
	101	+	set s.h[6] += g;
	102	+	set s.h[7] += hh;
103	103		}
104	104
105	105		/// Reset hash state to initial values.
106	106		fn resetHash(s: *mut Sha256) {
107	107		let mut i: u32 = 0;
108	108		while i < 8 {
109		-	s.h[i] = INIT_H[i];
110		-	i += 1;
	109	+	set s.h[i] = INIT_H[i];
	110	+	set i += 1;
111	111		}
112	112		}
113	113
114	114		/// Pad and hash a short message (up to 55 bytes, fits in one 512-bit block).
115	115		fn hashMessage(s: mut Sha256, k: [u32], msg: *[u8]) -> i32 {

    let mut blockBytes: [u8; 64] = [0; 64];

    // Copy message.
    let mut i: u32 = 0;
    while i < msg.len {
        blockBytes[i] = msg[i];
        i += 1;
        set blockBytes[i] = msg[i];
        set i += 1;
    }

    // Append the 1-bit (0x80).
    blockBytes[msg.len] = 0x80;
    set blockBytes[msg.len] = 0x80;

    // Append length in bits as big-endian 64-bit integer at the end.
    let bitLen: u32 = msg.len * 8;
    blockBytes[60] = (bitLen >> 24) as u8;
    blockBytes[61] = (bitLen >> 16) as u8;
    blockBytes[62] = (bitLen >> 8) as u8;
    blockBytes[63] = bitLen as u8;
    set blockBytes[60] = (bitLen >> 24) as u8;
    set blockBytes[61] = (bitLen >> 16) as u8;
    set blockBytes[62] = (bitLen >> 8) as u8;
    set blockBytes[63] = bitLen as u8;

    // Convert bytes to 16 big-endian 32-bit words.
    let mut block: [u32; 16] = [0; 16];
    let mut w: u32 = 0;
    while w < 16 {
        let base = w * 4;
        block[w] = (blockBytes[base] as u32 << 24)
                  | (blockBytes[base + 1] as u32 << 16)
                  | (blockBytes[base + 2] as u32 << 8)
                  | (blockBytes[base + 3] as u32);
        w += 1;
        set block[w] = (blockBytes[base] as u32 << 24)
                     | (blockBytes[base + 1] as u32 << 16)
                     | (blockBytes[base + 2] as u32 << 8)
                     | (blockBytes[base + 3] as u32);
        set w += 1;
    }

    resetHash(s);
    prepareSchedule(s, &block[..]);
    compress(s, k);

test/tests/prog.sieve.rad +9 -9


/// Mark all multiples of p as composite.
fn markMultiples(sieve: *mut [bool], p: u32) {
    let mut i: u32 = p * p;
    while i < sieve.len {
        sieve[i] = true;
        i += p;
        set sieve[i] = true;
        set i += p;
    }
}

/// Run the sieve algorithm.
fn runSieve(sieve: *mut [bool]) {
    // 0 and 1 are not prime.
    sieve[0] = true;
    sieve[1] = true;
    set sieve[0] = true;
    set sieve[1] = true;

    let mut p: u32 = 2;
    while p * p < sieve.len {
        if not sieve[p] {
            markMultiples(sieve, p);
        }
        p += 1;
        set p += 1;
    }
}

/// Count the number of primes found.
fn countPrimes(sieve: *[bool]) -> u32 {
    let mut count: u32 = 0;
    for composite in sieve {
        if not composite {
            count += 1;
            set count += 1;
        }
    }
    return count;
}


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 {
                primes[count] = idx;
                count += 1;
                set primes[count] = idx;
                set count += 1;
            }
        }
    }
    return count;
}

    let mut prev: ?u32 = nil;
    for p in collected {
        if let prevVal = prev {
            assert prevVal < p;
        }
        prev = p;
        set prev = p;
    }
    return 0;
}

@default fn main() -> i32 {

test/tests/prog.symtab.rad +28 -28


/// Simple string hash function.
fn hashName(name: *[u8]) -> u32 {
    let mut h: u32 = 5381;
    for ch in name {
        h = ((h << 5) + h) + ch as u32;
        set h = ((h << 5) + h) + ch as u32;
    }
    return h;
}

/// Initialize the symbol table.
fn init(tab: *mut SymTab) {
    tab.symbolCount = 0;
    tab.scopeDepth = 0;
    set tab.symbolCount = 0;
    set tab.scopeDepth = 0;

    for i in 0..HASH_SIZE {
        tab.buckets[i] = NIL;
        set tab.buckets[i] = NIL;
    }
}

/// Push a new scope.
fn pushScope(tab: *mut SymTab) {
    tab.scopes[tab.scopeDepth] = ScopeMarker { symbolCount: tab.symbolCount };
    tab.scopeDepth += 1;
    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) {
    if tab.scopeDepth == 0 {
        return;
    }
    tab.scopeDepth -= 1;
    set tab.scopeDepth -= 1;
    let marker = tab.scopes[tab.scopeDepth];

    // Remove symbols added in this scope (in reverse order).
    while tab.symbolCount > marker.symbolCount {
        tab.symbolCount -= 1;
        set tab.symbolCount -= 1;
        let sym = tab.symbols[tab.symbolCount];
        let bucket = sym.nameHash % HASH_SIZE;

        // Remove from hash chain.
        tab.buckets[bucket] = sym.next;
        set tab.buckets[bucket] = sym.next;

        // Restore shadowed symbol if any.
        if sym.shadow <> NIL {
            // The shadowed symbol is still in the symbols array;
            // re-link it into the hash chain.
            let shadowIdx = sym.shadow;
            tab.symbols[shadowIdx].next = tab.buckets[bucket];
            tab.buckets[bucket] = shadowIdx;
            set tab.symbols[shadowIdx].next = tab.buckets[bucket];
            set tab.buckets[bucket] = shadowIdx;
        }
    }
}

/// Define a symbol in the current scope.

    let mut cur = tab.buckets[bucket];
    while cur <> NIL {
        if tab.symbols[cur].nameHash == h {
            // Found existing symbol with same hash - shadow it.
            // Remove it from hash chain first.
            shadowIdx = cur;
            set shadowIdx = cur;
            // Remove the shadowed symbol from the bucket chain.
            if tab.buckets[bucket] == cur {
                tab.buckets[bucket] = tab.symbols[cur].next;
                set tab.buckets[bucket] = tab.symbols[cur].next;
            }
            break;
        }
        cur = tab.symbols[cur].next;
        set cur = tab.symbols[cur].next;
    }

    let idx = tab.symbolCount;
    tab.symbols[idx] = Symbol {
    set tab.symbols[idx] = Symbol {
        nameHash: h,
        value,
        depth: tab.scopeDepth,
        next: tab.buckets[bucket],
        shadow: shadowIdx,
    };
    tab.buckets[bucket] = idx;
    tab.symbolCount += 1;
    set tab.buckets[bucket] = idx;
    set tab.symbolCount += 1;
    return idx;
}

/// Look up a symbol by name. Returns the value if found.
fn lookup(tab: *SymTab, name: *[u8]) -> ?i32 {


    while cur <> NIL {
        if tab.symbols[cur].nameHash == h {
            return tab.symbols[cur].value;
        }
        cur = tab.symbols[cur].next;
        set cur = tab.symbols[cur].next;
    }
    return nil;
}

/// Update a symbol's value. Returns true if the symbol was found.

    let bucket = h % HASH_SIZE;
    let mut cur = tab.buckets[bucket];

    while cur <> NIL {
        if tab.symbols[cur].nameHash == h {
            tab.symbols[cur].value = newValue;
            set tab.symbols[cur].value = newValue;
            return true;
        }
        cur = tab.symbols[cur].next;
        set cur = tab.symbols[cur].next;
    }
    return false;
}

/// Test basic define and lookup.

    // Define x at each of 8 scope levels.
    let mut i: u32 = 0;
    while i < 8 {
        pushScope(tab);
        define(tab, "x", i as i32 * 10);
        i += 1;
        set i += 1;
    }

    // x should be the innermost value.
    let x = lookup(tab, "x") else {
        return 1;
    };
    assert x == 70;

    // Pop scopes one by one and check.
    i = 7;
    set i = 7;
    while i > 0 {
        popScope(tab);
        let val = lookup(tab, "x") else {
            return 3;
        };
        let expected = (i - 1) as i32 * 10;
        assert val == expected;
        i -= 1;
        set i -= 1;
    }

    popScope(tab);
    return 0;
}


    // Verify all of them.
    let mut sum: i32 = 0;
    for name, i in names {
        if let val = lookup(tab, name) {
            sum += val;
            set sum += val;
        } else {
            return 1;
        }
    }


    while i < 10 {
        let cur = lookup(tab, "counter") else {
            return 1;
        };
        assert update(tab, "counter", cur + 1);
        i += 1;
        set i += 1;
    }

    let finalVal = lookup(tab, "counter") else {
        return 3;
    };

        let result = lookup(tab, name);
        if let exp = expected[i] {
            // We expect a value.
            if let r = result {
                if r <> exp {
                    failures += 1;
                    set failures += 1;
                }
            } else {
                failures += 1;
                set failures += 1;
            }
        } else {
            // We expect nil.
            if let _ = result {
                failures += 1;
                set failures += 1;
            }
        }
    }

    if failures <> 0 {

test/tests/prog.tokenizer.rad +21 -21

}

/// Advance the lexer by one character.
fn advance(lex: *mut Lexer) {
    if lex.pos < lex.source.len {
        lex.pos += 1;
        set lex.pos += 1;
    }
}

/// Skip whitespace characters.
fn skipWhitespace(lex: *mut Lexer) {


/// Scan a number literal.
fn scanNumber(lex: *mut Lexer) -> i32 {
    let mut value: i32 = 0;
    while let ch = peek(lex); isDigit(ch) {
        value = value * 10 + (ch - 48) as i32;
        set value = value * 10 + (ch - 48) as i32;
        advance(lex);
    }
    return value;
}


        match tok {
            case Token::Invalid(_) => {
                return false;
            }
            case Token::Eof => {
                list.tokens[list.count] = tok;
                list.count += 1;
                done = true;
                set list.tokens[list.count] = tok;
                set list.count += 1;
                set done = true;
            }
            else => {
                if list.count >= list.tokens.len - 1 {
                    return false;
                }
                list.tokens[list.count] = tok;
                list.count += 1;
                set list.tokens[list.count] = tok;
                set list.count += 1;
            }
        }
    }
    return true;
}

/// Allocate a new expression node.
fn newExpr(pool: *mut ExprPool, expr: Expr) -> u32 {
    let idx = pool.count;
    pool.nodes[idx] = expr;
    pool.count += 1;
    set pool.nodes[idx] = expr;
    set pool.count += 1;
    return idx;
}

/// Get the current token in the parser.
fn currentToken(p: *Parser) -> Token {

}

/// Advance the parser to the next token.
fn advanceParser(p: *mut Parser) {
    if p.pos < p.tokenCount {
        p.pos += 1;
        set p.pos += 1;
    }
}

/// Parse a primary expression (number, parenthesized expression, or unary minus).
fn parsePrimary(p: *mut Parser) -> ?u32 {

        let tok = currentToken(p);
        match tok {
            case Token::Star => {
                advanceParser(p);
                if let right = parsePrimary(p) {
                    result = newExpr(p.pool, Expr::BinOp(BinOpData { op: 42, left: result, right }));
                    set result = newExpr(p.pool, Expr::BinOp(BinOpData { op: 42, left: result, right }));
                } else {
                    cont = false;
                    set cont = false;
                }
            }
            case Token::Slash => {
                advanceParser(p);
                if let right = parsePrimary(p) {
                    result = newExpr(p.pool, Expr::BinOp(BinOpData { op: 47, left: result, right }));
                    set result = newExpr(p.pool, Expr::BinOp(BinOpData { op: 47, left: result, right }));
                } else {
                    cont = false;
                    set cont = false;
                }
            }
            else => {
                cont = false;
                set cont = false;
            }
        }
    }
    return result;
}

        match tok {
            case Token::Plus => {
                advanceParser(p);
                if let right = parsePrimary(p) {
                    let rhs = parseMulDiv(p, right);
                    result = newExpr(p.pool, Expr::BinOp(BinOpData { op: 43, left: result, right: rhs }));
                    set result = newExpr(p.pool, Expr::BinOp(BinOpData { op: 43, left: result, right: rhs }));
                } else {
                    cont = false;
                    set cont = false;
                }
            }
            case Token::Minus => {
                advanceParser(p);
                if let right = parsePrimary(p) {
                    let rhs = parseMulDiv(p, right);
                    result = newExpr(p.pool, Expr::BinOp(BinOpData { op: 45, left: result, right: rhs }));
                    set result = newExpr(p.pool, Expr::BinOp(BinOpData { op: 45, left: result, right: rhs }));
                } else {
                    cont = false;
                    set cont = false;
                }
            }
            else => {
                cont = false;
                set cont = false;
            }
        }
    }
    return result;
}

    let mut numCount: u32 = 0;
    let slice = &tokenBuf[0..list.count];
    for tok in slice {
        match tok {
            case Token::Number(_) => {
                numCount += 1;
                set numCount += 1;
            }
            else => {}
        }
    }
    assert numCount == 3;

test/tests/prog.vm.rad +117 -117

/// Push a value onto the stack.
fn push(vm: *mut VM, value: i32) throws (VmError) {
    if vm.sp >= MAX_STACK {
        throw VmError::StackOverflow;
    }
    vm.stack[vm.sp] = value;
    vm.sp += 1;
    set vm.stack[vm.sp] = value;
    set vm.sp += 1;
}

/// Pop a value from the stack.
fn pop(vm: *mut VM) -> i32 throws (VmError) {
    if vm.sp == 0 {
        throw VmError::StackUnderflow;
    }
    vm.sp -= 1;
    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) {


/// Execute the bytecode program.
fn execute(vm: *mut VM) -> i32 throws (VmError) {
    while vm.pc < vm.codeLen {
        let instr = vm.code[vm.pc];
        vm.pc += 1;
        set vm.pc += 1;

        match instr {
            case Op::Push(val) => {
                try push(vm, val);
            }

            case Op::Eq => {
                let b = try pop(vm);
                let a = try pop(vm);
                let mut result: i32 = 0;
                if a == b {
                    result = 1;
                    set result = 1;
                }
                try push(vm, result);
            }
            case Op::Lt => {
                let b = try pop(vm);
                let a = try pop(vm);
                let mut result: i32 = 0;
                if a < b {
                    result = 1;
                    set result = 1;
                }
                try push(vm, result);
            }
            case Op::Gt => {
                let b = try pop(vm);
                let a = try pop(vm);
                let mut result: i32 = 0;
                if a > b {
                    result = 1;
                    set result = 1;
                }
                try push(vm, result);
            }
            case Op::Neg => {
                let a = try pop(vm);

            }
            case Op::Store(idx) => {
                let val = try pop(vm);
                let mut base: u32 = 0;
                if vm.frameCount > 0 {
                    base = vm.frames[vm.frameCount - 1].localBase;
                    set base = vm.frames[vm.frameCount - 1].localBase;
                }
                vm.locals[base + idx] = val;
                set vm.locals[base + idx] = val;
            }
            case Op::Load(idx) => {
                let mut base: u32 = 0;
                if vm.frameCount > 0 {
                    base = vm.frames[vm.frameCount - 1].localBase;
                    set base = vm.frames[vm.frameCount - 1].localBase;
                }
                let val = vm.locals[base + idx];
                try push(vm, val);
            }
            case Op::Jump(target) => {
                vm.pc = target;
                set vm.pc = target;
            }
            case Op::JumpIfZero(target) => {
                let cond = try pop(vm);
                if cond == 0 {
                    vm.pc = target;
                    set vm.pc = target;
                }
            }
            case Op::Call(target) => {
                if vm.frameCount >= MAX_FRAMES {
                    throw VmError::CallOverflow;
                }
                let mut base: u32 = 0;
                if vm.frameCount > 0 {
                    base = vm.frames[vm.frameCount - 1].localBase + MAX_LOCALS;
                    set base = vm.frames[vm.frameCount - 1].localBase + MAX_LOCALS;
                }
                vm.frames[vm.frameCount] = Frame { returnAddr: vm.pc, localBase: base };
                vm.frameCount += 1;
                vm.pc = target;
                set vm.frames[vm.frameCount] = Frame { returnAddr: vm.pc, localBase: base };
                set vm.frameCount += 1;
                set vm.pc = target;
            }
            case Op::Ret => {
                if vm.frameCount == 0 {
                    throw VmError::InvalidPC;
                }
                vm.frameCount -= 1;
                vm.pc = vm.frames[vm.frameCount].returnAddr;
                set vm.frameCount -= 1;
                set vm.pc = vm.frames[vm.frameCount].returnAddr;
            }
            case Op::Halt => {
                return try pop(vm);
            }
        }

}

/// Test basic arithmetic: 3 + 4 * 2 = 11
fn testArith(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {
    let mut code: [Op; 8] = [Op::Halt; 8];
    code[0] = Op::Push(3);
    code[1] = Op::Push(4);
    code[2] = Op::Push(2);
    code[3] = Op::Mul;
    code[4] = Op::Add;
    code[5] = Op::Halt;
    set code[0] = Op::Push(3);
    set code[1] = Op::Push(4);
    set code[2] = Op::Push(2);
    set code[3] = Op::Mul;
    set code[4] = Op::Add;
    set code[5] = Op::Halt;

    let result: i32 = try! runProgram(&code[..], 6, stackBuf, localsBuf, framesBuf);
    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 {
    let mut code: [Op; 16] = [Op::Halt; 16];
    code[0] = Op::Push(5);
    code[1] = Op::Store(0);   // x = 5
    code[2] = Op::Push(7);
    code[3] = Op::Store(1);   // y = 7
    code[4] = Op::Load(0);    // push x
    code[5] = Op::Load(1);    // push y
    code[6] = Op::Add;        // x + y
    code[7] = Op::Halt;
    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
    set code[4] = Op::Load(0);    // push x
    set code[5] = Op::Load(1);    // push y
    set code[6] = Op::Add;        // x + y
    set code[7] = Op::Halt;

    let result: i32 = try! runProgram(&code[..], 8, stackBuf, localsBuf, framesBuf);
    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 {
    let mut code: [Op; 16] = [Op::Halt; 16];
    code[0] = Op::Push(3);
    code[1] = Op::Push(2);
    code[2] = Op::Gt;            // 3 > 2 => 1
    code[3] = Op::JumpIfZero(6); // if false, jump to 6
    code[4] = Op::Push(42);      // true branch
    code[5] = Op::Jump(7);       // skip false branch
    code[6] = Op::Push(99);      // false branch
    code[7] = Op::Halt;
    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
    set code[4] = Op::Push(42);      // true branch
    set code[5] = Op::Jump(7);       // skip false branch
    set code[6] = Op::Push(99);      // false branch
    set code[7] = Op::Halt;

    let result: i32 = try! runProgram(&code[..], 8, stackBuf, localsBuf, framesBuf);
    assert result == 42;
    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 {
    let mut code: [Op; 32] = [Op::Halt; 32];
    code[0] = Op::Push(1);
    code[1] = Op::Store(0);      // counter = 1
    code[2] = Op::Push(0);
    code[3] = Op::Store(1);      // sum = 0
    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
    // Loop start (pc = 4):
    code[4] = Op::Load(0);       // push counter
    code[5] = Op::Push(6);
    code[6] = Op::Lt;            // counter < 6
    code[7] = Op::JumpIfZero(17); // if false, exit loop
    code[8] = Op::Load(1);       // push sum
    code[9] = Op::Load(0);       // push counter
    code[10] = Op::Add;          // sum + counter
    code[11] = Op::Store(1);     // sum = sum + counter
    code[12] = Op::Load(0);      // push counter
    code[13] = Op::Push(1);
    code[14] = Op::Add;          // counter + 1
    code[15] = Op::Store(0);     // counter = counter + 1
    code[16] = Op::Jump(4);      // back to loop start
    code[17] = Op::Load(1);      // push sum
    code[18] = Op::Halt;
    set code[4] = Op::Load(0);       // push counter
    set code[5] = Op::Push(6);
    set code[6] = Op::Lt;            // counter < 6
    set code[7] = Op::JumpIfZero(17); // if false, exit loop
    set code[8] = Op::Load(1);       // push sum
    set code[9] = Op::Load(0);       // push counter
    set code[10] = Op::Add;          // sum + counter
    set code[11] = Op::Store(1);     // sum = sum + counter
    set code[12] = Op::Load(0);      // push counter
    set code[13] = Op::Push(1);
    set code[14] = Op::Add;          // counter + 1
    set code[15] = Op::Store(0);     // counter = counter + 1
    set code[16] = Op::Jump(4);      // back to loop start
    set code[17] = Op::Load(1);      // push sum
    set code[18] = Op::Halt;

    let result: i32 = try! runProgram(&code[..], 19, stackBuf, localsBuf, framesBuf);
    // sum = 1+2+3+4+5 = 15
    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 {
    let mut code: [Op; 32] = [Op::Halt; 32];

    // Main: push argument on stack, call function, halt.
    code[0] = Op::Push(10);      // push argument
    code[1] = Op::Call(5);       // call function at 5
    set code[0] = Op::Push(10);      // push argument
    set code[1] = Op::Call(5);       // call function at 5
    // After return, result is on stack.
    code[2] = Op::Halt;
    code[3] = Op::Halt;          // padding
    code[4] = Op::Halt;          // padding
    set code[2] = Op::Halt;
    set code[3] = Op::Halt;          // padding
    set code[4] = Op::Halt;          // padding

    // Function at pc 5:
    code[5] = Op::Store(0);      // pop arg into local[0]
    code[6] = Op::Load(0);       // push local[0]
    code[7] = Op::Push(2);
    code[8] = Op::Mul;           // n * 2
    code[9] = Op::Push(1);
    code[10] = Op::Add;          // n * 2 + 1
    code[11] = Op::Ret;          // return (result on stack)
    set code[5] = Op::Store(0);      // pop arg into local[0]
    set code[6] = Op::Load(0);       // push local[0]
    set code[7] = Op::Push(2);
    set code[8] = Op::Mul;           // n * 2
    set code[9] = Op::Push(1);
    set code[10] = Op::Add;          // n * 2 + 1
    set code[11] = Op::Ret;          // return (result on stack)

    let result: i32 = try! runProgram(&code[..], 12, stackBuf, localsBuf, framesBuf);
    // 10 * 2 + 1 = 21
    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 {
    let mut code: [Op; 8] = [Op::Halt; 8];
    code[0] = Op::Push(42);
    code[1] = Op::Push(0);
    code[2] = Op::Div;
    code[3] = Op::Halt;
    set code[0] = Op::Push(42);
    set code[1] = Op::Push(0);
    set code[2] = Op::Div;
    set code[3] = Op::Halt;

    let mut caught: i32 = 0;
    try runProgram(&code[..], 4, stackBuf, localsBuf, framesBuf) catch e {
        if e == VmError::DivByZero {
            caught = 1;
            set caught = 1;
        } else {
            caught = 2;
            set caught = 2;
        }
    };
    assert caught == 1;
    return 0;
}

/// Test negation and equality.
fn testNegAndEq(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {
    let mut code: [Op; 16] = [Op::Halt; 16];
    code[0] = Op::Push(5);
    code[1] = Op::Neg;           // -5
    code[2] = Op::Push(-5);
    code[3] = Op::Eq;            // -5 == -5 => 1
    code[4] = Op::Halt;
    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
    set code[4] = Op::Halt;

    let result: i32 = try! runProgram(&code[..], 5, stackBuf, localsBuf, framesBuf);
    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 {
    let mut code: [Op; 32] = [Op::Halt; 32];

    // Main: push 6, call fact, halt.
    code[0] = Op::Push(6);
    code[1] = Op::Call(4);       // call fact at 4
    code[2] = Op::Halt;
    code[3] = Op::Halt;          // padding
    set code[0] = Op::Push(6);
    set code[1] = Op::Call(4);       // call fact at 4
    set code[2] = Op::Halt;
    set code[3] = Op::Halt;          // padding

    // fact(n) at pc 4:
    //   Store arg to local[0]
    //   If n <= 1, push 1, return
    //   Else push n, push fact(n-1), multiply, return
    code[4] = Op::Store(0);      // local[0] = n
    code[5] = Op::Load(0);       // push n
    code[6] = Op::Push(2);
    code[7] = Op::Lt;            // n < 2
    code[8] = Op::JumpIfZero(11); // if n >= 2, skip
    code[9] = Op::Push(1);       // base case: push 1
    code[10] = Op::Ret;
    set code[4] = Op::Store(0);      // local[0] = n
    set code[5] = Op::Load(0);       // push n
    set code[6] = Op::Push(2);
    set code[7] = Op::Lt;            // n < 2
    set code[8] = Op::JumpIfZero(11); // if n >= 2, skip
    set code[9] = Op::Push(1);       // base case: push 1
    set code[10] = Op::Ret;

    // Recursive case:
    code[11] = Op::Load(0);      // push n
    code[12] = Op::Push(1);
    code[13] = Op::Sub;          // n - 1
    code[14] = Op::Call(4);      // fact(n-1)
    code[15] = Op::Load(0);      // push n
    code[16] = Op::Mul;          // fact(n-1) * n
    code[17] = Op::Ret;
    set code[11] = Op::Load(0);      // push n
    set code[12] = Op::Push(1);
    set code[13] = Op::Sub;          // n - 1
    set code[14] = Op::Call(4);      // fact(n-1)
    set code[15] = Op::Load(0);      // push n
    set code[16] = Op::Mul;          // fact(n-1) * n
    set code[17] = Op::Ret;

    let result: i32 = try! runProgram(&code[..], 18, stackBuf, localsBuf, framesBuf);
    assert result == 720;
    return 0;
}

/// Test dup instruction.
fn testDup(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {
    let mut code: [Op; 8] = [Op::Halt; 8];
    code[0] = Op::Push(7);
    code[1] = Op::Dup;
    code[2] = Op::Add;           // 7 + 7 = 14
    code[3] = Op::Halt;
    set code[0] = Op::Push(7);
    set code[1] = Op::Dup;
    set code[2] = Op::Add;           // 7 + 7 = 14
    set code[3] = Op::Halt;

    let result: i32 = try! runProgram(&code[..], 4, stackBuf, localsBuf, framesBuf);
    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 {
    let mut code: [Op; 4] = [Op::Halt; 4];
    code[0] = Op::Add;  // nothing on stack
    code[1] = Op::Halt;
    set code[0] = Op::Add;  // nothing on stack
    set code[1] = Op::Halt;

    let mut caught: i32 = 0;
    try runProgram(&code[..], 2, stackBuf, localsBuf, framesBuf) catch e {
        if e == VmError::StackUnderflow {
            caught = 1;
            set caught = 1;
        } else {
            caught = 2;
            set caught = 2;
        }
    };
    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 {
    let mut code: [Op; 4] = [Op::Halt; 4];
    code[0] = Op::Push(99);
    code[1] = Op::Halt;
    set code[0] = Op::Push(99);
    set code[1] = Op::Halt;

    let mut caught: i32 = 0;
    let result: i32 = try runProgram(&code[..], 2, stackBuf, localsBuf, framesBuf) catch e {
        caught = 1;
        set caught = 1;
        return 1;
    };
    // Catch block should not have run.
    assert caught == 0;
    // Should have the success value.


/// Test call overflow detection by exhausting frames.
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.
    code[0] = Op::Call(0);
    code[1] = Op::Halt;
    set code[0] = Op::Call(0);
    set code[1] = Op::Halt;

    let mut caught: i32 = 0;
    try runProgram(&code[..], 2, stackBuf, localsBuf, framesBuf) catch e {
        if e == VmError::CallOverflow {
            caught = 1;
            set caught = 1;
        } else {
            caught = 2;
            set caught = 2;
        }
    };
    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 {
    let mut code: [Op; 4] = [Op::Halt; 4];
    code[0] = Op::Pop;  // underflow
    code[1] = Op::Halt;
    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;
}

test/tests/ptr.assign.rad +1 -1

//! returns: 42
@default fn main() -> i32 {
    let mut x: i32 = 1;
    let mut ptr: *mut i32 = &mut x;

    *ptr = 42;
    set *ptr = 42;

    return x;
}

test/tests/ptr.mutate.rad +3 -3

//! returns: 42

fn mutate1(ptr: *mut i32) {
    *ptr = 39;
    set *ptr = 39;
}

fn mutate2(ptr: *mut i32) {
    *ptr += 2;
    *ptr += 1;
    set *ptr += 2;
    set *ptr += 1;
}

@default fn main() -> i32 {
    let mut ptr: i32 = 0;


test/tests/ptr.opaque.rad +1 -1

fn testNullableOpaque() -> bool {
    let mut opt: ?*opaque = nil;
    if opt == nil {
        let x: u32 = 42;
        let ptr: *u8 = &x as *u8;
        opt = ptr;  // Automatic coercion in assignment.
        set opt = ptr;  // Automatic coercion in assignment.

        if let p = opt {
            return p as *u8 == ptr;
        }
    }

test/tests/ptr.subscript.assign.rad +1 -1

1	1		/// Writes to a slice element through subscript.
2	2		fn subscriptAssign(arr: *mut [i32], idx: u32, val: i32) {
3		-	arr[idx] = val;
	3	+	set arr[idx] = val;
4	4		}

test/tests/record.array.elements.rad +7 -7

fn vectorSum(vec: Vector) -> i32 {
    let mut sum: i32 = 0;
    let mut i: u32 = 0;

    while (i < vec.data.len) {
        sum += vec.data[i];
        i += 1;
        set sum += vec.data[i];
        set i += 1;
    }
    return sum;
}

fn vectorScale(vec: Vector, scale: i32) -> Vector {
    let mut result: Vector = Vector { data: [0, 0, 0, 0] };
    let mut i: u32 = 0;

    while (i < vec.data.len) {
        result.data[i] = vec.data[i] * scale;
        i += 1;
        set result.data[i] = vec.data[i] * scale;
        set i += 1;
    }
    return result;
}

// Sum of the diagonal elements.
fn matrixTrace(mat: Matrix) -> i32 {
    let mut sum: i32 = 0;
    let mut i: u32 = 0;

    while (i < mat.rows.len) {
        sum += mat.rows[i].data[i];
        i += 1;
        set sum += mat.rows[i].data[i];
        set i += 1;
    }
    return sum;
}

@default fn main() -> i32 {

    // Sum of v2: 2 + 4 + 6 + 8 = 20.
    let mut sumV2: i32 = vectorSum(v2);
    // Trace of matrix: 10 + 15 + 20 = 45.
    let mut trace: i32 = matrixTrace(m1);
    // Modify element in the matrix.
    m1.rows[0].data[0] = m1.rows[0].data[0] - 5; // 10 - 5 = 5
    set m1.rows[0].data[0] = m1.rows[0].data[0] - 5; // 10 - 5 = 5
    // Calculate new trace: 5 + 15 + 20 = 40.
    let mut newTrace: i32 = matrixTrace(m1);

    // Return combined results: 10 + 20 + 45 + 40 = 115.
    return sumV1 + sumV2 + trace + newTrace;

test/tests/record.assign.blit.rad +1 -1

record Point { x: i32, y: i32 }

fn copy() {
    let p = Point { x: 1, y: 2 };
    let mut q = p;
    q = p;
    set q = p;
}

test/tests/record.copy.rad +16 -16

15	15		return s;
16	16		}
17	17
18	18		fn func1(s: S) -> i32 {
19	19		let mut m: S = s;
20		-	m.x = 112;
21		-	m.y = 582;
22		-	m.z = 281;
	20	+	set m.x = 112;
	21	+	set m.y = 582;
	22	+	set m.z = 281;
23	23
24	24		assert m.x == 112;
25	25		assert m.y == 582;
26	26		assert m.z == 281;
27	27		return 0;

31	31		let p: i32 = 0;
32	32		let mut t: S = s;
33	33		let q: i32 = 0;
34	34		let mut u: S = s;
35	35
36		-	t.x = 12;
37		-	u.x = 13;
38		-	t.y = 52;
39		-	u.y = 54;
40		-	t.z = 21;
41		-	u.z = 25;
	36	+	set t.x = 12;
	37	+	set u.x = 13;
	38	+	set t.y = 52;
	39	+	set u.y = 54;
	40	+	set t.z = 21;
	41	+	set u.z = 25;
42	42
43	43		assert t.x == 12;
44	44		assert t.y == 52;
45	45		assert t.z == 21;
46	46		assert u.x == 13;

51	51
52	52		fn func3(s: S) -> i32 {
53	53		let mut a: [S; 4] = [s; 4];
54	54		let mut t: S = s;
55	55
56		-	t.x = 12;
57		-	t.y = 13;
58		-	t.z = 52;
	56	+	set t.x = 12;
	57	+	set t.y = 13;
	58	+	set t.z = 52;
59	59
60		-	a[1] = t;
61		-	a[3] = a[1];
	60	+	set a[1] = t;
	61	+	set a[3] = a[1];
62	62
63	63		assert a[0].x == 561;
64	64		assert a[0].y == 938;
65	65		assert a[0].z == 102;
66	66		assert a[1].x == 12;

71	71		return 0;
72	72		}
73	73
74	74		fn func4(s: S) -> i32 {
75	75		let mut a: [S; 2] = undefined;
76		-	a[0] = s;
	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	84		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		-	a[0] = t;
	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;

test/tests/record.field.assign.rad +3 -3

3	3		record Vector { x: i32, y: i32 }
4	4
5	5		@default fn main() -> i32 {
6	6		let mut v: Vector = Vector { x: 3, y: 2 };
7	7
8		-	v.x = 40;
9		-	v.y = 1;
10		-	v.y *= 2;
	8	+	set v.x = 40;
	9	+	set v.y = 1;
	10	+	set v.y *= 2;
11	11
12	12		return (v.x + v.y) - 42;
13	13		}

test/tests/record.nested.calls.2.rad +1 -1

16	16
17	17		@default fn main() -> i32 {
18	18		let mut p: Point = Point { x: 3, y: 4 };
19	19		let mut q: Point = Point { x: 5, y: 6 };
20	20
21		-	p = add(
	21	+	set p = add(
22	22		scale(p, 2), // (6, 8)
23	23		scale(q, 2) // (10, 12)
24	24		); // (16, 20)
25	25
26	26		// p.x + p.y = 16 + 20 = 36

test/tests/record.ptr.mutate.rad +2 -2

4	4		x: i32,
5	5		y: i32,
6	6		}
7	7
8	8		fn mutate(p: *mut Point) {
9		-	p.x = 4;
10		-	p.y = 38;
	9	+	set p.x = 4;
	10	+	set p.y = 38;
11	11		}
12	12
13	13		@default fn main() -> i32 {
14	14		let mut p: Point = Point { x: 0, y: 0 };
15	15

test/tests/record.unlabeled.deref.rad +1 -1

        return 9;
    }

    // Assignment through deref on mutable binding.
    let mut m: Wrap = Wrap(0);
    *m = 77;
    set *m = 77;
    if *m <> 77 {
        return 10;
    }

    return 0;

test/tests/ref.if.bug.rad +1 -1

//!
//! 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) {
    *ptr = val;
    set *ptr = val;
}

fn testIfBranch(cond: bool) -> u32 {
    let mut val: u32 = 42;
    if cond {

test/tests/ref.immut.loop.bug.rad +1 -1

fn testZeroIter(n: u32) -> u32 {
    let val: u32 = 42;
    let mut i: u32 = 0;
    while i < n {
        let _ = read(&val);
        i += 1;
        set i += 1;
    }
    return val;
}

@default fn main() -> i32 {

test/tests/ref.mut.ptr.rad +1 -1

//! returns: 84
//! Test mutable pointer references.

fn store(ptr: *mut i32) {
    *ptr = 42;
    set *ptr = 42;
}

@default fn main() -> i32 {
    let mut a: i32 = 0;
    let p: *mut i32 = &mut a;

test/tests/reserve.loop.rad +2 -2

4	4		@default fn main() -> i32 {
5	5		let mut total: i32 = 0;
6	6		let mut i: i32 = 0;
7	7		while i < 10000 {
8	8		let p: Pair = Pair { a: i, b: i + 1 };
9		-	total += p.a + p.b;
10		-	i += 1;
	9	+	set total += p.a + p.b;
	10	+	set i += 1;
11	11		}
12	12		// Expected: sum(i) + sum(i+1) for i=0..9999
13	13		// = 2 * 9999*10000/2 + 10000 = 99990000 + 10000 = 100000000
14	14		assert total == 100000000;
15	15		return 0;

test/tests/result.void.success.rad +1 -1

        return (2) - 42;
    }

    // Try the error path too.
    try voidError() catch {
        guard = 99;
        set guard = 99;
    };

    if guard <> 99 {
        return (3) - 42;
    }

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

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 {
        s[i] = 0;
        set s[i] = 0;
    }

    return s.len as i32;
}


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

    let newOffset = aligned + size;

    assert newOffset <= arena.data.len as u32;

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

    return base as *mut opaque;
}

/// Allocator record matching the compiler's expected layout.

    }

    // Sum all elements in nums.
    let mut sum: i32 = 0;
    for n in nums {
        sum += n;
        set sum += n;
    }
    if sum <> 150 {
        return 16;
    }


    // Test that .append() returns the slice, allowing rebinding.
    let ptr2 = arenaAlloc(&mut arena, @sizeOf(i32) * 2, @alignOf(i32));
    let mut vals = @sliceOf(ptr2 as *mut i32, 0, 2);

    // Append within capacity, rebind via return value.
    vals = vals.append(42, a);
    set vals = vals.append(42, a);
    assert vals.len == 1;
    assert vals[0] == 42;

    vals = vals.append(43, a);
    set vals = vals.append(43, a);
    assert vals.len == 2;

    // Append past capacity -- triggers growth and returns updated slice.
    let oldPtr = &vals[0] as *opaque;
    vals = vals.append(44, a);
    set vals = vals.append(44, a);
    assert vals.len == 3;
    assert vals.cap == 5;

    // After growth, the data pointer should have changed.
    let newPtr = &vals[0] as *opaque;

test/tests/slice.assign.mismatch.rad +1 -1

//! Test that slice copy with mismatched lengths traps.

@default fn main() -> i32 {
    let mut dst: [i32; 4] = [0, 0, 0, 0];
    let src: [i32; 2] = [1, 2];
    dst[..] = &src[..];
    set dst[..] = &src[..];
    return 0;
}

test/tests/slice.assign.rad +9 -9

1	1		//! returns: 0
2	2
3	3		@default fn main() -> i32 {
4	4		// Fill entire array.
5	5		let mut a: [i32; 4] = [1, 2, 3, 4];
6		-	a[..] = 0;
	6	+	set a[..] = 0;
7	7		assert a == [0, 0, 0, 0];
8	8
9	9		// Fill sub-range of array.
10	10		let mut b: [i32; 4] = [1, 2, 3, 4];
11		-	b[1..3] = 99;
	11	+	set b[1..3] = 99;
12	12		assert b == [1, 99, 99, 4];
13	13
14	14		// Fill mutable slice.
15	15		let mut c: [i32; 4] = [10, 20, 30, 40];
16	16		let cs: *mut [i32] = &mut c[..];
17		-	cs[..] = 7;
	17	+	set cs[..] = 7;
18	18		assert c == [7, 7, 7, 7];
19	19
20	20		// Fill sub-range of mutable slice.
21	21		let mut d: [i32; 5] = [1, 2, 3, 4, 5];
22	22		let ds: *mut [i32] = &mut d[..];
23		-	ds[1..4] = 0;
	23	+	set ds[1..4] = 0;
24	24		assert d == [1, 0, 0, 0, 5];
25	25
26	26		// Copy slice into array.
27	27		let mut e: [i32; 3] = [0, 0, 0];
28	28		let src: [i32; 3] = [10, 20, 30];
29		-	e[..] = &src[..];
	29	+	set e[..] = &src[..];
30	30		assert e == [10, 20, 30];
31	31
32	32		// Copy into sub-range.
33	33		let mut f: [i32; 5] = [1, 2, 3, 4, 5];
34	34		let src2: [i32; 2] = [88, 99];
35		-	f[1..3] = &src2[..];
	35	+	set f[1..3] = &src2[..];
36	36		assert f == [1, 88, 99, 4, 5];
37	37
38	38		// Empty range is a no-op.
39	39		let mut g: [i32; 3] = [1, 2, 3];
40		-	g[1..1] = 99;
	40	+	set g[1..1] = 99;
41	41		assert g == [1, 2, 3];
42	42
43	43		// Copy between sub-ranges.
44	44		let mut i: [i32; 10] = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100];
45	45		let s: *mut [i32] = &mut i[..];
46		-	s[1..4] = &s[7..10];
	46	+	set s[1..4] = &s[7..10];
47	47		assert i[1] == 80 and i[2] == 90 and i[3] == 100;
48	48
49	49		// Fill u8 array.
50	50		let mut h: [u8; 4] = [65, 66, 67, 68];
51		-	h[..] = 0;
	51	+	set h[..] = 0;
52	52		assert h == [0, 0, 0, 0];
53	53
54	54		return 0;
55	55		}

test/tests/slice.mutable.rad +4 -4

// Test mutable slice operations

fn mutSliceStore(s: *mut [i32], idx: u32, val: i32) {
    s[idx] = val;
    set s[idx] = val;
}

fn mutSliceIncrement(s: *mut [i32], idx: u32) {
    s[idx] += 1;
    set s[idx] += 1;
}

fn mutSliceSwap(s: *mut [i32], i: u32, j: u32) {
    let tmp = s[i];
    s[i] = s[j];
    s[j] = tmp;
    set s[i] = s[j];
    set s[j] = tmp;
}

test/tests/spill.blockarg.clobber.rad +22 -22

}

fn prepareSchedule(s: *mut State, block: *[u32]) {
    let mut i: u32 = 0;
    while i < 16 {
        s.w[i] = block[i];
        i += 1;
        set s.w[i] = block[i];
        set i += 1;
    }
    while i < 64 {
        s.w[i] = ssig1(s.w[i - 2]) + s.w[i - 7] + ssig0(s.w[i - 15]) + s.w[i - 16];
        i += 1;
        set s.w[i] = ssig1(s.w[i - 2]) + s.w[i - 7] + ssig0(s.w[i - 15]) + s.w[i - 16];
        set i += 1;
    }
}

/// SHA-256 compression: 64 rounds with 8 rotating working variables.
/// Exercises heavy register pressure and spilled block-argument shuffles.

64	64
65	65		let mut i: u32 = 0;
66	66		while i < 64 {
67	67		let t1 = hh + bsig1(e) + ch(e, f, g) + k[i] + s.w[i];
68	68		let t2 = bsig0(a) + maj(a, b, c);
69		-	hh = g;
70		-	g = f;
71		-	f = e;
72		-	e = d + t1;
73		-	d = c;
74		-	c = b;
75		-	b = a;
76		-	a = t1 + t2;
77		-	i += 1;
	69	+	set hh = g;
	70	+	set g = f;
	71	+	set f = e;
	72	+	set e = d + t1;
	73	+	set d = c;
	74	+	set c = b;
	75	+	set b = a;
	76	+	set a = t1 + t2;
	77	+	set i += 1;
78	78		}
79	79
80		-	s.h[0] += a;
81		-	s.h[1] += b;
82		-	s.h[2] += c;
83		-	s.h[3] += d;
84		-	s.h[4] += e;
85		-	s.h[5] += f;
86		-	s.h[6] += g;
87		-	s.h[7] += hh;
	80	+	set s.h[0] += a;
	81	+	set s.h[1] += b;
	82	+	set s.h[2] += c;
	83	+	set s.h[3] += d;
	84	+	set s.h[4] += e;
	85	+	set s.h[5] += f;
	86	+	set s.h[6] += g;
	87	+	set s.h[7] += hh;
88	88		}
89	89
90	90		@default fn main() -> i32 {
91	91		let k: [u32; 64] = [
92	92		0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,

        w: [0; 64]
    };

    // Padded empty-message block.
    let mut block: [u32; 16] = [0; 16];
    block[0] = 0x80000000;
    set block[0] = 0x80000000;

    prepareSchedule(&mut s, &block[..]);
    compress(&mut s, &k[..]);

    // SHA-256("") = e3b0c442 98fc1c14 ...

test/tests/spill.loop.rad +3 -3

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]);
        currentOffset = alignUp(currentOffset, layout.alignment);
        currentOffset += layout.size;
        maxAlignment = max(maxAlignment, layout.alignment);
        set currentOffset = alignUp(currentOffset, layout.alignment);
        set currentOffset += layout.size;
        set maxAlignment = max(maxAlignment, layout.alignment);
    }
    return Layout {
        size: alignUp(currentOffset, maxAlignment),
        alignment: maxAlignment,
    };

test/tests/static.array.mutate.rad +1 -1

//! Test mutating a static array.

static BUFFER: [i32; 3] = [1, 2, 3];

fn bump(slot: u32, amount: i32) -> i32 {
    BUFFER[slot] += amount;
    set BUFFER[slot] += amount;
    return BUFFER[0] + BUFFER[1] + BUFFER[2];
}

@default fn main() -> i32 {
    let a: i32 = bump(0, 4);

test/tests/static.assign.rad +1 -1

/// Test static variable assignment.
static COUNTER: i32 = 0;

fn increment() -> i32 {
    COUNTER += 1;
    set COUNTER += 1;
    return COUNTER;
}

test/tests/static.basic.rad +5 -5

static GLOBAL: i32 = 0;

fn updateCounter(i: i32) -> i32 {
    static counter: i32 = 0;

    counter += i;
    GLOBAL += i * 10;
    set counter += i;
    set GLOBAL += i * 10;

    return counter;
}

@default fn main() -> i32 {
    let mut n: i32 = 0;

    n = updateCounter(1);
    n = updateCounter(2);
    n = updateCounter(3);
    set n = updateCounter(1);
    set n = updateCounter(2);
    set n = updateCounter(3);

    return n + GLOBAL;
}

test/tests/static.local.decl.rad +1 -1

/// Test lowering of function-local static and constant declarations.
fn localStaticAndConst() -> i32 {
    static LOCAL: i32 = 7;
    constant ADD: i32 = 5;

    LOCAL += ADD;
    set LOCAL += ADD;
    return LOCAL;
}

test/tests/static.record.array.rad +2 -2

    values: [5, 1, 9, 2],
    bias: 4,
};

fn rebalance() -> i32 {
    TABLE.values[0] += TABLE.bias;
    TABLE.values[3] += 1;
    set TABLE.values[0] += TABLE.bias;
    set TABLE.values[3] += 1;
    return TABLE.values[0] + TABLE.values[3] + TABLE.bias;
}

@default fn main() -> i32 {
    let first: i32 = rebalance();

test/tests/static.slice.index.assign.rad +4 -4

}

static container: Container = undefined;

@default fn main() -> i32 {
    container.items[0].value = 10;
    container.items[1].value = 20;
    container.items[2].value = 30;
    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[..];

    slice[1].value = 42;
    set slice[1].value = 42;

    return container.items[1].value;
}

test/tests/static.slice.offset.rad +5 -5

    Entry { a: 0, b: 0 },
];
static TBL: Table = undefined;

@default fn main() -> i32 {
    TBL.scratch = &mut SCRATCH[..];
    TBL.entries = &mut STORAGE[..];
    TBL.len     = 0;
    set TBL.scratch = &mut SCRATCH[..];
    set TBL.entries = &mut STORAGE[..];
    set TBL.len     = 0;

    TBL.entries[TBL.len] = Entry { a: 7, b: 9 };
    TBL.len += 1;
    set TBL.entries[TBL.len] = Entry { a: 7, b: 9 };
    set TBL.len += 1;

    assert STORAGE[0].a == 7 and STORAGE[0].b == 9;
    assert SCRATCH[0].a == 0 and SCRATCH[0].b == 0;
    return 0;
}

test/tests/trait.array.optional.rad +1 -1


/// Apply a chain of transforms to a value.
fn applyAll(transforms: *[*opaque Transform], value: i32) -> i32 {
    let mut result = value;
    for i in 0..transforms.len {
        result = transforms[i].apply(result);
        set result = transforms[i].apply(result);
    }
    return result;
}

/// Apply an optional transform, returning the original value if nil.

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

    fn (*mut Adder) add(n: i32) -> i32;
}

instance Adder for Counter {
    fn (c: *mut Counter) add(n: i32) -> i32 {
        c.value = c.value + n;
        set c.value = c.value + n;
        return c.value;
    }
}

@default fn main() -> i32 {

test/tests/trait.control.flow.rad +2 -2

    fn (*Stepper) current() -> i32;
}

instance Stepper for Counter {
    fn (c: *mut Counter) step() -> i32 {
        c.value = c.value + 1;
        set c.value = c.value + 1;
        return c.value;
    }

    fn (c: *Counter) current() -> i32 {
        return c.value;


    // Dispatch in a while loop.
    let mut i: i32 = 0;
    while i < 5 {
        s.step();
        i = i + 1;
        set i = i + 1;
    }
    assert s.current() == 5;

    // Dispatch in a conditional.
    if s.current() > 3 {

test/tests/trait.dispatch.rad +1 -1

11	11		fn (a: *Acc) get() -> i32 {
12	12		return a.n;
13	13		}
14	14
15	15		fn (a: *mut Acc) put(n: i32) {
16		-	a.n = n;
	16	+	set a.n = n;
17	17		}
18	18		}
19	19
20	20		fn dispatch(o: *mut opaque Ops) -> i32 {
21	21		o.put(42);

test/tests/trait.fn.param.rad +1 -1

    }
}

instance Scalable for Circle {
    fn (c: *mut Circle) scale(factor: i32) {
        c.radius = c.radius * factor;
        set c.radius = c.radius * factor;
    }
}

/// Accept an immutable trait object parameter.
fn getArea(s: *opaque Shape) -> i32 {

test/tests/trait.multiple.methods.rad +2 -2

    fn (*mut Collector) isEmpty() -> bool;
}

instance Collector for Accumulator {
    fn (a: *mut Accumulator) add(n: i32) -> i32 {
        a.total = a.total + n;
        set a.total = a.total + n;
        return a.total;
    }

    fn (a: *mut Accumulator) clear() {
        a.total = 0;
        set a.total = 0;
    }

    fn (a: *mut Accumulator) isEmpty() -> bool {
        return a.total == 0;
    }

test/tests/trait.multiple.traits.rad +2 -2

    fn (*mut Resettable) isZero() -> bool;
}

instance Incrementable for Counter {
    fn (c: *mut Counter) inc() -> i32 {
        c.value = c.value + 1;
        set c.value = c.value + 1;
        return c.value;
    }
}

instance Resettable for Counter {
    fn (c: *mut Counter) reset() {
        c.value = 0;
        set c.value = 0;
    }

    fn (c: *mut Counter) isZero() -> bool {
        return c.value == 0;
    }

test/tests/trait.object.rad +1 -1

    fn (*mut Adder) add(n: i32) -> i32;
}

instance Adder for Counter {
    fn (c: *mut Counter) add(n: i32) -> i32 {
        c.value = c.value + n;
        set c.value = c.value + n;
        return c.value;
    }
}

fn use_adder() -> i32 {

test/tests/trait.supertrait.rad +12 -12


instance Reader for Socket {
    fn (s: *mut Socket) read(buf: *mut [u8]) -> i32 {
        let mut i: u32 = 0;
        while i < buf.len and s.rpos < s.rlen {
            buf[i] = s.rbuf[s.rpos as u32];
            s.rpos = s.rpos + 1;
            i = i + 1;
            set buf[i] = s.rbuf[s.rpos as u32];
            set s.rpos = s.rpos + 1;
            set i = i + 1;
        }
        return i as i32;
    }
}


        let mut i: u32 = 0;
        while i < data.len {
            if s.wpos >= 32 {
                return s.wpos;
            }
            s.wbuf[s.wpos as u32] = data[i];
            s.wpos = s.wpos + 1;
            i = i + 1;
            set s.wbuf[s.wpos as u32] = data[i];
            set s.wpos = s.wpos + 1;
            set i = i + 1;
        }
        return s.wpos;
    }
}

instance ReadWriter for Socket {
    fn (s: *mut Socket) flush() -> i32 {
        let pos = s.wpos;
        s.wpos = 0;
        set s.wpos = 0;
        return pos;
    }
}

@default fn main() -> i32 {

        rlen: 5,
        wbuf: undefined,
        wpos: 0,
    };
    // Pre-fill the read buffer with "hello".
    sock.rbuf[0] = 'h' as u8;
    sock.rbuf[1] = 'e' as u8;
    sock.rbuf[2] = 'l' as u8;
    sock.rbuf[3] = 'l' as u8;
    sock.rbuf[4] = 'o' as u8;
    set sock.rbuf[0] = 'h' as u8;
    set sock.rbuf[1] = 'e' as u8;
    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).

test/tests/trait.throws.rad +3 -3

    assert r1 == 10;

    // Error path: negative input.
    let mut caught = false;
    let r2 = try p.parse(-1) catch {
        caught = true;
        set caught = true;
        0
    };
    assert caught;

    // Error path: overflow.
    caught = false;
    set caught = false;
    let r3 = try p.parse(200) catch {
        caught = true;
        set caught = true;
        0
    };
    assert caught;

    return 0;

test/tests/trait.writer.rad +4 -4

        let mut i: u32 = 0;
        while i < data.len {
            if w.pos >= 64 {
                return w.pos;
            }
            w.buf[w.pos as u32] = data[i];
            w.pos = w.pos + 1;
            i = i + 1;
            set w.buf[w.pos as u32] = data[i];
            set w.pos = w.pos + 1;
            set i = i + 1;
        }
        return w.pos;
    }

    fn (w: *BufferWriter) total() -> i32 {

    count: i32,
}

instance Writer for CountingWriter {
    fn (w: *mut CountingWriter) write(data: *[u8]) -> i32 {
        w.count = w.count + data.len as i32;
        set w.count = w.count + data.len as i32;
        return w.inner.write(data);
    }

    fn (w: *CountingWriter) total() -> i32 {
        return w.count;

test/tests/trivial.phi.rad +2 -2

/// If-else with assignments that both assign the same param value.
/// The merge uses %1 (val param) directly - no block param.
fn condSameParam(cond: bool, val: i32) -> i32 {
    let mut result: i32 = 0;
    if cond {
        result = val;
        set result = val;
    } else {
        result = val;
        set result = val;
    }
    return result;
}

test/tests/type.unify.rad +9 -9

    let optComplex: ?i32 = (10 * 2) - 5;

    let opt1: ?i32 = 10;
    let opt2: ?i32 = 20;
    let mut optResult: ?i32 = opt1;
    optResult = opt2;
    set optResult = opt2;

    if let a = optExpr {
        if let b = optComplex {
            return a + b == 20;
        }

/// Verifies assignment compatibility for arrays with identical element types and lengths.
fn testArrayUnification() -> bool {
    let arr1: [i32; 3] = [1, 2, 3];
    let arr2: [i32; 3] = [4, 5, 6];
    let mut arrResult: [i32; 3] = arr1;
    arrResult = arr2;
    set arrResult = arr2;

    return true;
}

/// Verifies assignment compatibility for pointers with identical target types.

    let x: i32 = 42;
    let y: i32 = 24;
    let ptr1: *i32 = &x;
    let ptr2: *i32 = &y;
    let mut ptrResult: *i32 = ptr1;
    ptrResult = ptr2;
    set ptrResult = ptr2;

    return true;
}

/// Verifies conversion from array references to slices.

/// Verifies basic optional assignments between values of the same optional type.
fn testSimpleOptionalValues() -> bool {
    let opt1: ?i32 = 10;
    let opt2: ?i32 = 20;
    let mut result: ?i32 = opt1;
    result = opt2;
    set result = opt2;

    return true;
}

/// Verifies coercion from pointer values to optional pointer values.

/// Verifies optional assignments involving `nil` and concrete values.
fn testNilUnification() -> bool {
    let opt1: ?i32 = nil;
    let opt2: ?i32 = 42;
    let mut result: ?i32 = opt1;
    result = opt2;
    result = nil;
    set result = opt2;
    set result = nil;

    return true;
}

/// Verifies that arrays of different lengths remain distinct types.

    let ptr1: *i32 = &value1;
    let ptr2: *i32 = &value2;
    let ptr3: *i32 = &value3;

    let mut result: *i32 = ptr1;
    result = ptr2;
    result = ptr3;
    set result = ptr2;
    set result = ptr3;

    return true;
}

/// Verifies assignment compatibility for boolean values.
fn testBoolUnification() -> bool {
    let b1: bool = true;
    let b2: bool = false;
    let mut result: bool = b1;
    result = b2;
    set result = b2;

    return true;
}

@default fn main() -> i32 {

test/tests/undefined.rad +5 -5

@default fn main() -> i32 {
    let mut ary: [u16; 32] = undefined;
    let x: u32 = 8;
    let y: u32 = 9;

    ary[0] = 1;
    ary[1] = 2;
    ary[2] = 3;
    ary[3] = 4;
    ary[4] = 5;
    set ary[0] = 1;
    set ary[1] = 2;
    set ary[2] = 3;
    set ary[3] = 4;
    set ary[4] = 5;

    assert x == 8;
    assert y == 9;
    assert ary[0] == 1;
    assert ary[1] == 2;

test/tests/union.edge.case.3.rad +1 -1

record Parser {
    root: Node,
}

fn node(p: *mut Parser, value: Node) -> *Node {
    p.root = value;
    set p.root = value;
    return &p.root;
}

fn nodeBool(p: *mut Parser, value: bool) -> *Node {
    return node(p, Node::Bool(value));

test/tests/union.match.ref.rad +2 -2


/// While-let on a mutable union reference.
fn whileLetRef(ptr: *mut Option) -> u32 {
    let mut sum: u32 = 0;
    while let case Option::Some(val) = ptr {
        sum += *val;
        *ptr = Option::None;
        set sum += *val;
        set *ptr = Option::None;
    }
    return sum;
}

/// Match on an optional reference with binding pattern.

test/tests/union.mixed.assign.rad +2 -2

record Holder {
    value: Mixed,
}

fn storePayload(holder: *mut Holder, value: i32) {
    holder.value = Mixed::Payload(value);
    set holder.value = Mixed::Payload(value);
}

fn storeFinal(holder: *mut Holder) {
    holder.value = Mixed::Final;
    set holder.value = Mixed::Final;
}

fn checkIfLet(value: Mixed) -> i32 {
    if let case Mixed::Payload(v) = value {
        return v;

test/tests/union.payload.mutref.rad +2 -2

}

fn addItemViaMatchRef(blk: *mut Block, val: u32) -> bool {
    match &mut blk.state {
        case Sealed::No { items } => {
            items.data[items.len] = val;
            items.len += 1;
            set items.data[items.len] = val;
            set items.len += 1;
            return true;
        },
        case Sealed::Yes => {
            return false;
        },

test/tests/union.record.forward.rad +1 -1

    ];

    let mut result: u32 = 0;
    match wrappers[7] {
        case Wrapper::Data(payload) => {
            result = payload.f0 + payload.f15;
            set result = payload.f0 + payload.f15;
        }
    }
    return result;
}


test/tests/var.infer.rad +1 -1

@default fn main() -> i32 {
    let inferredFlag = alwaysTrue();
    assert inferredFlag;

    let mut counter = returnsCount();
    counter += 1;
    set counter += 1;
    assert counter == 6;

    let pair = loadPair();
    let left = pair.left;


test/tests/var.shadow.rad +2 -2

// Test variable reuse (not true shadowing)

fn reuseVar() -> i32 {
    let mut x: i32 = 1;
    x = 2;
    set x = 2;
    return x;
}

fn reuseWithComputation() -> i32 {
    let mut x: i32 = 10;
    let y: i32 = x + 5;
    x = 20;
    set x = 20;
    return x + y;
}

224	224		let mut pkgNames: [*[u8]; MAX_PACKAGES] = undefined;
225	225		let mut pkgCount: u32 = 0;
226	226		let mut currentPkgIdx: ?u32 = nil;
227	227
228	228		for i in 0..MAX_PACKAGES {
229		-	moduleCounts[i] = 0;
	229	+	set moduleCounts[i] = 0;
230	230		}
231	231		if args.len == 0 {
232	232		io::printError(USAGE);
233	233		throw Error::Other;
234	234		}

476	476		for i in 1..path.len {
477	477		let child = ast::synthNode(
478	478		arena,
479	479		ast::NodeValue::Ident(strings::intern(&mut STRING_POOL, path[i]))
480	480		);
481		-	result = ast::synthNode(arena, ast::NodeValue::ScopeAccess(ast::Access {
	481	+	set result = ast::synthNode(arena, ast::NodeValue::ScopeAccess(ast::Access {
482	482		parent: result, child,
483	483		}));
484	484		}
485	485		return result;
486	486		}

513	513
514	514		for stmt in block.statements {
515	515		if let case ast::NodeValue::FnDecl(decl) = stmt.value {
516	516		if let fnName = getTestFnName(&decl) {
517	517		if *testCount < tests.len {
518		-	tests[*testCount] = TestDesc { modPath, fnName };
519		-	*testCount += 1;
	518	+	set tests[*testCount] = TestDesc { modPath, fnName };
	519	+	set *testCount += 1;
520	520		} else {
521	521		panic "collectModuleTests: too many tests";
522	522		}
523	523		}
524	524		}

537	537		let nameArg = ast::synthNode(arena, ast::NodeValue::String(desc.fnName));
538	538
539	539		// Intra-package path: skip the package name prefix.
540	540		let mut funcPath: [*[u8]; 16] = undefined;
541	541		for j in 1..desc.modPath.len {
542		-	funcPath[j - 1] = desc.modPath[j];
	542	+	set funcPath[j - 1] = desc.modPath[j];
543	543		}
544		-	funcPath[desc.modPath.len - 1] = desc.fnName;
	544	+	set funcPath[desc.modPath.len - 1] = desc.fnName;
545	545		let funcArg = synthScopeAccess(arena, &funcPath[..desc.modPath.len]);
546	546
547	547		let a = alloc::arenaAllocator(&mut arena.arena);
548	548		let args = ast::nodeSlice(arena, 3)
549	549		.append(modArg, a)

654	654		) {
655	655		let case ast::NodeValue::Block(block) = blockNode.value else {
656	656		panic "injectIntoBlock: expected Block node";
657	657		};
658	658		let stmts = block.statements.append(decl, alloc::arenaAllocator(&mut arena.arena));
659		-	blockNode.value = ast::NodeValue::Block(ast::Block { statements: stmts });
	659	+	set blockNode.value = ast::NodeValue::Block(ast::Block { statements: stmts });
660	660		}
661	661
662	662		/// Write code buffer to file as raw bytes.
663	663		fn writeCode(code: [u32], path: [u8]) -> bool {
664	664		// Convert `u32` slice to `u8` slice (little-endian).

197	197		};
198	198		}
199	199
200	200		/// Consume the next argument, or print an error and throw.
201	201		fn nextArg(args: [[u8]], idx: mut u32, msg: [u8]) -> *[u8] throws (Error) {
202		-	*idx += 1;
	202	+	set *idx += 1;
203	203		if *idx >= args.len {
204	204		io::printError(msg);
205	205		throw Error::Other;
206	206		}
207	207		return args[*idx];

240	240		try nextArg(args, &mut idx, "radiance: `-pkg` requires a package name\n");
241	241		if pkgCount >= MAX_PACKAGES {
242	242		io::printError("radiance: too many packages specified\n");
243	243		throw Error::Other;
244	244		}
245		-	pkgNames[pkgCount] = args[idx];
246		-	currentPkgIdx = pkgCount;
247		-	pkgCount += 1;
	245	+	set pkgNames[pkgCount] = args[idx];
	246	+	set currentPkgIdx = pkgCount;
	247	+	set pkgCount += 1;
248	248		} else if mem::eq(arg, "-mod") {
249	249		try nextArg(args, &mut idx, "radiance: `-mod` requires a module path\n");
250	250		let pkgIdx = currentPkgIdx else {
251	251		io::printError("radiance: `-mod` must follow a `-pkg` argument\n");
252	252		throw Error::Other;
253	253		};
254	254		if moduleCounts[pkgIdx] >= MAX_LOADED_MODULES {
255	255		io::printError("radiance: too many modules specified for package\n");
256	256		throw Error::Other;
257	257		}
258		-	modulePaths[pkgIdx][moduleCounts[pkgIdx]] = args[idx];
259		-	moduleCounts[pkgIdx] += 1;
	258	+	set modulePaths[pkgIdx][moduleCounts[pkgIdx]] = args[idx];
	259	+	set moduleCounts[pkgIdx] += 1;
260	260		} else if mem::eq(arg, "-entry") {
261	261		try nextArg(args, &mut idx, "radiance: `-entry` requires a package name\n");
262		-	entryPkgName = args[idx];
	262	+	set entryPkgName = args[idx];
263	263		} else if mem::eq(arg, "-test") {
264		-	buildTest = true;
	264	+	set buildTest = true;
265	265		} else if mem::eq(arg, "-debug") {
266		-	debugEnabled = true;
	266	+	set debugEnabled = true;
267	267		} else if mem::eq(arg, "-o") {
268	268		try nextArg(args, &mut idx, "radiance: `-o` requires an output path\n");
269		-	outputPath = args[idx];
	269	+	set outputPath = args[idx];
270	270		} else if mem::eq(arg, "-dump") {
271	271		try nextArg(args, &mut idx, "radiance: `-dump` requires a mode (eg. ast)\n");
272	272		let mode = args[idx];
273	273		if mem::eq(mode, "ast") {
274		-	dump = Dump::Ast;
	274	+	set dump = Dump::Ast;
275	275		} else if mem::eq(mode, "graph") {
276		-	dump = Dump::Graph;
	276	+	set dump = Dump::Graph;
277	277		} else if mem::eq(mode, "il") {
278		-	dump = Dump::Il;
	278	+	set dump = Dump::Il;
279	279		} else if mem::eq(mode, "asm") {
280		-	dump = Dump::Asm;
	280	+	set dump = Dump::Asm;
281	281		} else {
282	282		io::printError("radiance: unknown dump mode `");
283	283		io::printError(mode);
284	284		io::printError("` (expected: ast, graph, il, asm)\n");
285	285		throw Error::Other;

288	288		io::printError("radiance: unknown argument `");
289	289		io::printError(arg);
290	290		io::printError("`\n");
291	291		throw Error::Other;
292	292		}
293		-	idx += 1;
	293	+	set idx += 1;
294	294		}
295	295		if pkgCount == 0 {
296	296		io::printError("radiance: no package specified\n");
297	297		throw Error::Other;
298	298		}
299	299
300	300		// Determine entry package index.
301	301		let mut entryPkgIdx: ?u32 = nil;
302	302		if pkgCount == 1 {
303	303		// Single package: it is the entry.
304		-	entryPkgIdx = 0;
	304	+	set entryPkgIdx = 0;
305	305		} else {
306	306		// Multiple packages: need -entry.
307	307		let entryName = entryPkgName else {
308	308		io::printError("radiance: `-entry` required when multiple packages specified\n");
309	309		throw Error::Other;
310	310		};
311	311		for i in 0..pkgCount {
312	312		if mem::eq(pkgNames[i], entryName) {
313		-	entryPkgIdx = i;
	313	+	set entryPkgIdx = i;
314	314		break;
315	315		}
316	316		}
317	317		if entryPkgIdx == nil {
318	318		io::printError("radiance: fatal: entry package `");

680	680		return;
681	681		}
682	682		let mut path: [u8; MAX_PATH_LEN] = undefined;
683	683		let mut pos: u32 = 0;
684	684
685		-	pos += try! mem::copy(&mut path[pos..], basePath);
686		-	pos += try! mem::copy(&mut path[pos..], ext);
687		-	path[pos] = 0; // Null-terminate for syscall.
	685	+	set pos += try! mem::copy(&mut path[pos..], basePath);
	686	+	set pos += try! mem::copy(&mut path[pos..], ext);
	687	+	set path[pos] = 0; // Null-terminate for syscall.
688	688
689	689		if not unix::writeFile(&path[..pos], data) {
690	690		io::printError("radiance: fatal: failed to write data file\n");
691	691		throw Error::Other;
692	692		}

711	711		for i in 0..entries.len {
712	712		let entry = &entries[i];
713	713		let modEntry = module::get(graph, entry.moduleId) else {
714	714		panic "writeDebugInfo: module not found for debug entry";
715	715		};
716		-	pos += try! mem::copy(&mut buf[pos..], @sliceOf(&entry.pc as *u8, 4));
717		-	pos += try! mem::copy(&mut buf[pos..], @sliceOf(&entry.offset as *u8, 4));
718		-	pos += try! mem::copy(&mut buf[pos..], modEntry.filePath);
	716	+	set pos += try! mem::copy(&mut buf[pos..], @sliceOf(&entry.pc as *u8, 4));
	717	+	set pos += try! mem::copy(&mut buf[pos..], @sliceOf(&entry.offset as *u8, 4));
	718	+	set pos += try! mem::copy(&mut buf[pos..], modEntry.filePath);
719	719
720		-	buf[pos] = 0;
721		-	pos += 1;
	720	+	set buf[pos] = 0;
	721	+	set pos += 1;
722	722		}
723	723		try writeDataWithExt(&buf[..pos], basePath, DEBUG_EXT);
724	724		}
725	725
726	726		/// Run the resolver on the parsed modules.

745	745		let mut packages: [resolver::Pkg; MAX_PACKAGES] = undefined;
746	746		for i in 0..ctx.packageCount {
747	747		let pkg = &ctx.packages[i];
748	748		let root = try getRootModule(pkg, &ctx.graph);
749	749
750		-	packages[i] = resolver::Pkg {
	750	+	set packages[i] = resolver::Pkg {
751	751		rootEntry: root.entry,
752	752		rootAst: root.ast,
753	753		};
754	754		}
755	755

197	197
198	198		// Emit placeholder entry jump to default function if there is one.
199	199		// We'll patch this at the end once we know where the function is.
200	200		let mut defaultName: ?*[u8] = nil;
201	201		if let defIdx = program.defaultFnIdx {
202		-	defaultName = program.fns[defIdx].name;
	202	+	set defaultName = program.fns[defIdx].name;
203	203		emit::emit(&mut e, encode::nop()); // Placeholder for two-instruction jump.
204	204		emit::emit(&mut e, encode::nop()); //
205	205		}
206	206
207	207		// Generate code for all functions.

151	151		let savedRegs = mem::popCount(usedCalleeSaved) + 2;
152	152		let totalSize = mem::alignUpI32(
153	153		localSize + savedRegs * super::DWORD_SIZE,
154	154		super::STACK_ALIGNMENT
155	155		);
156		-	frame.totalSize = totalSize;
	156	+	set frame.totalSize = totalSize;
157	157
158	158		// Build list of callee-saved registers with offsets.
159	159		let mut offset = totalSize - (super::DWORD_SIZE * 3);
160	160		for reg, i in super::CALLEE_SAVED {
161	161		// Check if this register is in use.
162	162		if (usedCalleeSaved & (1 << i)) <> 0 {
163		-	frame.savedRegs[frame.savedRegsLen] = SavedReg {
	163	+	set frame.savedRegs[frame.savedRegsLen] = SavedReg {
164	164		reg,
165	165		offset,
166	166		};
167		-	frame.savedRegsLen += 1;
168		-	offset -= super::DWORD_SIZE;
	167	+	set frame.savedRegsLen += 1;
	168	+	set offset -= super::DWORD_SIZE;
169	169		}
170	170		}
171	171		return frame;
172	172		}
173	173

181	181		let funcEntries = try alloc::allocSlice(arena, @sizeOf(dict::Entry), @alignOf(dict::Entry), labels::FUNC_TABLE_SIZE);
182	182		let funcs = try alloc::allocSlice(arena, @sizeOf(types::FuncAddr), @alignOf(types::FuncAddr), MAX_FUNCS);
183	183
184	184		let mut debugEntries: *mut [types::DebugEntry] = &mut [];
185	185		if debug {
186		-	debugEntries = try alloc::allocSlice(
	186	+	set debugEntries = try alloc::allocSlice(
187	187		arena, @sizeOf(types::DebugEntry), @alignOf(types::DebugEntry), MAX_DEBUG_ENTRIES
188	188		) as *mut [types::DebugEntry];
189	189		}
190	190		return Emitter {
191	191		code: code as *mut [u32],

209	209		///////////////////////
210	210
211	211		/// Emit a single instruction.
212	212		export fn emit(e: *mut Emitter, instr: u32) {
213	213		assert e.codeLen < e.code.len, "emit: code buffer full";
214		-	e.code[e.codeLen] = instr;
215		-	e.codeLen += 1;
	214	+	set e.code[e.codeLen] = instr;
	215	+	set e.codeLen += 1;
216	216		}
217	217
218	218		/// Compute branch offset to a function by name.
219	219		export fn branchOffsetToFunc(e: Emitter, srcIndex: u32, name: [u8]) -> i32 {
220	220		return labels::branchToFunc(&e.labels, srcIndex, name, super::INSTR_SIZE);
221	221		}
222	222
223	223		/// Patch an instruction at a given index.
224	224		export fn patch(e: *mut Emitter, index: u32, instr: u32) {
225		-	e.code[index] = instr;
	225	+	set e.code[index] = instr;
226	226		}
227	227
228	228		/// Record a block's address for branch resolution.
229	229		export fn recordBlock(e: *mut Emitter, blockIdx: u32) {
230	230		assert e.codeLen <= MAX_CODE_LEN;

1116	1116		emitMv(s, dst, srcRegs[i]);
1117	1117		} else {
1118	1118		// Load immediate, symbol, or spilled value.
1119	1119		loadVal(s, dst, args[i]);
1120	1120		}
1121		-	found = true;
1122		-	pending[i] = false;
1123		-	numPending -= 1;
	1121	+	set found = true;
	1122	+	set pending[i] = false;
	1123	+	set numPending -= 1;
1124	1124
1125	1125		break;
1126	1126		}
1127	1127		}
1128	1128		}

1175	1175		} else {
1176	1176		let rs = resolveVal(s, super::SCRATCH1, arg);
1177	1177		emit::emitSd(s.e, rs, spillBase(s), spillOffset(s, slot));
1178	1178		}
1179	1179		} else {
1180		-	dsts[i] = getReg(s, param);
	1180	+	set dsts[i] = getReg(s, param);
1181	1181		}
1182	1182		}
1183	1183		emitParallelMoves(s, &dsts[..], args);
1184	1184		}
1185	1185

238	238		}
239	239
240	240		/// Record a function's start position for printing.
241	241		export fn recordFunc(e: mut Emitter, name: [u8]) {
242	242		assert e.funcsLen < e.funcs.len, "recordFunc: funcs buffer full";
243		-	e.funcs[e.funcsLen] = types::FuncAddr { name, index: e.codeLen };
244		-	e.funcsLen += 1;
	243	+	set e.funcs[e.funcsLen] = types::FuncAddr { name, index: e.codeLen };
	244	+	set e.funcsLen += 1;
245	245		}
246	246
247	247		/// Record a local branch needing later patching.
248	248		/// Unconditional jumps use a single slot (J-type, +-1MB range).
249	249		/// Conditional branches use two slots (B-type has only +-4KB range,
250	250		/// so large functions may need the inverted-branch + JAL fallback).
251	251		export fn recordBranch(e: *mut Emitter, targetBlock: u32, kind: BranchKind) {
252	252		assert e.pendingBranchesLen < e.pendingBranches.len, "recordBranch: buffer full";
253		-	e.pendingBranches[e.pendingBranchesLen] = PendingBranch {
	253	+	set e.pendingBranches[e.pendingBranchesLen] = PendingBranch {
254	254		index: e.codeLen,
255	255		target: targetBlock,
256	256		kind: kind,
257	257		};
258		-	e.pendingBranchesLen += 1;
	258	+	set e.pendingBranchesLen += 1;
259	259
260	260		emit(e, encode::nop()); // First slot, always needed.
261	261
262	262		match kind {
263	263		case BranchKind::Jump => {},

268	268		/// Record a function call needing later patching.
269	269		/// Emits placeholder instructions that will be patched later.
270	270		/// Uses two slots to support long-distance calls.
271	271		export fn recordCall(e: mut Emitter, target: [u8]) {
272	272		assert e.pendingCallsLen < e.pendingCalls.len, "recordCall: buffer full";
273		-	e.pendingCalls[e.pendingCallsLen] = PendingCall {
	273	+	set e.pendingCalls[e.pendingCallsLen] = PendingCall {
274	274		index: e.codeLen,
275	275		target,
276	276		};
277		-	e.pendingCallsLen += 1;
	277	+	set e.pendingCallsLen += 1;
278	278
279	279		emit(e, encode::nop()); // Placeholder for AUIPC.
280	280		emit(e, encode::nop()); // Placeholder for JALR.
281	281		}
282	282
283	283		/// Record a function address load needing later patching.
284	284		/// Emits placeholder instructions that will be patched to load the function's address.
285	285		/// Uses two slots to compute long-distance addresses.
286	286		export fn recordAddrLoad(e: mut Emitter, target: [u8], rd: gen::Reg) {
287	287		assert e.pendingAddrLoadsLen < e.pendingAddrLoads.len, "recordAddrLoad: buffer full";
288		-	e.pendingAddrLoads[e.pendingAddrLoadsLen] = PendingAddrLoad {
	288	+	set e.pendingAddrLoads[e.pendingAddrLoadsLen] = PendingAddrLoad {
289	289		index: e.codeLen,
290	290		target,
291	291		rd: rd,
292	292		};
293		-	e.pendingAddrLoadsLen += 1;
	293	+	set e.pendingAddrLoadsLen += 1;
294	294
295	295		emit(e, encode::nop()); // Placeholder for AUIPC.
296	296		emit(e, encode::nop()); // Placeholder for ADDI.
297	297		}
298	298

332	332		assert encode::isJumpImm(offset), "patchLocalBranches: jump offset too large";
333	333		patch(e, p.index, encode::jal(super::ZERO, offset));
334	334		},
335	335		}
336	336		}
337		-	e.pendingBranchesLen = 0;
	337	+	set e.pendingBranchesLen = 0;
338	338		}
339	339
340	340		/// Encode a conditional branch instruction.
341	341		fn encodeCondBranch(op: il::CmpOp, rs1: gen::Reg, rs2: gen::Reg, offset: i32) -> u32 {
342	342		match op {

406	406		let lo = imm & 0xFFF;
407	407		let mut hi = (imm >> 12) & 0xFFFFF;
408	408		// If `lo`'s sign bit is set, it will be sign-extended to negative.
409	409		// Compensate by incrementing `hi`.
410	410		if (lo & 0x800) <> 0 {
411		-	hi += 1;
	411	+	set hi += 1;
412	412		return SplitImm { hi, lo: lo \| 0xFFFFF000 as i32 };
413	413		}
414	414		return SplitImm { hi, lo };
415	415		}
416	416

664	664		if prev.offset == loc.offset and prev.moduleId == loc.moduleId {
665	665		return;
666	666		}
667	667		}
668	668		assert e.debugEntriesLen < e.debugEntries.len, "recordSrcLoc: debug entry buffer full";
669		-	e.debugEntries[e.debugEntriesLen] = types::DebugEntry {
	669	+	set e.debugEntries[e.debugEntriesLen] = types::DebugEntry {
670	670		pc,
671	671		moduleId: loc.moduleId,
672	672		offset: loc.offset,
673	673		};
674		-	e.debugEntriesLen += 1;
	674	+	set e.debugEntriesLen += 1;
675	675		}
676	676
677	677		/// Get debug entries as a slice.
678	678		export fn getDebugEntries(e: Emitter) -> [types::DebugEntry] {
679	679		return &e.debugEntries[..e.debugEntriesLen];

144	144		/// If the register is spilled, records a pending spill and returns the scratch
145	145		/// register. The pending spill is auto-committed by [`selectBlock`] after each
146	146		/// instruction. If not spilled, returns the physical register.
147	147		fn getDstReg(s: *mut Selector, ssa: il::Reg, scratch: gen::Reg) -> gen::Reg {
148	148		if let _ = regalloc::spill::spillSlot(&s.ralloc.spill, ssa) {
149		-	s.pendingSpill = PendingSpill { ssa, rd: scratch };
	149	+	set s.pendingSpill = PendingSpill { ssa, rd: scratch };
150	150		return scratch;
151	151		}
152	152		return getReg(s, ssa);
153	153		}
154	154

255	255		/// Resolve a value, trap if zero (unless known non-zero), and return the register.
256	256		fn resolveAndTrapIfZero(s: *mut Selector, b: il::Val) -> gen::Reg {
257	257		let rs2 = resolveVal(s, super::SCRATCH2, b);
258	258		let mut knownNonZero = false;
259	259		if let case il::Val::Imm(imm) = b {
260		-	knownNonZero = imm <> 0;
	260	+	set knownNonZero = imm <> 0;
261	261		}
262	262		if not knownNonZero {
263	263		emit::emit(s.e, encode::bne(rs2, super::ZERO, super::INSTR_SIZE * 2));
264	264		emit::emit(s.e, encode::ebreak());
265	265		}

288	288		let block = &func.blocks[b];
289	289		for instr in block.instrs {
290	290		match instr {
291	291		case il::Instr::Reserve { size, alignment, .. } => {
292	292		if let case il::Val::Imm(sz) = size {
293		-	offset = mem::alignUpI32(offset, alignment as i32);
294		-	offset += sz as i32;
	293	+	set offset = mem::alignUpI32(offset, alignment as i32);
	294	+	set offset += sz as i32;
295	295		} else {
296		-	isDynamic = true;
	296	+	set isDynamic = true;
297	297		}
298	298		},
299	299		else => {},
300	300		}
301	301		}

379	379		for instr, i in block.instrs {
380	380		// Record debug location before emitting machine instructions.
381	381		if hasLocs {
382	382		emit::recordSrcLoc(s.e, block.locs[i]);
383	383		}
384		-	s.pendingSpill = nil;
	384	+	set s.pendingSpill = nil;
385	385		selectInstr(s, blockIdx, instr, frame, func);
386	386
387	387		// Flush the pending spill store, if any.
388	388		if let p = s.pendingSpill {
389	389		if let slot = regalloc::spill::spillSlot(&s.ralloc.spill, p.ssa) {
390	390		emit::emitSd(s.e, p.rd, spillBase(s), spillOffset(s, slot));
391	391		}
392		-	s.pendingSpill = nil;
	392	+	set s.pendingSpill = nil;
393	393		}
394	394		}
395	395		}
396	396
397	397		/// Select instructions for a single IL instruction.

436	436		let base = spillBase(s);
437	437		let offset = s.ralloc.spill.frameSize + aligned
438	438		- (s.frameSize if s.isDynamic else 0);
439	439
440	440		emit::emitAddImm(s.e, rd, base, offset);
441		-	s.reserveOffset = aligned + (sz as i32);
	441	+	set s.reserveOffset = aligned + (sz as i32);
442	442		},
443	443		case il::Val::Reg(r) => {
444	444		// Dynamic-sized reserve: runtime SP adjustment.
445	445		let rd = getDstReg(s, dst, super::SCRATCH1);
446	446		let rs = getSrcReg(s, r, super::SCRATCH2);

482	482		};
483	483		let srcSlot = regalloc::spill::spillSlot(&s.ralloc.spill, src) else {
484	484		panic "selectInstr: blit src not spilled";
485	485		};
486	486		emit::emitLd(s.e, super::SCRATCH2, spillBase(s), spillOffset(s, dstSlot));
487		-	srcReload = spillOffset(s, srcSlot);
	487	+	set srcReload = spillOffset(s, srcSlot);
488	488		} else {
489		-	rdst = getSrcReg(s, dst, super::SCRATCH2);
490		-	rsrc = getSrcReg(s, src, super::SCRATCH2);
	489	+	set rdst = getSrcReg(s, dst, super::SCRATCH2);
	490	+	set rsrc = getSrcReg(s, src, super::SCRATCH2);
491	491		}
492	492		let mut offset: i32 = 0;
493	493		let mut remaining = staticSize as i32;
494	494
495	495		// For large blits where both pointers are in real registers,

512	512		emit::emit(s.e, encode::addi(rdst, rdst, super::DWORD_SIZE));
513	513		}
514	514		let brOff = (loopStart as i32 - s.e.codeLen as i32) * super::INSTR_SIZE;
515	515
516	516		emit::emit(s.e, encode::bne(rsrc, super::SCRATCH1, brOff));
517		-	remaining -= dwordBytes;
	517	+	set remaining -= dwordBytes;
518	518		}
519	519
520	520		// Copy remaining: 8 bytes, then 4 bytes, then 1 byte at a time.
521	521		// Before each load/store pair, check whether the offset is
522	522		// about to exceed the 12-bit signed immediate range. When

526	526		if offset > super::MAX_IMM - super::DWORD_SIZE {
527	527		emit::emitAddImm(s.e, rsrc, rsrc, offset);
528	528		if rdst <> rsrc {
529	529		emit::emitAddImm(s.e, rdst, rdst, offset);
530	530		}
531		-	offset = 0;
	531	+	set offset = 0;
532	532		}
533	533		if let off = srcReload {
534	534		emit::emitLd(s.e, super::SCRATCH1, spillBase(s), off);
535	535		emit::emitLd(s.e, super::SCRATCH1, super::SCRATCH1, offset);
536	536		} else {
537	537		emit::emitLd(s.e, super::SCRATCH1, rsrc, offset);
538	538		}
539	539		emit::emitSd(s.e, super::SCRATCH1, rdst, offset);
540		-	offset += super::DWORD_SIZE;
541		-	remaining -= super::DWORD_SIZE;
	540	+	set offset += super::DWORD_SIZE;
	541	+	set remaining -= super::DWORD_SIZE;
542	542		}
543	543		if remaining >= super::WORD_SIZE {
544	544		if offset > super::MAX_IMM - super::WORD_SIZE {
545	545		emit::emitAddImm(s.e, rsrc, rsrc, offset);
546	546		if rdst <> rsrc {
547	547		emit::emitAddImm(s.e, rdst, rdst, offset);
548	548		}
549		-	offset = 0;
	549	+	set offset = 0;
550	550		}
551	551		if let off = srcReload {
552	552		emit::emitLd(s.e, super::SCRATCH1, spillBase(s), off);
553	553		emit::emitLw(s.e, super::SCRATCH1, super::SCRATCH1, offset);
554	554		} else {
555	555		emit::emitLw(s.e, super::SCRATCH1, rsrc, offset);
556	556		}
557	557		emit::emitSw(s.e, super::SCRATCH1, rdst, offset);
558		-	offset += super::WORD_SIZE;
559		-	remaining -= super::WORD_SIZE;
	558	+	set offset += super::WORD_SIZE;
	559	+	set remaining -= super::WORD_SIZE;
560	560		}
561	561		while remaining > 0 {
562	562		if offset > super::MAX_IMM - 1 {
563	563		emit::emitAddImm(s.e, rsrc, rsrc, offset);
564	564		if rdst <> rsrc {
565	565		emit::emitAddImm(s.e, rdst, rdst, offset);
566	566		}
567		-	offset = 0;
	567	+	set offset = 0;
568	568		}
569	569		if let off = srcReload {
570	570		emit::emitLd(s.e, super::SCRATCH1, spillBase(s), off);
571	571		emit::emitLb(s.e, super::SCRATCH1, super::SCRATCH1, offset);
572	572		} else {
573	573		emit::emitLb(s.e, super::SCRATCH1, rsrc, offset);
574	574		}
575	575		emit::emitSb(s.e, super::SCRATCH1, rdst, offset);
576		-	offset += 1;
577		-	remaining -= 1;
	576	+	set offset += 1;
	577	+	set remaining -= 1;
578	578		}
579	579		// Restore base registers if they were advanced (never happens
580	580		// in the both-spilled case since size <= MAX_IMM).
581	581		if not bothSpilled {
582	582		let advanced = staticSize as i32 - offset;

639	639		// Skip extension for zero register.
640	640		// Determine extension mode: sign-extend for W32 or SLT,
641	641		// zero-extend otherwise.
642	642		let mut useSext: bool = undefined;
643	643		if let case il::CmpOp::Slt = op {
644		-	useSext = true;
	644	+	set useSext = true;
645	645		} else {
646		-	useSext = typ == il::Type::W32;
	646	+	set useSext = typ == il::Type::W32;
647	647		}
648	648		if useSext {
649	649		if not aIsZero and not isExtendedImm(a, typ, true) {
650	650		emitSext(s.e, rs1, rs1, typ);
651	651		}

697	697		for c in cases {
698	698		emit::loadImm(s.e, super::SCRATCH2, c.value);
699	699
700	700		if c.args.len > 0 {
701	701		let skip = s.nextSynthBlock;
702		-	s.nextSynthBlock = skip + 1;
	702	+	set s.nextSynthBlock = skip + 1;
703	703
704	704		emit::recordBranch(s.e, skip, emit::BranchKind::InvertedCond {
705	705		op: il::CmpOp::Eq, rs1, rs2: super::SCRATCH2,
706	706		});
707	707		emitBlockArgs(s, func, c.target, c.args);

1062	1062		if dst <> super::ZERO { // Skip entries with no destination.
1063	1063		match args[i] {
1064	1064		case il::Val::Reg(r) => {
1065	1065		if let _ = regalloc::spill::spillSlot(&s.ralloc.spill, r) {
1066	1066		// Spilled value needs load, not a register move.
1067		-	pending[i] = true;
1068		-	numPending += 1;
	1067	+	set pending[i] = true;
	1068	+	set numPending += 1;
1069	1069		} else {
1070	1070		let src = getReg(s, r);
1071	1071		if src <> dst {
1072	1072		// Register-to-register move needed.
1073		-	srcRegs[i] = src;
1074		-	isRegMove[i] = true;
1075		-	pending[i] = true;
1076		-	numPending += 1;
	1073	+	set srcRegs[i] = src;
	1074	+	set isRegMove[i] = true;
	1075	+	set pending[i] = true;
	1076	+	set numPending += 1;
1077	1077		} else {
1078	1078		// No move needed.
1079	1079		}
1080	1080		}
1081	1081		},
1082	1082		case il::Val::Imm(_), il::Val::DataSym(_), il::Val::FnAddr(_) => {
1083		-	pending[i] = true;
1084		-	numPending += 1;
	1083	+	set pending[i] = true;
	1084	+	set numPending += 1;
1085	1085		},
1086	1086		case il::Val::Undef => {
1087	1087		// Undefined values don't need any move.
1088	1088		}
1089	1089		}

1104	1104		let mut isReady = true;
1105	1105
1106	1106		// Check if `dst` is used as source by any other pending register move.
1107	1107		for j in 0..n {
1108	1108		if j <> i and pending[j] and isRegMove[j] and srcRegs[j] == dst {
1109		-	isReady = false;
	1109	+	set isReady = false;
1110	1110		break;
1111	1111		}
1112	1112		}
1113	1113		if isReady {
1114	1114		// Execute this move.

1136	1136		// Save this source to scratch.
1137	1137		emitMv(s, super::SCRATCH1, src);
1138	1138		// Update all pending moves that use this source.
1139	1139		for j in 0..n {
1140	1140		if pending[j] and isRegMove[j] and srcRegs[j] == src {
1141		-	srcRegs[j] = super::SCRATCH1;
	1141	+	set srcRegs[j] = super::SCRATCH1;
1142	1142		}
1143	1143		}
1144	1144		break;
1145	1145		}
1146	1146		}

91	91		fn writeMnem(out: mut sexpr::Output, m: [u8]) {
92	92		write(out, m);
93	93		let mut i = m.len;
94	94		while i < MNEMONIC_WIDTH {
95	95		write(out, " ");
96		-	i += 1;
	96	+	set i += 1;
97	97		}
98	98		}
99	99
100	100		////////////////////////////////
101	101		// Instruction Format Helpers //

23	23
24	24		/// Create a dict backed by the given entry storage.
25	25		/// The storage length must be a power of two.
26	26		export fn init(entries: *mut [Entry]) -> Dict {
27	27		for i in 0..entries.len {
28		-	entries[i] = Entry { key: &[], value: 0 };
	28	+	set entries[i] = Entry { key: &[], value: 0 };
29	29		}
30	30		return Dict { entries, count: 0 };
31	31		}
32	32
33	33		/// Insert or update a key-value pair. Panics if the table exceeds 50% load.