radiance · commit

compiler/radiance.rad +15 -25

        io::printError("radiance: error setting source\n");
        throw Error::Other;
    };
}

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

/// Parse CLI arguments and return compilation context.
fn processCommand(
    args: *[*[u8]],
    arena: *mut ast::NodeArena
) -> CompileContext throws (Error) {

    let mut idx: u32 = 0;

    while idx < args.len {
        let arg = args[idx];
        if mem::eq(arg, "-pkg") {
            idx += 1;
            if idx >= args.len {
                io::printError("radiance: `-pkg` requires a package name\n");
                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;
        } else if mem::eq(arg, "-mod") {
            idx += 1;
            if idx >= args.len {
                io::printError("radiance: `-mod` requires a module path\n");
                throw Error::Other;
            }
            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 {

                throw Error::Other;
            }
            modulePaths[pkgIdx][moduleCounts[pkgIdx]] = args[idx];
            moduleCounts[pkgIdx] += 1;
        } else if mem::eq(arg, "-entry") {
            idx += 1;
            if idx >= args.len {
                io::printError("radiance: `-entry` requires a package name\n");
                throw Error::Other;
            }
            try nextArg(args, &mut idx, "radiance: `-entry` requires a package name\n");
            entryPkgName = args[idx];
        } else if mem::eq(arg, "-test") {
            buildTest = true;
        } else if mem::eq(arg, "-debug") {
            debugEnabled = true;
        } else if mem::eq(arg, "-o") {
            idx += 1;
            if idx >= args.len {
                io::printError("radiance: `-o` requires an output path\n");
                throw Error::Other;
            }
            try nextArg(args, &mut idx, "radiance: `-o` requires an output path\n");
            outputPath = args[idx];
        } else if mem::eq(arg, "-dump") {
            idx += 1;
            if idx >= args.len {
                io::printError("radiance: `-dump` requires a mode (eg. ast)\n");
                throw Error::Other;
            }
            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;
            } else if mem::eq(mode, "graph") {
                dump = Dump::Graph;

lib/std/arch/rv64/encode.rad +0 -12

/// Implemented as `blt rs2, rs1, imm` (swap operands).
pub fn bgt(rs1: super::Reg, rs2: super::Reg, imm: i32) -> u32 {
    return blt(rs2, rs1, imm);
}

/// Branch if less than or equal unsigned: `if (rs1 <= rs2) pc += imm`.
/// Implemented as `bgeu rs2, rs1, imm` (swap operands).
pub fn bleu(rs1: super::Reg, rs2: super::Reg, imm: i32) -> u32 {
    return bgeu(rs2, rs1, imm);
}

/// Branch if greater than unsigned: `if (rs1 > rs2) pc += imm`.
/// Implemented as `bltu rs2, rs1, imm` (swap operands).
pub fn bgtu(rs1: super::Reg, rs2: super::Reg, imm: i32) -> u32 {
    return bltu(rs2, rs1, imm);
}

/// Set if equal to zero: `rd = (rs == 0) ? 1 : 0`.
/// Implemented as `sltiu rd, rs, 1`.
pub fn seqz(rd: super::Reg, rs: super::Reg) -> u32 {
    return sltiu(rd, rs, 1);
}

lib/std/arch/rv64/isel.rad +18 -30

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

/// Resolve a value, trap if zero (unless known non-zero), and return the register.
fn resolveAndTrapIfZero(s: *mut Selector, b: il::Val) -> super::Reg {
    let rs2 = resolveVal(s, super::SCRATCH2, b);
    let mut knownNonZero = false;
    if let case il::Val::Imm(imm) = b {
        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());
    }
    return rs2;
}

////////////////////////
// Instruction Select //
////////////////////////

/// Pre-scan result for reserve analysis.

        return imm == 0;
    }
    return false;
}

/// Check if a value is a known non-zero immediate.
fn isNonZeroImm(val: il::Val) -> bool {
    if let case il::Val::Imm(imm) = val {
        return imm != 0;
    }
    return false;
}

/// Emit runtime trap for division/modulo by zero.
fn emitTrapIfZero(s: *mut Selector, rs: super::Reg) {
    emit::emit(s.e, encode::bne(rs, super::ZERO, super::INSTR_SIZE * 2));
    emit::emit(s.e, encode::ebreak());
}

/// Select a binary ALU operation, dispatching to the appropriate
/// instruction pattern based on the operation kind and type.
fn selectAluBinOp(s: *mut Selector, op: il::BinOp, typ: il::Type, rd: super::Reg, rs1: super::Reg, b: il::Val) {
    match op {
        case il::BinOp::Add => {

                        if typ == il::Type::W32 else
                    encode::mul(rd, rs1, rs2));
            }
        }
        case il::BinOp::Sdiv => {
            let rs2 = resolveVal(s, super::SCRATCH2, b);
            if not isNonZeroImm(b) {
                emitTrapIfZero(s, rs2);
            }
            let rs2 = resolveAndTrapIfZero(s, b);
            emit::emit(s.e,
                encode::divw(rd, rs1, rs2)
                    if typ == il::Type::W32 else
                encode::div(rd, rs1, rs2));
        }
        case il::BinOp::Udiv => {
            let rs2 = resolveVal(s, super::SCRATCH2, b);
            if not isNonZeroImm(b) {
                emitTrapIfZero(s, rs2);
            }
            let rs2 = resolveAndTrapIfZero(s, b);
            emit::emit(s.e,
                encode::divuw(rd, rs1, rs2)
                    if typ == il::Type::W32 else
                encode::divu(rd, rs1, rs2));
        }
        case il::BinOp::Srem => {
            let rs2 = resolveVal(s, super::SCRATCH2, b);
            if not isNonZeroImm(b) {
                emitTrapIfZero(s, rs2);
            }
            let rs2 = resolveAndTrapIfZero(s, b);
            emit::emit(s.e,
                encode::remw(rd, rs1, rs2)
                    if typ == il::Type::W32 else
                encode::rem(rd, rs1, rs2));
        }
        case il::BinOp::Urem => {
            let rs2 = resolveVal(s, super::SCRATCH2, b);
            if not isNonZeroImm(b) {
                emitTrapIfZero(s, rs2);
            }
            let rs2 = resolveAndTrapIfZero(s, b);
            emit::emit(s.e,
                encode::remuw(rd, rs1, rs2)
                    if typ == il::Type::W32 else
                encode::remu(rd, rs1, rs2));
        }

lib/std/arch/rv64/printer.rad +0 -14

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

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

/// Print spaces for indentation.
fn writeIndent(out: *mut sexpr::Output) {
    write(out, "  ");
}

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

            return funcs[i].name;
        }
    }
    return nil;
}

/// Print code with labels to buffer, returns slice.
pub fn printCode(pkgName: *[u8], code: *[u32], funcs: *[types::FuncAddr], arena: *mut alloc::Arena, buf: *mut [u8]) -> *[u8] {
    let mut pos: u32 = 0;
    let mut out = sexpr::Output::Buffer { buf, pos: &mut pos };
    printCodeTo(&mut out, pkgName, code, funcs, arena);

    return &buf[..pos];
}

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

use std::lang::alloc;

/// Maximum number of trait methods.
pub const MAX_TRAIT_METHODS: u32 = 8;

/// Maximum number of supertraits.
pub const MAX_SUPERTRAITS: u32 = 4;

/// Arena for all parser allocations.
///
/// Uses a bump allocator for both AST nodes and node pointer arrays.
pub record NodeArena {
    /// Bump allocator for all allocations.

lib/std/lang/gen/data.rad +0 -11

    if let v = dict::get(&m.dict, name) {
        return v as u32;
    }
    return nil;
}

/// Resolve a data symbol to its final absolute address (linear scan fallback).
pub fn lookupDataSymAddr(dataSyms: *[DataSym], name: *[u8]) -> ?u32 {
    for i in 0..dataSyms.len {
        let sym = dataSyms[i];
        if mem::eq(sym.name, name) {
            return sym.addr;
        }
    }
    return nil;
}

lib/std/lang/gen/regalloc/assign.rad +5 -10

                    assignments[dst.n] = rallocReg(&mut current, &mut usedRegs, dst.n, allocatable, config.calleeSaved, spillInfo);
                }
            }
        }
        // Save block-end state.
        rmapCopy(&mut blkEnd[b], &current);
        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];
        }
    }
    // Compute bitmask of used callee-saved registers.
    let mut usedCalleeSaved: u32 = 0;
    for i in 0..maxReg {
        if let phys = assignments[i] {

    let physRegs = try alloc::allocSlice(arena, @sizeOf(u8), @alignOf(u8), MAX_ACTIVE) as *mut [u8];

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

/// Copy a register map.
fn rmapCopy(dst: *mut RegMap, src: *RegMap) {
    dst.n = src.n;
    for i in 0..src.n {
        dst.virtRegs[i] = src.virtRegs[i];
        dst.physRegs[i] = src.physRegs[i];
    }
}

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

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

}

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

/// Call a function for each register used by an instruction.

            withReg(a0, f, ctx);
            withReg(a1, f, ctx);
            withReg(a2, f, ctx);
            withReg(a3, f, ctx);
        },
        case Instr::Unreachable => {},
        case Instr::Ebreak => {},
        case Instr::Unreachable,
             Instr::Ebreak => {},
    }
}

/// Call callback if value is a register.
fn withReg(val: Val, callback: fn(Reg, *mut opaque), ctx: *mut opaque) {

lib/std/lang/il/printer.rad +11 -24


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

/// Copy a byte slice into arena-allocated storage.
fn copyToArena(a: *mut alloc::Arena, text: *[u8]) -> *[u8] {
    let slice = try! alloc::allocSlice(a, 1, 1, text.len) as *mut [u8];
    try! mem::copy(slice, text);
    return slice;
}

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

    return slice;
    return copyToArena(a, fmt::formatU32(val, &mut digits[..]));
}

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

    return slice;
    return copyToArena(a, fmt::formatI32(val, &mut digits[..]));
}

/// Format an `i64` into a string in the arena.
fn formatI64(a: *mut alloc::Arena, val: i64) -> *[u8] {
    let mut digits: [u8; 20] = undefined;
    let text = fmt::formatI64(val, &mut digits[..]);
    let ptr = try! alloc::allocSlice(a, 1, 1, text.len);
    let slice = ptr as *mut [u8];
    try! mem::copy(slice, text);

    return slice;
    return copyToArena(a, fmt::formatI64(val, &mut digits[..]));
}

/// Concatenate prefix and string in the arena.
fn prefixStr(a: *mut alloc::Arena, prefix: u8, str: *[u8]) -> *[u8] {
    let len = str.len + 1;

    for _ in 0..depth {
        write(out, "    ");
    }
}

/// Write a quoted string with escaping.
fn writeString(out: *mut sexpr::Output, s: *[u8]) {
    sexpr::printStringTo(out, s);
}

/// Check if name contains the path separator.
fn needsQuoting(name: *[u8]) -> bool {
    for ch in name {
        if ch == ':' {
            return true;

            write(out, "fn ");
            writeSymbol(out, name);
        }
        case super::DataItem::Str(s) => {
            write(out, "str ");
            writeString(out, s);
            sexpr::printStringTo(out, s);
        }
        case super::DataItem::Undef => {
            write(out, "undef");
        }
    }

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

        lengthVal: il::Val,
        elemType: *resolver::Type,
    },
}


//////////////////////////////
// Pattern Matching Support //
//////////////////////////////

// Match expressions are lowered by evaluating the subject once, then emitting

    let reg = il::Reg { n: self.regCounter };
    self.regCounter += 1;
    return reg;
}

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

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

/// Remove the last block parameter and its associated variable.
/// Used when detecting a trivial phi that can be eliminated.
fn removeLastBlockParam(self: *mut FnLowerer, block: BlockId) {
    let blk = getBlockMut(self, block);
    if blk.params.len > 0 {

    thenBlock: BlockId,
    elseBlock: BlockId
) throws (LowerError) {
    // Try fused compare-and-branch for simple scalar comparisons.
    if let case ast::NodeValue::BinOp(binop) = cond.value {
        let leftTy = resolver::typeFor(self.low.resolver, binop.left) else {
            throw LowerError::MissingType(binop.left);
        };
        let rightTy = resolver::typeFor(self.low.resolver, binop.right) else {
            throw LowerError::MissingType(binop.right);
        };
        let leftTy = try typeOf(self, binop.left);
        let rightTy = try typeOf(self, binop.right);
        if not isAggregateType(leftTy) and not isAggregateType(rightTy) {
            let unsigned = isUnsignedType(leftTy);
            if let op = cmpOpFrom(binop.op, unsigned) {
                let a = try lowerExpr(self, binop.left);
                let b = try lowerExpr(self, binop.right);

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

/// Emit a 32-bit store instruction with default alignment.
fn emitStoreW32(self: *mut FnLowerer, src: il::Val, dst: il::Reg) {
    emitStoreW32At(self, src, dst, 0);
}

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

/// Emit a 32-bit load instruction with default alignment.
fn emitLoadW32(self: *mut FnLowerer, dst: il::Reg, src: il::Reg) {
    emitLoadW32At(self, dst, src, 0);
}

/// Emit an 8-bit store instruction.
fn emitStoreW8(self: *mut FnLowerer, src: il::Val, dst: il::Reg) {
    emit(self, il::Instr::Store { typ: il::Type::W8, src, dst, offset: 0 });
}

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

/// Emit an 8-bit load instruction.
fn emitLoadW8(self: *mut FnLowerer, dst: il::Reg, src: il::Reg) {
    emit(self, il::Instr::Load { typ: il::Type::W8, dst, src, offset: 0 });
}

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

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

/// Emit a 64-bit store instruction with default alignment.
fn emitStoreW64(self: *mut FnLowerer, src: il::Val, dst: il::Reg) {
    emitStoreW64At(self, src, dst, 0);
}

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

/// Emit a 64-bit load instruction with default alignment.
fn emitLoadW64(self: *mut FnLowerer, dst: il::Reg, src: il::Reg) {
    emitLoadW64At(self, dst, src, 0);
}

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

        }
    }
    return sameVal;
}

/// Patch switch case arguments for a specific target.
// TODO: Inline this when we don't have register pressure issues.
fn patchSwitchCases(self: *mut FnLowerer, cases: *mut [il::SwitchCase], target: u32, paramIdx: u32, val: il::Val) {
    let idx = paramIdx + 1;
    for i in 0..cases.len {
        if cases[i].target == target {
            cases[i].args = growArgs(self, cases[i].args, idx);
            cases[i].args[paramIdx] = val;
        }
    }
}

/// Patch a single terminator argument for a specific edge. This is used during
/// SSA construction to pass variable values along control flow edges.
fn patchTerminatorArg(
    self: *mut FnLowerer,
    from: BlockId,         // The predecessor block containing the terminator to patch.

        case il::Instr::Switch { defaultTarget, defaultArgs, cases, .. } => {
            if *defaultTarget == target {
                *defaultArgs = growArgs(self, *defaultArgs, paramIdx + 1);
                defaultArgs[paramIdx] = val;
            }
            patchSwitchCases(self, *cases, target, 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;
                }
            }
        }
        else => {
            // Other terminators (e.g. `Ret`, `Unreachable`) don't have successor blocks.
        }
    }

}

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

    // When matching an aggregate by value, copy it to a fresh stack slot so
    // that bindings are independent of the original memory.  Without this,
    // the lowerer returns a pointer into the source and mutations to the

    }
}

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

    let payloadBase = emitPtrOffset(self, base, valOffset);

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

/// Emit a field read from a base pointer.
fn emitFieldRead(self: *mut FnLowerer, base: il::Reg, fieldInfo: resolver::RecordField, matchBy: resolver::MatchBy) -> il::Val {
    match matchBy {
        case resolver::MatchBy::Value => {
            return emitRead(self, base, fieldInfo.offset, fieldInfo.fieldType);
        }
        case resolver::MatchBy::Ref, resolver::MatchBy::MutRef => {
            return il::Val::Reg(emitPtrOffset(self, base, fieldInfo.offset));
        }
    }
}

/// Bind a single record field to a pattern variable, with support for nested
/// pattern tests that branch to `failBlock` on mismatch.
fn bindFieldVariable(
    self: *mut FnLowerer,
    binding: *ast::Node,

    matchBy: resolver::MatchBy,
    failBlock: BlockId
) throws (LowerError) {
    match binding.value {
        case ast::NodeValue::Ident(name) => {
            let val = emitFieldRead(self, base, fieldInfo, matchBy);
            let val = emitRead(self, base, fieldInfo.offset, fieldInfo.fieldType)
                if matchBy == resolver::MatchBy::Value
                else il::Val::Reg(emitPtrOffset(self, base, fieldInfo.offset));
            newVar(self, name, ilType(self.low, fieldInfo.fieldType), false, val);
        }
        case ast::NodeValue::Placeholder => {}
        case ast::NodeValue::RecordLit(lit) => {
            // Check if this record literal is a union variant pattern.

            // Auto-deref: if the field is a pointer, load it first.
            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);
                emitLoadW64(self, ptrReg, nestedBase);
                emitLoadW64At(self, ptrReg, nestedBase, 0);
                nestedBase = ptrReg;
                derefType = *target;
            }
            let recInfo = resolver::getRecord(derefType)
                else throw LowerError::ExpectedRecord;

    // The loaded pointer becomes the base address for the nested subject.
    let mut derefBase: ?il::Reg = nil;
    if let case resolver::Type::Pointer { target, .. } = fieldType {
        if resolver::isDestructuringPattern(pattern) {
            let ptrReg = nextReg(self);
            emitLoadW64(self, ptrReg, fieldPtr);
            emitLoadW64At(self, ptrReg, fieldPtr, 0);
            derefBase = ptrReg;
            fieldType = *target;
        }
    }
    // Build a MatchSubject for the nested field.

/// Return the effective type of a node after any coercion applied by
/// the resolver. `lowerExpr` already materializes the coercion in the
/// IL value, so the lowerer must use the post-coercion type when
/// choosing how to compare or store that value.
fn effectiveType(self: *mut FnLowerer, node: *ast::Node) -> resolver::Type throws (LowerError) {
    let ty = resolver::typeFor(self.low.resolver, node) else {
        throw LowerError::MissingType(node);
    };
    let ty = try typeOf(self, node);
    if let coerce = resolver::coercionFor(self.low.resolver, node) {
        if let case resolver::Coercion::OptionalLift(optTy) = coerce {
            return optTy;
        }
    }

    match typ {
        case resolver::Type::Nominal(_) => {
            // Void unions are small enough to pass by value.
            return not resolver::isVoidUnion(typ);
        }
        case resolver::Type::Slice { .. } => return true,
        case resolver::Type::TraitObject { .. } => return true,
        case resolver::Type::Array(_) => return true,
        case resolver::Type::Nil => return true,
        case resolver::Type::Slice { .. },
             resolver::Type::TraitObject { .. },
             resolver::Type::Array(_),
             resolver::Type::Nil => return true,
        case resolver::Type::Optional(resolver::Type::Pointer { .. }) => {
            // Optional pointers are scalar due to NPO.
            return false;
        }
        case resolver::Type::Optional(_) => {

}

/// Lower a record literal expression. Handles both plain records and union variant
/// record literals like `Union::Variant { field: value }`.
fn lowerRecordLit(self: *mut FnLowerer, node: *ast::Node, lit: ast::RecordLit) -> il::Val throws (LowerError) {
    let typ = resolver::typeFor(self.low.resolver, node) else {
        throw LowerError::MissingType(node);
    };
    let typ = try typeOf(self, node);
    match typ {
        case resolver::Type::Nominal(resolver::NominalType::Record(recInfo)) => {
            let dst = try emitReserve(self, typ);
            try lowerRecordFields(self, dst, &recInfo, lit.fields, 0);


/// Lower a union variant record literal like `Union::Variant { field: value }`.
fn lowerUnionRecordLit(self: *mut FnLowerer, typ: resolver::Type, lit: ast::RecordLit) -> il::Val throws (LowerError) {
    let typeName = lit.typeName else {
        throw LowerError::ExpectedVariant;
    };
    let sym = resolver::nodeData(self.low.resolver, typeName).sym else {
        throw LowerError::MissingSymbol(typeName);
    };
    let sym = try symOf(self, typeName);
    let case resolver::SymbolData::Variant { type: payloadType, index, .. } = sym.data else {
        throw LowerError::ExpectedVariant;
    };
    let recInfo = recordInfoFromType(payloadType) else {
        throw LowerError::ExpectedRecord;


/// Lower an array literal expression like `[1, 2, 3]`.
fn lowerArrayLit(self: *mut FnLowerer, node: *ast::Node, elements: *mut [*ast::Node]) -> il::Val
    throws (LowerError)
{
    let typ = resolver::typeFor(self.low.resolver, node) else {
        throw LowerError::MissingType(node);
    };
    let typ = try typeOf(self, node);
    let case resolver::Type::Array(arrInfo) = typ else {
        throw LowerError::ExpectedArray;
    };
    let elemTy = *arrInfo.item;
    let elemLayout = resolver::getTypeLayout(elemTy);

/// Unrolls the initialization at compile time.
// TODO: Beyond a certain length, lower this to a loop.
fn lowerArrayRepeatLit(self: *mut FnLowerer, node: *ast::Node, repeat: ast::ArrayRepeatLit) -> il::Val
    throws (LowerError)
{
    let typ = resolver::typeFor(self.low.resolver, node) else {
        throw LowerError::MissingType(node);
    };
    let typ = try typeOf(self, node);
    let case resolver::Type::Array(arrInfo) = typ else {
        throw LowerError::ExpectedArray;
    };
    let elemTy = *arrInfo.item;
    let length = arrInfo.length;


/// Lower a union constructor call like `Union::Variant(...)`.
fn lowerUnionCtor(self: *mut FnLowerer, node: *ast::Node, sym: *mut resolver::Symbol, call: ast::Call) -> il::Val
    throws (LowerError)
{
    let unionTy = resolver::typeFor(self.low.resolver, node) else {
        throw LowerError::MissingType(node);
    };
    let unionTy = try typeOf(self, node);
    let case resolver::SymbolData::Variant { type: payloadType, index, .. } = sym.data else {
        throw LowerError::ExpectedVariant;
    };
    let unionInfo = unionInfoFromType(unionTy) else {
        throw LowerError::MissingMetadata;

    return try buildTagged(self, resolver::getTypeLayout(unionTy), index as i64, payloadVal, payloadType, 1, valOffset);
}

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

    }
    // Handle variable address: `&x`
    if let case ast::NodeValue::Ident(_) = addr.target.value {
        if let v = lookupLocalVar(self, addr.target) {
            let val = try useVar(self, v);
            let typ = resolver::typeFor(self.low.resolver, addr.target) else {
                throw LowerError::MissingType(addr.target);
            };
            let typ = try typeOf(self, addr.target);
            // For aggregates, the value is already a pointer.
            if isAggregateType(typ) {
                return val;
            }
            // For scalars, if we've already materialized a stack slot for this

    sliceNode: *ast::Node,
    arrayNode: *ast::Node,
    elements: *mut [*ast::Node]
) -> il::Val throws (LowerError) {
    // Get the slice type from the address-of expression.
    let sliceTy = resolver::typeFor(self.low.resolver, sliceNode) else {
        throw LowerError::MissingType(sliceNode);
    };
    let sliceTy = try typeOf(self, sliceNode);
    let case resolver::Type::Slice { item, mutable } = sliceTy else {
        throw LowerError::UnexpectedType(&sliceTy);
    };
    if elements.len == 0 { // Empty slices don't need to be stored as data.
        return try buildSliceValue(self, item, mutable, il::Val::Imm(0), il::Val::Imm(0), il::Val::Imm(0));

/// the data pointer (for slices), and emitting an [`il::Instr::Elem`] to compute
/// the element address.
fn lowerElemPtr(
    self: *mut FnLowerer, container: *ast::Node, index: *ast::Node
) -> ElemPtrResult throws (LowerError) {
    let containerTy = resolver::typeFor(self.low.resolver, container) else {
        throw LowerError::MissingType(container);
    };
    let containerTy = try typeOf(self, container);
    let subjectTy = resolver::autoDeref(containerTy);
    let indexVal = try lowerExpr(self, index);
    let baseVal = try lowerExpr(self, container);
    let baseReg = emitValToReg(self, baseVal);


    return ElemPtrResult { elemReg, elemType };
}

/// Lower a dereference expression.
fn lowerDeref(self: *mut FnLowerer, node: *ast::Node, target: *ast::Node) -> il::Val throws (LowerError) {
    let type = resolver::typeFor(self.low.resolver, node) else {
        throw LowerError::MissingType(node);
    };
    let type = try typeOf(self, node);
    let ptrVal = try lowerExpr(self, target);
    let ptrReg = emitValToReg(self, ptrVal);

    return emitRead(self, ptrReg, 0, type);
}

        return;
    }
    let case ast::NodeValue::Ident(name) = l.ident.value else {
        throw LowerError::ExpectedIdentifier;
    };
    let typ = resolver::typeFor(self.low.resolver, l.value) else {
        throw LowerError::MissingType(l.value);
    };
    let typ = try typeOf(self, l.value);
    let ilType = ilType(self.low, typ);
    let mut varVal = val;

    // Aggregates with persistent storage need a local copy to avoid aliasing.
    // Temporaries such as literals or call results can be adopted directly.

            // First try local variable lookup.
            if let v = lookupLocalVar(self, a.left) {
                if not getVar(self, v).mutable {
                    throw LowerError::ImmutableAssignment;
                }
                let leftTy = resolver::typeFor(self.low.resolver, a.left) else {
                    throw LowerError::MissingType(a.left);
                };
                let leftTy = try typeOf(self, a.left);
                if isAggregateType(leftTy) or getVar(self, v).addressTaken {
                    // Aggregates and address-taken scalars are represented as
                    // pointers to stack memory. Store through the pointer.
                    let val = try useVar(self, v);
                    let dst = emitValToReg(self, val);

        }
        case ast::NodeValue::Deref(target) => {
            // Assignment through pointer dereference: `*ptr = value`.
            let ptrVal = try lowerExpr(self, target);
            let ptrReg = emitValToReg(self, ptrVal);
            let targetTy = resolver::typeFor(self.low.resolver, a.left) else {
                throw LowerError::MissingType(a.left);
            };
            let targetTy = try typeOf(self, a.left);
            try emitStore(self, ptrReg, 0, targetTy, rhs);
        }
        case ast::NodeValue::Subscript { container, index } => {
            // Assignment to array/slice element: `arr[i] = value`.
            let result = try lowerElemPtr(self, container, index);

    range: ast::Range,
    info: resolver::SliceRangeInfo
) throws (LowerError) {
    let r = try resolveSliceRangePtr(self, container, range, info);
    let elemSize = resolver::getTypeLayout(*info.itemType).size;
    let rhsTy = resolver::typeFor(self.low.resolver, rhs) else {
        throw LowerError::MissingType(rhs);
    };
    let rhsTy = try typeOf(self, rhs);

    if let case resolver::Type::Slice { .. } = rhsTy {
        // Copy from source slice.
        let srcReg = emitValToReg(self, try lowerExpr(self, rhs));
        let srcData = loadSlicePtr(self, srcReg);

/// into the buffer and the buffer pointer is returned. Otherwise, the value is
/// returned directly.
fn emitRetVal(self: *mut FnLowerer, val: il::Val) throws (LowerError) {
    if let retReg = self.returnReg {
        let src = emitValToReg(self, val);
        let size = retBufSize(self);
        let size = resolver::getResultLayout(*self.fnType.returnType, self.fnType.throwList).size
            if self.fnType.throwList.len > 0
            else resolver::getTypeLayout(*self.fnType.returnType).size;

        emit(self, il::Instr::Blit { dst: retReg, src, size: il::Val::Imm(size as i64) });
        emit(self, il::Instr::Ret { val: il::Val::Reg(retReg) });
    } else if isSmallAggregate(*self.fnType.returnType) {
        let src = emitValToReg(self, val);

    } else {
        emit(self, il::Instr::Ret { val });
    }
}

/// Compute the size of the return buffer for the current function.
fn retBufSize(self: *mut FnLowerer) -> u32 {
    if self.fnType.throwList.len > 0 {
        let successType = *self.fnType.returnType;

        return resolver::getResultLayout(successType, self.fnType.throwList).size;
    }
    return resolver::getTypeLayout(*self.fnType.returnType).size;
}

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


/// Lower a throw statement.
fn lowerThrowStmt(self: *mut FnLowerer, expr: *ast::Node) throws (LowerError) {
    assert self.fnType.throwList.len > 0;

    let errType = resolver::typeFor(self.low.resolver, expr) else {
        throw LowerError::MissingType(expr);
    };
    let errType = try typeOf(self, expr);
    let tag = getOrAssignErrorTag(self.low, errType) as i64;
    let errVal = try lowerExpr(self, expr);
    let resultVal = try buildResult(self, tag, errVal, errType);

    try emitRetVal(self, resultVal);


/// Lower a conditional expression (`thenExpr if condition else elseExpr`).
fn lowerCondExpr(self: *mut FnLowerer, node: *ast::Node, cond: ast::CondExpr) -> il::Val
    throws (LowerError)
{
    let typ = resolver::typeFor(self.low.resolver, node) else {
        throw LowerError::MissingType(node);
    };
    let typ = try typeOf(self, node);
    let thenBlock = try createBlock(self, "cond#then");
    let elseBlock = try createBlock(self, "cond#else");

    if isAggregateType(typ) {
        let dst = try emitReserve(self, typ);

    let b = try lowerExpr(self, binop.right);
    let isComparison = cmpOpFrom(binop.op, false) != nil;

    // The result type for comparisons is always `bool`, while for arithmetic
    // operations, it's the operand type. We set this appropriately here.
    let nodeTy = resolver::typeFor(self.low.resolver, node) else {
        throw LowerError::MissingType(node);
    };
    let nodeTy = try typeOf(self, node);
    let mut resultTy = nodeTy;

    if isComparison {
        let leftTy = try effectiveType(self, binop.left);
        let rightTy = try effectiveType(self, binop.right);

}

/// Lower a unary operation.
fn lowerUnOp(self: *mut FnLowerer, node: *ast::Node, unop: ast::UnOp) -> il::Val throws (LowerError) {
    let val = try lowerExpr(self, unop.value);
    let t = resolver::typeFor(self.low.resolver, node) else {
        throw LowerError::MissingType(node);
    };
    let t = try typeOf(self, node);
    let typ = ilType(self.low, t);
    let dst = nextReg(self);
    let mut needsExt: bool = false;

    match unop.op {


/// Lower a cast expression (`x as T`).
fn lowerCast(self: *mut FnLowerer, node: *ast::Node, cast: ast::As) -> il::Val throws (LowerError) {
    let val = try lowerExpr(self, cast.value);

    let srcType = resolver::typeFor(self.low.resolver, cast.value) else {
        throw LowerError::MissingType(cast.value);
    };
    let dstType = resolver::typeFor(self.low.resolver, node) else {
        throw LowerError::MissingType(node);
    };
    let srcType = try typeOf(self, cast.value);
    let dstType = try typeOf(self, node);
    if resolver::typesEqual(srcType, dstType) {
        return val;
    }
    return lowerNumericCast(self, val, srcType, dstType);
}

///
/// String literals are stored as global data and the result is a slice
/// pointing to the data with the appropriate length.
fn lowerStringLit(self: *mut FnLowerer, node: *ast::Node, s: *[u8]) -> il::Val throws (LowerError) {
    // Get the slice type from the node.
    let sliceTy = resolver::typeFor(self.low.resolver, node) else {
        throw LowerError::MissingType(node);
    };
    let sliceTy = try typeOf(self, node);
    let case resolver::Type::Slice { item, mutable } = sliceTy else {
        throw LowerError::ExpectedSliceOrArray;
    };
    // Build the string data value.
    let ptr = try! alloc::alloc(

/// Lower a `@sliceOf(ptr, len)` or `@sliceOf(ptr, len, cap)` builtin call.
fn lowerSliceOf(self: *mut FnLowerer, node: *ast::Node, args: *mut [*ast::Node]) -> il::Val throws (LowerError) {
    if args.len != 2 and args.len != 3 {
        throw LowerError::InvalidArgCount;
    }
    let sliceTy = resolver::typeFor(self.low.resolver, node) else {
        throw LowerError::MissingType(node);
    };
    let sliceTy = try typeOf(self, node);
    let case resolver::Type::Slice { item, mutable } = sliceTy else {
        throw LowerError::ExpectedSliceOrArray;
    };
    let ptrVal = try lowerExpr(self, args[0]);
    let lenVal = try lowerExpr(self, args[1]);

/// Lower a `try` expression.
fn lowerTry(self: *mut FnLowerer, node: *ast::Node, t: ast::Try) -> il::Val throws (LowerError) {
    let case ast::NodeValue::Call(callExpr) = t.expr.value else {
        throw LowerError::ExpectedCall;
    };
    let calleeTy = resolver::typeFor(self.low.resolver, callExpr.callee) else {
        throw LowerError::MissingType(callExpr.callee);
    };
    let calleeTy = try typeOf(self, callExpr.callee);
    let case resolver::Type::Fn(calleeInfo) = calleeTy else {
        throw LowerError::ExpectedFunction;
    };
    let okValueTy = *calleeInfo.returnType; // The type of the success payload.

    // Type of the try expression, which is either the return type of the function
    // if successful, or an optional of it, if using `try?`.
    let tryExprTy = resolver::typeFor(self.low.resolver, node) else {
        throw LowerError::MissingType(node);
    };
    let tryExprTy = try typeOf(self, node);
    // Check for trait method dispatch or standalone method call.
    let mut resVal: il::Val = undefined;
    let callNodeExtra = resolver::nodeData(self.low.resolver, t.expr).extra;
    if let case resolver::NodeExtra::TraitMethodCall {
        traitInfo, methodIndex


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

        if let typeNode = clause.typeNode {
            let errTy = resolver::typeFor(self.low.resolver, typeNode) else {
                throw LowerError::MissingType(typeNode);
            };
            let errTy = try typeOf(self, typeNode);
            errTypes[i] = errTy;

            cases.append(il::SwitchCase {
                value: getOrAssignErrorTag(self.low, errTy) as i64,
                target: blocks[i].n,

) -> il::Val throws (LowerError) {
    let case ast::NodeValue::FieldAccess(access) = call.callee.value
        else throw LowerError::MissingMetadata;

    // Get the receiver as a pointer.
    let parentTy = resolver::typeFor(self.low.resolver, access.parent)
        else throw LowerError::MissingType(access.parent);
    let parentTy = try typeOf(self, access.parent);
    let receiverVal = try lowerReceiver(self, access.parent, parentTy);

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

fn lowerCall(self: *mut FnLowerer, node: *ast::Node, call: ast::Call) -> il::Val throws (LowerError) {
    // Check for intrinsic calls before normal call lowering.
    if let intrinsicVal = try lowerIntrinsicCall(self, call) {
        return intrinsicVal;
    }
    let calleeTy = resolver::typeFor(self.low.resolver, call.callee) else {
        throw LowerError::MissingType(call.callee);
    };
    let calleeTy = try typeOf(self, call.callee);
    let case resolver::Type::Fn(fnInfo) = calleeTy else {
        throw LowerError::ExpectedFunction;
    };
    let callee = try lowerCallee(self, call.callee);
    let offset: u32 = 1 if requiresReturnParam(fnInfo) else 0;

/// for signed source types and zero-extension for unsigned source types.
fn lowerNumericCast(self: *mut FnLowerer, val: il::Val, srcType: resolver::Type, dstType: resolver::Type) -> il::Val {
    let srcLayout = resolver::getTypeLayout(srcType);
    let dstLayout = resolver::getTypeLayout(dstType);

    if srcLayout.size < dstLayout.size {
        // Widening conversion: sign/zero-extend based on source signedness.
        let dst = nextReg(self);
        let srcIrType = ilType(self.low, srcType);

        if isSignedType(srcType) {
            emit(self, il::Instr::Sext { typ: srcIrType, dst, val });
        } else {
            emit(self, il::Instr::Zext { typ: srcIrType, dst, val });
        }
        return il::Val::Reg(dst);
    if srcLayout.size == dstLayout.size {
        // Same size: bit pattern is unchanged, value is returned as-is.
        return val;
    }
    if srcLayout.size > dstLayout.size {
        // Narrowing conversion: truncate and normalize to destination width.
        let dstIrType = ilType(self.low, dstType);
        let dst = nextReg(self);
    // Widening: extend based on source signedness.
    // Narrowing: truncate and normalize to destination width.
    let widening = srcLayout.size < dstLayout.size;
    let extType = ilType(self.low, srcType) if widening else ilType(self.low, dstType);
    let signed = isSignedType(srcType) if widening else isSignedType(dstType);
    let dst = nextReg(self);

        if isSignedType(dstType) {
            emit(self, il::Instr::Sext { typ: dstIrType, dst, val });
        } else {
            emit(self, il::Instr::Zext { typ: dstIrType, dst, val });
        }
        return il::Val::Reg(dst);
    if signed {
        emit(self, il::Instr::Sext { typ: extType, dst, val });
    } else {
        emit(self, il::Instr::Zext { typ: extType, dst, val });
    }
    // Same size: bit pattern is unchanged, value is returned as-is.
    // The backend is responsible for normalizing to the correct width
    // when performing comparisons.
    return val;
    return il::Val::Reg(dst);
}

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

    match sym.data {
        case resolver::SymbolData::Constant { type, .. } =>
            ty = type,

    return emitRead(self, dst, 0, ty);
}

/// Lower an assignment to a static variable.
fn lowerStaticAssign(self: *mut FnLowerer, target: *ast::Node, val: il::Val) throws (LowerError) {
    let sym = resolver::nodeData(self.low.resolver, target).sym else {
        throw LowerError::MissingSymbol(target);
    };
    let sym = try symOf(self, target);
    let case resolver::SymbolData::Value { type, .. } = sym.data else {
        throw LowerError::ImmutableAssignment;
    };
    let dst = emitDataAddr(self, sym);


            // First try local variable lookup.
            // Otherwise fall back to global symbol lookup.
            if let v = lookupLocalVar(self, node) {
                val = try useVar(self, v);
                if self.vars[v.id].addressTaken {
                    let typ = resolver::typeFor(self.low.resolver, node) else {
                        throw LowerError::MissingType(node);
                    };
                    let typ = try typeOf(self, node);
                    let ptr = emitValToReg(self, val);
                    val = emitRead(self, ptr, 0, typ);
                }
            } else {
                val = try lowerGlobalSymbol(self, node);

        }
        case ast::NodeValue::Char(c) => {
            val = il::Val::Imm(c as i64);
        }
        case ast::NodeValue::Nil => {
            let typ = resolver::typeFor(self.low.resolver, node) else {
                throw LowerError::MissingType(node);
            };
            let typ = try typeOf(self, node);
            if let case resolver::Type::Optional(_) = typ {
                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.

        }
        case ast::NodeValue::String(s) => {
            val = try lowerStringLit(self, node, s);
        }
        case ast::NodeValue::Undef => {
            let typ = resolver::typeFor(self.low.resolver, node) else {
                throw LowerError::MissingType(node);
            };
            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);

///
/// The IL doesn't track signedness - that's encoded in the instructions
/// (e.g., Slt vs Ult).
fn ilType(self: *mut Lowerer, typ: resolver::Type) -> il::Type {
    match typ {
        // Scalars map to their natural widths.
        case resolver::Type::Bool => return il::Type::W8,
        case resolver::Type::I8 => return il::Type::W8,
        case resolver::Type::I16 => return il::Type::W16,
        case resolver::Type::I32 => return il::Type::W32,
        case resolver::Type::U8 => return il::Type::W8,
        case resolver::Type::U16 => return il::Type::W16,
        case resolver::Type::U32 => return il::Type::W32,
        case resolver::Type::I64 => return il::Type::W64,
        case resolver::Type::U64 => return il::Type::W64,
        // Reference types are all pointer-sized (64-bit on RV64).
        case resolver::Type::Pointer { .. } => return il::Type::W64,
        // Aggregates are represented as pointers to stack memory.
        case resolver::Type::Slice { .. } => return il::Type::W64,
        case resolver::Type::Array(_) => return il::Type::W64,
        case resolver::Type::Optional(_) => return il::Type::W64,
        case resolver::Type::Bool,
             resolver::Type::I8,
             resolver::Type::U8 => return il::Type::W8,
        case resolver::Type::I16,
             resolver::Type::U16 => return il::Type::W16,
        case resolver::Type::I32,
             resolver::Type::U32 => return il::Type::W32,
        case resolver::Type::I64,
             resolver::Type::U64,
             resolver::Type::Pointer { .. },
             resolver::Type::Slice { .. },
             resolver::Type::Array(_),
             resolver::Type::Optional(_),
             resolver::Type::Fn(_),
             resolver::Type::TraitObject { .. } => return il::Type::W64,
        case resolver::Type::Nominal(_) => {
            if resolver::isVoidUnion(typ) {
                return il::Type::W8;
            }
            return il::Type::W64;
        }
        case resolver::Type::Fn(_) => return il::Type::W64,
        case resolver::Type::TraitObject { .. } => return il::Type::W64,
        // Void functions return zero at the IL level.
        case resolver::Type::Void => return il::Type::W32,
        // FIXME: We shouldn't try to lower this type, it should be behind a pointer.
        case resolver::Type::Opaque => return il::Type::W32,
        // FIXME: This should be resolved to a concrete integer type in the resolver.
        case resolver::Type::Int => return il::Type::W32,
        case resolver::Type::Void,
             // FIXME: We shouldn't try to lower this type, it should be behind a pointer.
             resolver::Type::Opaque,
             // FIXME: This should be resolved to a concrete integer type in the resolver.
             resolver::Type::Int => return il::Type::W32,
        else => panic "ilType: type cannot be lowered",
    }
}

lib/std/lang/module.rad +0 -20

use std::lang::ast;
use std::lang::strings;

/// Maximum number of modules tracked in a single compilation graph.
pub const MAX_MODULES: u32 = 128;
/// Maximum number of characters for a module name.
const MAX_MODULE_NAME_LEN: u32 = 64;
/// Maximum number of characters for a module path.
const MAX_PATH_LEN: u32 = 256;
/// Maximum number of components that make up a logical module path.
const MAX_MODULE_PATH_DEPTH: u32 = 16;
/// Filesystem separator used when constructing child paths.


/// Error categories that can be produced by the module graph.
pub union ModuleError {
    /// Module not found.
    NotFound(u16),
    /// Module path not found.
    PathNotFound(*[u8]),
    /// Adding the module would exceed the fixed storage.
    CapacityExceeded,
    /// Requested parent identifier is invalid.
    InvalidParent,
    /// Provided path is missing the required `.rad` extension or otherwise invalid.
    InvalidPath,
    /// Attempted to register a module whose name already exists in the same namespace.
    DuplicateModule,
    /// Attempt to register a root module when there already is one.
    DuplicateRoot,
    /// Fully qualified file path exceeds the fixed storage.
    PathTooLong,
    /// Module name exceeds the fixed storage.
    NameTooLong,
    /// Module graph path exceeded the maximum logical depth.
    PathTooDeep,
    /// Attempt to register a module before its parent.
    MissingParent,
}

pub fn moduleQualifiedPath(m: *ModuleEntry) -> *[*[u8]] {
    assert m.pathDepth > 0, "moduleQualifiedPath: path must not be empty";
    return &m.path[..m.pathDepth];
}

/// Update the recorded lifecycle state for `id`.
pub fn setState(graph: *mut ModuleGraph, id: u16, state: ModuleState) throws (ModuleError) {
    let m = getMut(graph, id) else throw ModuleError::NotFound(id);
    m.state = state;
}

/// Retrieve the lifecycle state for `id`.
pub fn state(graph: *ModuleGraph, id: u16) -> ModuleState throws (ModuleError) {
    let m = get(graph, id) else {
        throw ModuleError::NotFound(id);
    };

lib/std/lang/package.rad +0 -8

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

/// Maximum number of packages processed in a single invocation.
pub const MAX_PACKAGES: u32 = 4;
/// Maximum byte length for a package name.
pub const MAX_PACKAGE_NAME_LEN: u32 = 64;

/// Errors produced while configuring packages.
pub union PackageError {
    /// The provided name exceeds the buffer.
    NameTooLong,
}

/// A compilation unit.
pub record Package {
    /// Package identifier (index in the package array).
    id: u16,

lib/std/lang/parser.rad +21 -74

/// Emit a number literal node with the provided literal metadata.
fn nodeNumber(p: *mut Parser, literal: ast::IntLiteral) -> *ast::Node {
    return node(p, ast::NodeValue::Number(literal));
}

/// Emit an identifier node with the given name.
fn nodeIdent(p: *mut Parser, name: *[u8]) -> *ast::Node {
    return node(p, ast::NodeValue::Ident(name));
}

/// Emit a `super` node.
fn nodeSuper(p: *mut Parser) -> *ast::Node {
    return node(p, ast::NodeValue::Super);
}

/// Emit a `nil` literal node.
fn nodeNil(p: *mut Parser) -> *ast::Node {
    return node(p, ast::NodeValue::Nil);
}

/// Emit an `undefined` literal node.
fn nodeUndef(p: *mut Parser) -> *ast::Node {
    return node(p, ast::NodeValue::Undef);
}

/// Emit a character literal node.
fn nodeChar(p: *mut Parser, value: u8) -> *ast::Node {
    return node(p, ast::NodeValue::Char(value));
}

/// Emit a string literal node.
fn nodeString(p: *mut Parser, data: *[u8]) -> *ast::Node {
    return node(p, ast::NodeValue::String(data));
}

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

/// Emit a unary operator node.
fn nodeUnary(p: *mut Parser, op: ast::UnaryOp, value: *ast::Node) -> *ast::Node {
    return node(p, ast::NodeValue::UnOp({ op, value }));
}

/// Emit an address-of (reference) node.
fn nodeAddressOf(p: *mut Parser, target: *ast::Node, mutable: bool) -> *ast::Node {
    return node(p, ast::NodeValue::AddressOf({ target, mutable }));
}

/// Emit a dereference node.
fn nodeDeref(p: *mut Parser, target: *ast::Node) -> *ast::Node {
    return node(p, ast::NodeValue::Deref(target));
}

/// Parse a parenthesized expression without applying postfix operators.
fn parseParenthesized(p: *mut Parser) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::LParen, "expected `(`");

            return nodeUnary(p, ast::UnaryOp::BitNot, value);
        }
        case scanner::TokenKind::Star => {
            advance(p);
            let value = try parseUnaryExpr(p);
            return nodeDeref(p, value);
            return node(p, ast::NodeValue::Deref(value));
        }
        case scanner::TokenKind::Amp => {
            advance(p);
            let mutable = consume(p, scanner::TokenKind::Mut);
            let target = try parseUnaryExpr(p);
            return nodeAddressOf(p, target, mutable);
            return node(p, ast::NodeValue::AddressOf({ target: target, mutable: mutable }));
        }
        else => {
            return try parsePrimary(p);
        }
    }

///
/// Statements that end with blocks don't require semicolons.
/// All other statements do.
fn expectsSemicolon(stmt: *ast::Node) -> bool {
    match stmt.value {
        case ast::NodeValue::If(_) => return false,
        case ast::NodeValue::IfLet(_) => return false,
        case ast::NodeValue::While(_) => return false,
        case ast::NodeValue::WhileLet(_) => return false,
        case ast::NodeValue::For(_) => return false,
        case ast::NodeValue::Loop { .. } => return false,
        case ast::NodeValue::Match(_) => return false,
        case ast::NodeValue::Block(_) => return false,
        case ast::NodeValue::FnDecl(_) => return false,
        case ast::NodeValue::RecordDecl(_) => return false,
        case ast::NodeValue::UnionDecl(_) => return false,
        case ast::NodeValue::TraitDecl { .. } => return false,
        case ast::NodeValue::InstanceDecl { .. } => return false,
        case ast::NodeValue::MethodDecl { .. } => return false,
        case ast::NodeValue::If(_),
             ast::NodeValue::IfLet(_),
             ast::NodeValue::While(_),
             ast::NodeValue::WhileLet(_),
             ast::NodeValue::For(_),
             ast::NodeValue::Loop { .. },
             ast::NodeValue::Match(_),
             ast::NodeValue::Block(_),
             ast::NodeValue::FnDecl(_),
             ast::NodeValue::RecordDecl(_),
             ast::NodeValue::UnionDecl(_),
             ast::NodeValue::TraitDecl { .. },
             ast::NodeValue::InstanceDecl { .. },
             ast::NodeValue::MethodDecl { .. } => return false,
        else => return true,
    }
}

/// Parse a primary leaf expression without postfix operators.

            advance(p);
            return nodeBool(p, false);
        }
        case scanner::TokenKind::Ident => {
            advance(p);
            return nodeIdent(p, p.previous.source);
            return node(p, ast::NodeValue::Ident(p.previous.source));
        }
        case scanner::TokenKind::Super => {
            advance(p);
            return nodeSuper(p);
        }

        case scanner::TokenKind::Try => {
            return try parseTryExpr(p);
        }
        case scanner::TokenKind::Nil => {
            advance(p);
            return nodeNil(p);
            return node(p, ast::NodeValue::Nil);
        }
        case scanner::TokenKind::Undefined => {
            advance(p);
            return nodeUndef(p);
            return node(p, ast::NodeValue::Undef);
        }
        case scanner::TokenKind::Char => {
            advance(p);
            let src = p.previous.source;
            let mut ch: u8 = 0;

                    else      => { ch = src[2]; }
                }
            } else {
                ch = src[1];
            }
            return nodeChar(p, ch);
            return node(p, ast::NodeValue::Char(ch));
        }
        case scanner::TokenKind::String => {
            advance(p);
            let src = p.previous.source;
            let raw = &src[1..src.len - 1]; // Strip quotes.

            // Process escape sequences into arena buffer.
            let buf = alloc::remainingBuf(&mut p.arena.arena);
            let len = unescapeString(raw, buf);
            alloc::commit(&mut p.arena.arena, len);

            return nodeString(p, &buf[..len]);
            return node(p, ast::NodeValue::String(&buf[..len]));
        }
        case scanner::TokenKind::Underscore => {
            advance(p);
            return node(p, ast::NodeValue::Placeholder);
        }

        message = try parseExpr(p);
    }
    return node(p, ast::NodeValue::Assert { condition, message });
}

/// Parse a `break` statement.
fn parseBreak(p: *mut Parser) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Break, "expected `break`");

    return node(p, ast::NodeValue::Break);
}

/// Parse a `continue` statement.
fn parseContinue(p: *mut Parser) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Continue, "expected `continue`");

    return node(p, ast::NodeValue::Continue);
}

/// Parse a `try` expression with optional `catch` clause(s).
fn parseTryExpr(p: *mut Parser) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Try, "expected `try`");

lib/std/lang/resolver.rad +22 -72

    UnresolvedSymbol(*[u8]),
    /// Attempted to assign to an immutable binding.
    ImmutableBinding,
    /// Expected a compile-time constant expression.
    ConstExprRequired,
    /// Scope stack exceeded its fixed capacity.
    ScopeOverflow,
    /// Node table capacity reached.
    NodeOverflow,
    /// Symbol arena exhausted while binding identifiers.
    SymbolOverflow,
    /// Expression has the wrong type.
    TypeMismatch(TypeMismatch),
    /// Numeric literal does not fit within the required range.

    ExpectedRecord,
    /// Expected an array or slice value.
    ExpectedIndexable,
    /// Expected an iterable (array, slice, or range) for a `for` loop.
    ExpectedIterable,
    /// Expected a block node.
    ExpectedBlock,
    /// Invalid `as` cast between the provided types.
    InvalidAsCast(InvalidAsCast),
    /// Invalid alignment value specified.
    InvalidAlignmentValue(u32),
    /// Invalid module path.

    TryCatchDuplicateType,
    /// Typed catch clauses do not cover all error types.
    TryCatchNonExhaustive,
    /// Called a fallible function without using `try`.
    MissingTry,
    /// `else` branch of a `let` guard must not fall through.
    ElseBranchMustDiverge,
    /// Cannot use opaque type in this context.
    OpaqueTypeNotAllowed,
    /// Cannot dereference pointer to opaque type.
    OpaqueTypeDeref,
    /// Cannot perform pointer arithmetic on opaque pointer.
    OpaquePointerArithmetic,
    /// Cannot infer type from context.
    CannotInferType,
    /// Cyclic type dependency detected during resolution.
    CyclicTypeDependency(*[u8]),
    /// Cannot assign a void value to a variable.
    CannotAssignVoid,
    /// `default` attribute used on a non-function declaration.
    DefaultAttrOnlyOnFn,
    /// Union variant requires a payload but none was provided.

        return a;
    }
    return b;
}


/// Get the layout of a type.
pub fn getTypeLayout(ty: Type) -> Layout {
    match ty {
        case Type::Void, Type::Never => return Layout { size: 0, alignment: 0 },
        case Type::Bool => return Layout { size: 1, alignment: 1 },
        case Type::U8, Type::I8 => return Layout { size: 1, alignment: 1 },
        case Type::Bool, Type::U8, Type::I8 => return Layout { size: 1, alignment: 1 },
        case Type::U16, Type::I16 => return Layout { size: 2, alignment: 2 },
        case Type::U32, Type::I32, Type::Int => return Layout { size: 4, alignment: 4 },
        case Type::U64, Type::I64 => return Layout { size: 8, alignment: 8 },
        case Type::Pointer { .. } => return Layout { size: PTR_SIZE, alignment: PTR_SIZE },
        case Type::Slice { .. } => return Layout { size: PTR_SIZE * 2, alignment: PTR_SIZE },
        case Type::Pointer { .. },
             Type::Fn(_) => return Layout { size: PTR_SIZE, alignment: PTR_SIZE },
        case Type::Slice { .. },
             Type::TraitObject { .. } => return Layout { size: PTR_SIZE * 2, alignment: PTR_SIZE },
        case Type::Array(arr) => return getArrayLayout(arr),
        case Type::Optional(inner) => return getOptionalLayout(*inner),
        case Type::Nominal(info) => return getNominalLayout(*info),
        case Type::Fn(_) => return Layout { size: PTR_SIZE, alignment: PTR_SIZE },
        case Type::TraitObject { .. } => return Layout { size: PTR_SIZE * 2, alignment: PTR_SIZE },
        else => {
            panic "getTypeLayout: the given type cannot be layed out";
        }
    }
}

            bits: 16,
            min: I16_MIN as i64,
            max: I16_MAX as i64,
            lim: (I16_MAX as u64) + 1,
        },
        case Type::I32 => return IntegerRange::Signed {
        case Type::I32,
             Type::Int => return IntegerRange::Signed {
            bits: 32,
            min: I32_MIN as i64,
            max: I32_MAX as i64,
            lim: (I32_MAX as u64) + 1,
        },

            bits: 64,
            min: I64_MIN,
            max: I64_MAX,
            lim: (I64_MAX as u64) + 1,
        },
        case Type::Int => return IntegerRange::Signed {
            bits: 32,
            min: I32_MIN as i64,
            max: I32_MAX as i64,
            lim: (I32_MAX as u64) + 1,
        },
        case Type::U8 => return IntegerRange::Unsigned { bits: 8, max: U8_MAX as u64 },
        case Type::U16 => return IntegerRange::Unsigned { bits: 16, max: U16_MAX as u64 },
        case Type::U32 => return IntegerRange::Unsigned { bits: 32, max: parser::U32_MAX as u64 },
        case Type::U64 => return IntegerRange::Unsigned { bits: 64, max: parser::U64_MAX },
        else => return nil,

                        return Coercion::Identity;
                    }
                    return nil;
                }
            }
            // For non-literal arrays, require exact element type match.
            if lhs.item == rhs.item {
                return Coercion::Identity;
            }
            return nil;
        }
        case Type::Pointer { target: lhsTarget, mutable: lhsMutable } => {
            let case Type::Pointer { target: rhsTarget, mutable: rhsMutable } = from
                else return nil;


/// Function bodies are deferred to the definition phase.
///
/// Nb. User-defined types are already handled by this point.
fn visitDecl(self: *mut Resolver, node: *ast::Node) throws (ResolveError) {
    match node.value {
        case ast::NodeValue::FnDecl(_) => {
            // Handled in previous pass (function signature binding).
        }
        case ast::NodeValue::ConstDecl(_) => {
            // Handled in previous pass.
        case ast::NodeValue::FnDecl(_),
             ast::NodeValue::ConstDecl(_),
             ast::NodeValue::Mod(_),
             ast::NodeValue::Use(_) => {
            // Handled in previous passes.
        }
        case ast::NodeValue::StaticDecl(_) => {
            try infer(self, node);
        }
        case ast::NodeValue::Mod(_) => {
            // Handled in previous pass.
        }
        case ast::NodeValue::Use(_) => {
            // Handled in previous pass.
        }
        case ast::NodeValue::InstanceDecl { traitName, targetType, methods } => {
            try resolveInstanceDecl(self, node, traitName, targetType, methods);
        }
        case ast::NodeValue::MethodDecl { name, receiverName, receiverType, sig, body, attrs } => {
            try resolveMethodDecl(self, node, name, receiverName, receiverType, sig, attrs);

            let case ast::NodeValue::Block(block) = submod.root.value
                else panic "visitDef: expected block for module root";
            try resolveModuleDefs(self, &block);
            exitModuleScope(self, submod);
        }
        case ast::NodeValue::RecordDecl(_) => {
            // Skip: already analyzed in declaration phase.
        }
        case ast::NodeValue::UnionDecl(_) => {
            // Skip: already analyzed in declaration phase.
        }
        case ast::NodeValue::Use(_) => {
            // Skip: already analyzed in declaration phase.
        }
        case ast::NodeValue::TraitDecl { .. } => {
        case ast::NodeValue::RecordDecl(_),
             ast::NodeValue::UnionDecl(_),
             ast::NodeValue::Use(_),
             ast::NodeValue::TraitDecl { .. } => {
            // Skip: already analyzed in declaration phase.
        }
        case ast::NodeValue::InstanceDecl { methods, .. } => {
            try resolveInstanceMethodBodies(self, methods);
        }

                    }
                }
            }
            return true;
        },
        case ast::NodeValue::Ident(_) => {
            // Identifiers referencing constants or functions are constant expressions.
            if let sym = symbolFor(self, node) {
                match sym.data {
                    case SymbolData::Constant { .. } => return true,
                    case SymbolData::Value { type, .. } => {
                        if let case Type::Fn(_) = type {
                            return true;
                        }
                    }
                    else => {}
                }
            }
            return false;
        },
        case ast::NodeValue::ScopeAccess(_) => {
            // Scope accesses to union variants (eg. TokenKind::Fn) are constant.
            // The symbol for this node indicates whether it's a variant.
            // Function references are also compile-time constants.
        case ast::NodeValue::Ident(_),
             ast::NodeValue::ScopeAccess(_) => {
            // Identifiers and scope accesses referencing constants, union
            // variants, or function values are constant expressions.
            if let sym = symbolFor(self, node) {
                match sym.data {
                    case SymbolData::Variant { .. } => return true,
                    case SymbolData::Constant { .. } => return true,
                    case SymbolData::Variant { .. },
                         SymbolData::Constant { .. } => return true,
                    case SymbolData::Value { type, .. } => {
                        if let case Type::Fn(_) = type {
                            return true;
                        }
                    }

        }
    }
    return setNodeType(self, node, tryResultTy);
}


/// Check that a `catch` body is assignable to the expected result type, but only
/// in expression context (`hint` is neither `Unknown` nor `Void`).
fn checkCatchBody(self: *mut Resolver, body: *ast::Node, resultTy: Type, hint: Type)
    throws (ResolveError)
{

lib/std/lang/resolver/printer.rad +51 -224

use std::io;
use std::lang::ast;
use std::lang::scanner;
use std::lang::module;

/// Single indentation unit used when rendering nested scopes.
const INDENT_STEP: *[u8] = "  ";

/// Emit indentation for a given nesting depth.
fn printIndent(depth: u32) {
    for i in 0..depth {
        io::print(INDENT_STEP);
    }
}

/// Print a span in `@offset:length` form.
fn printSpan(span: ast::Span) {
    io::print("@");
    io::printU32(span.offset);
    io::print(":");
    io::printU32(span.length);
}

/// Print a count mismatch message: `<prefix>: <verb> <expected>, got <actual>`.
fn printMismatch(prefix: *[u8], verb: *[u8], m: super::CountMismatch) {
    io::print(prefix);
    io::print(": ");
    io::print(verb);
    io::print(" ");
    io::printU32(m.expected);
    io::print(", got ");
    io::printU32(m.actual);
}

/// Print `<prefix>'<name>'`.
fn printQuoted(prefix: *[u8], name: *[u8]) {
    io::print(prefix);
    io::print(name);
    io::print("'");
}

/// Print `*` or `*mut ` depending on mutability.
fn printPtrPrefix(mutable: bool) {
    io::print("*");
    if mutable {
        io::print("mut ");
    }
}

/// Print a resolved type in a textual form.
fn printType(ty: super::Type) {
    printTypeBody(ty, false);
}


        }
        case super::Type::I64 => {
            io::print("i64");
        }
        case super::Type::Pointer { target, mutable } => {
            io::print("*");
            if mutable {
                io::print("mut ");
            }
            printPtrPrefix(mutable);
            printTypeBody(*target, brief);
        }
        case super::Type::Slice { item, mutable } => {
            io::print("*");
            if mutable {
                io::print("mut ");
            }
            printPtrPrefix(mutable);
            io::print("[");
            printTypeBody(*item, brief);
            io::print("]");
        }
        case super::Type::Array(array) => {

            } else {
                printNominalType(info);
            }
        }
        case super::Type::TraitObject { traitInfo, mutable } => {
            io::print("*");
            if mutable {
                io::print("mut ");
            }
            printPtrPrefix(mutable);
            io::print("opaque ");
            io::print(traitInfo.name);
        }
        case super::Type::Range { start, end } => {
            if let s = start {

            io::print("<union>");
        }
    }
}

/// Print a single symbol within a scope.
fn printSymbol(symbol: *super::Symbol, depth: u32) {
    printIndent(depth);

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

    match symbol.data {
        case super::SymbolData::Variant { .. } => {
            io::print("variant");
        }
        case super::SymbolData::Value { .. } => {
            io::print("value");
        }
        case super::SymbolData::Constant { .. } => {
            io::print("constant");
        }
        case super::SymbolData::Type(_) => {
            io::print("type");
        }
        case super::SymbolData::Module { .. } => {
            io::print("module");
        }
        case super::SymbolData::Trait(_) => {
            io::print("trait");
        }
    }

    match symbol.data {
        case super::SymbolData::Value { mutable, type, .. } => {
            if mutable {
                io::print(" mut");
            }
            io::print(" ");
            io::print(symbol.name);
            io::print(" ");
            printSpan(symbol.node.span);
            io::print(" : ");
            printType(type);
            io::print("\n");
        }
        case super::SymbolData::Constant { type, .. } => {
            io::print(" ");
            io::print(symbol.name);
            io::print(" ");
            printSpan(symbol.node.span);
            io::print(" : ");
            printType(type);
            io::print("\n");
        }
        case super::SymbolData::Type(t) => {
            printType(super::Type::Nominal(t));
        }
        case super::SymbolData::Variant { .. } => {
            // TODO
        }
        case super::SymbolData::Module { .. } => {
            // TODO
        }
        case super::SymbolData::Trait(_) => {
            io::print(" ");
            io::print(symbol.name);
            io::print("\n");
        }
    }
}

/// Print a single diagnostic entry.
fn printError(err: *super::Error, res: *super::Resolver) {
    if let node = err.node {
        // Find the module containing this error.
        if let moduleEntry = module::get(res.moduleGraph, err.moduleId) {

            printType(mismatch.expected);
            io::print(", got ");
            printType(mismatch.actual);
        }
        case super::ErrorKind::UnresolvedSymbol(name) => {
            io::print("unresolved symbol '");
            io::print(name);
            io::print("'");
            printQuoted("unresolved symbol '", name);
        }
        case super::ErrorKind::DuplicateBinding(name) => {
            io::print("duplicate binding '");
            io::print(name);
            io::print("'");
        }
        case super::ErrorKind::FnArgCountMismatch(mismatch) => {
            io::print("function argument count mismatch: expected ");
            io::printU32(mismatch.expected);
            io::print(", got ");
            io::printU32(mismatch.actual);
        }
        case super::ErrorKind::FnThrowCountMismatch(mismatch) => {
            io::print("function throws count mismatch: expected ");
            io::printU32(mismatch.expected);
            io::print(", got ");
            io::printU32(mismatch.actual);
        }
        case super::ErrorKind::RecordFieldCountMismatch(mismatch) => {
            io::print("record field count mismatch: expected ");
            io::printU32(mismatch.expected);
            io::print(", got ");
            io::printU32(mismatch.actual);
        }
            printQuoted("duplicate binding '", name);
        }
        case super::ErrorKind::FnArgCountMismatch(m) =>
            printMismatch("function argument count mismatch", "expected", m),
        case super::ErrorKind::FnThrowCountMismatch(m) =>
            printMismatch("function throws count mismatch", "expected", m),
        case super::ErrorKind::RecordFieldCountMismatch(m) =>
            printMismatch("record field count mismatch", "expected", m),
        case super::ErrorKind::RecordFieldMissing(name) => {
            io::print("record field missing: '");
            io::print(name);
            io::print("'");
            printQuoted("record field missing: '", name);
        }
        case super::ErrorKind::RecordFieldUnknown(name) => {
            io::print("record field unknown: '");
            io::print(name);
            io::print("'");
            printQuoted("record field unknown: '", name);
        }
        case super::ErrorKind::InvalidAsCast(info) => {
            io::print("invalid cast: cannot cast ");
            printType(info.from);
            io::print(" to ");
            printType(info.to);
        }
        case super::ErrorKind::ExpectedIterable => {
            io::print("expected iterable type");
        }
        case super::ErrorKind::ElseBranchMustDiverge => {
            io::print("else branch must not fall through");
        }
        case super::ErrorKind::FnMissingReturn => {
            io::print("function must return a value on all paths");
        }
        case super::ErrorKind::UnionMatchNonExhaustive(name) => {
            io::print("union match non-exhaustive: missing case for variant '");
            io::print(name);
            io::print("'");
            printQuoted("union match non-exhaustive: missing case for variant '", name);
        }
        case super::ErrorKind::OptionalMatchMissingValue => {
            io::print("optional match non-exhaustive: missing value case");
        }
        case super::ErrorKind::OptionalMatchMissingNil => {

            io::print("cannot assign to immutable binding");
        }
        case super::ErrorKind::ConstExprRequired => {
            io::print("expected compile-time constant expression");
        }
        case super::ErrorKind::ScopeOverflow => {
            io::print("scope stack overflow");
        }
        case super::ErrorKind::NodeOverflow => {
            io::print("node table overflow");
        }
        case super::ErrorKind::SymbolOverflow => {
            io::print("symbol arena overflow");
        }
        case super::ErrorKind::NumericLiteralOverflow => {
            io::print("numeric literal overflow");

            io::print("expected record type");
        }
        case super::ErrorKind::ExpectedIndexable => {
            io::print("expected array or slice");
        }
        case super::ErrorKind::ExpectedBlock => {
            io::print("expected block");
        }
        case super::ErrorKind::InvalidAlignmentValue(val) => {
            io::print("invalid alignment value: ");
            io::printU32(val);
        }
        case super::ErrorKind::InvalidModulePath => {

        }
        case super::ErrorKind::InvalidScopeAccess => {
            io::print("invalid scope access");
        }
        case super::ErrorKind::ArrayFieldUnknown(name) => {
            io::print("array field unknown: '");
            io::print(name);
            io::print("'");
            printQuoted("array field unknown: '", name);
        }
        case super::ErrorKind::SliceFieldUnknown(name) => {
            io::print("slice field unknown: '");
            io::print(name);
            io::print("'");
            printQuoted("slice field unknown: '", name);
        }
        case super::ErrorKind::SliceRequiresAddress => {
            io::print("slicing requires taking an address with '&'");
        }
        case super::ErrorKind::SliceRangeOutOfBounds => {

        }
        case super::ErrorKind::DuplicateInstance => {
            io::print("duplicate instance declaration for the same trait and type");
        }
        case super::ErrorKind::MissingTraitMethod(name) => {
            io::print("missing trait method '");
            io::print(name);
            io::print("'");
            printQuoted("missing trait method '", name);
        }
        case super::ErrorKind::UnexpectedTraitName => {
            io::print("trait name cannot be used as a value");
        }
        case super::ErrorKind::TraitReceiverMismatch => {
            io::print("trait method receiver must be a pointer to the declaring trait");
        }
        case super::ErrorKind::FnParamOverflow(mismatch) => {
            io::print("too many function parameters: maximum ");
            io::printU32(mismatch.expected);
            io::print(", got ");
            io::printU32(mismatch.actual);
        }
        case super::ErrorKind::FnThrowOverflow(mismatch) => {
            io::print("too many function throws: maximum ");
            io::printU32(mismatch.expected);
            io::print(", got ");
            io::printU32(mismatch.actual);
        }
        case super::ErrorKind::TraitMethodOverflow(mismatch) => {
            io::print("too many trait methods: maximum ");
            io::printU32(mismatch.expected);
            io::print(", got ");
            io::printU32(mismatch.actual);
        }
        case super::ErrorKind::FnParamOverflow(m) =>
            printMismatch("too many function parameters", "maximum", m),
        case super::ErrorKind::FnThrowOverflow(m) =>
            printMismatch("too many function throws", "maximum", m),
        case super::ErrorKind::TraitMethodOverflow(m) =>
            printMismatch("too many trait methods", "maximum", m),
        case super::ErrorKind::MissingSupertraitInstance(name) => {
            io::print("missing instance for supertrait '");
            io::print(name);
            io::print("'");
            printQuoted("missing instance for supertrait '", name);
        }
        case super::ErrorKind::Internal => {
            io::print("internal compiler error");
        }
        case super::ErrorKind::RecordFieldOutOfOrder { .. } => {

            io::print("opaque types cannot be dereferenced");
        }
        case super::ErrorKind::OpaquePointerArithmetic => {
            io::print("opaque pointer arithmetic is not allowed");
        }
        case super::ErrorKind::CyclicTypeDependency(_) => {
            io::print("cyclic type dependency");
        }
        case super::ErrorKind::BuiltinArgCountMismatch { .. } => {
            io::print("built-in argument count mismatch");
        }
    }
    io::print("\n");
}

/// Recursively print a scope and its nested children.
fn printScopeTree(res: *super::Resolver, scope: *super::Scope, depth: u32) {
    printIndent(depth);
    io::print("Scope ");

    if let owner = scope.owner {
        printSpan(owner.span);
    } else {
        io::print("<root>");
    }
    io::print("\n");
    printScope(scope, depth);

    for entry in res.nodeData.entries {
        if let childScopePtr = entry.scope {
            if childScopePtr.parent != nil and childScopePtr.parent == scope {
                printScopeTree(res, childScopePtr, depth + 1);
            }
        }
    }
}

/// Entry point for printing the resolver scope tree.
pub fn printScopes(res: *super::Resolver, root: *ast::Node) {
    if let scope = super::scopeFor(res, root) {
        printScopeTree(res, scope, 0);
    }
    io::print("\n");
}

/// Print the given scope.
pub fn printScope(scope: *super::Scope, depth: u32) {
    for i in 0..scope.symbolsLen {
        let symbol = scope.symbols[i];
        printSymbol(symbol, depth);
        io::print("\n");
    }
}

/// Print the given scope, and all enclosing scopes.
pub fn printEnclosingScopes(res: *super::Resolver, scope: *super::Scope) {
    let mut curr = scope;

    loop {
        io::printLn("Scope");
        printScope(curr, 1);

        if let parent = curr.parent {
            curr = parent;
        } else {
            break;
        }
    }
}

/// Entry point for printing resolver diagnostics in vim quickfix format.
pub fn printDiagnostics(diag: *super::Diagnostics, res: *super::Resolver) {
    for i in 0..diag.errors.len {
        printError(&diag.errors[i], res);
    }

lib/std/lang/scanner.rad +0 -113

    GtGtEqual,    // >>=

    // Boolean operators.
    Not, And, Or,

    /// Eg. `input:`
    Label,
    /// Eg. `fnord`
    Ident,
    /// Eg. `@default`
    AtIdent,
    /// The `log` keyword.

    // Type-related tokens.
    I8, I16, I32, I64, U8, U16, U32, U64,
    Void, Opaque, Fn, Bool, Union, Record, As
}

/// Convert a token kind to its string representation.
pub fn tokenKindToString(kind: TokenKind) -> *[u8] {
    match kind {
        case TokenKind::Eof => return "Eof",
        case TokenKind::Invalid => return "Invalid",
        case TokenKind::LParen => return "LParen",
        case TokenKind::RParen => return "RParen",
        case TokenKind::LBrace => return "LBrace",
        case TokenKind::RBrace => return "RBrace",
        case TokenKind::LBracket => return "LBracket",
        case TokenKind::RBracket => return "RBracket",
        case TokenKind::Comma => return "Comma",
        case TokenKind::Dot => return "Dot",
        case TokenKind::DotDot => return "DotDot",
        case TokenKind::Minus => return "Minus",
        case TokenKind::Plus => return "Plus",
        case TokenKind::Colon => return "Colon",
        case TokenKind::ColonColon => return "ColonColon",
        case TokenKind::Semicolon => return "Semicolon",
        case TokenKind::Slash => return "Slash",
        case TokenKind::Star => return "Star",
        case TokenKind::Percent => return "Percent",
        case TokenKind::Amp => return "Amp",
        case TokenKind::Pipe => return "Pipe",
        case TokenKind::Caret => return "Caret",
        case TokenKind::Tilde => return "Tilde",
        case TokenKind::Underscore => return "Underscore",
        case TokenKind::AtIdent => return "AtIdent",
        case TokenKind::Question => return "Question",
        case TokenKind::Bang => return "Bang",
        case TokenKind::BangEqual => return "BangEqual",
        case TokenKind::Equal => return "Equal",
        case TokenKind::EqualEqual => return "EqualEqual",
        case TokenKind::Gt => return "Gt",
        case TokenKind::GtEqual => return "GtEqual",
        case TokenKind::Lt => return "Lt",
        case TokenKind::LtEqual => return "LtEqual",
        case TokenKind::LtLt => return "LtLt",
        case TokenKind::GtGt => return "GtGt",
        case TokenKind::Arrow => return "Arrow",
        case TokenKind::FatArrow => return "FatArrow",
        case TokenKind::PlusEqual => return "PlusEqual",
        case TokenKind::MinusEqual => return "MinusEqual",
        case TokenKind::StarEqual => return "StarEqual",
        case TokenKind::SlashEqual => return "SlashEqual",
        case TokenKind::PercentEqual => return "PercentEqual",
        case TokenKind::AmpEqual => return "AmpEqual",
        case TokenKind::PipeEqual => return "PipeEqual",
        case TokenKind::CaretEqual => return "CaretEqual",
        case TokenKind::LtLtEqual => return "LtLtEqual",
        case TokenKind::GtGtEqual => return "GtGtEqual",
        case TokenKind::Not => return "Not",
        case TokenKind::And => return "And",
        case TokenKind::Or => return "Or",
        case TokenKind::Label => return "Label",
        case TokenKind::Ident => return "Ident",
        case TokenKind::Log => return "Log",
        case TokenKind::String => return "String",
        case TokenKind::Char => return "Char",
        case TokenKind::Number => return "Number",
        case TokenKind::True => return "True",
        case TokenKind::False => return "False",
        case TokenKind::Nil => return "Nil",
        case TokenKind::Undefined => return "Undefined",
        case TokenKind::If => return "If",
        case TokenKind::Else => return "Else",
        case TokenKind::Return => return "Return",
        case TokenKind::Break => return "Break",
        case TokenKind::Continue => return "Continue",
        case TokenKind::While => return "While",
        case TokenKind::For => return "For",
        case TokenKind::In => return "In",
        case TokenKind::Loop => return "Loop",
        case TokenKind::Match => return "Match",
        case TokenKind::Case => return "Case",
        case TokenKind::Try => return "Try",
        case TokenKind::Catch => return "Catch",
        case TokenKind::Throw => return "Throw",
        case TokenKind::Throws => return "Throws",
        case TokenKind::Panic => return "Panic",
        case TokenKind::Assert => return "Assert",
        case TokenKind::Let => return "Let",
        case TokenKind::Mut => return "Mut",
        case TokenKind::Const => return "Const",
        case TokenKind::Align => return "Align",
        case TokenKind::Mod => return "Mod",
        case TokenKind::Use => return "Use",
        case TokenKind::Super => return "Super",
        case TokenKind::Pub => return "Pub",
        case TokenKind::Extern => return "Extern",
        case TokenKind::Static => return "Static",
        case TokenKind::Trait => return "Trait",
        case TokenKind::Instance => return "Instance",
        case TokenKind::I8 => return "I8",
        case TokenKind::I16 => return "I16",
        case TokenKind::I32 => return "I32",
        case TokenKind::I64 => return "I64",
        case TokenKind::U8 => return "U8",
        case TokenKind::U16 => return "U16",
        case TokenKind::U32 => return "U32",
        case TokenKind::U64 => return "U64",
        case TokenKind::Void => return "Void",
        case TokenKind::Opaque => return "Opaque",
        case TokenKind::Fn => return "Fn",
        case TokenKind::Bool => return "Bool",
        case TokenKind::Union => return "Union",
        case TokenKind::Record => return "Record",
        case TokenKind::As => return "As",
    }
}

/// A reserved keyword.
record Keyword {
    /// Keyword string.
    name: *[u8],
    /// Corresponding token.

lib/std/lang/sexpr.rad +0 -27

        buf[i] = item;
    }
    return buf;
}

/// Allocate and copy prefix items followed by suffix items.
pub fn concatItems(a: *mut alloc::Arena, prefix: *[Expr], suffix: *[Expr]) -> *[Expr] {
    let total = prefix.len + suffix.len;
    if total == 0 {
        return &[];
    }
    let buf = try! allocExprs(a, total);
    for item, i in prefix {
        buf[i] = item;
    }
    for item, i in suffix {
        buf[prefix.len + i] = item;
    }
    return buf;
}

/// Shorthand for creating a symbol.
pub fn sym(s: *[u8]) -> Expr {
    return Expr::Sym(s);
}


pub fn indent(depth: u32) {
    let mut out = Output::Stdout;
    indentTo(&mut out, depth);
}

/// Print a quoted string with escape sequences to stdout.
pub fn printString(s: *[u8]) {
    let mut out = Output::Stdout;
    printStringTo(&mut out, s);
}

/// Print a character literal with escape sequences to stdout.
pub fn printChar(c: u8) {
    let mut out = Output::Stdout;
    printCharTo(&mut out, c);
}

lib/std/mem.rad +0 -2

/// Memory error.
union MemoryError {
    /// Buffer is too small.
    BufferTooSmall,
    /// An offset is out of bounds of the given buffer.
    OutOfBounds,
}

/// Copy bytes between two slices. Returns the number of bytes copied.
pub fn copy(into: *mut [u8], from: *[u8]) -> u32 throws (MemoryError) {
    if into.len < from.len {

lib/std/sys/unix.rad +0 -1

/// Returns `0` on success, or a negative value on error.
pub fn close(fd: i64) -> i64 {
    return intrinsics::ecall(57, fd, 0, 0, 0);
}


/// Reads the entire contents of a file at the given path into the provided buffer.
/// Returns a slice containing the data read, or `nil` on error.
pub fn readFile(path: *[u8], buf: *mut [u8]) -> ?*[u8] {
    let fd = open(path, O_RDONLY);
    if fd < 0 {

test/tests/array.math.rad +0 -1

19	19		}
20	20		}
21	21		return sum;
22	22		}
23	23
24		-
25	24		fn transpose(matrix: [[i32; 3]; 2]) -> [[i32; 2]; 3] {
26	25		let mut result: [[i32; 2]; 3] = [[0, 0], [0, 0], [0, 0]];
27	26		let mut i: u32 = 0;
28	27
29	28		while (i < matrix.len) {

test/tests/as.precedence.rad +0 -1

//! returns: 0


@default fn main() -> i32 {
    let p1: u8 = 1;
    let p2: u8 = 2;

    // Simple cast.

test/tests/prog.dijkstra.rad +0 -2

//! returns: 0
//! Dijkstra's shortest path algorithm.
//! Find shortest paths in a weighted directed graph using an adjacency matrix
//! and a min-heap priority queue. Reconstruct paths and verify distances.


const MAX_NODES: u32 = 16;
const INF: u32 = 0xFFFFFFFF;

record HeapEntry {
    dist: u32,

178	177		addEdge(g, 2, 3, 10);
179	178		addEdge(g, 3, 4, 10);
180	179
181	180		dijkstra(g, 0);
182	181
183		-
184	182		let expected: [u32; 5] = [0, 10, 20, 30, 40];
185	183		for exp, i in expected {
186	184		if g.dist[i] != exp {
187	185		return i as i32 + 1;
188	186		}

test/tests/prog.huffman.rad +0 -3

//! returns: 0
//! Huffman encoding.
//! Build a Huffman tree from character frequencies, generate prefix codes,
//! encode a message, decode it, and verify round-trip correctness.


const MAX_SYMBOLS: u32 = 32;
const MAX_NODES: u32 = 63;
const MAX_BITS: u32 = 512;

/// A node in the Huffman tree.


fn buildTree(s: *mut HuffState, freqs: *[u32]) -> u32 {
    s.nodeCount = 0;
    s.heapSize = 0;


    for freq, sym in freqs {
        if freq > 0 {
            let idx: u32 = newLeaf(s, freq, sym);
            heapPush(s, idx);
        }

    while i < MAX_BITS {
        s.bitstream[i] = 0;
        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 {

test/tests/prog.linkedlist.rad +0 -1

//! returns: 0
//! Linked list via array pool.
//! Implement a singly-linked list using an array of node records
//! (pool allocator pattern). Operations: push, pop, find, reverse, length.


/// A node in the linked list.
record Node {
    value: i32,
    next: ?u32,
}

195	195		io::printError("radiance: error setting source\n");
196	196		throw Error::Other;
197	197		};
198	198		}
199	199
	200	+	/// Consume the next argument, or print an error and throw.
	201	+	fn nextArg(args: [[u8]], idx: mut u32, msg: [u8]) -> *[u8] throws (Error) {
	202	+	*idx += 1;
	203	+	if *idx >= args.len {
	204	+	io::printError(msg);
	205	+	throw Error::Other;
	206	+	}
	207	+	return args[*idx];
	208	+	}
	209	+
200	210		/// Parse CLI arguments and return compilation context.
201	211		fn processCommand(
202	212		args: [[u8]],
203	213		arena: *mut ast::NodeArena
204	214		) -> CompileContext throws (Error) {

225	235		let mut idx: u32 = 0;
226	236
227	237		while idx < args.len {
228	238		let arg = args[idx];
229	239		if mem::eq(arg, "-pkg") {
230		-	idx += 1;
231		-	if idx >= args.len {
232		-	io::printError("radiance: `-pkg` requires a package name\n");
233		-	throw Error::Other;
234		-	}
	240	+	try nextArg(args, &mut idx, "radiance: `-pkg` requires a package name\n");
235	241		if pkgCount >= MAX_PACKAGES {
236	242		io::printError("radiance: too many packages specified\n");
237	243		throw Error::Other;
238	244		}
239	245		pkgNames[pkgCount] = args[idx];
240	246		currentPkgIdx = pkgCount;
241	247		pkgCount += 1;
242	248		} else if mem::eq(arg, "-mod") {
243		-	idx += 1;
244		-	if idx >= args.len {
245		-	io::printError("radiance: `-mod` requires a module path\n");
246		-	throw Error::Other;
247		-	}
	249	+	try nextArg(args, &mut idx, "radiance: `-mod` requires a module path\n");
248	250		let pkgIdx = currentPkgIdx else {
249	251		io::printError("radiance: `-mod` must follow a `-pkg` argument\n");
250	252		throw Error::Other;
251	253		};
252	254		if moduleCounts[pkgIdx] >= MAX_LOADED_MODULES {

254	256		throw Error::Other;
255	257		}
256	258		modulePaths[pkgIdx][moduleCounts[pkgIdx]] = args[idx];
257	259		moduleCounts[pkgIdx] += 1;
258	260		} else if mem::eq(arg, "-entry") {
259		-	idx += 1;
260		-	if idx >= args.len {
261		-	io::printError("radiance: `-entry` requires a package name\n");
262		-	throw Error::Other;
263		-	}
	261	+	try nextArg(args, &mut idx, "radiance: `-entry` requires a package name\n");
264	262		entryPkgName = args[idx];
265	263		} else if mem::eq(arg, "-test") {
266	264		buildTest = true;
267	265		} else if mem::eq(arg, "-debug") {
268	266		debugEnabled = true;
269	267		} else if mem::eq(arg, "-o") {
270		-	idx += 1;
271		-	if idx >= args.len {
272		-	io::printError("radiance: `-o` requires an output path\n");
273		-	throw Error::Other;
274		-	}
	268	+	try nextArg(args, &mut idx, "radiance: `-o` requires an output path\n");
275	269		outputPath = args[idx];
276	270		} else if mem::eq(arg, "-dump") {
277		-	idx += 1;
278		-	if idx >= args.len {
279		-	io::printError("radiance: `-dump` requires a mode (eg. ast)\n");
280		-	throw Error::Other;
281		-	}
	271	+	try nextArg(args, &mut idx, "radiance: `-dump` requires a mode (eg. ast)\n");
282	272		let mode = args[idx];
283	273		if mem::eq(mode, "ast") {
284	274		dump = Dump::Ast;
285	275		} else if mem::eq(mode, "graph") {
286	276		dump = Dump::Graph;

579	579		/// Implemented as `blt rs2, rs1, imm` (swap operands).
580	580		pub fn bgt(rs1: super::Reg, rs2: super::Reg, imm: i32) -> u32 {
581	581		return blt(rs2, rs1, imm);
582	582		}
583	583
584		-	/// Branch if less than or equal unsigned: `if (rs1 <= rs2) pc += imm`.
585		-	/// Implemented as `bgeu rs2, rs1, imm` (swap operands).
586		-	pub fn bleu(rs1: super::Reg, rs2: super::Reg, imm: i32) -> u32 {
587		-	return bgeu(rs2, rs1, imm);
588		-	}
589		-
590		-	/// Branch if greater than unsigned: `if (rs1 > rs2) pc += imm`.
591		-	/// Implemented as `bltu rs2, rs1, imm` (swap operands).
592		-	pub fn bgtu(rs1: super::Reg, rs2: super::Reg, imm: i32) -> u32 {
593		-	return bltu(rs2, rs1, imm);
594		-	}
595		-
596	584		/// Set if equal to zero: `rd = (rs == 0) ? 1 : 0`.
597	585		/// Implemented as `sltiu rd, rs, 1`.
598	586		pub fn seqz(rd: super::Reg, rs: super::Reg) -> u32 {
599	587		return sltiu(rd, rs, 1);
600	588		}

236	236		},
237	237		case il::Type::W64 => {}
238	238		}
239	239		}
240	240
	241	+	/// Resolve a value, trap if zero (unless known non-zero), and return the register.
	242	+	fn resolveAndTrapIfZero(s: *mut Selector, b: il::Val) -> super::Reg {
	243	+	let rs2 = resolveVal(s, super::SCRATCH2, b);
	244	+	let mut knownNonZero = false;
	245	+	if let case il::Val::Imm(imm) = b {
	246	+	knownNonZero = imm != 0;
	247	+	}
	248	+	if not knownNonZero {
	249	+	emit::emit(s.e, encode::bne(rs2, super::ZERO, super::INSTR_SIZE * 2));
	250	+	emit::emit(s.e, encode::ebreak());
	251	+	}
	252	+	return rs2;
	253	+	}
	254	+
241	255		////////////////////////
242	256		// Instruction Select //
243	257		////////////////////////
244	258
245	259		/// Pre-scan result for reserve analysis.

709	723		return imm == 0;
710	724		}
711	725		return false;
712	726		}
713	727
714		-	/// Check if a value is a known non-zero immediate.
715		-	fn isNonZeroImm(val: il::Val) -> bool {
716		-	if let case il::Val::Imm(imm) = val {
717		-	return imm != 0;
718		-	}
719		-	return false;
720		-	}
721		-
722		-	/// Emit runtime trap for division/modulo by zero.
723		-	fn emitTrapIfZero(s: *mut Selector, rs: super::Reg) {
724		-	emit::emit(s.e, encode::bne(rs, super::ZERO, super::INSTR_SIZE * 2));
725		-	emit::emit(s.e, encode::ebreak());
726		-	}
727		-
728	728		/// Select a binary ALU operation, dispatching to the appropriate
729	729		/// instruction pattern based on the operation kind and type.
730	730		fn selectAluBinOp(s: *mut Selector, op: il::BinOp, typ: il::Type, rd: super::Reg, rs1: super::Reg, b: il::Val) {
731	731		match op {
732	732		case il::BinOp::Add => {

782	782		if typ == il::Type::W32 else
783	783		encode::mul(rd, rs1, rs2));
784	784		}
785	785		}
786	786		case il::BinOp::Sdiv => {
787		-	let rs2 = resolveVal(s, super::SCRATCH2, b);
788		-	if not isNonZeroImm(b) {
789		-	emitTrapIfZero(s, rs2);
790		-	}
	787	+	let rs2 = resolveAndTrapIfZero(s, b);
791	788		emit::emit(s.e,
792	789		encode::divw(rd, rs1, rs2)
793	790		if typ == il::Type::W32 else
794	791		encode::div(rd, rs1, rs2));
795	792		}
796	793		case il::BinOp::Udiv => {
797		-	let rs2 = resolveVal(s, super::SCRATCH2, b);
798		-	if not isNonZeroImm(b) {
799		-	emitTrapIfZero(s, rs2);
800		-	}
	794	+	let rs2 = resolveAndTrapIfZero(s, b);
801	795		emit::emit(s.e,
802	796		encode::divuw(rd, rs1, rs2)
803	797		if typ == il::Type::W32 else
804	798		encode::divu(rd, rs1, rs2));
805	799		}
806	800		case il::BinOp::Srem => {
807		-	let rs2 = resolveVal(s, super::SCRATCH2, b);
808		-	if not isNonZeroImm(b) {
809		-	emitTrapIfZero(s, rs2);
810		-	}
	801	+	let rs2 = resolveAndTrapIfZero(s, b);
811	802		emit::emit(s.e,
812	803		encode::remw(rd, rs1, rs2)
813	804		if typ == il::Type::W32 else
814	805		encode::rem(rd, rs1, rs2));
815	806		}
816	807		case il::BinOp::Urem => {
817		-	let rs2 = resolveVal(s, super::SCRATCH2, b);
818		-	if not isNonZeroImm(b) {
819		-	emitTrapIfZero(s, rs2);
820		-	}
	808	+	let rs2 = resolveAndTrapIfZero(s, b);
821	809		emit::emit(s.e,
822	810		encode::remuw(rd, rs1, rs2)
823	811		if typ == il::Type::W32 else
824	812		encode::remu(rd, rs1, rs2));
825	813		}

67	67		///////////////////////////////
68	68
69	69		/// Mnemonic column width for alignment.
70	70		const MNEMONIC_WIDTH: u32 = 8;
71	71
72		-	/// Print spaces for indentation.
73		-	fn writeIndent(out: *mut sexpr::Output) {
74		-	write(out, " ");
75		-	}
76		-
77	72		/// Write text wrapped in parentheses.
78	73		fn writeParens(out: mut sexpr::Output, s: [u8]) {
79	74		write(out, "(");
80	75		write(out, s);
81	76		write(out, ")");

334	329		return funcs[i].name;
335	330		}
336	331		}
337	332		return nil;
338	333		}
339		-
340		-	/// Print code with labels to buffer, returns slice.
341		-	pub fn printCode(pkgName: [u8], code: [u32], funcs: [types::FuncAddr], arena: mut alloc::Arena, buf: mut [u8]) -> [u8] {
342		-	let mut pos: u32 = 0;
343		-	let mut out = sexpr::Output::Buffer { buf, pos: &mut pos };
344		-	printCodeTo(&mut out, pkgName, code, funcs, arena);
345		-
346		-	return &buf[..pos];
347		-	}

5	5		use std::lang::alloc;
6	6
7	7		/// Maximum number of trait methods.
8	8		pub const MAX_TRAIT_METHODS: u32 = 8;
9	9
10		-	/// Maximum number of supertraits.
11		-	pub const MAX_SUPERTRAITS: u32 = 4;
12		-
13	10		/// Arena for all parser allocations.
14	11		///
15	12		/// Uses a bump allocator for both AST nodes and node pointer arrays.
16	13		pub record NodeArena {
17	14		/// Bump allocator for all allocations.

155	155		if let v = dict::get(&m.dict, name) {
156	156		return v as u32;
157	157		}
158	158		return nil;
159	159		}
160		-
161		-	/// Resolve a data symbol to its final absolute address (linear scan fallback).
162		-	pub fn lookupDataSymAddr(dataSyms: [DataSym], name: [u8]) -> ?u32 {
163		-	for i in 0..dataSyms.len {
164		-	let sym = dataSyms[i];
165		-	if mem::eq(sym.name, name) {
166		-	return sym.addr;
167		-	}
168		-	}
169		-	return nil;
170		-	}

167	167		assignments[dst.n] = rallocReg(&mut current, &mut usedRegs, dst.n, allocatable, config.calleeSaved, spillInfo);
168	168		}
169	169		}
170	170		}
171	171		// Save block-end state.
172		-	rmapCopy(&mut blkEnd[b], &current);
	172	+	blkEnd[b].n = current.n;
	173	+	for ri in 0..current.n {
	174	+	blkEnd[b].virtRegs[ri] = current.virtRegs[ri];
	175	+	blkEnd[b].physRegs[ri] = current.physRegs[ri];
	176	+	}
173	177		}
174	178		// Compute bitmask of used callee-saved registers.
175	179		let mut usedCalleeSaved: u32 = 0;
176	180		for i in 0..maxReg {
177	181		if let phys = assignments[i] {

195	199		let physRegs = try alloc::allocSlice(arena, @sizeOf(u8), @alignOf(u8), MAX_ACTIVE) as *mut [u8];
196	200
197	201		return RegMap { virtRegs, physRegs, n: 0 };
198	202		}
199	203
200		-	/// Copy a register map.
201		-	fn rmapCopy(dst: mut RegMap, src: RegMap) {
202		-	dst.n = src.n;
203		-	for i in 0..src.n {
204		-	dst.virtRegs[i] = src.virtRegs[i];
205		-	dst.physRegs[i] = src.physRegs[i];
206		-	}
207		-	}
208		-
209	204		/// Find physical register for a virtual register in RegMap.
210	205		fn rmapFind(rmap: *RegMap, virtReg: u32) -> ?u8 {
211	206		for i in 0..rmap.n {
212	207		if rmap.virtRegs[i] == virtReg {
213	208		return rmap.physRegs[i];

417	417		}
418	418
419	419		/// Check if an instruction is a function call.
420	420		pub fn isCall(instr: Instr) -> bool {
421	421		match instr {
422		-	case Instr::Call { .. } => return true,
423		-	case Instr::Ecall { .. } => return true,
	422	+	case Instr::Call { .. },
	423	+	Instr::Ecall { .. } => return true,
424	424		else => return false,
425	425		}
426	426		}
427	427
428	428		/// Call a function for each register used by an instruction.

496	496		withReg(a0, f, ctx);
497	497		withReg(a1, f, ctx);
498	498		withReg(a2, f, ctx);
499	499		withReg(a3, f, ctx);
500	500		},
501		-	case Instr::Unreachable => {},
502		-	case Instr::Ebreak => {},
	501	+	case Instr::Unreachable,
	502	+	Instr::Ebreak => {},
503	503		}
504	504		}
505	505
506	506		/// Call callback if value is a register.
507	507		fn withReg(val: Val, callback: fn(Reg, mut opaque), ctx: mut opaque) {

517	517		lengthVal: il::Val,
518	518		elemType: *resolver::Type,
519	519		},
520	520		}
521	521
522		-
523	522		//////////////////////////////
524	523		// Pattern Matching Support //
525	524		//////////////////////////////
526	525
527	526		// Match expressions are lowered by evaluating the subject once, then emitting

7	7
8	8		///////////////////////
9	9		// String formatting //
10	10		///////////////////////
11	11
	12	+	/// Copy a byte slice into arena-allocated storage.
	13	+	fn copyToArena(a: mut alloc::Arena, text: [u8]) -> *[u8] {
	14	+	let slice = try! alloc::allocSlice(a, 1, 1, text.len) as *mut [u8];
	15	+	try! mem::copy(slice, text);
	16	+	return slice;
	17	+	}
	18	+
12	19		/// Format a `u32` into a string in the arena.
13	20		fn formatU32(a: mut alloc::Arena, val: u32) -> [u8] {
14	21		let mut digits: [u8; 10] = undefined;
15		-	let text = fmt::formatU32(val, &mut digits[..]);
16		-	let ptr = try! alloc::allocSlice(a, 1, 1, text.len);
17		-	let slice = ptr as *mut [u8];
18		-	try! mem::copy(slice, text);
19		-
20		-	return slice;
	22	+	return copyToArena(a, fmt::formatU32(val, &mut digits[..]));
21	23		}
22	24
23	25		/// Format an `i32` into a string in the arena.
24	26		fn formatI32(a: mut alloc::Arena, val: i32) -> [u8] {
25	27		let mut digits: [u8; 12] = undefined;
26		-	let text = fmt::formatI32(val, &mut digits[..]);
27		-	let ptr = try! alloc::allocSlice(a, 1, 1, text.len);
28		-	let slice = ptr as *mut [u8];
29		-	try! mem::copy(slice, text);
30		-
31		-	return slice;
	28	+	return copyToArena(a, fmt::formatI32(val, &mut digits[..]));
32	29		}
33	30
34	31		/// Format an `i64` into a string in the arena.
35	32		fn formatI64(a: mut alloc::Arena, val: i64) -> [u8] {
36	33		let mut digits: [u8; 20] = undefined;
37		-	let text = fmt::formatI64(val, &mut digits[..]);
38		-	let ptr = try! alloc::allocSlice(a, 1, 1, text.len);
39		-	let slice = ptr as *mut [u8];
40		-	try! mem::copy(slice, text);
41		-
42		-	return slice;
	34	+	return copyToArena(a, fmt::formatI64(val, &mut digits[..]));
43	35		}
44	36
45	37		/// Concatenate prefix and string in the arena.
46	38		fn prefixStr(a: mut alloc::Arena, prefix: u8, str: [u8]) -> *[u8] {
47	39		let len = str.len + 1;

72	64		for _ in 0..depth {
73	65		write(out, " ");
74	66		}
75	67		}
76	68
77		-	/// Write a quoted string with escaping.
78		-	fn writeString(out: mut sexpr::Output, s: [u8]) {
79		-	sexpr::printStringTo(out, s);
80		-	}
81		-
82	69		/// Check if name contains the path separator.
83	70		fn needsQuoting(name: *[u8]) -> bool {
84	71		for ch in name {
85	72		if ch == ':' {
86	73		return true;

495	482		write(out, "fn ");
496	483		writeSymbol(out, name);
497	484		}
498	485		case super::DataItem::Str(s) => {
499	486		write(out, "str ");
500		-	writeString(out, s);
	487	+	sexpr::printStringTo(out, s);
501	488		}
502	489		case super::DataItem::Undef => {
503	490		write(out, "undef");
504	491		}
505	492		}

1759	1758		let reg = il::Reg { n: self.regCounter };
1760	1759		self.regCounter += 1;
1761	1760		return reg;
1762	1761		}
1763	1762
	1763	+	/// Look up the resolved type of an AST node, or throw `MissingType`.
	1764	+	fn typeOf(self: mut FnLowerer, node: ast::Node) -> resolver::Type throws (LowerError) {
	1765	+	let ty = resolver::typeFor(self.low.resolver, node)
	1766	+	else throw LowerError::MissingType(node);
	1767	+	return ty;
	1768	+	}
	1769	+
	1770	+	/// Look up the symbol for an AST node, or throw `MissingSymbol`.
	1771	+	fn symOf(self: mut FnLowerer, node: ast::Node) -> *mut resolver::Symbol throws (LowerError) {
	1772	+	let sym = resolver::nodeData(self.low.resolver, node).sym
	1773	+	else throw LowerError::MissingSymbol(node);
	1774	+	return sym;
	1775	+	}
	1776	+
1764	1777		/// Remove the last block parameter and its associated variable.
1765	1778		/// Used when detecting a trivial phi that can be eliminated.
1766	1779		fn removeLastBlockParam(self: *mut FnLowerer, block: BlockId) {
1767	1780		let blk = getBlockMut(self, block);
1768	1781		if blk.params.len > 0 {

2030	2043		thenBlock: BlockId,
2031	2044		elseBlock: BlockId
2032	2045		) throws (LowerError) {
2033	2046		// Try fused compare-and-branch for simple scalar comparisons.
2034	2047		if let case ast::NodeValue::BinOp(binop) = cond.value {
2035		-	let leftTy = resolver::typeFor(self.low.resolver, binop.left) else {
2036		-	throw LowerError::MissingType(binop.left);
2037		-	};
2038		-	let rightTy = resolver::typeFor(self.low.resolver, binop.right) else {
2039		-	throw LowerError::MissingType(binop.right);
2040		-	};
	2048	+	let leftTy = try typeOf(self, binop.left);
	2049	+	let rightTy = try typeOf(self, binop.right);
2041	2050		if not isAggregateType(leftTy) and not isAggregateType(rightTy) {
2042	2051		let unsigned = isUnsignedType(leftTy);
2043	2052		if let op = cmpOpFrom(binop.op, unsigned) {
2044	2053		let a = try lowerExpr(self, binop.left);
2045	2054		let b = try lowerExpr(self, binop.right);

2070	2079		/// Emit a 32-bit store instruction at the given offset.
2071	2080		fn emitStoreW32At(self: *mut FnLowerer, src: il::Val, dst: il::Reg, offset: i32) {
2072	2081		emit(self, il::Instr::Store { typ: il::Type::W32, src, dst, offset });
2073	2082		}
2074	2083
2075		-	/// Emit a 32-bit store instruction with default alignment.
2076		-	fn emitStoreW32(self: *mut FnLowerer, src: il::Val, dst: il::Reg) {
2077		-	emitStoreW32At(self, src, dst, 0);
2078		-	}
2079		-
2080	2084		/// Emit a 32-bit load instruction at the given offset.
2081	2085		fn emitLoadW32At(self: *mut FnLowerer, dst: il::Reg, src: il::Reg, offset: i32) {
2082	2086		emit(self, il::Instr::Load { typ: il::Type::W32, dst, src, offset });
2083	2087		}
2084	2088
2085		-	/// Emit a 32-bit load instruction with default alignment.
2086		-	fn emitLoadW32(self: *mut FnLowerer, dst: il::Reg, src: il::Reg) {
2087		-	emitLoadW32At(self, dst, src, 0);
2088		-	}
2089		-
2090		-	/// Emit an 8-bit store instruction.
2091		-	fn emitStoreW8(self: *mut FnLowerer, src: il::Val, dst: il::Reg) {
2092		-	emit(self, il::Instr::Store { typ: il::Type::W8, src, dst, offset: 0 });
2093		-	}
2094		-
2095	2089		/// Emit an 8-bit store instruction at the given offset.
2096	2090		fn emitStoreW8At(self: *mut FnLowerer, src: il::Val, dst: il::Reg, offset: i32) {
2097	2091		emit(self, il::Instr::Store { typ: il::Type::W8, src, dst, offset });
2098	2092		}
2099	2093
2100		-	/// Emit an 8-bit load instruction.
2101		-	fn emitLoadW8(self: *mut FnLowerer, dst: il::Reg, src: il::Reg) {
2102		-	emit(self, il::Instr::Load { typ: il::Type::W8, dst, src, offset: 0 });
2103		-	}
2104		-
2105	2094		/// Emit an 8-bit load instruction at the given offset.
2106	2095		fn emitLoadW8At(self: *mut FnLowerer, dst: il::Reg, src: il::Reg, offset: i32) {
2107	2096		emit(self, il::Instr::Load { typ: il::Type::W8, dst, src, offset });
2108	2097		}
2109	2098
2110	2099		/// Emit a 64-bit store instruction at the given offset.
2111	2100		fn emitStoreW64At(self: *mut FnLowerer, src: il::Val, dst: il::Reg, offset: i32) {
2112	2101		emit(self, il::Instr::Store { typ: il::Type::W64, src, dst, offset });
2113	2102		}
2114	2103
2115		-	/// Emit a 64-bit store instruction with default alignment.
2116		-	fn emitStoreW64(self: *mut FnLowerer, src: il::Val, dst: il::Reg) {
2117		-	emitStoreW64At(self, src, dst, 0);
2118		-	}
2119		-
2120	2104		/// Emit a 64-bit load instruction at the given offset.
2121	2105		fn emitLoadW64At(self: *mut FnLowerer, dst: il::Reg, src: il::Reg, offset: i32) {
2122	2106		emit(self, il::Instr::Load { typ: il::Type::W64, dst, src, offset });
2123	2107		}
2124	2108
2125		-	/// Emit a 64-bit load instruction with default alignment.
2126		-	fn emitLoadW64(self: *mut FnLowerer, dst: il::Reg, src: il::Reg) {
2127		-	emitLoadW64At(self, dst, src, 0);
2128		-	}
2129		-
2130	2109		/// Load a tag from memory at `src` plus `offset` with the given IL type.
2131	2110		fn loadTag(self: *mut FnLowerer, src: il::Reg, offset: i32, tagType: il::Type) -> il::Val {
2132	2111		let dst = nextReg(self);
2133	2112		emit(self, il::Instr::Load { typ: tagType, dst, src, offset });
2134	2113		return il::Val::Reg(dst);

2813	2792		}
2814	2793		}
2815	2794		return sameVal;
2816	2795		}
2817	2796
2818		-	/// Patch switch case arguments for a specific target.
2819		-	// TODO: Inline this when we don't have register pressure issues.
2820		-	fn patchSwitchCases(self: mut FnLowerer, cases: mut [il::SwitchCase], target: u32, paramIdx: u32, val: il::Val) {
2821		-	let idx = paramIdx + 1;
2822		-	for i in 0..cases.len {
2823		-	if cases[i].target == target {
2824		-	cases[i].args = growArgs(self, cases[i].args, idx);
2825		-	cases[i].args[paramIdx] = val;
2826		-	}
2827		-	}
2828		-	}
2829		-
2830	2797		/// Patch a single terminator argument for a specific edge. This is used during
2831	2798		/// SSA construction to pass variable values along control flow edges.
2832	2799		fn patchTerminatorArg(
2833	2800		self: *mut FnLowerer,
2834	2801		from: BlockId, // The predecessor block containing the terminator to patch.

2860	2827		case il::Instr::Switch { defaultTarget, defaultArgs, cases, .. } => {
2861	2828		if *defaultTarget == target {
2862	2829		defaultArgs = growArgs(self, defaultArgs, paramIdx + 1);
2863	2830		defaultArgs[paramIdx] = val;
2864	2831		}
2865		-	patchSwitchCases(self, *cases, target, paramIdx, val);
	2832	+	let idx = paramIdx + 1;
	2833	+	for ci in 0..cases.len {
	2834	+	if cases[ci].target == target {
	2835	+	cases[ci].args = growArgs(self, cases[ci].args, idx);
	2836	+	cases[ci].args[paramIdx] = val;
	2837	+	}
	2838	+	}
2866	2839		}
2867	2840		else => {
2868	2841		// Other terminators (e.g. `Ret`, `Unreachable`) don't have successor blocks.
2869	2842		}
2870	2843		}

2951	2924		}
2952	2925
2953	2926		/// Resolve match subject.
2954	2927		fn lowerMatchSubject(self: mut FnLowerer, subject: ast::Node) -> MatchSubject throws (LowerError) {
2955	2928		let mut val = try lowerExpr(self, subject);
2956		-	let subjectType = resolver::typeFor(self.low.resolver, subject) else {
2957		-	throw LowerError::MissingType(subject);
2958		-	};
	2929	+	let subjectType = try typeOf(self, subject);
2959	2930		let unwrapped = resolver::unwrapMatchSubject(subjectType);
2960	2931
2961	2932		// When matching an aggregate by value, copy it to a fresh stack slot so
2962	2933		// that bindings are independent of the original memory. Without this,
2963	2934		// the lowerer returns a pointer into the source and mutations to the

3024	2995		}
3025	2996		}
3026	2997
3027	2998		/// Lower an optional nil check (`opt == nil` or `opt != nil`).
3028	2999		fn lowerNilCheck(self: mut FnLowerer, opt: ast::Node, isEq: bool) -> il::Val throws (LowerError) {
3029		-	let optTy = resolver::typeFor(self.low.resolver, opt) else {
3030		-	throw LowerError::MissingType(opt);
3031		-	};
	3000	+	let optTy = try typeOf(self, opt);
3032	3001		// Handle `nil == nil` or `nil != nil`.
3033	3002		if optTy == resolver::Type::Nil {
3034	3003		return il::Val::Imm(1) if isEq else il::Val::Imm(0);
3035	3004		}
3036	3005		let val = try lowerExpr(self, opt);

3205	3174		let payloadBase = emitPtrOffset(self, base, valOffset);
3206	3175
3207	3176		try bindNestedRecordFields(self, payloadBase, lit, recInfo, subject.by, failBlock);
3208	3177		}
3209	3178
3210		-	/// Emit a field read from a base pointer.
3211		-	fn emitFieldRead(self: *mut FnLowerer, base: il::Reg, fieldInfo: resolver::RecordField, matchBy: resolver::MatchBy) -> il::Val {
3212		-	match matchBy {
3213		-	case resolver::MatchBy::Value => {
3214		-	return emitRead(self, base, fieldInfo.offset, fieldInfo.fieldType);
3215		-	}
3216		-	case resolver::MatchBy::Ref, resolver::MatchBy::MutRef => {
3217		-	return il::Val::Reg(emitPtrOffset(self, base, fieldInfo.offset));
3218		-	}
3219		-	}
3220		-	}
3221		-
3222	3179		/// Bind a single record field to a pattern variable, with support for nested
3223	3180		/// pattern tests that branch to `failBlock` on mismatch.
3224	3181		fn bindFieldVariable(
3225	3182		self: *mut FnLowerer,
3226	3183		binding: *ast::Node,

3229	3186		matchBy: resolver::MatchBy,
3230	3187		failBlock: BlockId
3231	3188		) throws (LowerError) {
3232	3189		match binding.value {
3233	3190		case ast::NodeValue::Ident(name) => {
3234		-	let val = emitFieldRead(self, base, fieldInfo, matchBy);
	3191	+	let val = emitRead(self, base, fieldInfo.offset, fieldInfo.fieldType)
	3192	+	if matchBy == resolver::MatchBy::Value
	3193	+	else il::Val::Reg(emitPtrOffset(self, base, fieldInfo.offset));
3235	3194		newVar(self, name, ilType(self.low, fieldInfo.fieldType), false, val);
3236	3195		}
3237	3196		case ast::NodeValue::Placeholder => {}
3238	3197		case ast::NodeValue::RecordLit(lit) => {
3239	3198		// Check if this record literal is a union variant pattern.

3247	3206		// Auto-deref: if the field is a pointer, load it first.
3248	3207		let mut derefType = fieldInfo.fieldType;
3249	3208		let mut nestedBase = emitPtrOffset(self, base, fieldInfo.offset);
3250	3209		if let case resolver::Type::Pointer { target, .. } = fieldInfo.fieldType {
3251	3210		let ptrReg = nextReg(self);
3252		-	emitLoadW64(self, ptrReg, nestedBase);
	3211	+	emitLoadW64At(self, ptrReg, nestedBase, 0);
3253	3212		nestedBase = ptrReg;
3254	3213		derefType = *target;
3255	3214		}
3256	3215		let recInfo = resolver::getRecord(derefType)
3257	3216		else throw LowerError::ExpectedRecord;

3284	3243		// The loaded pointer becomes the base address for the nested subject.
3285	3244		let mut derefBase: ?il::Reg = nil;
3286	3245		if let case resolver::Type::Pointer { target, .. } = fieldType {
3287	3246		if resolver::isDestructuringPattern(pattern) {
3288	3247		let ptrReg = nextReg(self);
3289		-	emitLoadW64(self, ptrReg, fieldPtr);
	3248	+	emitLoadW64At(self, ptrReg, fieldPtr, 0);
3290	3249		derefBase = ptrReg;
3291	3250		fieldType = *target;
3292	3251		}
3293	3252		}
3294	3253		// Build a MatchSubject for the nested field.

3859	3818		/// Return the effective type of a node after any coercion applied by
3860	3819		/// the resolver. `lowerExpr` already materializes the coercion in the
3861	3820		/// IL value, so the lowerer must use the post-coercion type when
3862	3821		/// choosing how to compare or store that value.
3863	3822		fn effectiveType(self: mut FnLowerer, node: ast::Node) -> resolver::Type throws (LowerError) {
3864		-	let ty = resolver::typeFor(self.low.resolver, node) else {
3865		-	throw LowerError::MissingType(node);
3866		-	};
	3823	+	let ty = try typeOf(self, node);
3867	3824		if let coerce = resolver::coercionFor(self.low.resolver, node) {
3868	3825		if let case resolver::Coercion::OptionalLift(optTy) = coerce {
3869	3826		return optTy;
3870	3827		}
3871	3828		}

3877	3834		match typ {
3878	3835		case resolver::Type::Nominal(_) => {
3879	3836		// Void unions are small enough to pass by value.
3880	3837		return not resolver::isVoidUnion(typ);
3881	3838		}
3882		-	case resolver::Type::Slice { .. } => return true,
3883		-	case resolver::Type::TraitObject { .. } => return true,
3884		-	case resolver::Type::Array(_) => return true,
3885		-	case resolver::Type::Nil => return true,
	3839	+	case resolver::Type::Slice { .. },
	3840	+	resolver::Type::TraitObject { .. },
	3841	+	resolver::Type::Array(_),
	3842	+	resolver::Type::Nil => return true,
3886	3843		case resolver::Type::Optional(resolver::Type::Pointer { .. }) => {
3887	3844		// Optional pointers are scalar due to NPO.
3888	3845		return false;
3889	3846		}
3890	3847		case resolver::Type::Optional(_) => {

4565	4522		}
4566	4523
4567	4524		/// Lower a record literal expression. Handles both plain records and union variant
4568	4525		/// record literals like `Union::Variant { field: value }`.
4569	4526		fn lowerRecordLit(self: mut FnLowerer, node: ast::Node, lit: ast::RecordLit) -> il::Val throws (LowerError) {
4570		-	let typ = resolver::typeFor(self.low.resolver, node) else {
4571		-	throw LowerError::MissingType(node);
4572		-	};
	4527	+	let typ = try typeOf(self, node);
4573	4528		match typ {
4574	4529		case resolver::Type::Nominal(resolver::NominalType::Record(recInfo)) => {
4575	4530		let dst = try emitReserve(self, typ);
4576	4531		try lowerRecordFields(self, dst, &recInfo, lit.fields, 0);
4577	4532

4588	4543		/// Lower a union variant record literal like `Union::Variant { field: value }`.
4589	4544		fn lowerUnionRecordLit(self: *mut FnLowerer, typ: resolver::Type, lit: ast::RecordLit) -> il::Val throws (LowerError) {
4590	4545		let typeName = lit.typeName else {
4591	4546		throw LowerError::ExpectedVariant;
4592	4547		};
4593		-	let sym = resolver::nodeData(self.low.resolver, typeName).sym else {
4594		-	throw LowerError::MissingSymbol(typeName);
4595		-	};
	4548	+	let sym = try symOf(self, typeName);
4596	4549		let case resolver::SymbolData::Variant { type: payloadType, index, .. } = sym.data else {
4597	4550		throw LowerError::ExpectedVariant;
4598	4551		};
4599	4552		let recInfo = recordInfoFromType(payloadType) else {
4600	4553		throw LowerError::ExpectedRecord;

4663	4616
4664	4617		/// Lower an array literal expression like `[1, 2, 3]`.
4665	4618		fn lowerArrayLit(self: mut FnLowerer, node: ast::Node, elements: mut [ast::Node]) -> il::Val
4666	4619		throws (LowerError)
4667	4620		{
4668		-	let typ = resolver::typeFor(self.low.resolver, node) else {
4669		-	throw LowerError::MissingType(node);
4670		-	};
	4621	+	let typ = try typeOf(self, node);
4671	4622		let case resolver::Type::Array(arrInfo) = typ else {
4672	4623		throw LowerError::ExpectedArray;
4673	4624		};
4674	4625		let elemTy = *arrInfo.item;
4675	4626		let elemLayout = resolver::getTypeLayout(elemTy);

4688	4639		/// Unrolls the initialization at compile time.
4689	4640		// TODO: Beyond a certain length, lower this to a loop.
4690	4641		fn lowerArrayRepeatLit(self: mut FnLowerer, node: ast::Node, repeat: ast::ArrayRepeatLit) -> il::Val
4691	4642		throws (LowerError)
4692	4643		{
4693		-	let typ = resolver::typeFor(self.low.resolver, node) else {
4694		-	throw LowerError::MissingType(node);
4695		-	};
	4644	+	let typ = try typeOf(self, node);
4696	4645		let case resolver::Type::Array(arrInfo) = typ else {
4697	4646		throw LowerError::ExpectedArray;
4698	4647		};
4699	4648		let elemTy = *arrInfo.item;
4700	4649		let length = arrInfo.length;