radiance · commit

Use `export` instead of `pub`

52b9cccca36dd131b1b8033ae21973ebed025d1b72ab5bff40cde3bf8d39672e

Alexis Sellier committed 4 days ago 1 parent bfa128ab

lib/std.rad +11 -11

//! The Radiance Standard Library.

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

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

lib/std/arch.rad +1 -1

1	1		//! RISC-V instruction set architecture encodings.
2		-	pub mod rv64;
	2	+	export mod rv64;

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

//! * decode: Instruction decoding (for disassembly/printing)
//! * emit: Binary emission context and branch patching
//! * isel: Instruction selection (IL to RV64 instructions)
//! * printer: Assembly text output

pub mod encode;
pub mod decode;
pub mod emit;
pub mod isel;
pub mod printer;
export mod encode;
export mod decode;
export mod emit;
export mod isel;
export mod printer;

@test mod tests;

use std::mem;
use std::collections::dict;


////////////////
// Registers  //
////////////////

pub const ZERO: gen::Reg = gen::Reg(0);   /// Hard-wired zero.
pub const RA:   gen::Reg = gen::Reg(1);   /// Return address.
pub const SP:   gen::Reg = gen::Reg(2);   /// Stack pointer.
pub const GP:   gen::Reg = gen::Reg(3);   /// Global pointer.
pub const TP:   gen::Reg = gen::Reg(4);   /// Thread pointer.
pub const T0:   gen::Reg = gen::Reg(5);   /// Temporary/alternate link register.
pub const T1:   gen::Reg = gen::Reg(6);   /// Temporary.
pub const T2:   gen::Reg = gen::Reg(7);   /// Temporary.
pub const S0:   gen::Reg = gen::Reg(8);   /// Saved register/frame pointer.
pub const FP:   gen::Reg = gen::Reg(8);   /// Frame pointer (alias for S0).
pub const S1:   gen::Reg = gen::Reg(9);   /// Saved register.
pub const A0:   gen::Reg = gen::Reg(10);  /// Function argument/return.
pub const A1:   gen::Reg = gen::Reg(11);  /// Function argument/return.
pub const A2:   gen::Reg = gen::Reg(12);  /// Function argument.
pub const A3:   gen::Reg = gen::Reg(13);  /// Function argument.
pub const A4:   gen::Reg = gen::Reg(14);  /// Function argument.
pub const A5:   gen::Reg = gen::Reg(15);  /// Function argument.
pub const A6:   gen::Reg = gen::Reg(16);  /// Function argument.
pub const A7:   gen::Reg = gen::Reg(17);  /// Function argument.
pub const S2:   gen::Reg = gen::Reg(18);  /// Saved register.
pub const S3:   gen::Reg = gen::Reg(19);  /// Saved register.
pub const S4:   gen::Reg = gen::Reg(20);  /// Saved register.
pub const S5:   gen::Reg = gen::Reg(21);  /// Saved register.
pub const S6:   gen::Reg = gen::Reg(22);  /// Saved register.
pub const S7:   gen::Reg = gen::Reg(23);  /// Saved register.
pub const S8:   gen::Reg = gen::Reg(24);  /// Saved register.
pub const S9:   gen::Reg = gen::Reg(25);  /// Saved register.
pub const S10:  gen::Reg = gen::Reg(26);  /// Saved register.
pub const S11:  gen::Reg = gen::Reg(27);  /// Saved register.
pub const T3:   gen::Reg = gen::Reg(28);  /// Temporary.
pub const T4:   gen::Reg = gen::Reg(29);  /// Temporary.
pub const T5:   gen::Reg = gen::Reg(30);  /// Temporary.
pub const T6:   gen::Reg = gen::Reg(31);  /// Temporary.
export const ZERO: gen::Reg = gen::Reg(0);   /// Hard-wired zero.
export const RA:   gen::Reg = gen::Reg(1);   /// Return address.
export const SP:   gen::Reg = gen::Reg(2);   /// Stack pointer.
export const GP:   gen::Reg = gen::Reg(3);   /// Global pointer.
export const TP:   gen::Reg = gen::Reg(4);   /// Thread pointer.
export const T0:   gen::Reg = gen::Reg(5);   /// Temporary/alternate link register.
export const T1:   gen::Reg = gen::Reg(6);   /// Temporary.
export const T2:   gen::Reg = gen::Reg(7);   /// Temporary.
export const S0:   gen::Reg = gen::Reg(8);   /// Saved register/frame pointer.
export const FP:   gen::Reg = gen::Reg(8);   /// Frame pointer (alias for S0).
export const S1:   gen::Reg = gen::Reg(9);   /// Saved register.
export const A0:   gen::Reg = gen::Reg(10);  /// Function argument/return.
export const A1:   gen::Reg = gen::Reg(11);  /// Function argument/return.
export const A2:   gen::Reg = gen::Reg(12);  /// Function argument.
export const A3:   gen::Reg = gen::Reg(13);  /// Function argument.
export const A4:   gen::Reg = gen::Reg(14);  /// Function argument.
export const A5:   gen::Reg = gen::Reg(15);  /// Function argument.
export const A6:   gen::Reg = gen::Reg(16);  /// Function argument.
export const A7:   gen::Reg = gen::Reg(17);  /// Function argument.
export const S2:   gen::Reg = gen::Reg(18);  /// Saved register.
export const S3:   gen::Reg = gen::Reg(19);  /// Saved register.
export const S4:   gen::Reg = gen::Reg(20);  /// Saved register.
export const S5:   gen::Reg = gen::Reg(21);  /// Saved register.
export const S6:   gen::Reg = gen::Reg(22);  /// Saved register.
export const S7:   gen::Reg = gen::Reg(23);  /// Saved register.
export const S8:   gen::Reg = gen::Reg(24);  /// Saved register.
export const S9:   gen::Reg = gen::Reg(25);  /// Saved register.
export const S10:  gen::Reg = gen::Reg(26);  /// Saved register.
export const S11:  gen::Reg = gen::Reg(27);  /// Saved register.
export const T3:   gen::Reg = gen::Reg(28);  /// Temporary.
export const T4:   gen::Reg = gen::Reg(29);  /// Temporary.
export const T5:   gen::Reg = gen::Reg(30);  /// Temporary.
export const T6:   gen::Reg = gen::Reg(31);  /// Temporary.

/// Create a register from a number. Panics if `n > 31`.
pub fn reg(n: u8) -> gen::Reg {
export fn reg(n: u8) -> gen::Reg {
    assert n < 32;
    return gen::Reg(n);
}

////////////////////////////
// Architecture constants //
////////////////////////////

/// Total number of general-purpose registers.
pub const NUM_REGISTERS: u8 = 32;
export const NUM_REGISTERS: u8 = 32;
/// Number of saved registers.
pub const NUM_SAVED_REGISTERS: u8 = 11;
export const NUM_SAVED_REGISTERS: u8 = 11;
/// Word size in bytes (32-bit).
pub const WORD_SIZE: i32 = 4;
export const WORD_SIZE: i32 = 4;
/// Doubleword size in bytes (64-bit).
pub const DWORD_SIZE: i32 = 8;
export const DWORD_SIZE: i32 = 8;
/// Instruction size in bytes.
pub const INSTR_SIZE: i32 = 4;
export const INSTR_SIZE: i32 = 4;
/// Stack alignment requirement in bytes.
pub const STACK_ALIGNMENT: i32 = 16;
export const STACK_ALIGNMENT: i32 = 16;

/// Minimum blit size (in bytes) to use a loop instead of inline copy.
/// Blits below this threshold are fully unrolled as LD/SD pairs.
pub const BLIT_LOOP_THRESHOLD: i32 = 256;
export const BLIT_LOOP_THRESHOLD: i32 = 256;

/////////////////////////
// Codegen Allocation  //
/////////////////////////

/// Argument registers for function calls.
pub const ARG_REGS: [gen::Reg; 8] = [A0, A1, A2, A3, A4, A5, A6, A7];
export const ARG_REGS: [gen::Reg; 8] = [A0, A1, A2, A3, A4, A5, A6, A7];

/// Scratch register for code gen. Never allocated to user values.
pub const SCRATCH1: gen::Reg = T5;
export const SCRATCH1: gen::Reg = T5;

/// Second scratch register for operations needing two temporaries.
pub const SCRATCH2: gen::Reg = T6;
export const SCRATCH2: gen::Reg = T6;

/// Dedicated scratch for address offset adjustment. Never allocated to user
/// values and never used for operand materialization, so it can never
/// conflict with `rd`, `rs`, or `base` in load/store helpers.
pub const ADDR_SCRATCH: gen::Reg = T4;
export const ADDR_SCRATCH: gen::Reg = T4;

/// Callee-saved registers that need save/restore if used.
pub const CALLEE_SAVED: [gen::Reg; NUM_SAVED_REGISTERS] = [S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11];
export const CALLEE_SAVED: [gen::Reg; NUM_SAVED_REGISTERS] = [S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11];

/// Maximum 12-bit signed immediate value.
pub const MAX_IMM: i32 = 2047;
export const MAX_IMM: i32 = 2047;

/// Minimum 12-bit signed immediate value.
pub const MIN_IMM: i32 = -2048;
export const MIN_IMM: i32 = -2048;

/// Allocatable registers for register allocation.
const ALLOCATABLE_REGS: [gen::Reg; 23] = [
    T0, T1, T2, T3,                             // Temporaries
    A0, A1, A2, A3, A4, A5, A6, A7,             // Arguments
    S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, // Saved
];

/// Get target configuration for register allocation.
// TODO: This should be a constant variable.
pub fn targetConfig() -> regalloc::TargetConfig {
export fn targetConfig() -> regalloc::TargetConfig {
    return regalloc::TargetConfig {
        allocatable: &ALLOCATABLE_REGS[..],
        argRegs: &ARG_REGS[..],
        calleeSaved: &CALLEE_SAVED[..],
        slotSize: DWORD_SIZE,

///////////////////////
// Codegen Constants //
///////////////////////

/// Base address where read-only data is loaded.
pub const RO_DATA_BASE: u32 = 0x10000;
export const RO_DATA_BASE: u32 = 0x10000;

/// Base address where read-write data is loaded.
pub const RW_DATA_BASE: u32 = 0xFFFFF0;
export const RW_DATA_BASE: u32 = 0xFFFFF0;

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

/// Result of code generation.
pub record Program {
export record Program {
    /// Slice of emitted code.
    code: *[u32],
    /// Slice of function addresses (name + start index).
    funcs: *[types::FuncAddr],
    /// Number of read-only data bytes emitted.

    /// Debug entries mapping PCs to source locations. Empty when debug is off.
    debugEntries: *[types::DebugEntry],
}

/// Generate code for an IL program.
pub fn generate(
export fn generate(
    program: *il::Program,
    storage: Storage,
    roDataBuf: *mut [u8],
    rwDataBuf: *mut [u8],
    arena: *mut alloc::Arena,

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

///////////////////////
// Field Extraction  //
///////////////////////

/// Extract opcode (bits 6:0).
pub fn opcode(instr: u32) -> u32 {
export fn opcode(instr: u32) -> u32 {
    return instr & 0x7F;
}

/// Extract rd (bits 11:7).
pub fn rd(instr: u32) -> u8 {
export fn rd(instr: u32) -> u8 {
    return ((instr >> 7) & 0x1F) as u8;
}

/// Extract funct3 (bits 14:12).
pub fn funct3(instr: u32) -> u32 {
export fn funct3(instr: u32) -> u32 {
    return (instr >> 12) & 0x07;
}

/// Extract rs1 (bits 19:15).
pub fn rs1(instr: u32) -> u8 {
export fn rs1(instr: u32) -> u8 {
    return ((instr >> 15) & 0x1F) as u8;
}

/// Extract rs2 (bits 24:20).
pub fn rs2(instr: u32) -> u8 {
export fn rs2(instr: u32) -> u8 {
    return ((instr >> 20) & 0x1F) as u8;
}

/// Extract funct7 (bits 31:25).
pub fn funct7(instr: u32) -> u32 {
export fn funct7(instr: u32) -> u32 {
    return instr >> 25;
}

//////////////////////////
// Immediate Extraction //
//////////////////////////

/// Extract I-type immediate (sign-extended).
pub fn immI(instr: u32) -> i32 {
export fn immI(instr: u32) -> i32 {
    let imm = instr >> 20;
    if (imm & 0x800) != 0 {
        return (imm | 0xFFFFF000) as i32;
    }
    return imm as i32;
}

/// Extract S-type immediate (sign-extended).
pub fn immS(instr: u32) -> i32 {
export fn immS(instr: u32) -> i32 {
    let lo = (instr >> 7) & 0x1F;
    let hi = (instr >> 25) & 0x7F;
    let imm = (hi << 5) | lo;
    if (imm & 0x800) != 0 {
        return (imm | 0xFFFFF000) as i32;
    }
    return imm as i32;
}

/// Extract B-type immediate (sign-extended).
pub fn immB(instr: u32) -> i32 {
export fn immB(instr: u32) -> i32 {
    let imm11 = (instr >> 7) & 0x1;
    let imm4_1 = (instr >> 8) & 0xF;
    let imm10_5 = (instr >> 25) & 0x3F;
    let imm12 = (instr >> 31) & 0x1;
    let imm = (imm12 << 12) | (imm11 << 11) | (imm10_5 << 5) | (imm4_1 << 1);

    }
    return imm as i32;
}

/// Extract J-type immediate (sign-extended).
pub fn immJ(instr: u32) -> i32 {
export fn immJ(instr: u32) -> i32 {
    let imm19_12 = (instr >> 12) & 0xFF;
    let imm11 = (instr >> 20) & 0x1;
    let imm10_1 = (instr >> 21) & 0x3FF;
    let imm20 = (instr >> 31) & 0x1;
    let imm = (imm20 << 20) | (imm19_12 << 12) | (imm11 << 11) | (imm10_1 << 1);

    }
    return imm as i32;
}

/// Extract U-type immediate (upper 20 bits, sign-extended).
pub fn immU(instr: u32) -> i32 {
export fn immU(instr: u32) -> i32 {
    let imm = instr >> 12;
    if (imm & 0x80000) != 0 {
        return (imm | 0xFFF00000) as i32;
    }
    return imm as i32;

/////////////////////////
// Decoded Instruction //
/////////////////////////

/// Decoded RV64 instruction.
pub union Instr {
export union Instr {
    // R-type ALU.
    Add  { rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg },
    Sub  { rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg },
    Sll  { rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg },
    Slt  { rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg },

    // Unknown/invalid instruction.
    Unknown { bits: u32 },
}

/// Decode a 32-bit instruction word into an [`Instr`].
pub fn decode(instr: u32) -> Instr {
export fn decode(instr: u32) -> Instr {
    let op = opcode(instr);
    let f3 = funct3(instr);
    let f7 = funct7(instr);
    let rd = super::reg(rd(instr));
    let rs1 = super::reg(rs1(instr));

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

//////////////////////
// Emission Context //
//////////////////////

/// Branch/jump that needs offset patching after all blocks are emitted.
pub record PendingBranch {
export record PendingBranch {
    /// Index into code buffer where the branch instruction is.
    index: u32,
    /// Target block index.
    target: u32,
    /// Type of branch for re-encoding.
    kind: BranchKind,
}

/// Type of branch instruction.
pub union BranchKind {
export union BranchKind {
    /// Conditional branch (B-type encoding).
    Cond { op: il::CmpOp, rs1: gen::Reg, rs2: gen::Reg },
    /// Inverted conditional branch (B-type encoding with negated condition).
    InvertedCond { op: il::CmpOp, rs1: gen::Reg, rs2: gen::Reg },
    /// Unconditional jump (J-type encoding).
    Jump,
}

/// Function call that needs offset patching.
pub record PendingCall {
export record PendingCall {
    /// Index in code buffer where the call was emitted.
    index: u32,
    /// Target function name.
    target: *[u8],
}

/// Function address load that needs offset patching.
/// Used when taking a function's address as a value.
pub record PendingAddrLoad {
export record PendingAddrLoad {
    /// Index in code buffer where the load was emitted.
    index: u32,
    /// Target function name.
    target: *[u8],
    /// Destination register.
    rd: gen::Reg,
}

/// Adjusted base register and offset for addressing.
pub record AdjustedOffset {
export record AdjustedOffset {
    /// Base register.
    base: gen::Reg,
    /// Byte offset from register.
    offset: i32,
}

/// Callee-saved register with its stack offset.
pub record SavedReg {
export record SavedReg {
    /// Register to save/restore.
    reg: gen::Reg,
    /// Offset from SP.
    offset: i32,
}

/// Emission context. Tracks state during code generation.
pub record Emitter {
export record Emitter {
    /// Emitted instructions storage.
    code: *mut [u32],
    /// Current number of emitted instructions.
    codeLen: u32,
    /// Local branches needing offset patching.

    /// Number of debug entries recorded.
    debugEntriesLen: u32,
}

/// Computed stack frame layout for a function.
pub record Frame {
export record Frame {
    /// Total frame size in bytes (aligned).
    totalSize: i32,
    /// Callee-saved registers and their offsets.
    // TODO: Use constant length when language supports it.
    savedRegs: [SavedReg; super::NUM_SAVED_REGISTERS],

    /// When false, SP never changes after the prologue.
    isDynamic: bool,
}

/// Compute frame layout from local size and used callee-saved registers.
pub fn computeFrame(localSize: i32, usedCalleeSaved: u32, epilogueBlock: u32, isLeaf: bool, isDynamic: bool) -> Frame {
export fn computeFrame(localSize: i32, usedCalleeSaved: u32, epilogueBlock: u32, isLeaf: bool, isDynamic: bool) -> Frame {
    let mut frame = Frame {
        totalSize: 0,
        savedRegs: undefined,
        savedRegsLen: 0,
        epilogueBlock,

    }
    return frame;
}

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

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

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

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

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

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

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

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

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

}

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

}

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

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

    }
}

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


}

/// Patch all pending function address loads.
/// Called after all functions have been generated.
/// Uses PC-relative addresses up to 2GB away.
pub fn patchAddrLoads(e: *mut Emitter) {
export fn patchAddrLoads(e: *mut Emitter) {
    for i in 0..e.pendingAddrLoadsLen {
        let p = e.pendingAddrLoads[i];
        let offset = branchOffsetToFunc(e, p.index, p.target);
        let s = splitImm(offset);


/////////////////////////
// Immediate Handling  //
/////////////////////////

/// Split immediate into `hi` and `lo` bits.
pub record SplitImm {
export record SplitImm {
    /// Upper 20 bits.
    hi: i32,
    /// Lower 12 bits.
    lo: i32,
}

/// Split a 32-bit immediate for `AUIPC, ADDI` / `JALR` sequences.
/// Handles sign extension: if *lo* is negative, increment *hi*.
pub fn splitImm(imm: i32) -> SplitImm {
export fn splitImm(imm: i32) -> SplitImm {
    let lo = imm & 0xFFF;
    let mut hi = (imm >> 12) & 0xFFFFF;
    // If `lo`'s sign bit is set, it will be sign-extended to negative.
    // Compensate by incrementing `hi`.
    if (lo & 0x800) != 0 {

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

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

    emit(e, encode::slli(rd, rd, 10));
    emit(e, encode::addi(rd, rd, lower & 0x3FF));
}

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

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

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

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

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

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

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

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

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

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

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

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

/// Emit function prologue.
/// Allocates stack frame, saves RA/FP, saves callee-saved registers.
pub fn emitPrologue(e: *mut Emitter, frame: *Frame) {
export fn emitPrologue(e: *mut Emitter, frame: *Frame) {
    // Fast path: leaf function with no locals.
    if frame.totalSize == 0 {
        return;
    }
    let totalSize = frame.totalSize;

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

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

/// Emit function epilogue.
/// Restores callee-saved registers, `RA/FP`, deallocates frame, returns.
pub fn emitEpilogue(e: *mut Emitter, frame: *Frame) {
export fn emitEpilogue(e: *mut Emitter, frame: *Frame) {
    // Record epilogue block address for return jumps.
    recordBlock(e, frame.epilogueBlock);

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

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

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

/// Get function addresses for printing.
pub fn getFuncs(e: *Emitter) -> *[types::FuncAddr] {
export fn getFuncs(e: *Emitter) -> *[types::FuncAddr] {
    return &e.funcs[..e.funcsLen];
}

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

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

    };
    e.debugEntriesLen += 1;
}

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

lib/std/arch/rv64/encode.rad +118 -118


//////////////////////
// Opcode Constants //
//////////////////////

pub const OP_LOAD:   u32 = 0x03;
pub const OP_STORE:  u32 = 0x23;
pub const OP_BRANCH: u32 = 0x63;
pub const OP_JALR:   u32 = 0x67;
pub const OP_JAL:    u32 = 0x6F;
pub const OP_OP:     u32 = 0x33;
pub const OP_IMM:    u32 = 0x13;
pub const OP_AUIPC:  u32 = 0x17;
pub const OP_LUI:    u32 = 0x37;
pub const OP_SYSTEM: u32 = 0x73;
pub const OP_OP32:   u32 = 0x3B;  // RV64: 32-bit operations
pub const OP_IMM32:  u32 = 0x1B;  // RV64: 32-bit immediate operations
export const OP_LOAD:   u32 = 0x03;
export const OP_STORE:  u32 = 0x23;
export const OP_BRANCH: u32 = 0x63;
export const OP_JALR:   u32 = 0x67;
export const OP_JAL:    u32 = 0x6F;
export const OP_OP:     u32 = 0x33;
export const OP_IMM:    u32 = 0x13;
export const OP_AUIPC:  u32 = 0x17;
export const OP_LUI:    u32 = 0x37;
export const OP_SYSTEM: u32 = 0x73;
export const OP_OP32:   u32 = 0x3B;  // RV64: 32-bit operations
export const OP_IMM32:  u32 = 0x1B;  // RV64: 32-bit immediate operations

//////////////////////
// Funct3 Constants //
//////////////////////

// Memory operations

pub const F3_BYTE:   u32 = 0x0;  // LB/SB
pub const F3_HALF:   u32 = 0x1;  // LH/SH
pub const F3_WORD:   u32 = 0x2;  // LW/SW
pub const F3_DWORD:  u32 = 0x3;  // LD/SD (RV64)
pub const F3_BYTE_U: u32 = 0x4;  // LBU
pub const F3_HALF_U: u32 = 0x5;  // LHU
pub const F3_WORD_U: u32 = 0x6;  // LWU (RV64)
export const F3_BYTE:   u32 = 0x0;  // LB/SB
export const F3_HALF:   u32 = 0x1;  // LH/SH
export const F3_WORD:   u32 = 0x2;  // LW/SW
export const F3_DWORD:  u32 = 0x3;  // LD/SD (RV64)
export const F3_BYTE_U: u32 = 0x4;  // LBU
export const F3_HALF_U: u32 = 0x5;  // LHU
export const F3_WORD_U: u32 = 0x6;  // LWU (RV64)

// ALU operations

pub const F3_ADD:  u32 = 0x0;  // ADD/SUB/ADDI
pub const F3_SLL:  u32 = 0x1;  // SLL/SLLI
pub const F3_SLT:  u32 = 0x2;  // SLT/SLTI
pub const F3_SLTU: u32 = 0x3;  // SLTU/SLTIU
pub const F3_XOR:  u32 = 0x4;  // XOR/XORI
pub const F3_SRL:  u32 = 0x5;  // SRL/SRA/SRLI/SRAI
pub const F3_OR:   u32 = 0x6;  // OR/ORI
pub const F3_AND:  u32 = 0x7;  // AND/ANDI
export const F3_ADD:  u32 = 0x0;  // ADD/SUB/ADDI
export const F3_SLL:  u32 = 0x1;  // SLL/SLLI
export const F3_SLT:  u32 = 0x2;  // SLT/SLTI
export const F3_SLTU: u32 = 0x3;  // SLTU/SLTIU
export const F3_XOR:  u32 = 0x4;  // XOR/XORI
export const F3_SRL:  u32 = 0x5;  // SRL/SRA/SRLI/SRAI
export const F3_OR:   u32 = 0x6;  // OR/ORI
export const F3_AND:  u32 = 0x7;  // AND/ANDI

// Branch operations

pub const F3_BEQ:  u32 = 0x0;
pub const F3_BNE:  u32 = 0x1;
pub const F3_BLT:  u32 = 0x4;
pub const F3_BGE:  u32 = 0x5;
pub const F3_BLTU: u32 = 0x6;
pub const F3_BGEU: u32 = 0x7;
export const F3_BEQ:  u32 = 0x0;
export const F3_BNE:  u32 = 0x1;
export const F3_BLT:  u32 = 0x4;
export const F3_BGE:  u32 = 0x5;
export const F3_BLTU: u32 = 0x6;
export const F3_BGEU: u32 = 0x7;

//////////////////////
// Funct7 Constants //
//////////////////////

pub const F7_NORMAL: u32 = 0b0000000;
pub const F7_SUB:    u32 = 0b0100000;  // Bit 5 set
pub const F7_SRA:    u32 = 0b0100000;  // Bit 5 set
pub const F7_MUL:    u32 = 0b0000001;  // Bit 0 set
export const F7_NORMAL: u32 = 0b0000000;
export const F7_SUB:    u32 = 0b0100000;  // Bit 5 set
export const F7_SRA:    u32 = 0b0100000;  // Bit 5 set
export const F7_MUL:    u32 = 0b0000001;  // Bit 0 set

/////////////////////////
// Validation Helpers  //
/////////////////////////

/// Returns `true` if the value fits in a signed 12-bit immediate.
pub fn isSmallImm(value: i32) -> bool {
export fn isSmallImm(value: i32) -> bool {
    return value >= super::MIN_IMM and value <= super::MAX_IMM;
}

/// Returns `true` if a 64-bit value fits in a 12-bit signed immediate.
pub fn isSmallImm64(value: i64) -> bool {
export fn isSmallImm64(value: i64) -> bool {
    return value >= (super::MIN_IMM as i64) and value <= (super::MAX_IMM as i64);
}

/// Returns `true` if the value is valid for branch immediates.
/// Branch immediates are 13-bit signed, even aligned.
pub fn isBranchImm(value: i32) -> bool {
export fn isBranchImm(value: i32) -> bool {
    return value >= -(1 << 12) and value <= ((1 << 12) - 2) and (value & 1) == 0;
}

/// Returns `true` if the value is valid for jump immediates (JAL).
/// Jump immediates are 21-bit signed, even aligned.
pub fn isJumpImm(value: i32) -> bool {
export fn isJumpImm(value: i32) -> bool {
    return value >= -(1 << 20) and value <= ((1 << 20) - 2) and (value & 1) == 0;
}

//////////////////////
// Format Encoders  //

////////////////////////////
// ALU Immediate (I-type) //
////////////////////////////

/// Add immediate: `rd = rs1 + imm`.
pub fn addi(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
export fn addi(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
    return encodeI(OP_IMM, rd, rs1, F3_ADD, imm);
}

/// Set less than immediate (signed): `rd = (rs1 < imm) ? 1 : 0`.
pub fn slti(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
export fn slti(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
    return encodeI(OP_IMM, rd, rs1, F3_SLT, imm);
}

/// Set less than immediate unsigned: `rd = (rs1 < imm) ? 1 : 0`.
pub fn sltiu(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
export fn sltiu(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
    return encodeI(OP_IMM, rd, rs1, F3_SLTU, imm);
}

/// XOR immediate: `rd = rs1 ^ imm`.
pub fn xori(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
export fn xori(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
    return encodeI(OP_IMM, rd, rs1, F3_XOR, imm);
}

/// OR immediate: `rd = rs1 | imm`.
pub fn ori(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
export fn ori(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
    return encodeI(OP_IMM, rd, rs1, F3_OR, imm);
}

/// AND immediate: `rd = rs1 & imm`.
pub fn andi(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
export fn andi(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
    return encodeI(OP_IMM, rd, rs1, F3_AND, imm);
}

/// Shift left logical immediate: `rd = rs1 << shamt`.
pub fn slli(rd: gen::Reg, rs1: gen::Reg, shamt: i32) -> u32 {
export fn slli(rd: gen::Reg, rs1: gen::Reg, shamt: i32) -> u32 {
    assert shamt >= 0 and shamt < 64;
    return encodeI(OP_IMM, rd, rs1, F3_SLL, shamt & 0x3F);
}

/// Shift right logical immediate: `rd = rs1 >> shamt` (zero-extend).
pub fn srli(rd: gen::Reg, rs1: gen::Reg, shamt: i32) -> u32 {
export fn srli(rd: gen::Reg, rs1: gen::Reg, shamt: i32) -> u32 {
    assert shamt >= 0 and shamt < 64;
    return encodeI(OP_IMM, rd, rs1, F3_SRL, shamt & 0x3F);
}

/// Shift right arithmetic immediate: `rd = rs1 >> shamt` (sign-extend).
pub fn srai(rd: gen::Reg, rs1: gen::Reg, shamt: i32) -> u32 {
export fn srai(rd: gen::Reg, rs1: gen::Reg, shamt: i32) -> u32 {
    assert shamt >= 0 and shamt < 64;
    // SRAI has bit 10 set in immediate field (becomes bit 30 in instruction)
    return encodeI(OP_IMM, rd, rs1, F3_SRL, (shamt & 0x3F) | 0b10000000000);
}

///////////////////////////
// ALU Register (R-type) //
///////////////////////////

/// Add: `rd = rs1 + rs2`.
pub fn add(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn add(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP, rd, rs1, rs2, F3_ADD, F7_NORMAL);
}

/// Subtract: `rd = rs1 - rs2`.
pub fn sub(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn sub(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP, rd, rs1, rs2, F3_ADD, F7_SUB);
}

/// Shift left logical: `rd = rs1 << rs2[5:0]`.
pub fn sll(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn sll(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP, rd, rs1, rs2, F3_SLL, F7_NORMAL);
}

/// Set less than (signed): `rd = (rs1 < rs2) ? 1 : 0`.
pub fn slt(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn slt(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP, rd, rs1, rs2, F3_SLT, F7_NORMAL);
}

/// Set less than unsigned: `rd = (rs1 < rs2) ? 1 : 0`.
pub fn sltu(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn sltu(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP, rd, rs1, rs2, F3_SLTU, F7_NORMAL);
}

/// XOR: `rd = rs1 ^ rs2`.
pub fn xor(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn xor(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP, rd, rs1, rs2, F3_XOR, F7_NORMAL);
}

/// Shift right logical: `rd = rs1 >> rs2[5:0]` (zero-extend).
pub fn srl(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn srl(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP, rd, rs1, rs2, F3_SRL, F7_NORMAL);
}

/// Shift right arithmetic: `rd = rs1 >> rs2[5:0]` (sign-extend).
pub fn sra(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn sra(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP, rd, rs1, rs2, F3_SRL, F7_SRA);
}

/// OR: `rd = rs1 | rs2`.
pub fn or_(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn or_(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP, rd, rs1, rs2, F3_OR, F7_NORMAL);
}

/// AND: `rd = rs1 & rs2`.
pub fn and_(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn and_(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP, rd, rs1, rs2, F3_AND, F7_NORMAL);
}

/////////////////
// M Extension //
/////////////////

/// Multiply: `rd = (rs1 * rs2)[63:0]`.
pub fn mul(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn mul(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP, rd, rs1, rs2, F3_ADD, F7_MUL);
}

/// Multiply high (signed x signed): `rd = (rs1 * rs2)[127:64]`.
pub fn mulh(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn mulh(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP, rd, rs1, rs2, F3_SLL, F7_MUL);
}

/// Multiply high (signed x unsigned): `rd = (rs1 * rs2)[127:64]`.
pub fn mulhsu(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn mulhsu(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP, rd, rs1, rs2, F3_SLT, F7_MUL);
}

/// Multiply high (unsigned x unsigned): `rd = (rs1 * rs2)[127:64]`.
pub fn mulhu(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn mulhu(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP, rd, rs1, rs2, F3_SLTU, F7_MUL);
}

/// Divide (signed): `rd = rs1 / rs2`.
pub fn div(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn div(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP, rd, rs1, rs2, F3_XOR, F7_MUL);
}

/// Divide (unsigned): `rd = rs1 / rs2`.
pub fn divu(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn divu(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP, rd, rs1, rs2, F3_SRL, F7_MUL);
}

/// Remainder (signed): `rd = rs1 % rs2`.
pub fn rem(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn rem(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP, rd, rs1, rs2, F3_OR, F7_MUL);
}

/// Remainder (unsigned): `rd = rs1 % rs2`.
pub fn remu(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn remu(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP, rd, rs1, rs2, F3_AND, F7_MUL);
}

//////////////////////////
// RV64 Word Operations //
//////////////////////////

/// Add immediate word (32-bit, sign-extended): `rd = sign_ext((rs1 + imm)[31:0])`.
pub fn addiw(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
export fn addiw(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
    return encodeI(OP_IMM32, rd, rs1, F3_ADD, imm);
}

/// Shift left logical immediate word: `rd = sign_ext((rs1 << shamt)[31:0])`.
pub fn slliw(rd: gen::Reg, rs1: gen::Reg, shamt: i32) -> u32 {
export fn slliw(rd: gen::Reg, rs1: gen::Reg, shamt: i32) -> u32 {
    assert shamt >= 0 and shamt < 32;
    return encodeI(OP_IMM32, rd, rs1, F3_SLL, shamt & 0x1F);
}

/// Shift right logical immediate word: `rd = sign_ext((rs1[31:0] >> shamt))`.
pub fn srliw(rd: gen::Reg, rs1: gen::Reg, shamt: i32) -> u32 {
export fn srliw(rd: gen::Reg, rs1: gen::Reg, shamt: i32) -> u32 {
    assert shamt >= 0 and shamt < 32;
    return encodeI(OP_IMM32, rd, rs1, F3_SRL, shamt & 0x1F);
}

/// Shift right arithmetic immediate word: `rd = sign_ext((rs1[31:0] >> shamt))` (sign-extended).
pub fn sraiw(rd: gen::Reg, rs1: gen::Reg, shamt: i32) -> u32 {
export fn sraiw(rd: gen::Reg, rs1: gen::Reg, shamt: i32) -> u32 {
    assert shamt >= 0 and shamt < 32;
    return encodeI(OP_IMM32, rd, rs1, F3_SRL, (shamt & 0x1F) | 0b10000000000);
}

/// Add word: `rd = sign_ext((rs1 + rs2)[31:0])`.
pub fn addw(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn addw(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP32, rd, rs1, rs2, F3_ADD, F7_NORMAL);
}

/// Subtract word: `rd = sign_ext((rs1 - rs2)[31:0])`.
pub fn subw(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn subw(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP32, rd, rs1, rs2, F3_ADD, F7_SUB);
}

/// Shift left logical word: `rd = sign_ext((rs1 << rs2[4:0])[31:0])`.
pub fn sllw(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn sllw(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP32, rd, rs1, rs2, F3_SLL, F7_NORMAL);
}

/// Shift right logical word: `rd = sign_ext((rs1[31:0] >> rs2[4:0]))`.
pub fn srlw(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn srlw(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP32, rd, rs1, rs2, F3_SRL, F7_NORMAL);
}

/// Shift right arithmetic word: `rd = sign_ext((rs1[31:0] >> rs2[4:0]))` (sign-extended).
pub fn sraw(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn sraw(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP32, rd, rs1, rs2, F3_SRL, F7_SRA);
}

/// Multiply word: `rd = sign_ext((rs1 * rs2)[31:0])`.
pub fn mulw(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn mulw(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP32, rd, rs1, rs2, F3_ADD, F7_MUL);
}

/// Divide word (signed): `rd = sign_ext(rs1[31:0] / rs2[31:0])`.
pub fn divw(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn divw(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP32, rd, rs1, rs2, F3_XOR, F7_MUL);
}

/// Divide word (unsigned): `rd = sign_ext(rs1[31:0] / rs2[31:0])`.
pub fn divuw(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn divuw(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP32, rd, rs1, rs2, F3_SRL, F7_MUL);
}

/// Remainder word (signed): `rd = sign_ext(rs1[31:0] % rs2[31:0])`.
pub fn remw(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn remw(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP32, rd, rs1, rs2, F3_OR, F7_MUL);
}

/// Remainder word (unsigned): `rd = sign_ext(rs1[31:0] % rs2[31:0])`.
pub fn remuw(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
export fn remuw(rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg) -> u32 {
    return encodeR(OP_OP32, rd, rs1, rs2, F3_AND, F7_MUL);
}

///////////////////
// Load (I-type) //
///////////////////

/// Load byte (sign-extend): `rd = mem[rs1 + imm][7:0]`.
pub fn lb(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
export fn lb(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
    return encodeI(OP_LOAD, rd, rs1, F3_BYTE, imm);
}

/// Load halfword (sign-extend): `rd = mem[rs1 + imm][15:0]`.
pub fn lh(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
export fn lh(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
    return encodeI(OP_LOAD, rd, rs1, F3_HALF, imm);
}

/// Load word (sign-extend to 64-bit): `rd = sign_ext(mem[rs1 + imm][31:0])`.
pub fn lw(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
export fn lw(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
    return encodeI(OP_LOAD, rd, rs1, F3_WORD, imm);
}

/// Load byte unsigned (zero-extend): `rd = mem[rs1 + imm][7:0]`.
pub fn lbu(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
export fn lbu(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
    return encodeI(OP_LOAD, rd, rs1, F3_BYTE_U, imm);
}

/// Load halfword unsigned (zero-extend): `rd = mem[rs1 + imm][15:0]`.
pub fn lhu(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
export fn lhu(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
    return encodeI(OP_LOAD, rd, rs1, F3_HALF_U, imm);
}

/// Load word unsigned (zero-extend to 64-bit): `rd = mem[rs1 + imm][31:0]`.
pub fn lwu(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
export fn lwu(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
    return encodeI(OP_LOAD, rd, rs1, F3_WORD_U, imm);
}

/// Load doubleword: `rd = mem[rs1 + imm][63:0]`.
pub fn ld(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
export fn ld(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
    return encodeI(OP_LOAD, rd, rs1, F3_DWORD, imm);
}

////////////////////
// Store (S-type) //
////////////////////

/// Store byte: `mem[rs1 + imm] = rs2[7:0]`.
pub fn sb(rs2: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
export fn sb(rs2: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
    return encodeS(OP_STORE, rs1, rs2, F3_BYTE, imm);
}

/// Store halfword: `mem[rs1 + imm] = rs2[15:0]`.
pub fn sh(rs2: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
export fn sh(rs2: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
    return encodeS(OP_STORE, rs1, rs2, F3_HALF, imm);
}

/// Store word: `mem[rs1 + imm] = rs2[31:0]`.
pub fn sw(rs2: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
export fn sw(rs2: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
    return encodeS(OP_STORE, rs1, rs2, F3_WORD, imm);
}

/// Store doubleword: `mem[rs1 + imm] = rs2[63:0]`.
pub fn sd(rs2: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
export fn sd(rs2: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
    return encodeS(OP_STORE, rs1, rs2, F3_DWORD, imm);
}

/////////////////////
// Branch (B-type) //
/////////////////////

/// Branch if equal: `if (rs1 == rs2) pc += imm`.
pub fn beq(rs1: gen::Reg, rs2: gen::Reg, imm: i32) -> u32 {
export fn beq(rs1: gen::Reg, rs2: gen::Reg, imm: i32) -> u32 {
    return encodeB(OP_BRANCH, rs1, rs2, F3_BEQ, imm);
}

/// Branch if not equal: `if (rs1 != rs2) pc += imm`.
pub fn bne(rs1: gen::Reg, rs2: gen::Reg, imm: i32) -> u32 {
export fn bne(rs1: gen::Reg, rs2: gen::Reg, imm: i32) -> u32 {
    return encodeB(OP_BRANCH, rs1, rs2, F3_BNE, imm);
}

/// Branch if less than (signed): `if (rs1 < rs2) pc += imm`.
pub fn blt(rs1: gen::Reg, rs2: gen::Reg, imm: i32) -> u32 {
export fn blt(rs1: gen::Reg, rs2: gen::Reg, imm: i32) -> u32 {
    return encodeB(OP_BRANCH, rs1, rs2, F3_BLT, imm);
}

/// Branch if greater or equal (signed): `if (rs1 >= rs2) pc += imm`.
pub fn bge(rs1: gen::Reg, rs2: gen::Reg, imm: i32) -> u32 {
export fn bge(rs1: gen::Reg, rs2: gen::Reg, imm: i32) -> u32 {
    return encodeB(OP_BRANCH, rs1, rs2, F3_BGE, imm);
}

/// Branch if less than unsigned: `if (rs1 < rs2) pc += imm`.
pub fn bltu(rs1: gen::Reg, rs2: gen::Reg, imm: i32) -> u32 {
export fn bltu(rs1: gen::Reg, rs2: gen::Reg, imm: i32) -> u32 {
    return encodeB(OP_BRANCH, rs1, rs2, F3_BLTU, imm);
}

/// Branch if greater or equal unsigned: `if (rs1 >= rs2) pc += imm`.
pub fn bgeu(rs1: gen::Reg, rs2: gen::Reg, imm: i32) -> u32 {
export fn bgeu(rs1: gen::Reg, rs2: gen::Reg, imm: i32) -> u32 {
    return encodeB(OP_BRANCH, rs1, rs2, F3_BGEU, imm);
}

//////////
// Jump //
//////////

/// Jump and link: `rd = pc + 4; pc += imm`.
pub fn jal(rd: gen::Reg, imm: i32) -> u32 {
export fn jal(rd: gen::Reg, imm: i32) -> u32 {
    return encodeJ(OP_JAL, rd, imm);
}

/// Jump and link register: `rd = pc + 4; pc = rs1 + imm`.
pub fn jalr(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
export fn jalr(rd: gen::Reg, rs1: gen::Reg, imm: i32) -> u32 {
    return encodeI(OP_JALR, rd, rs1, 0, imm);
}

/////////////////////
// Upper Immediate //
/////////////////////

/// Load upper immediate: `rd = imm << 12`.
pub fn lui(rd: gen::Reg, imm: i32) -> u32 {
export fn lui(rd: gen::Reg, imm: i32) -> u32 {
    return encodeU(OP_LUI, rd, imm);
}

/// Add upper immediate to PC: `rd = pc + (imm << 12)`.
pub fn auipc(rd: gen::Reg, imm: i32) -> u32 {
export fn auipc(rd: gen::Reg, imm: i32) -> u32 {
    return encodeU(OP_AUIPC, rd, imm);
}

////////////
// System //
////////////

/// Environment call (system call).
pub fn ecall() -> u32 {
export fn ecall() -> u32 {
    return encodeI(OP_SYSTEM, super::ZERO, super::ZERO, 0, 0);
}

/// Environment break (debugger breakpoint).
pub fn ebreak() -> u32 {
export fn ebreak() -> u32 {
    return encodeI(OP_SYSTEM, super::ZERO, super::ZERO, 0, 1);
}

/////////////////////////
// Pseudo-instructions //
/////////////////////////

/// No operation: `addi zero, zero, 0`.
pub fn nop() -> u32 {
export fn nop() -> u32 {
    return addi(super::ZERO, super::ZERO, 0);
}

/// Move: `rd = rs` (`addi rd, rs, 0`).
pub fn mv(rd: gen::Reg, rs: gen::Reg) -> u32 {
export fn mv(rd: gen::Reg, rs: gen::Reg) -> u32 {
    return addi(rd, rs, 0);
}

/// Bitwise NOT: `rd = ~rs` (`xori rd, rs, -1`).
pub fn not_(rd: gen::Reg, rs: gen::Reg) -> u32 {
export fn not_(rd: gen::Reg, rs: gen::Reg) -> u32 {
    return xori(rd, rs, -1);
}

/// Negate: `rd = -rs` (`sub rd, zero, rs`).
pub fn neg(rd: gen::Reg, rs: gen::Reg) -> u32 {
export fn neg(rd: gen::Reg, rs: gen::Reg) -> u32 {
    return sub(rd, super::ZERO, rs);
}

/// Return: `jalr zero, ra, 0`.
pub fn ret() -> u32 {
export fn ret() -> u32 {
    return jalr(super::ZERO, super::RA, 0);
}

/// Jump (unconditional): `jal zero, imm`.
pub fn j(imm: i32) -> u32 {
export fn j(imm: i32) -> u32 {
    return jal(super::ZERO, imm);
}

/// Branch if less than or equal (signed): `if (rs1 <= rs2) pc += imm`.
/// Implemented as `bge rs2, rs1, imm` (swap operands).
pub fn ble(rs1: gen::Reg, rs2: gen::Reg, imm: i32) -> u32 {
export fn ble(rs1: gen::Reg, rs2: gen::Reg, imm: i32) -> u32 {
    return bge(rs2, rs1, imm);
}

/// Branch if greater than (signed): `if (rs1 > rs2) pc += imm`.
/// Implemented as `blt rs2, rs1, imm` (swap operands).
pub fn bgt(rs1: gen::Reg, rs2: gen::Reg, imm: i32) -> u32 {
export fn bgt(rs1: gen::Reg, rs2: gen::Reg, imm: i32) -> u32 {
    return blt(rs2, rs1, imm);
}

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

/// Set if not equal to zero: `rd = (rs != 0) ? 1 : 0`.
/// Implemented as `sltu rd, zero, rs`.
pub fn snez(rd: gen::Reg, rs: gen::Reg) -> u32 {
export fn snez(rd: gen::Reg, rs: gen::Reg) -> u32 {
    return sltu(rd, super::ZERO, rs);
}

/// Branch if equal to zero: `if (rs == 0) pc += imm`.
pub fn beqz(rs: gen::Reg, imm: i32) -> u32 {
export fn beqz(rs: gen::Reg, imm: i32) -> u32 {
    return beq(rs, super::ZERO, imm);
}

/// Branch if not equal to zero: `if (rs != 0) pc += imm`.
pub fn bnez(rs: gen::Reg, imm: i32) -> u32 {
export fn bnez(rs: gen::Reg, imm: i32) -> u32 {
    return bne(rs, super::ZERO, imm);
}

/// Call: `jal ra, imm`.
pub fn call(imm: i32) -> u32 {
export fn call(imm: i32) -> u32 {
    return jal(super::RA, imm);
}

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

union ShiftOp { Sll, Srl, Sra }
/// Compare operation.
union CmpOp { Slt, Ult }

/// Selector errors.
pub union SelectorError {
export union SelectorError {
    Internal,
}

/// A pending spill store to be flushed after instruction selection.
record PendingSpill {

////////////////////
// Selector State //
////////////////////

/// Instruction selector state.
pub record Selector {
export record Selector {
    /// Emitter for outputting instructions.
    e: *mut emit::Emitter,
    /// Register allocation result.
    ralloc: *regalloc::AllocResult,
    /// Hash-indexed data symbol map.

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

/// Select instructions for a function.
pub fn selectFn(
export fn selectFn(
    e: *mut emit::Emitter,
    dataSymMap: *data::DataSymMap,
    ralloc: *regalloc::AllocResult,
    func: *il::Fn
) {

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

    writeMnem(out, m);
    writeDelim(out, &[regNameR(rs1), formatI32(a, imm)]);
}

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

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

        },
    }
}

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


lib/std/collections.rad +1 -1

1	1		//! Collection types.
2		-	pub mod dict;
	2	+	export mod dict;

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

//! of two and is provided by the caller via arena-allocated storage.

use std::mem;

/// Hash map entry.
pub record Entry {
export record Entry {
    /// Key.
    key: *[u8],
    /// Associated value.
    value: i32,
}

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

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

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

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

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

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

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

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

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

lib/std/fmt.rad +14 -14

//! Formatting utilities for converting values to strings.
use super::mem;

/// Maximum string length for a formatted u32 (eg. "4294967295").
pub const U32_STR_LEN: u32 = 10;
export const U32_STR_LEN: u32 = 10;
/// Maximum string length for a formatted i32 (eg. "-2147483648").
pub const I32_STR_LEN: u32 = U32_STR_LEN + 1;
export const I32_STR_LEN: u32 = U32_STR_LEN + 1;
/// Maximum string length for a formatted u64 (eg. "18446744073709551615").
pub const U64_STR_LEN: u32 = 20;
export const U64_STR_LEN: u32 = 20;
/// Maximum string length for a formatted i64 (eg. "-9223372036854775808").
pub const I64_STR_LEN: u32 = 20;
export const I64_STR_LEN: u32 = 20;
/// Maximum string length for a formatted bool (eg. "false").
pub const BOOL_STR_LEN: u32 = 5;
export const BOOL_STR_LEN: u32 = 5;

/// Format a u32 by writing it to the provided buffer.
pub fn formatU32(val: u32, buffer: *mut [u8]) -> *[u8] {
export fn formatU32(val: u32, buffer: *mut [u8]) -> *[u8] {
    assert buffer.len >= U32_STR_LEN;

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


    // the end of the buffer.
    return &buffer[i..];
}

/// Format a i32 by writing it to the provided buffer.
pub fn formatI32(val: i32, buffer: *mut [u8]) -> *[u8] {
export fn formatI32(val: i32, buffer: *mut [u8]) -> *[u8] {
    assert buffer.len >= I32_STR_LEN;

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

    }
    return &buffer[i..];
}

/// Format a u64 by writing it to the provided buffer.
pub fn formatU64(val: u64, buffer: *mut [u8]) -> *[u8] {
export fn formatU64(val: u64, buffer: *mut [u8]) -> *[u8] {
    assert buffer.len >= U64_STR_LEN;

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


    }
    return &buffer[i..];
}

/// Format a i64 by writing it to the provided buffer.
pub fn formatI64(val: i64, buffer: *mut [u8]) -> *[u8] {
export fn formatI64(val: i64, buffer: *mut [u8]) -> *[u8] {
    assert buffer.len >= I64_STR_LEN;

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

    }
    return &buffer[i..];
}

/// Format a i8 by writing it to the provided buffer.
pub fn formatI8(val: i8, buffer: *mut [u8]) -> *[u8] {
export fn formatI8(val: i8, buffer: *mut [u8]) -> *[u8] {
    return formatI32(val as i32, buffer);
}

/// Format a i16 by writing it to the provided buffer.
pub fn formatI16(val: i16, buffer: *mut [u8]) -> *[u8] {
export fn formatI16(val: i16, buffer: *mut [u8]) -> *[u8] {
    return formatI32(val as i32, buffer);
}

/// Format a u8 by writing it to the provided buffer.
pub fn formatU8(val: u8, buffer: *mut [u8]) -> *[u8] {
export fn formatU8(val: u8, buffer: *mut [u8]) -> *[u8] {
    return formatU32(val as u32, buffer);
}

/// Format a u16 by writing it to the provided buffer.
pub fn formatU16(val: u16, buffer: *mut [u8]) -> *[u8] {
export fn formatU16(val: u16, buffer: *mut [u8]) -> *[u8] {
    return formatU32(val as u32, buffer);
}

/// Format a bool by writing it to the provided buffer.
pub fn formatBool(val: bool, buffer: *mut [u8]) -> *[u8] {
export fn formatBool(val: bool, buffer: *mut [u8]) -> *[u8] {
    if val {
        try! mem::copy(buffer, "true");
        return &buffer[..4];
    } else {
        try! mem::copy(buffer, "false");

lib/std/intrinsics.rad +2 -2

/// Environment call.
///
/// Issues a system call with the given number and arguments.
/// Arguments and the return value are `i64` to support both 32-bit
/// emulator addresses and 64-bit native (AMD64) pointers.
@intrinsic pub fn ecall(number: u32, arg1: i64, arg2: i64, arg3: i64, arg4: i64) -> i64;
@intrinsic export fn ecall(number: u32, arg1: i64, arg2: i64, arg3: i64, arg4: i64) -> i64;

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

lib/std/io.rad +8 -8

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

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

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

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

pub fn printI32(val: i32) {
export fn printI32(val: i32) {
    let mut buffer: [u8; 11] = [0; 11];
    let result: *[u8] = fmt::formatI32(val, &mut buffer[..]);
    print(result);
}

pub fn printU32(val: u32) {
export fn printU32(val: u32) {
    let mut buffer: [u8; 10] = [0; 10];
    let result: *[u8] = fmt::formatU32(val, &mut buffer[..]);
    print(result);
}

pub fn printBool(val: bool) {
export fn printBool(val: bool) {
    let mut buffer: [u8; 5] = [0; 5];
    let result: *[u8] = fmt::formatBool(val, &mut buffer[..]);
    print(result);
}

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

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

    while total < buf.len {
        let chunk: *mut [u8] = &mut buf[total..];
        let n: u32 = read(chunk);

lib/std/lang.rad +12 -12

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

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

@test mod tests;

use std::mem;

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

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

/// Create a new arena backed by the given byte slice.
pub fn new(data: *mut [u8]) -> Arena {
export fn new(data: *mut [u8]) -> Arena {
    return Arena { data, offset: 0 };
}

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

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

}

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

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

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

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

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

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

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

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


/// Bundles an allocation function with an opaque context pointer so that
/// any allocation strategy (arena, free-list, mmap, pool) can be used
/// through a uniform interface. The `func` field is called with the context
/// pointer, a byte size and an alignment, and must return a pointer to
/// the allocated memory or panic on failure.
pub record Allocator {
export record Allocator {
    /// Allocation function. Returns a pointer to `size` bytes
    /// aligned to `alignment`, or panics on failure.
    func: fn(*mut opaque, u32, u32) -> *mut opaque,
    /// Opaque context pointer passed to `func`.
    ctx: *mut opaque,
}

/// Create an `Allocator` backed by an `Arena`.
pub fn arenaAllocator(arena: *mut Arena) -> Allocator {
export fn arenaAllocator(arena: *mut Arena) -> Allocator {
    return Allocator {
        func: arenaAllocFn,
        ctx: arena as *mut opaque,
    };
}

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

//! Radiance AST modules.
pub mod printer;
export mod printer;

use std::io;
use std::lang::alloc;

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

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

/// Initialize a node arena backed by the given byte slice.
pub fn nodeArena(data: *mut [u8]) -> NodeArena {
export fn nodeArena(data: *mut [u8]) -> NodeArena {
    return NodeArena {
        arena: alloc::new(data),
        nextId: 0,
    };
}

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

    return @sliceOf(ptr.ptr as *mut *Node, 0, capacity);
}

/// Attribute bit set applied to declarations or fields.
pub union Attribute {
export union Attribute {
    /// Public visibility attribute.
    Pub = 0b1,
    Export = 0b1,
    /// Default implementation attribute.
    Default = 0b10,
    /// Extern linkage attribute.
    Extern = 0b100,
    /// Test-only declaration attribute.

    /// Compiler intrinsic attribute.
    Intrinsic = 0b10000,
}

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

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

/// Check if an attribute set includes the given attribute.
pub fn hasAttribute(attrs: u32, attr: Attribute) -> bool {
export fn hasAttribute(attrs: u32, attr: Attribute) -> bool {
    return (attrs & (attr as u32)) != 0;
}

/// Signedness of an integer type.
pub union Signedness {
export union Signedness {
    /// Signed, eg. `i8`.
    Signed,
    /// Unsigned, eg. `u32`.
    Unsigned,
}

/// Radix/base of a number.
pub union Radix {
export union Radix {
    /// Binary literal (0b...).
    Binary,
    /// Decimal literal.
    Decimal,
    /// Hexadecimal literal (0x...).
    Hex,
}

/// Parsed integer literal metadata.
pub record IntLiteral {
export record IntLiteral {
    /// Raw characters that comprised the literal.
    text: *[u8],
    /// Absolute magnitude parsed from the literal.
    magnitude: u64,
    /// Radix used by the literal.

    /// Whether the literal used a negative sign.
    negative: bool,
}

/// Binary operator kinds used in numeric expressions.
pub union BinaryOp {
export union BinaryOp {
    /// Addition (`+`).
    Add,
    /// Subtraction (`-`).
    Sub,
    /// Multiplication (`*`).

    /// Logical exclusive disjunction (`xor`).
    Xor,
}

/// Unary operator kinds used in expressions.
pub union UnaryOp {
export union UnaryOp {
    /// Logical negation (`not`).
    Not,
    /// Arithmetic negation (`-`).
    Neg,
    /// Bitwise NOT (`~`).
    BitNot,
}

/// Builtin function kind.
pub union Builtin {
export union Builtin {
    /// Size of type in bytes (`@sizeOf`).
    SizeOf,
    /// Alignment requirement of type (`@alignOf`).
    AlignOf,
    /// Construct a slice from pointer, length, and optional capacity (`@sliceOf`).
    SliceOf,
}

/// Source extent for a node measured in bytes.
pub record Span {
export record Span {
    /// Byte offset from the start of the source file.
    offset: u32,
    /// Length of the node in bytes.
    length: u32,
}

/// Type signature node.
pub union TypeSig {
export union TypeSig {
    /// Absence of type.
    Void,
    /// Opaque type.
    Opaque,
    /// Boolean type.

        mutable: bool,
    },
}

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

/// Address-of expression metadata.
pub record AddressOf {
export record AddressOf {
    /// Target expression being referenced.
    target: *Node,
    /// Indicates whether the reference is mutable.
    mutable: bool,
}

/// Compound statement block with optional dedicated scope.
pub record Block {
export record Block {
    /// Statements that belong to this block.
    statements: *mut [*Node],
}

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

/// Single argument to a function or record literal, optionally labeled.
pub record Arg {
export record Arg {
    /// Optional label applied to the argument.
    label: ?*Node,
    /// Expression supplying the argument value.
    value: *Node,
}

/// Assignment expression connecting a target and value.
pub record Assign {
export record Assign {
    /// Expression representing the assignment target.
    left: *Node,
    /// Expression providing the value being assigned.
    right: *Node,
}

/// While loop with an optional alternate branch.
pub record While {
export record While {
    /// Condition evaluated before each iteration.
    condition: *Node,
    /// Loop body executed while `condition` is true.
    body: *Node,
    /// Optional branch executed when the condition is false at entry.
    elseBranch: ?*Node,
}

/// `while let` loop binding metadata.
pub record WhileLet {
export record WhileLet {
    /// Pattern matching structure.
    pattern: PatternMatch,
    /// Loop body executed when the pattern matches.
    body: *Node,
    /// Optional branch executed when the match fails immediately.
    elseBranch: ?*Node,
}

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

    /// Whether the try should return an optional instead of propagating error.
    returnsOptional: bool,
}

/// A single catch clause in a `try ... catch` expression.
pub record CatchClause {
export record CatchClause {
    /// Optional identifier binding for the error value (eg. `e`).
    binding: ?*Node,
    /// Optional type annotation after `as` (eg. `IoError`).
    typeNode: ?*Node,
    /// Block body executed when this clause matches.
    body: *Node,
}

/// `for` loop metadata.
pub record For {
export record For {
    /// Loop variable binding.
    binding: *Node,
    /// Optional index binding for enumeration loops.
    index: ?*Node,
    /// Expression producing the iterable value.

    /// Optional branch executed when the loop body never runs.
    elseBranch: ?*Node,
}

/// Conditional `if` statement metadata.
pub record If {
export record If {
    /// Condition controlling the branch.
    condition: *Node,
    /// Branch executed when `condition` is true.
    thenBranch: *Node,
    /// Optional branch executed when `condition` is false.
    elseBranch: ?*Node,
}

/// Conditional expression (`<true> if <condition> else <false>`).
pub record CondExpr {
export record CondExpr {
    /// Condition controlling which branch is evaluated.
    condition: *Node,
    /// Expression evaluated when `condition` is true.
    thenExpr: *Node,
    /// Expression evaluated when `condition` is false.
    elseExpr: *Node,
}

/// Classification of pattern matches (if-let, while-let, let-else).
pub union PatternKind {
export union PatternKind {
    /// Case pattern match.
    Case,
    /// Binding pattern match.
    Binding,
}

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

/// Common pattern matching structure used by `if let`, `while let`, and `let-else`.
pub record PatternMatch {
export record PatternMatch {
    /// Pattern or binding to match against.
    pattern: *Node,
    /// Scrutinee expression to match against.
    scrutinee: *Node,
    /// Optional guard that must evaluate to `true`.

    /// Whether the binding is mutable.
    mutable: bool,
}

/// `if let` conditional binding metadata.
pub record IfLet {
export record IfLet {
    /// Pattern matching structure.
    pattern: PatternMatch,
    /// Branch executed when the pattern matches.
    thenBranch: *Node,
    /// Optional branch executed when the match fails.
    elseBranch: ?*Node,
}

/// `let-else` statement metadata.
pub record LetElse {
export record LetElse {
    /// Pattern matching structure.
    pattern: PatternMatch,
    /// Else branch executed if match fails (must diverge).
    elseBranch: *Node,
}

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

/// `match` prong metadata.
pub record MatchProng {
export record MatchProng {
    /// Prong arm.
    arm: ProngArm,
    /// Optional guard that must evaluate to `true`.
    guard: ?*Node,
    /// Body executed when patterns match and guard passes.
    body: *Node,
}

/// `let` binding.
pub record Let {
export record Let {
    /// Identifier bound by the declaration.
    ident: *Node,
    /// Declared type annotation.
    type: ?*Node,
    /// Initializer expression.

    /// Whether the variable is mutable.
    mutable: bool,
}

/// Constant declaration.
pub record ConstDecl {
export record ConstDecl {
    /// Identifier bound by the declaration.
    ident: *Node,
    /// Declared type annotation.
    type: *Node,
    /// Constant initializer expression.

    /// Optional attribute list applied to the constant.
    attrs: ?Attributes,
}

/// Static storage declaration.
pub record StaticDecl {
export record StaticDecl {
    /// Identifier bound by the declaration.
    ident: *Node,
    /// Declared storage type.
    type: *Node,
    /// Initialization expression.

    /// Optional attribute list applied to the static.
    attrs: ?Attributes,
}

/// Function parameter declaration.
pub record FnParam {
export record FnParam {
    /// Parameter identifier.
    name: *Node,
    /// Parameter type annotation.
    type: *Node,
}

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

/// Record declaration.
pub record RecordDecl {
export record RecordDecl {
    /// Identifier naming the record.
    name: *Node,
    /// Field declaration nodes.
    fields: *mut [*Node],
    /// Optional attribute list applied to the record.

    /// Whether this record has labeled fields.
    labeled: bool,
}

/// Union declarations.
pub record UnionDecl {
export record UnionDecl {
    /// Identifier naming the union.
    name: *Node,
    /// Variant nodes making up the union.
    variants: *mut [*Node],
    /// Optional attribute list applied to the union.

    /// Trait derivations attached to the union.
    derives: *mut [*Node],
}

/// Union variant declaration.
pub record UnionDeclVariant {
export record UnionDeclVariant {
    /// Identifier naming the variant.
    name: *Node,
    /// Variant index.
    index: u32,
    /// Explicit discriminant value, if provided.

    /// Optional payload type.
    type: ?*Node,
}

/// Function declaration.
pub record FnDecl {
export record FnDecl {
    /// Identifier naming the function.
    name: *Node,
    /// Function type signature.
    sig: FnSig,
    /// Optional function body (`nil` for extern functions).

    /// Optional attribute list applied to the function.
    attrs: ?Attributes,
}

/// Array repeat literal metadata.
pub record ArrayRepeatLit {
export record ArrayRepeatLit {
    /// Expression providing the repeated value.
    item: *Node,
    /// Expression providing the repetition count.
    count: *Node,
}

/// Module declaration.
pub record Mod {
export record Mod {
    /// Identifier naming the module.
    name: *Node,
    /// Optional attribute list applied to the module.
    attrs: ?Attributes,
}

/// Use declaration for importing modules.
pub record Use {
export record Use {
    /// Access node identifying the imported module.
    path: *Node,
    /// Whether this is a wildcard import (e.g. `use ast::*`).
    wildcard: bool,
    /// Optional attribute list applied to the use declaration.
    attrs: ?Attributes,
}

/// Access expression used for field, scope, and index lookups.
pub record Access {
export record Access {
    /// Expression providing the container or namespace.
    parent: *Node,
    /// Expression identifying the member, scope element, or index.
    child: *Node,
}

/// `as` cast expression metadata.
pub record As {
export record As {
    /// Expression being coerced.
    value: *Node,
    /// Target type annotation.
    type: *Node,
}

/// Range expression metadata.
pub record Range {
export record Range {
    /// Optional inclusive start expression.
    start: ?*Node,
    /// Optional exclusive end expression.
    end: ?*Node,
}

/// Binary operation expression, eg. `x * y`.
pub record BinOp {
export record BinOp {
    /// Operator applied to the operands.
    op: BinaryOp,
    /// Left-hand operand.
    left: *Node,
    /// Right-hand operand.
    right: *Node,
}

/// Unary operation expression, eg. `-x`.
pub record UnOp {
export record UnOp {
    /// Operator applied to the operand.
    op: UnaryOp,
    /// Operand expression.
    value: *Node,
}

/// Tagged union describing every possible AST node payload.
pub union NodeValue {
export union NodeValue {
    /// Placeholder `_` expression.
    Placeholder,
    /// Nil literal (`nil`).
    Nil,
    /// Undefined literal (`undefined`).

        attrs: ?Attributes,
    },
}

/// Full AST node with shared metadata and variant-specific payload.
pub record Node {
export record Node {
    /// Unique identifier for this node.
    id: u32,
    /// Source span describing where the node originated.
    span: Span,
    /// Variant-specific payload for the node.
    value: NodeValue,
}

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



    return node;
}

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

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

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

/// Synthesize a module with a function in it with the given name and statements.
pub fn synthFnModule(
export fn synthFnModule(
    arena: *mut NodeArena, name: *[u8], bodyStmts: *mut [*Node]
) -> SynthFnMod {
    let a = alloc::arenaAllocator(&mut arena.arena);
    let fnName = synthNode(arena, NodeValue::Ident(name));
    let params: *mut [*Node] = &mut [];

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

    }
    return buf;
}

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

        case super::NodeValue::TypeSig(sig) => return typeSigToExpr(a, sig),
        case super::NodeValue::FnParam(p) =>
            return sexpr::list(a, "param", &[toExpr(a, p.name), toExpr(a, p.type)]),
        case super::NodeValue::Attribute(attr) => {
            match attr {
                case super::Attribute::Pub => return sexpr::sym("@pub"),
                case super::Attribute::Export => return sexpr::sym("@export"),
                case super::Attribute::Default => return sexpr::sym("@default"),
                case super::Attribute::Extern => return sexpr::sym("@extern"),
                case super::Attribute::Test => return sexpr::sym("@test"),
                case super::Attribute::Intrinsic => return sexpr::sym("@intrinsic"),
            }

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

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

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

//!
//! Target-independent infrastructure for lowering IL to machine code.
//! Target-specific backends (e.g., `std::arch::rv64`) provide
//! instruction selection and emission.

pub mod labels;
pub mod bitset;
pub mod regalloc;
pub mod data;
pub mod types;
export mod labels;
export mod bitset;
export mod regalloc;
export mod data;
export mod types;

/// Physical register.
///
/// Lightweight wrapper around a register number. Used both in the
/// target-independent register allocator and in architecture-specific
/// backends.
pub record Reg(u8);
export record Reg(u8);

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

    }
    return b;
}

/// Calculate the number of 32-bit words needed to store `n` bits.
pub fn wordsFor(n: u32) -> u32 {
export fn wordsFor(n: u32) -> u32 {
    return (n + 31) / 32;
}

/// A fixed-size bitset backed by an array of 32-bit words.
pub record Bitset {
export record Bitset {
    /// Backing storage for bits, organized as 32-bit words.
    bits: *mut [u32],
    /// Number of bits this bitset can hold.
    len: u32,
}

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

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

/// Create a bitset from arena allocation.
pub fn allocate(arena: *mut alloc::Arena, len: u32) -> Bitset throws (alloc::AllocError) {
export fn allocate(arena: *mut alloc::Arena, len: u32) -> Bitset throws (alloc::AllocError) {
    let numWords = wordsFor(len);
    let bits = try alloc::allocSlice(arena, @sizeOf(u32), @alignOf(u32), numWords) as *mut [u32];

    return init(bits);
}

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

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

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

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

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

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

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


    return n & 0x3F;
}

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

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

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

    for i in 0..maxWords {

    }
    return true;
}

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

    for i in 0..minWords {

        dst.bits[i] = 0;
    }
}

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

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

/// Create an iterator over set bits.
pub fn iter(bs: *Bitset) -> BitIter {
export fn iter(bs: *Bitset) -> BitIter {
    let remaining = bs.bits[0] if bs.len > 0 else 0;
    return BitIter { bs, wordIdx: 0, remaining };
}

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

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

use std::collections::dict;
use std::lang::il;
use std::lang::gen::labels;

/// Maximum number of data symbols.
pub const MAX_DATA_SYMS: u32 = 8192;
export const MAX_DATA_SYMS: u32 = 8192;

/// Size of the data symbol hash table. Must be a power of two
/// and at least twice the size of [`MAX_DATA_SYMS`].
pub const DATA_SYM_TABLE_SIZE: u32 = MAX_DATA_SYMS * 2;
export const DATA_SYM_TABLE_SIZE: u32 = MAX_DATA_SYMS * 2;

/// Data symbol entry mapping name to address.
pub record DataSym {
export record DataSym {
    /// Symbol name.
    name: *[u8],
    /// Absolute address, including data base address.
    addr: u32,
}

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

/// Lay out data symbols for a single section.
/// Initialized data is placed first, then uninitialized, so that only
/// initialized data needs to be written to the output file.
/// Returns the updated offset past all placed symbols.
pub fn layoutSection(
export fn layoutSection(
    program: *il::Program,
    syms: *mut [DataSym],
    count: *mut u32,
    base: u32,
    readOnly: bool

}

/// Emit data bytes for a single section (read-only or read-write) into `buf`.
/// Iterates initialized data in the IL program, serializing each data item.
/// Returns the total number of bytes written.
pub fn emitSection(
export fn emitSection(
    program: *il::Program,
    dataSymMap: *DataSymMap,
    fnLabels: *labels::Labels,
    codeBase: u32,
    buf: *mut [u8],

    return offset;
}

/// Build a hash-indexed data symbol map from the laid-out symbols.
/// The `entries` slice must have length `DATA_SYM_TABLE_SIZE`.
pub fn buildMap(syms: *[DataSym], entries: *mut [dict::Entry]) -> DataSymMap {
export fn buildMap(syms: *[DataSym], entries: *mut [dict::Entry]) -> DataSymMap {
    let mut d = dict::init(entries);
    for i in 0..syms.len {
        dict::insert(&mut d, syms[i].name, syms[i].addr as i32);
    }
    return DataSymMap { dict: d, syms };
}

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

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

//! Provides target-independent block/label tracking for branch resolution.

use std::collections::dict;

/// Maximum number of blocks per function.
pub const MAX_BLOCKS_PER_FN: u32 = 4096;
export const MAX_BLOCKS_PER_FN: u32 = 4096;
/// Maximum number of functions.
pub const MAX_FUNCS: u32 = 8192;
export const MAX_FUNCS: u32 = 8192;
/// Size of the function hash table. Must be a power of two.
pub const FUNC_TABLE_SIZE: u32 = MAX_FUNCS * 2;
export const FUNC_TABLE_SIZE: u32 = MAX_FUNCS * 2;

/// Label tracking for code emission.
pub record Labels {
export record Labels {
    /// Block offsets indexed by block index.
    /// Per-function, reset each function.
    blockOffsets: *mut [i32],
    /// Number of blocks recorded in current function.
    blockCount: u32,
    /// Function name to byte offset mapping.
    funcs: dict::Dict,
}

/// Create a new labels tracker with caller-provided storage.
pub fn init(blockOffsets: *mut [i32], funcEntries: *mut [dict::Entry]) -> Labels {
export fn init(blockOffsets: *mut [i32], funcEntries: *mut [dict::Entry]) -> Labels {
    return Labels {
        blockOffsets,
        blockCount: 0,
        funcs: dict::init(funcEntries),
    };
}

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

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

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

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

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

    return targetOffset - srcOffset;
}

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

    return targetOffset - srcOffset;
}

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

//!
//! Note that the IL is not modified. The allocator produces a mapping that
//! instruction selection uses to emit physical registers. Spilled values are
//! handled by [`isel`] inserting loads/stores.

pub mod liveness;
pub mod spill;
pub mod assign;
export mod liveness;
export mod spill;
export mod assign;

use std::lang::il;
use std::lang::alloc;

/// Target configuration for register allocation.
pub record TargetConfig {
export record TargetConfig {
    /// List of allocatable physical registers.
    /// Order determines allocation preference.
    allocatable: *[super::Reg],
    /// Function argument registers.
    argRegs: *[super::Reg],

    /// Size of a spill slot in bytes.
    slotSize: u32,
}

/// Complete register allocation result.
pub record AllocResult {
export record AllocResult {
    /// SSA register to physical register mapping.
    assignments: *[?super::Reg],
    /// Spill slot information.
    spill: spill::SpillInfo,
    /// Bitmask of used callee-saved registers.


/// Run register allocation on a function.
///
/// Returns a mapping from SSA registers to physical registers, plus
/// spill information.
pub fn allocate(
export fn allocate(
    func: *il::Fn,
    config: *TargetConfig,
    arena: *mut alloc::Arena
) -> AllocResult throws (alloc::AllocError) {
    // Phase 1: Liveness analysis.

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

/// Maximum number of active register mappings.
const MAX_ACTIVE: u32 = 64;

/// Register mapping at a program point.
/// Maps SSA registers to physical registers.
pub record RegMap {
export record RegMap {
    /// SSA (virtual) registers that have mappings.
    virtRegs: *mut [u32],
    /// Physical register for each virtual register.
    physRegs: *mut [gen::Reg],
    /// Number of active mappings.
    n: u32,
}

/// Register assignment result, per function.
pub record AssignInfo {
export record AssignInfo {
    /// SSA register -> physical register mapping.
    assignments: *mut [?gen::Reg],
    /// Bitmask of used callee-saved registers.
    usedCalleeSaved: u32,
}

    assignments: *mut [?gen::Reg],
    spillInfo: *spill::SpillInfo,
}

/// Compute register assignment.
pub fn assign(
export fn assign(
    func: *il::Fn,
    live: *liveness::LiveInfo,
    spillInfo: *spill::SpillInfo,
    config: *super::TargetConfig,
    arena: *mut alloc::Arena

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

use std::lang::il;
use std::lang::alloc;
use std::lang::gen::bitset;

/// Maximum number of SSA registers supported.
pub const MAX_SSA_REGS: u32 = 8192;
export const MAX_SSA_REGS: u32 = 8192;

/// Liveness information for a function.
pub record LiveInfo {
export record LiveInfo {
    /// Per-block live-in sets (indexed by block index).
    liveIn: *mut [bitset::Bitset],
    /// Per-block live-out sets (indexed by block index).
    liveOut: *mut [bitset::Bitset],
    /// Per-block defs sets (registers defined in block).

    target: u32,
    found: bool,
}

/// Compute liveness information for a function.
pub fn analyze(func: *il::Fn, arena: *mut alloc::Arena) -> LiveInfo throws (alloc::AllocError) {
export fn analyze(func: *il::Fn, arena: *mut alloc::Arena) -> LiveInfo throws (alloc::AllocError) {
    let blockCount = func.blocks.len;
    if blockCount == 0 {
        return LiveInfo {
            liveIn: &mut [],
            liveOut: &mut [],

fn unionBlockLiveIn(target: u32, liveIn: *[bitset::Bitset], scratch: *mut bitset::Bitset) {
    bitset::union_(scratch, &liveIn[target]);
}

/// Check if this is the last use of a register at this instruction.
pub fn isLastUse(info: *LiveInfo, func: *il::Fn, blockIdx: u32, instrIdx: u32, reg: il::Reg) -> bool {
export fn isLastUse(info: *LiveInfo, func: *il::Fn, blockIdx: u32, instrIdx: u32, reg: il::Reg) -> bool {
    let block = &func.blocks[blockIdx];
    let instr = block.instrs[instrIdx];

    if not instrUsesReg(instr, reg) {
        return false;

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

    /// Number of uses (weighted by loop depth).
    uses: u32,
}

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

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

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

fn addRegToSetCallback(reg: il::Reg, ctx: *mut opaque) {
    bitset::set(ctx as *mut bitset::Bitset, reg.n);
}

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

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

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

//! Target-independent code generation types.
//!
//! Defines common records used by all code generation backends.

/// Function address entry for printing.
pub record FuncAddr {
export record FuncAddr {
    /// Function name.
    name: *[u8],
    /// Instruction index where this function starts.
    index: u32,
}

/// Debug entry mapping an instruction to a source location.
pub record DebugEntry {
export record DebugEntry {
    /// Byte offset of the instruction from the start of the program.
    pc: u32,
    /// Module identifier.
    moduleId: u16,
    /// Byte offset into the module's source file.

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

//! can declare parameters, and jumps/branches pass arguments to their targets.

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

pub mod printer;
export mod printer;

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

/// Source location for debug info.
///
/// Associates an IL instruction with its originating source module and
/// byte offset.
pub record SrcLoc {
export record SrcLoc {
    /// Module identifier.
    moduleId: u16,
    /// Byte offset into the module's source file.
    offset: u32,
}

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

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

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

///////////
// Types //
///////////

/// IL type representation. Integer signedness is encoded in operations, not types.
pub union Type {
export union Type {
    /// 8-bit value.
    W8,
    /// 16-bit value.
    W16,
    /// 32-bit value.

    /// 64-bit value (used for pointers on RV64).
    W64,
}

/// Get the size of a type in bytes.
pub fn typeSize(t: Type) -> u32 {
export fn typeSize(t: Type) -> u32 {
    match t {
        case Type::W8 => return 1,
        case Type::W16 => return 2,
        case Type::W32 => return 4,
        case Type::W64 => return 8,
    }
}

/// SSA register reference.
pub record Reg { n: u32 }
export record Reg { n: u32 }

/// Instruction value.
pub union Val {
export union Val {
    /// Register reference.
    Reg(Reg),
    /// Immediate integer value.
    Imm(i64),
    /// Data symbol address (globals, constants, string literals).

    /// eg. in void returns.
    Undef,
}

/// Comparison operation for compare-and-branch.
pub union CmpOp { Eq, Ne, Slt, Ult }
export union CmpOp { Eq, Ne, Slt, Ult }

/// Binary ALU operation kind.
pub union BinOp {
export union BinOp {
    // Arithmetic.
    Add, Sub, Mul, Sdiv, Udiv, Srem, Urem,
    // Comparison.
    Eq, Ne, Slt, Sge, Ult, Uge,
    // Bitwise.
    And, Or, Xor, Shl, Sshr, Ushr,
}

/// Unary ALU operation kind.
pub union UnOp {
export union UnOp {
    Neg, Not,
}

//////////////////
// Instructions //
//////////////////

/// Block parameter.
pub record Param {
export record Param {
    /// SSA register.
    value: Reg,
    /// Parameter type.
    type: Type,
}

/// Switch case mapping a constant value to a branch target.
pub record SwitchCase {
export record SwitchCase {
    /// The constant value to match against.
    value: i64,
    /// The target block index.
    target: u32,
    /// Arguments to pass to the target block.
    args: *mut [Val],
}

/// IL instruction.
/// SSA registers are represented as `Reg`, values as `Val`.
pub union Instr {
export union Instr {
    ///////////////////////
    // Memory operations //
    ///////////////////////

    /// Allocate space on the stack: `reserve %dst <size> <alignment>;`

///
/// Basic blocks are instruction sequences with a single entry point and no branch
/// instruction, except possibly at the end of the sequence, where a terminator
/// may be found, ie. an instruction that terminates the sequence by jumping
/// to another sequence.
pub record Block {
export record Block {
    /// Block label.
    label: *[u8],
    /// Block parameters.
    params: *[Param],
    /// Instructions in the block. The last instruction must be a terminator.

    /// Used for spill cost weighting in register allocation.
    loopDepth: u32,
}

/// An IL function.
pub record Fn {
export record Fn {
    /// Qualified function name (e.g. `$mod$path$func`).
    name: *[u8],
    /// Function parameters.
    params: *[Param],
    /// Return type.

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

/// Data initializer item.
pub union DataItem {
export union DataItem {
    /// Typed value: `w32 42;` or `w8 255;`
    Val { typ: Type, val: i64 },
    /// Symbol reference: `$symbol`
    Sym(*[u8]),
    /// Function reference: `$fnName`

    /// Undefined value. Used for padding and `void` returns.
    Undef,
}

/// Data initializer value with optional repeat count.
pub record DataValue {
export record DataValue {
    /// The item contained in the value.
    item: DataItem,
    /// The number of times the item should be repeated.
    count: u32,
}

/// Global data definition.
pub record Data {
export record Data {
    /// Data name.
    name: *[u8],
    /// Size in bytes.
    size: u32,
    /// Alignment requirement.

    /// Initializer values.
    values: *[DataValue],
}

/// An IL program (compilation unit).
pub record Program {
export record Program {
    /// Global data.
    data: *[Data],
    /// Functions.
    fns: *[*Fn],
    /// Index of entry point function, if any.

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

/// Get the destination register of an instruction, if any.
pub fn instrDst(instr: Instr) -> ?Reg {
export fn instrDst(instr: Instr) -> ?Reg {
    match instr {
        case Instr::Reserve { dst, .. } => return dst,
        case Instr::Load { dst, .. } => return dst,
        case Instr::Sload { dst, .. } => return dst,
        case Instr::Copy { dst, .. } => return dst,

        else => return nil,
    }
}

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

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

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

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

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

        }
    }
}

/// Print a program to a buffer, returning the written slice.
pub fn printProgramToBuffer(
export fn printProgramToBuffer(
    program: *super::Program,
    arena: *mut alloc::Arena,
    buf: *mut [u8]
) -> *[u8] {
    let mut pos: u32 = 0;

lib/std/lang/lower.rad +12 -12

// Error Handling //
////////////////////

/// Lowering errors are typically unrecoverable since they indicate bugs in
/// the resolver or malformed AST that should have been caught earlier.
pub union LowerError {
export union LowerError {
    /// A node's symbol was not set before lowering.
    MissingSymbol(*ast::Node),
    /// A node's type was not set before lowering.
    MissingType(*ast::Node),
    /// A node's constant value was not set before lowering.

    /// Allocation failure.
    AllocationFailed,
}

/// Print a LowerError for debugging.
pub fn printError(err: LowerError) {
export fn printError(err: LowerError) {
    match err {
        case LowerError::MissingSymbol(_) => io::print("MissingSymbol"),
        case LowerError::MissingType(_) => io::print("MissingType"),
        case LowerError::MissingConst(_) => io::print("MissingConst"),
        case LowerError::ExpectedOptional => io::print("ExpectedOptional"),

//////////////////////////
// Core Data Structures //
//////////////////////////

/// Options controlling the lowering pass.
pub record LowerOptions {
export record LowerOptions {
    /// Whether to emit source location info.
    debug: bool,
    /// Whether to lower `@test` functions.
    buildTest: bool,
}

/// Module-level lowering context. Shared across all function lowerings.
/// Holds global state like the data section (strings, constants) and provides
/// access to the resolver for type queries.
pub record Lowerer {
export record Lowerer {
    /// Arena for IL allocations. All IL nodes are allocated here.
    arena: *mut alloc::Arena,
    /// Allocator backed by the arena.
    allocator: alloc::Allocator,
    /// Resolver for type information. Used to query types, symbols, and

// a mapping from [`Var`] to current SSA value. When control flow merges,
// block parameters are inserted to merge values from different control flow paths.

/// A variable handle. Represents a source-level variable during lowering.
/// The same [`Var`] can have different SSA values in different blocks.
pub record Var(u32);
export record Var(u32);

/// Metadata for a source-level variable, stored once per function.
///
/// Each variable declaration in the source creates one [`VarData`] entry in the
/// function's `variables` array, indexed by `id`. This contains static

// instructions until terminated by a jump, branch, return, or unreachable.
// Blocks can be created before they're filled (forward references for jumps).

/// A handle to a basic block within the current function.
/// Block handles are stable, they don't change as more blocks are added.
pub record BlockId(u32);
export record BlockId(u32);

/// Internal block state during construction.
///
/// The key invariants:
///

// Loop and Control Flow Context //
///////////////////////////////////

/// Context for break/continue statements within a loop.
/// Each nested loop pushes a new context onto the loop stack.
pub record LoopCtx {
export record LoopCtx {
    /// Where `break` should transfer control (the loop's exit block).
    breakTarget: BlockId,
    /// Where `continue` should transfer control.
    continueTarget: ?BlockId,
}

/// 2. Iterates over top-level declarations, lowering each.
/// 3. Returns the complete IL program with functions and data section.
///
/// The resolver must have already processed the AST -- we rely on its type
/// annotations, symbol table, and constant evaluations.
pub fn lower(
export fn lower(
    res: *resolver::Resolver,
    root: *ast::Node,
    pkgName: *[u8],
    arena: *mut alloc::Arena
) -> il::Program throws (LowerError) {

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

/// Create a lowerer for multi-module compilation.
pub fn lowerer(
export fn lowerer(
    res: *resolver::Resolver,
    graph: *module::ModuleGraph,
    pkgName: *[u8],
    arena: *mut alloc::Arena,
    options: LowerOptions

    };
}

/// Lower a module's AST into the lowerer accumulator.
/// Call this for each module in the package, then use `finalize` to get the program.
pub fn lowerModule(
export fn lowerModule(
    low: *mut Lowerer,
    moduleId: u16,
    root: *ast::Node,
    isRoot: bool
) -> ?u32 throws (LowerError) {

    }
    return defaultFnIdx;
}

/// Finalize lowering and return the unified IL program.
pub fn finalize(low: *Lowerer, defaultFnIdx: ?u32) -> il::Program {
export fn finalize(low: *Lowerer, defaultFnIdx: ?u32) -> il::Program {
    return il::Program {
        data: &low.data[..],
        fns: &low.fns[..],
        defaultFnIdx,
    };

    return nil;
}

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


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

//!
//! This module tracks source files, parent/child relationships, and basic state for each
//! module so that later phases (parser, semantic analyzer) can resolve imports (`use`)
//! and avoid reloading the same file twice.

pub mod printer;
export mod printer;

@test mod tests;

use std::mem;
use std::lang::alloc;
use std::lang::ast;
use std::lang::strings;

/// Maximum number of modules tracked in a single compilation graph.
pub const MAX_MODULES: u32 = 128;
export const MAX_MODULES: u32 = 128;
/// 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.
const PATH_SEP: u8 = '/';
/// Source file extension handled by the loader.
const SOURCE_EXT: *[u8] = ".rad";

/// Lifecycle state for modules in the dependency graph.
pub union ModuleState {
export union ModuleState {
    /// Slot unused or yet to be initialized.
    Vacant,
    /// Module registered with a known path but not parsed yet.
    Registered,
    /// Module is currently being parsed (used for cycle detection).

    /// Module finished semantic analysis and is ready for codegen.
    Ready,
}

/// Error categories that can be produced by the module graph.
pub union ModuleError {
export union ModuleError {
    /// Module not found.
    NotFound(u16),
    /// Adding the module would exceed the fixed storage.
    CapacityExceeded,
    /// Provided path is missing the required `.rad` extension or otherwise invalid.

    /// Attempt to register a module before its parent.
    MissingParent,
}

/// Module metadata recorded inside the dependency graph.
pub record ModuleEntry {
export record ModuleEntry {
    /// Numeric identifier for the slot (index in the graph array).
    id: u16,
    /// Package identifier this module belongs to.
    packageId: u16,
    /// Parent module identifier, or `nil` for root modules.

    /// Source text for this module (for error reporting).
    source: ?*[u8],
}

/// Dense storage for all modules referenced by the compilation unit.
pub record ModuleGraph {
export record ModuleGraph {
    entries: *mut [ModuleEntry],
    entriesLen: u32,
    pool: *mut strings::Pool,
    /// Arena used for all AST node allocations.
    arena: ?*ast::NodeArena,
}

/// Initialize an empty module graph backed by the provided storage.
pub fn moduleGraph(
export fn moduleGraph(
    storage: *mut [ModuleEntry],
    pool: *mut strings::Pool,
    arena: *mut ast::NodeArena
) -> ModuleGraph {
    return ModuleGraph {

        arena,
    };
}

/// Register a root module residing at `path` for a package.
pub fn registerRoot(graph: *mut ModuleGraph, packageId: u16, filePath: *[u8]) -> u16 throws (ModuleError) {
export fn registerRoot(graph: *mut ModuleGraph, packageId: u16, filePath: *[u8]) -> u16 throws (ModuleError) {
    let name = try basenameSlice(filePath);
    return try registerRootWithName(graph, packageId, name, filePath);
}

/// Register a root module with an explicit name and file path for a package.
pub fn registerRootWithName(
export fn registerRootWithName(
    graph: *mut ModuleGraph,
    packageId: u16,
    name: *[u8],
    filePath: *[u8]
) -> u16 throws (ModuleError) {

    return m.id;
}

/// Register a child module.
/// Returns the module identifier.
pub fn registerChild(
export fn registerChild(
    graph: *mut ModuleGraph,
    parentId: u16,
    name: *[u8],
    filePath: *[u8]
) -> u16 throws (ModuleError) {


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

/// Fetch a read-only view of the module identified by `id`.
pub fn get(graph: *ModuleGraph, id: u16) -> ?*ModuleEntry {
export fn get(graph: *ModuleGraph, id: u16) -> ?*ModuleEntry {
    if not isValidId(graph, id) {
        return nil;
    }
    return &graph.entries[id as u32];
}

    }
    return &mut graph.entries[id as u32];
}

/// Return the identifier of the child stored at `index`.
pub fn childAt(m: *ModuleEntry, index: u32) -> u16 {
export fn childAt(m: *ModuleEntry, index: u32) -> u16 {
    assert index < m.childrenLen, "childAt: index must be valid";
    return m.children[index];
}

/// Public accessor for a module's directory prefix.
pub fn moduleDir(m: *ModuleEntry) -> *[u8] {
export fn moduleDir(m: *ModuleEntry) -> *[u8] {
    return &m.filePath[..m.dirLen];
}

/// Public accessor to the logical module path segments.
pub fn moduleQualifiedPath(m: *ModuleEntry) -> *[*[u8]] {
export fn moduleQualifiedPath(m: *ModuleEntry) -> *[*[u8]] {
    assert m.pathDepth > 0, "moduleQualifiedPath: path must not be empty";
    return &m.path[..m.pathDepth];
}

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

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

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

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

    let parent = &graph.entries[parentId as u32];
    for i in 0..parent.childrenLen {
        let childId = parent.children[i];

}

/// Parse a file path into components by splitting on '/'.
/// Expects and removes the '.rad' extension from the last component.
/// Returns the number of components extracted, or `nil` if the path is invalid.
pub fn parsePath(filePath: *[u8], components: *mut [*[u8]]) -> ?u32 {
export fn parsePath(filePath: *[u8], components: *mut [*[u8]]) -> ?u32 {
    let mut count: u32 = 0;
    let mut last: u32 = 0;

    // Split on '/' to extract all but the last component.
    for i in 0..filePath.len {


/// Register a module from a file path, creating the full hierarchy as needed.
/// The path is split into components and the module hierarchy is built accordingly.
/// If `rootId` is `nil`, registers a new root for the given package.
/// Returns the module ID of the last component.
pub fn registerFromPath(graph: *mut ModuleGraph, packageId: u16, rootId: ?u16, filePath: *[u8]) -> u16 throws (ModuleError) {
export fn registerFromPath(graph: *mut ModuleGraph, packageId: u16, rootId: ?u16, filePath: *[u8]) -> u16 throws (ModuleError) {
    let root = rootId else {
        return try registerRoot(graph, packageId, filePath);
    };
    let rootEntry = get(graph, root) else {
        panic "registerFromPath: root is missing from storage";

    return start;
}

/// Trim the `.rad` extension from `path` if present.
/// Returns the path slice without the extension.
pub fn trimExtension(path: *[u8]) -> ?*[u8] {
export fn trimExtension(path: *[u8]) -> ?*[u8] {
    if path.len < SOURCE_EXT.len {
        return nil;
    }
    let extStart = path.len - SOURCE_EXT.len;
    for ext, i in SOURCE_EXT {

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

        sexpr::Expr::List { head: "::", tail: pathBuf, multiline: false }
    ], childBuf);
}

/// Print the entire module graph in S-expression format.
pub fn printGraph(graph: *super::ModuleGraph, arena: *mut alloc::Arena) {
export fn printGraph(graph: *super::ModuleGraph, arena: *mut alloc::Arena) {
    // Print all root modules.
    for i in 0..graph.entriesLen {
        let entry = &graph.entries[i];
        if entry.parent == nil {
            sexpr::print(subtreeToExpr(arena, graph, entry), 0);

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

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

/// Maximum number of packages processed in a single invocation.
pub const MAX_PACKAGES: u32 = 4;
export const MAX_PACKAGES: u32 = 4;

/// A compilation unit.
pub record Package {
export record Package {
    /// Package identifier (index in the package array).
    id: u16,
    /// Package name.
    name: *[u8],
    /// Root module identifier for this package, or `nil` if not yet registered.
    // TODO: This shouldn't be optional.
    rootModuleId: ?u16,
}

/// Initialize `pkg` with the provided name and ID.
pub fn init(
export fn init(
    pkg: *mut Package,
    id: u16,
    name: *[u8],
    pool: *mut strings::Pool
) -> *mut Package {


    return pkg;
}

/// Register a module described by the file path.
pub fn registerModule(pkg: *mut Package, graph: *mut module::ModuleGraph, filePath: *[u8]) -> u16
export fn registerModule(pkg: *mut Package, graph: *mut module::ModuleGraph, filePath: *[u8]) -> u16
    throws (module::ModuleError)
{
    let modId = try module::registerFromPath(graph, pkg.id, pkg.rootModuleId, filePath);
    // First registered module becomes the root.
    if pkg.rootModuleId == nil {

lib/std/lang/parser.rad +26 -26

//! Recursive descent parser for the Radiance programming language.
@test pub mod tests;
@test export mod tests;

use std::mem;
use std::io;
use std::lang::alloc;
use std::lang::ast;
use std::lang::strings;
use std::lang::scanner;

/// Maximum `u32` value.
pub const U32_MAX: u32 = 0xFFFFFFFF;
export const U32_MAX: u32 = 0xFFFFFFFF;
/// Maximum representable `u64` value.
pub const U64_MAX: u64 = 0xFFFFFFFFFFFFFFFF;
export const U64_MAX: u64 = 0xFFFFFFFFFFFFFFFF;
/// Maximum number of fields in a record.
pub const MAX_RECORD_FIELDS: u32 = 32;
export const MAX_RECORD_FIELDS: u32 = 32;

/// Maximum number of parser errors before aborting.
const MAX_ERRORS: u32 = 8;

/// Parser error type.
pub union ParseError {
export union ParseError {
    /// Encountered a token that was not expected in the current context.
    UnexpectedToken,
}

/// Represents a parsed name-type-value triple.

    /// and `if` is reserved for guards.
    Condition,
}

/// A single parser error with location information.
pub record Error {
export record Error {
    /// Human-readable error message.
    message: *[u8],
    /// The token where the error occurred.
    token: scanner::Token,
}

            return nil,
    }
}

/// Parser state.
pub record Parser {
export record Parser {
    /// The scanner that provides tokens.
    scanner: scanner::Scanner,
    /// The current token being examined.
    current: scanner::Token,
    /// The most recently consumed token.

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

/// Create a new parser initialized with the given source kind, source and node arena.
pub fn mkParser(sourceLoc: scanner::SourceLoc, source: *[u8], arena: *mut ast::NodeArena, pool: *mut strings::Pool) -> Parser {
export fn mkParser(sourceLoc: scanner::SourceLoc, source: *[u8], arena: *mut ast::NodeArena, pool: *mut strings::Pool) -> Parser {
    return Parser {
        scanner: scanner::scanner(sourceLoc, source, pool),
        current: scanner::invalid(0, ""),
        previous: scanner::invalid(0, ""),
        errors: ErrorList { list: undefined, count: 0 },

fn nodeBool(p: *mut Parser, value: bool) -> *ast::Node {
    return node(p, ast::NodeValue::Bool(value));
}

/// Convert a single ASCII digit into its numeric value for the given radix.
pub fn digitFromAscii(ch: u8, radix: u32) -> ?u32 {
export fn digitFromAscii(ch: u8, radix: u32) -> ?u32 {
    assert radix >= 2 and radix <= 36;

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


    }
    return result;
}

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



/// Parse a single expression.
///
/// Parses unary and binary operators using precedence climbing.
/// Conditional expressions (`x if cond else y`) have lowest precedence.
pub fn parseExpr(p: *mut Parser) -> *ast::Node
export fn parseExpr(p: *mut Parser) -> *ast::Node
    throws (ParseError)
{
    let left = try parseUnary(p);
    let expr = try parseBinary(p, left, -1);
    return try parseCondExpr(p, expr);

        else => return nil,
    }
}

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

    if consume(p, scanner::TokenKind::Equal) {

    let mut attrs = ast::nodeSlice(p.arena, 4);

    if let attr = tryParseAnnotation(p) {
        attrs.append(attr, p.allocator);
    }
    if consume(p, scanner::TokenKind::Pub) or consume(p, scanner::TokenKind::Export) {
        let attrNode = nodeAttribute(p, ast::Attribute::Pub);
    if consume(p, scanner::TokenKind::Export) {
        let attrNode = nodeAttribute(p, ast::Attribute::Export);
        attrs.append(attrNode, p.allocator);
    }
    if attrs.len > 0 {
        return ast::Attributes { list: attrs };
    }

}

/// Parse a single statement.
///
/// Dispatches to the appropriate statement parser based on the current token.
pub fn parseStmt(p: *mut Parser) -> *ast::Node
export fn parseStmt(p: *mut Parser) -> *ast::Node
    throws (ParseError)
{
    // TODO: Why is `parseStmt` checking for attributes?
    // We should have a `parseDecl` which is top-level, and `parseStmt` which
    // is inside functions.

}

/// Parse statements until the specified ending token is encountered.
///
/// Adds each parsed statement to the given block's statement list.
pub fn parseStmtsUntil(p: *mut Parser, end: scanner::TokenKind, blk: *mut ast::Block)
export fn parseStmtsUntil(p: *mut Parser, end: scanner::TokenKind, blk: *mut ast::Block)
    throws (ParseError)
{
    while not check(p, end) {
        let stmt = try parseStmt(p);
        blk.statements.append(stmt, p.allocator);

        }
    }
}

/// Parse a block of statements enclosed in curly braces.
pub fn parseBlock(p: *mut Parser) -> *ast::Node
export fn parseBlock(p: *mut Parser) -> *ast::Node
    throws (ParseError)
{
    let start = p.current;
    let mut blk = mkBlock(p, 64);


    reportError(p, p.current, err);
    return ParseError::UnexpectedToken;
}

/// Print all errors that have been collected during parsing.
pub fn printErrors(p: *Parser) {
export fn printErrors(p: *Parser) {
    for i in 0..p.errors.count {
        let e = p.errors.list[i];
        if let loc = scanner::getLocation(
            p.scanner.sourceLoc, p.scanner.source, e.token.offset
        ) {

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

/// Check whether the current token matches the expected kind.
pub fn check(p: *Parser, kind: scanner::TokenKind) -> bool {
export fn check(p: *Parser, kind: scanner::TokenKind) -> bool {
    return p.current.kind == kind;
}

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

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

    }
    return path;
}

/// Parse a type annotation.
pub fn parseType(p: *mut Parser) -> *ast::Node
export fn parseType(p: *mut Parser) -> *ast::Node
    throws (ParseError)
{
    match p.current.kind {
        case scanner::TokenKind::Question => {
            advance(p);

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

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


/// Parse a complete module into a block of top-level statements.
///
/// This is the main entry point for parsing an entire Radiance source file.
/// The parser must already be initialized with source code.
pub fn parseModule(p: *mut Parser) -> *mut ast::Node
export fn parseModule(p: *mut Parser) -> *mut ast::Node
    throws (ParseError)
{
    advance(p); // Set the parser up with a first token.

    let mut blk = mkBlock(p, 512);


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

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

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

}

/// Parse an instance block.
/// Syntax: `instance Trait for Type { fn (t: *mut Type) fnord(..) {..} }`
///
/// Instance declarations do not accept attributes (e.g. `pub`).
/// Instance declarations do not accept attributes (e.g. `export`).
/// Visibility is determined by the trait declaration itself.
fn parseInstanceDecl(p: *mut Parser) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Instance, "expected `instance`");

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


    return root;
}

/// Parse a single expression from a string.
pub fn parseExprStr(input: *[u8]) -> *ast::Node
export fn parseExprStr(input: *[u8]) -> *ast::Node
    throws (super::ParseError)
{
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let mut parser = super::mkParser(scanner::SourceLoc::String, input, &mut arena, &mut STRING_POOL);
    super::advance(&mut parser);

    }
    panic "expectBlockExprStmt: comparing values we don't know how to compare";
}

/// Get the first statement from a block node.
pub fn getBlockFirstStmt(blk: *ast::Node) -> *ast::Node
export fn getBlockFirstStmt(blk: *ast::Node) -> *ast::Node
    throws (testing::TestError)
{
    let case ast::NodeValue::Block(block) = blk.value
        else throw testing::TestError::Failed;


    }
    return block.statements[0];
}

/// Get the last statement from a block node.
pub fn getBlockLastStmt(blk: *ast::Node) -> *ast::Node
export fn getBlockLastStmt(blk: *ast::Node) -> *ast::Node
    throws (testing::TestError)
{
    let case ast::NodeValue::Block(block) = blk.value
        else throw testing::TestError::Failed;


    try testing::expect(decl.attrs == nil);
}

/// Test parsing a module declaration with attributes.
@test fn testParseModAttributes() throws (testing::TestError) {
    let node = try! parseStmtStr("pub mod io;");
    let node = try! parseStmtStr("export mod io;");
    let case ast::NodeValue::Mod(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "io");
    let attrs = decl.attrs

    try testing::expect(attrs.list.len == 1);

    let case ast::NodeValue::Attribute(attr) = attrs.list[0].value
        else throw testing::TestError::Failed;

    try testing::expect(attr == ast::Attribute::Pub);
    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Pub));
    try testing::expect(attr == ast::Attribute::Export);
    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Export));
}

/// Test parsing an optional type.
@test fn testParseTypeOptional() throws (testing::TestError) {
    let node = try! parseTypeStr("?i32");

    try testing::expect(super::check(&parser, scanner::TokenKind::Ident));
}

/// Test parsing a function declaration with attributes.
@test fn testParseFnDeclAttributes() throws (testing::TestError) {
    let node = try! parseStmtStr("pub fn run();");
    let node = try! parseStmtStr("export fn run();");
    let case ast::NodeValue::FnDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "run");



    try testing::expect(attrs.list.len == 2);

    let case ast::NodeValue::Attribute(attr0) = attrs.list[0].value
        else throw testing::TestError::Failed;
    try testing::expect(attr0 == ast::Attribute::Pub);
    try testing::expect(attr0 == ast::Attribute::Export);

    let case ast::NodeValue::Attribute(attr1) = attrs.list[1].value
        else throw testing::TestError::Failed;
    try testing::expect(attr1 == ast::Attribute::Extern);

    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Pub));
    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Export));
    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Extern));
    try testing::expect(decl.body == nil);
}

/// Test parsing a top-level function declaration with inferred extern from `;`.


    try testing::expect(attrs.list.len == 2);

    let case ast::NodeValue::Attribute(attr0) = attrs.list[0].value
        else throw testing::TestError::Failed;
    try testing::expect(attr0 == ast::Attribute::Pub);
    try testing::expect(attr0 == ast::Attribute::Export);

    let case ast::NodeValue::Attribute(attr1) = attrs.list[1].value
        else throw testing::TestError::Failed;
    try testing::expect(attr1 == ast::Attribute::Extern);

    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Pub));
    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Export));
    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Extern));
    try testing::expect(decl.body == nil);
}

/// Test parsing a scoped identifier type.

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

//! Radiance semantic analyzer and type resolver.
//!
//! This module performs scope construction, symbol binding, and identifier
//! resolution on top of the AST produced by the parser.

pub mod printer;
export mod printer;

/// Unit tests for the resolver.
@test mod tests;

// TODO: Move to raw vectors to reduce list duplication?

use std::lang::ast;
use std::lang::parser;
use std::lang::module;

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

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

/// Maximum number of symbols stored within a module scope.
pub const MAX_MODULE_SYMBOLS: u32 = 512;
export const MAX_MODULE_SYMBOLS: u32 = 512;
/// Maximum number of symbols stored within a local scope.
pub const MAX_LOCAL_SYMBOLS: u32 = 32;
export const MAX_LOCAL_SYMBOLS: u32 = 32;
/// Maximum function parameters.
pub const MAX_FN_PARAMS: u32 = 8;
export const MAX_FN_PARAMS: u32 = 8;
/// Maximum function thrown types.
pub const MAX_FN_THROWS: u32 = 8;
export const MAX_FN_THROWS: u32 = 8;
/// Maximum number of variants in a union.
/// Nb. This should not be raised above `255`,
/// as tags are stored using 8-bits only.
pub const MAX_UNION_VARIANTS: u32 = 128;
export const MAX_UNION_VARIANTS: u32 = 128;
/// Maximum nesting of loops.
pub const MAX_LOOP_DEPTH: u32 = 16;
export const MAX_LOOP_DEPTH: u32 = 16;
/// Maximum trait instances.
pub const MAX_INSTANCES: u32 = 128;
export const MAX_INSTANCES: u32 = 128;
/// Maximum standalone methods (across all types).
pub const MAX_METHODS: u32 = 256;
export const MAX_METHODS: u32 = 256;

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

/// A single method signature within a trait.
pub record TraitMethod {
export record TraitMethod {
    /// Method name.
    name: *[u8],
    /// Function type for the method, excluding the receiver.
    fnType: *FnType,
    /// Whether the receiver is mutable.

    /// V-table slot index.
    index: u32,
}

/// An entry in the trait instance registry.
pub record InstanceEntry {
export record InstanceEntry {
    /// Trait type descriptor.
    traitType: *TraitType,
    /// Concrete type that implements the trait.
    concreteType: Type,
    /// Name of the concrete type.

    /// Method symbols for each trait method, in declaration order.
    methods: *mut [*mut Symbol],
}

/// An entry in the method registry.
pub record MethodEntry {
export record MethodEntry {
    /// Concrete type that owns the method.
    concreteType: Type,
    /// Name of the concrete type.
    concreteTypeName: *[u8],
    /// Method name.

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

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

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

const I64_MIN: i64 = -9223372036854775808;
/// Maximum `i64` value: 2^63 - 1.
const I64_MAX: i64 = 9223372036854775807;

/// Size of a pointer in bytes.
pub const PTR_SIZE: u32 = 8;
export const PTR_SIZE: u32 = 8;

/// Information about a record or tuple field.
pub record RecordField {
export record RecordField {
    /// Field name, `nil` for positional fields.
    name: ?*[u8],
    /// Field type.
    fieldType: Type,
    /// Byte offset from the start of the record.

    valueType: Type,
    symbol: *mut Symbol,
}

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

/// Record nominal type.
pub record RecordType {
export record RecordType {
    fields: *[RecordField],
    labeled: bool,
    /// Cached layout.
    layout: Layout,
}

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

/// Metadata for user-defined types.
pub union NominalType {
export union NominalType {
    /// Placeholder for a type that hasn't been fully resolved yet.
    /// Stores the declaration node for lazy resolution.
    Placeholder(*ast::Node),
    Record(RecordType),
    Union(UnionType),
}

/// Coercion plan, when coercion from one type to another.
pub union Coercion {
export union Coercion {
    /// No coercion, eg. `T -> T`.
    Identity,
    /// Eg. `u8 -> i32`. Stores both source and target types for lowering.
    NumericCast { from: Type, to: Type },
    /// Eg. `T -> ?T`. Stores the inner value type.

    /// Scope containing the module's declarations.
    scope: *mut Scope,
}

/// Type layout.
pub record Layout {
export record Layout {
    /// Size in bytes.
    size: u32,
    /// Alignment in bytes.
    alignment: u32,
}

    isAllVoid: bool,
}

/// Pre-computed metadata for slice range expressions.
/// Used by the lowerer.
pub record SliceRangeInfo {
export record SliceRangeInfo {
    /// Element type of the resulting slice.
    itemType: *Type,
    /// Whether the resulting slice is mutable.
    mutable: bool,
    /// Static capacity if container is an array.
    capacity: ?u32,
}

/// Pre-computed metadata for `for` loop iteration.
/// Used by the lowerer to avoid re-analyzing the iterable type.
pub union ForLoopInfo {
export union ForLoopInfo {
    /// Iterating over a range expression (e.g., `for i in 0..n`).
    Range {
        valType: *Type,
        range: ast::Range,
        bindingName: ?*[u8],

        indexName: ?*[u8]
    },
}

/// Resolved function signature details.
pub record FnType {
export record FnType {
    paramTypes: *[*Type],
    returnType: *Type,
    throwList: *[*Type],
    localCount: u32,
}

/// Describes a type computed during semantic analysis.
pub union Type {
export union Type {
    /// A type that couldn't be decided.
    Unknown,
    /// Types only used during inference.
    Nil, Undefined, Int,
    /// Primitive types.

        mutable: bool,
    },
}

/// Structured diagnostic payload for type mismatches.
pub record TypeMismatch {
export record TypeMismatch {
    expected: Type,
    actual: Type,
}

/// Structured diagnostic payload for invalid `as` casts.
pub record InvalidAsCast {
export record InvalidAsCast {
    from: Type,
    to: Type,
}

/// Diagnostic payload for argument count mismatches.
pub record CountMismatch {
export record CountMismatch {
    expected: u32,
    actual: u32,
}

/// Detailed payload attached to a symbol, specialized per symbol kind.
pub union SymbolData {
export union SymbolData {
    /// Payload describing mutable bindings like variables or functions.
    Value {
        /// Whether the binding permits mutation.
        mutable: bool,
        /// Custom alignment requirement, or 0 for default.

    /// Trait symbol.
    Trait(*mut TraitType),
}

/// Resolved symbol allocated during semantic analysis.
pub record Symbol {
export record Symbol {
    /// Symbol name in source code.
    name: *[u8],
    /// Data associated with the symbol.
    data: SymbolData,
    /// Bitset of attributes applied to the declaration.

    /// Module ID this symbol belongs to. Only for module-level symbols.
    moduleId: ?u16,
}

/// Integer constant payload.
pub record ConstInt {
export record ConstInt {
    /// Absolute magnitude of the value.
    magnitude: u64,
    /// Bit width of the integer.
    bits: u8,
    /// Whether the integer is signed.

    /// Whether the value is negative (only valid when `signed` is true).
    negative: bool,
}

/// Constant value recorded for literal nodes.
pub union ConstValue {
export union ConstValue {
    Bool(bool),
    Char(u8),
    String(*[u8]),
    Int(ConstInt),
}

        max: u64,
    },
}

/// Diagnostic emitted by the analyzer.
pub record Error {
export record Error {
    /// Error category.
    kind: ErrorKind,
    /// Node associated with the error, if known.
    node: ?*ast::Node,
    /// Module ID where this error occurred.
    moduleId: u16,
}

/// High-level classification for semantic diagnostics.
pub union ErrorKind {
export union ErrorKind {
    /// Identifier declared more than once in the same scope.
    DuplicateBinding(*[u8]),
    /// Identifier referenced before it was declared.
    UnresolvedSymbol(*[u8]),
    /// Attempted to assign to an immutable binding.

    /// Internal error.
    Internal,
}

/// Diagnostics returned by the analyzer.
pub record Diagnostics {
export record Diagnostics {
    errors: *mut [Error],
}

/// Call context.
union CallCtx {

    scope: *mut Scope,
    child: *ast::Node,
}

/// Node-specific resolver metadata.
pub union NodeExtra {
export union NodeExtra {
    /// No extra data for this node.
    None,
    /// Resolved field index for record literal fields.
    RecordField { index: u32 },
    /// Slice range metadata for subscript expressions with ranges.

    /// Slice `.delete(index)` method call.
    SliceDelete { elemType: *Type },
}

/// Combined resolver metadata for a single AST node.
pub record NodeData {
export record NodeData {
    /// Resolved type for this node.
    ty: Type,
    /// Coercion plan applied to this node.
    coercion: Coercion,
    /// Symbol associated with this node.

record NodeDataTable {
    entries: *mut [NodeData],
}

/// Lexical scope.
pub record Scope {
export record Scope {
    /// Owning AST node, or `nil` for the root scope.
    owner: ?*ast::Node,
    /// Parent/enclosing scope.
    parent: ?*mut Scope,
    /// Module ID if this is a module scope.

    /// This is used to determine whether a loop diverges.
    hasBreak: bool,
}

/// Configuration for semantic analysis.
pub record Config {
export record Config {
    /// Whether we're building in test mode.
    buildTest: bool,
}

/// How pattern bindings are created during match.
pub union MatchBy {
export union MatchBy {
    /// Match by value.
    Value,
    /// Match by immutable reference.
    Ref,
    /// Match by mutable reference.

    /// Is the match constant?
    isConst: bool
}

/// Result of unwrapping a type for pattern matching.
pub record MatchSubject {
export record MatchSubject {
    /// The effective type to match against.
    effectiveTy: Type,
    /// How bindings should be created.
    by: MatchBy,
}

/// Unwrap a pointer type for pattern matching.
pub fn unwrapMatchSubject(ty: Type) -> MatchSubject {
export fn unwrapMatchSubject(ty: Type) -> MatchSubject {
    if let case Type::Pointer { target, mutable } = ty {
        let by = MatchBy::MutRef if mutable else MatchBy::Ref;
        return MatchSubject { effectiveTy: *target, by };
    }
    return MatchSubject { effectiveTy: ty, by: MatchBy::Value };
}

/// Global resolver state.
pub record Resolver {
export record Resolver {
    /// Current scope.
    scope: *mut Scope,
    /// Package scope containing package roots and top-level symbols.
    pkgScope: *mut Scope,
    /// Stack of loop contexts for nested loops.

    /// Number of registered standalone methods.
    methodsLen: u32,
}

/// Internal error sentinel thrown when analysis cannot proceed.
pub union ResolveError {
export union ResolveError {
    Failure,
}

/// Node in the type interning linked list.
record TypeNode {
    ty: Type,
    next: ?*TypeNode,
}

/// Allocate and intern a type in the arena, returning a pointer for deduplication.
pub fn allocType(self: *mut Resolver, ty: Type) -> *Type {
export fn allocType(self: *mut Resolver, ty: Type) -> *Type {
    // Search existing types for a match.
    let mut cursor = self.types;
    while let node = cursor {
        if node.ty == ty {
            return &node.ty;

    }
    return nil;
}

/// Storage buffers used by the analyzer.
pub record ResolverStorage {
export record ResolverStorage {
    /// Unified arena for symbols, scopes, and nominal type.
    arena: alloc::Arena,
    /// Node semantic metadata indexed by node ID.
    nodeData: *mut [NodeData],
    /// Package scope.

    /// Error storage.
    errors: *mut [Error],
}

/// Input for resolving a single package.
pub record Pkg {
export record Pkg {
    /// Root module entry.
    rootEntry: *module::ModuleEntry,
    /// Root AST node.
    rootAst: *ast::Node,
}

/// Construct a resolver with module context and backing storage.
pub fn resolver(
export fn resolver(
    storage: ResolverStorage,
    config: Config
) -> Resolver {
    let mut arena = storage.arena;
    let symbols = try! alloc::allocSlice(

        methodsLen: 0,
    };
}

/// Return `true` if there are no errors in the diagnostics.
pub fn success(diag: *Diagnostics) -> bool {
export fn success(diag: *Diagnostics) -> bool {
    return diag.errors.len == 0;
}

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

}

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

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

    self.scope = scope;


    return enterModuleScope(self, modRoot, modEntry);
}

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

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

fn setForLoopInfo(self: *mut Resolver, node: *ast::Node, info: ForLoopInfo) {
    self.nodeData.entries[node.id].extra = NodeExtra::ForLoop(info);
}

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

/// Get the resolved record field index for a record literal field node.
pub fn recordFieldIndexFor(self: *Resolver, node: *ast::Node) -> ?u32 {
export fn recordFieldIndexFor(self: *Resolver, node: *ast::Node) -> ?u32 {
    if let case NodeExtra::RecordField { index } = self.nodeData.entries[node.id].extra {
        return index;
    }
    return nil;
}

/// Get the slice range metadata for a subscript expression with a range index.
pub fn sliceRangeInfoFor(self: *Resolver, node: *ast::Node) -> ?SliceRangeInfo {
export fn sliceRangeInfoFor(self: *Resolver, node: *ast::Node) -> ?SliceRangeInfo {
    if let case NodeExtra::SliceRange(info) = self.nodeData.entries[node.id].extra {
        return info;
    }
    return nil;
}

/// Get the for-loop metadata for a for-loop node.
pub fn forLoopInfoFor(self: *Resolver, node: *ast::Node) -> ?ForLoopInfo {
export fn forLoopInfoFor(self: *Resolver, node: *ast::Node) -> ?ForLoopInfo {
    if let case NodeExtra::ForLoop(info) = self.nodeData.entries[node.id].extra {
        return info;
    }
    return nil;
}

fn setProngCatchAll(self: *mut Resolver, node: *ast::Node, catchAll: bool) {
    self.nodeData.entries[node.id].extra = NodeExtra::MatchProng { catchAll };
}

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

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

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

/// Get the resolver metadata for a node.
pub fn nodeData(self: *Resolver, node: *ast::Node) -> *NodeData {
export fn nodeData(self: *Resolver, node: *ast::Node) -> *NodeData {
    return &self.nodeData.entries[node.id];
}

/// Get the type for a node, or `nil` if unknown.
pub fn typeFor(self: *Resolver, node: *ast::Node) -> ?Type {
export fn typeFor(self: *Resolver, node: *ast::Node) -> ?Type {
    let ty = self.nodeData.entries[node.id].ty;
    if ty == Type::Unknown {
        return nil;
    }
    return ty;
}

/// Get the scope associated with a node.
pub fn scopeFor(self: *Resolver, node: *ast::Node) -> ?*mut Scope {
export fn scopeFor(self: *Resolver, node: *ast::Node) -> ?*mut Scope {
    return self.nodeData.entries[node.id].scope;
}

/// Get the symbol bound to a node.
pub fn symbolFor(self: *Resolver, node: *ast::Node) -> ?*mut Symbol {
export fn symbolFor(self: *Resolver, node: *ast::Node) -> ?*mut Symbol {
    return self.nodeData.entries[node.id].sym;
}

/// Get the coercion plan associated with a node, if any.
pub fn coercionFor(self: *Resolver, node: *ast::Node) -> ?Coercion {
export fn coercionFor(self: *Resolver, node: *ast::Node) -> ?Coercion {
    let c = self.nodeData.entries[node.id].coercion;
    if c == Coercion::Identity {
        return nil;
    }
    return c;
}

/// Get the module ID for a symbol by walking up its scope chain.
pub fn moduleIdForSymbol(self: *Resolver, sym: *Symbol) -> ?u16 {
export fn moduleIdForSymbol(self: *Resolver, sym: *Symbol) -> ?u16 {
    // For module-level symbols, return the cached module ID.
    if let id = sym.moduleId {
        return id;
    }
    // For module symbols, return the module ID directly.

    return nil;
}

/// Get the binding node for a variant pattern.
/// Returns the argument node if this is a variant constructor with a non-placeholder binding.
pub fn variantPatternBinding(self: *Resolver, pattern: *ast::Node) -> ?*ast::Node {
export fn variantPatternBinding(self: *Resolver, pattern: *ast::Node) -> ?*ast::Node {
    let case ast::NodeValue::Call(call) = pattern.value
        else return nil;
    let sym = symbolFor(self, call.callee)
        else return nil;
    let case SymbolData::Variant { .. } = sym.data

        else => return false,
    }
}

/// Check if a type is an unsigned integer type.
pub fn isUnsignedIntegerType(ty: Type) -> bool {
export fn isUnsignedIntegerType(ty: Type) -> bool {
    match ty {
        case Type::U8, Type::U16, Type::U32, Type::U64 => return true,
        else => return false,
    }
}

    }
    return b;
}

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

        }
    }
}

/// Get the layout of a type or value.
pub fn getLayout(self: *Resolver, node: *ast::Node, ty: Type) -> Layout {
export fn getLayout(self: *Resolver, node: *ast::Node, ty: Type) -> Layout {
    let mut layout = getTypeLayout(ty);
    // Check for symbol-specific alignment override.
    if let sym = symbolFor(self, node) {
        if let case SymbolData::Value { alignment, .. } = sym.data {
            if alignment > 0 {

    }
    return layout;
}

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

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

        alignment,
    };
}

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

/// Check if a type is optional.
pub fn isOptionalType(ty: Type) -> bool {
export fn isOptionalType(ty: Type) -> bool {
    match ty {
        case Type::Optional(_) => return true,
        else => return false,
    }
}

/// Check if a type uses null pointer optimization.
/// This applies to optional pointers `?*T` and optional slices `?*[T]`,
/// where `nil` is represented as a null data pointer with no tag byte.
pub fn isOptionalPointer(ty: Type) -> bool {
export fn isOptionalPointer(ty: Type) -> bool {
    if let case Type::Optional(inner) = ty {
        return isNullableType(*inner);
    }
    return false;
}

/// Check if a type uses the optional aggregate representation.
pub fn isOptionalAggregate(ty: Type) -> bool {
export fn isOptionalAggregate(ty: Type) -> bool {
    if let case Type::Optional(inner) = ty {
        return not isNullableType(*inner);
    }
    return false;
}

/// Check if a type can use null to represent `nil`.
/// Pointers and slices have a data pointer that is never null when valid.
pub fn isNullableType(ty: Type) -> bool {
export fn isNullableType(ty: Type) -> bool {
    match ty {
        case Type::Pointer { .. }, Type::Slice { .. } => return true,
        else => return false,
    }
}

/// Get the layout of a nominal type.
pub fn getNominalLayout(info: NominalType) -> Layout {
export fn getNominalLayout(info: NominalType) -> Layout {
    match info {
        case NominalType::Placeholder(_) => {
            panic "getNominalLayout: placeholder type";
        }
        case NominalType::Record(recordType) => {

        }
    }
}

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

    for errType in throwList {

    *iota = tag + 1;
    return tag;
}

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


    }
    return true;
}

/// Check if two types are structurally equal.
pub fn typesEqual(a: Type, b: Type) -> bool {
export fn typesEqual(a: Type, b: Type) -> bool {
    if a == b {
        return true;
    }
    match a {
        case Type::Pointer { target: aTarget, mutable: aMutable } => {

        else => return false,
    }
}

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

/// Auto-dereference a type: if it's a pointer, return the target type.
pub fn autoDeref(ty: Type) -> Type {
export fn autoDeref(ty: Type) -> Type {
    if let case Type::Pointer { target, .. } = ty {
        return *target;
    }
    return ty;
}

/// Get field info for a record-like type (records, slices) by field index.
pub fn getRecordField(ty: Type, index: u32) -> ?RecordField {
export fn getRecordField(ty: Type, index: u32) -> ?RecordField {
    match ty {
        case Type::Nominal(NominalType::Record(recInfo)) => {
            if index >= recInfo.fields.len {
                return nil;
            }

    }
    return nil;
}

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

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

    return nil;
}

/// Check if a symbol is accessible from the given scope.
/// A symbol is accessible if:
/// * It has the `pub` attribute, OR
/// * It has the `export` attribute, OR
/// * It's being accessed from within the module where it was defined.
fn isSymbolVisible(sym: *Symbol, symScope: *Scope, fromScope: *Scope) -> bool {
    // Public symbols are visible from anywhere.
    if ast::hasAttribute(sym.attrs, ast::Attribute::Pub) {
    if ast::hasAttribute(sym.attrs, ast::Attribute::Export) {
        return true;
    }
    // In test mode, @test symbols are visible from anywhere
    // so the test runner can reference them.
    if ast::hasAttribute(sym.attrs, ast::Attribute::Test) {

    }
    return false;
}

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


    return sym;
}

/// Find a trait method by name.
pub fn findTraitMethod(traitType: *TraitType, name: *[u8]) -> ?*TraitMethod {
export fn findTraitMethod(traitType: *TraitType, name: *[u8]) -> ?*TraitMethod {
    for i in 0..traitType.methods.len {
        if traitType.methods[i].name == name {
            return &traitType.methods[i];
        }
    }

    }
    return nil;
}

/// Look up a standalone method by concrete type and name.
pub fn findMethod(self: *Resolver, concreteType: Type, name: *[u8]) -> ?*MethodEntry {
export fn findMethod(self: *Resolver, concreteType: Type, name: *[u8]) -> ?*MethodEntry {
    for i in 0..self.methodsLen {
        let entry = &self.methods[i];
        if typesEqual(entry.concreteType, concreteType) and entry.name == name {
            return entry;
        }
    }
    return nil;
}

/// Look up a standalone method entry by its symbol.
pub fn findMethodBySymbol(self: *Resolver, sym: *mut Symbol) -> ?*MethodEntry {
export fn findMethodBySymbol(self: *Resolver, sym: *mut Symbol) -> ?*MethodEntry {
    for i in 0..self.methodsLen {
        let entry = &self.methods[i];
        if entry.symbol == sym {
            return entry;
        }


    if decl.wildcard {
        // Import all public symbols from the target module.
        for i in 0..resolved.scope.symbolsLen {
            let sym = resolved.scope.symbols[i];
            if ast::hasAttribute(sym.attrs, ast::Attribute::Pub) {
            if ast::hasAttribute(sym.attrs, ast::Attribute::Export) {
                try addSymbolToScope(self, sym, self.scope, node);
            }
        }
    } else {
        // Regular module import.

}

/// Check whether a pattern node is a destructuring pattern that looks
/// through structure (union variant, record literal, scope access).
/// Identifiers, placeholders, and plain literals are not destructuring.
pub fn isDestructuringPattern(pattern: *ast::Node) -> bool {
export fn isDestructuringPattern(pattern: *ast::Node) -> bool {
    match pattern.value {
        case ast::NodeValue::Call(_),
             ast::NodeValue::RecordLit(_),
             ast::NodeValue::ScopeAccess(_) => return true,
        else => return false,

}

/// Get the node within a pattern that carries the `UnionVariant` extra.
/// For `ScopeAccess` it is the pattern itself, for `RecordLit` it is the
/// type name, and for `Call` it is the callee.
pub fn patternVariantKeyNode(pattern: *ast::Node) -> ?*ast::Node {
export fn patternVariantKeyNode(pattern: *ast::Node) -> ?*ast::Node {
    match pattern.value {
        case ast::NodeValue::ScopeAccess(_) => return pattern,
        case ast::NodeValue::RecordLit(lit) => return lit.typeName,
        case ast::NodeValue::Call(call) => return call.callee,
        else => return nil,

        else => return true,
    }
}

/// Analyze a standalone expression by wrapping it in a synthetic function.
pub fn resolveExpr(
export fn resolveExpr(
    self: *mut Resolver, expr: *ast::Node, arena: *mut ast::NodeArena
) -> Diagnostics throws (ResolveError) {
    let a = alloc::arenaAllocator(&mut arena.arena);
    let exprStmt = ast::synthNode(arena, ast::NodeValue::ExprStmt(expr));
    let bodyStmts = ast::nodeSlice(arena, 1).append(exprStmt, a);


    return Diagnostics { errors: self.errors };
}

/// Analyze a parsed module root, ie. a block of top-level statements.
pub fn resolveModuleRoot(self: *mut Resolver, root: *ast::Node) -> Diagnostics throws (ResolveError) {
export fn resolveModuleRoot(self: *mut Resolver, root: *ast::Node) -> Diagnostics throws (ResolveError) {
    let case ast::NodeValue::Block(block) = root.value
        else panic "resolveModuleRoot: expected block for module root";

    enterScope(self, root);
    try resolveModuleDecls(self, &block) catch {

        if let case ast::NodeValue::Mod(decl) = node.value {
            try resolveModDecl(res, node, decl);
        }
    }
    // Phase 5b: Process wildcard imports after submodules are resolved,
    // so that transitive re-exports (pub use foo::*) are visible.
    // so that transitive re-exports (export use foo::*) are visible.
    for node in block.statements {
        if let case ast::NodeValue::Use(decl) = node.value {
            if decl.wildcard {
                try resolveUse(res, node, decl);
            }

        try visitDef(self, stmt);
    }
}

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

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

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

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

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

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

        else throw testing::TestError::Failed;
}

@test fn testSymbolStoresFnAttributes() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "@default pub fn f() { return; }";
    let program = "@default export fn f() { return; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let scope = super::scopeFor(&a, result.root)
        else throw testing::TestError::Failed;
    let sym = super::findSymbolInScope(scope, "f")
        else throw testing::TestError::Failed;

    try testing::expect(ast::hasAttribute(sym.attrs, ast::Attribute::Pub));
    try testing::expect(ast::hasAttribute(sym.attrs, ast::Attribute::Export));
    try testing::expect(ast::hasAttribute(sym.attrs, ast::Attribute::Default));
    try testing::expectNot(ast::hasAttribute(sym.attrs, ast::Attribute::Extern));
}

@test fn testSymbolStoresRecordAttributes() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "pub record S { value: i32 }";
    let program = "export record S { value: i32 }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let scope = super::scopeFor(&a, result.root)
        else throw testing::TestError::Failed;
    let sym = super::findSymbolInScope(scope, "S")
        else throw testing::TestError::Failed;

    try testing::expect(ast::hasAttribute(sym.attrs, ast::Attribute::Pub));
    try testing::expect(ast::hasAttribute(sym.attrs, ast::Attribute::Export));
    try testing::expectNot(ast::hasAttribute(sym.attrs, ast::Attribute::Default));
}

@test fn testDefaultAttributeRejectedOnRecord() throws (testing::TestError) {
    let mut a = testResolver();

@test fn testResolveModuleCannotAccessParentScope() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root and util modules.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod util; pub fn helper() {}", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod util; export fn helper() {}", &mut arena);
    let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "util", "fn main() { helper(); }", &mut arena);

    // Resolve should fail: the parent module is not in scope.
    let result = try resolveModuleTree(&mut a, rootId);
    let err = try expectError(&result);

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

    // Register root and util modules.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod util; fn main() { util::helper(); }", &mut arena);
    let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "util", "pub fn helper() {}", &mut arena);
    let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "util", "export fn helper() {}", &mut arena);

    // Resolve should succeed: parent can access child.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

@test fn testResolveSiblingModulesCannotAccessDirectly() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with two sibling modules.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod paul; pub mod patrick;", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod paul; export mod patrick;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "paul", "fn main() { patrick::helper(); }", &mut arena);
    let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "patrick", "pub fn helper() -> i32 { return 42; }", &mut arena);
    let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "patrick", "export fn helper() -> i32 { return 42; }", &mut arena);

    // Resolve should fail: siblings can't access each other directly.
    let result = try resolveModuleTree(&mut a, rootId);
    let err = try expectError(&result);
    let case super::ErrorKind::UnresolvedSymbol(name) = err.kind

@test fn testResolveSiblingModulesViaRoot() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with two sibling modules.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod paul; pub mod patrick;", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod paul; export mod patrick;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "paul", "use root::patrick; fn main() -> i32 { return patrick::helper(); }", &mut arena);
    let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "patrick", "pub fn helper() -> i32 { return 42; }", &mut arena);
    let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "patrick", "export fn helper() -> i32 { return 42; }", &mut arena);

    // Resolve should succeed: siblings can access each other via root.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

@test fn testResolveModuleMutualRecursion() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with two sibling modules that call each other.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "pub mod left; pub mod right;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "left", "use root::right; pub fn leftHelper() -> i32 { return right::rightHelper(); }", &mut arena);
    let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "right", "use root::left; pub fn rightHelper() -> i32 { return left::leftHelper(); }", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod left; export mod right;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "left", "use root::right; export fn leftHelper() -> i32 { return right::rightHelper(); }", &mut arena);
    let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "right", "use root::left; export fn rightHelper() -> i32 { return left::leftHelper(); }", &mut arena);

    // Resolve should succeed: cyclic use is allowed.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

@test fn testResolveAccessModuleType() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with types module containing a record.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "pub mod types; mod app;", &mut arena);
    let typesId = try registerModule(&mut MODULE_GRAPH, rootId, "types", "pub record Point { x: i32, y: i32 }", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod types; mod app;", &mut arena);
    let typesId = try registerModule(&mut MODULE_GRAPH, rootId, "types", "export record Point { x: i32, y: i32 }", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::types; fn main() -> i32 { let p = types::Point { x: 1, y: 2 }; return p.x; }", &mut arena);

    // Resolve should succeed: types can be accessed.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);

@test fn testResolveAccessModuleConstant() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with constants module.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "pub mod consts; mod app;", &mut arena);
    let constantsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "pub const MAX_SIZE: i32 = 100;", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
    let constantsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export const MAX_SIZE: i32 = 100;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; fn main() -> i32 { return consts::MAX_SIZE; }", &mut arena);

    // Resolve should succeed: constants can be accessed.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);

@test fn testResolveRootSymbolMustBeImported() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register deeply nested modules: `root::app::services::auth`.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod main; pub fn helper() -> i32 { return 42; }", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod main; export fn helper() -> i32 { return 42; }", &mut arena);
    let mainId = try registerModule(&mut MODULE_GRAPH, rootId, "main", "fn run() -> i32 { return root::helper(); }", &mut arena);

    // Resolve should fail: the `root` module must be imported.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("root"));

@test fn testResolveUseImportsNestedSymbol() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register deeply nested modules: `root::app::services::auth`.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "pub mod app; mod main;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "pub mod services;", &mut arena);
    let servicesId = try registerModule(&mut MODULE_GRAPH, appId, "services", "pub mod auth;", &mut arena);
    let authId = try registerModule(&mut MODULE_GRAPH, servicesId, "auth", "pub fn login() -> i32 { return 1; }", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod app; mod main;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "export mod services;", &mut arena);
    let servicesId = try registerModule(&mut MODULE_GRAPH, appId, "services", "export mod auth;", &mut arena);
    let authId = try registerModule(&mut MODULE_GRAPH, servicesId, "auth", "export fn login() -> i32 { return 1; }", &mut arena);
    let mainId = try registerModule(&mut MODULE_GRAPH, rootId, "main", "use root::app::services::auth; fn run() -> i32 { return auth::login(); }", &mut arena);
    let otherId = try registerModule(&mut MODULE_GRAPH, rootId, "other", "use root; fn run() -> i32 { return root::app::services::auth::login(); }", &mut arena);

    // Resolve should succeed: use imports the module symbol.
    let result = try resolveModuleTree(&mut a, rootId);

@test fn testResolveUsePrivateFn() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with util module containing a private function.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "pub mod util; mod app;", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod util; mod app;", &mut arena);
    let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "util", "fn private() -> i32 { return 42; }", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::util; fn main() -> i32 { return util::private(); }", &mut arena);

    // Resolve should fail: function is not public.
    let result = try resolveModuleTree(&mut a, rootId);

@test fn testResolveUsePublicMod() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with public and private child modules.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod main; pub mod public;", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod main; export mod public;", &mut arena);
    let privateId = try registerModule(&mut MODULE_GRAPH, rootId, "public", "{}", &mut arena);
    let publicId = try registerModule(&mut MODULE_GRAPH, rootId, "main", "use root::public;", &mut arena);

    // Resolve should succeed: module is public.
    let result = try resolveModuleTree(&mut a, rootId);

@test fn testResolveUseNonPublicType() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with types module containing a private record.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "pub mod types; mod app;", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod types; mod app;", &mut arena);
    let typesId = try registerModule(&mut MODULE_GRAPH, rootId, "types", "record Priv { x: i32 }", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::types; fn main() -> types::Priv { return types::Priv { x: 1 }; }", &mut arena);

    // Resolve should fail: record is not public.
    let result = try resolveModuleTree(&mut a, rootId);

@test fn testResolveImportPublicType() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with types module containing a public record.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "pub mod types; mod app;", &mut arena);
    let typesId = try registerModule(&mut MODULE_GRAPH, rootId, "types", "pub record Pub { x: i32 }", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod types; mod app;", &mut arena);
    let typesId = try registerModule(&mut MODULE_GRAPH, rootId, "types", "export record Pub { x: i32 }", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::types; fn main() -> types::Pub { return types::Pub { x: 1 }; }", &mut arena);

    // Resolve should succeed: record is public.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);

@test fn testResolveUseNonPublicStatic() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with statics module containing a private static.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "pub mod statics; mod app;", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod statics; mod app;", &mut arena);
    let staticsId = try registerModule(&mut MODULE_GRAPH, rootId, "statics", "static PRIVATE: i32 = 42;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::statics; fn main() -> i32 { return statics::PRIVATE; }", &mut arena);

    // Resolve should fail: static is not public.
    let result = try resolveModuleTree(&mut a, rootId);

@test fn testResolveImportPublicStatic() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with statics module containing a public static.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "pub mod statics; mod app;", &mut arena);
    let staticsId = try registerModule(&mut MODULE_GRAPH, rootId, "statics", "pub static PUBLIC: i32 = 42;", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod statics; mod app;", &mut arena);
    let staticsId = try registerModule(&mut MODULE_GRAPH, rootId, "statics", "export static PUBLIC: i32 = 42;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::statics; fn main() -> i32 { return statics::PUBLIC; }", &mut arena);

    // Resolve should succeed: static is public.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);

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

        // Test function access.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod child; pub fn parentFn() -> i32 { return 42; }", &mut arena);
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod child; export fn parentFn() -> i32 { return 42; }", &mut arena);
        let childId = try registerModule(&mut MODULE_GRAPH, rootId, "child", "fn main() -> i32 { return super::parentFn(); }", &mut arena);
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

        // Test type access.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod child; pub record Point { x: i32, y: i32 }", &mut arena);
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod child; export record Point { x: i32, y: i32 }", &mut arena);
        let childId = try registerModule(&mut MODULE_GRAPH, rootId, "child", "fn make() -> super::Point { return super::Point { x: 1, y: 2 }; }", &mut arena);
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    }
}

/// Test nested super access to union variants (e.g. `super::E::A`).
@test fn testResolveSuperUnionVariant() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod c; pub union E { A, B }", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod c; export union E { A, B }", &mut arena);
    let childId = try registerModule(&mut MODULE_GRAPH, rootId, "c",
        "fn f(x: super::E) { match x { case super::E::A => {}, case super::E::B => {} } }",
        &mut arena);
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);

@test fn testResolveUseSuper() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    // Register root with a function, and a child module that uses super to access it.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod joe; pub mod kate;", &mut arena);
    let kateId = try registerModule(&mut MODULE_GRAPH, rootId, "kate", "pub fn run() {}", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod joe; export mod kate;", &mut arena);
    let kateId = try registerModule(&mut MODULE_GRAPH, rootId, "kate", "export fn run() {}", &mut arena);
    let joeId = try registerModule(&mut MODULE_GRAPH, rootId, "joe", "use super::kate; fn main() { kate::run(); }", &mut arena);

    // Resolve should succeed - super allows accessing parent module.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);

/// Test transitive re-export.
@test fn testWildcardReexportTransitive() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod a; pub mod b;", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod a; export mod b;", &mut arena);
    let aId = try registerModule(&mut MODULE_GRAPH, rootId, "a", "use root::b; fn main() -> i32 { return b::helper() + b::MAX; }", &mut arena);
    let bId = try registerModule(&mut MODULE_GRAPH, rootId, "b", "mod c; pub use c::*;", &mut arena);
    let cId = try registerModule(&mut MODULE_GRAPH, bId, "c", "mod d; pub use d::*; pub fn helper() -> i32 { return 42; }", &mut arena);
    let dId = try registerModule(&mut MODULE_GRAPH, cId, "d", "pub const MAX: i32 = 100;", &mut arena);
    let bId = try registerModule(&mut MODULE_GRAPH, rootId, "b", "mod c; export use c::*;", &mut arena);
    let cId = try registerModule(&mut MODULE_GRAPH, bId, "c", "mod d; export use d::*; export fn helper() -> i32 { return 42; }", &mut arena);
    let dId = try registerModule(&mut MODULE_GRAPH, cId, "d", "export const MAX: i32 = 100;", &mut arena);

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

/// Test that wildcard import can access public symbols.
@test fn testWildcardImportPublicOnly() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "pub mod b; mod a;", &mut arena);
    let bId = try registerModule(&mut MODULE_GRAPH, rootId, "b", "pub fn public() -> i32 { return 1; } fn private() -> i32 { return 2; }", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod b; mod a;", &mut arena);
    let bId = try registerModule(&mut MODULE_GRAPH, rootId, "b", "export fn public() -> i32 { return 1; } fn private() -> i32 { return 2; }", &mut arena);
    let aId = try registerModule(&mut MODULE_GRAPH, rootId, "a", "use root::b::*; fn main() -> i32 { return public(); }", &mut arena);

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

/// Test that wildcard import cannot access private symbols.
@test fn testWildcardImportSkipsPrivate() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "pub mod b; mod a;", &mut arena);
    let bId = try registerModule(&mut MODULE_GRAPH, rootId, "b", "pub fn public() -> i32 { return 1; } fn private() -> i32 { return 2; }", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod b; mod a;", &mut arena);
    let bId = try registerModule(&mut MODULE_GRAPH, rootId, "b", "export fn public() -> i32 { return 1; } fn private() -> i32 { return 2; }", &mut arena);
    let aId = try registerModule(&mut MODULE_GRAPH, rootId, "a", "use root::b::*; fn main() -> i32 { return private(); }", &mut arena);

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

/// allowing record fields to use types from imported modules.
@test fn testRecordFieldUsesImportedType() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "pub mod types; mod scanner;", &mut arena);
    let typesId = try registerModule(&mut MODULE_GRAPH, rootId, "types", "pub record Pool { count: u32 }", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod types; mod scanner;", &mut arena);
    let typesId = try registerModule(&mut MODULE_GRAPH, rootId, "types", "export record Pool { count: u32 }", &mut arena);
    let scannerId = try registerModule(&mut MODULE_GRAPH, rootId, "scanner", "use root::types; record Scanner { pool: *types::Pool }", &mut arena);

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

/// enabling compile-time evaluation of array sizes using imported constants.
@test fn testImportedConstantInArraySize() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "pub mod consts; mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "pub const SIZE: u32 = 8;", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export const SIZE: u32 = 8;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; static BUFFER: [u8; consts::SIZE] = undefined;", &mut arena);

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

/// Cross-module trait: coerce to trait object and dispatch from a different module.
@test fn testResolveTraitCrossModuleCoercion() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "pub mod defs; mod app;", &mut arena);
    let defsId = try registerModule(&mut MODULE_GRAPH, rootId, "defs", "pub record Counter { value: i32 } pub trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { c.value = c.value + n; return c.value; } }", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod defs; mod app;", &mut arena);
    let defsId = try registerModule(&mut MODULE_GRAPH, rootId, "defs", "export record Counter { value: i32 } export trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { c.value = c.value + n; return c.value; } }", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::defs; fn test() -> i32 { let mut c = defs::Counter { value: 10 }; let a: *mut opaque defs::Adder = &mut c; return a.add(5); }", &mut arena);

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

/// Instance in a different module from trait and type.
@test fn testResolveInstanceCrossModule() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "pub mod defs; pub mod impls; mod app;", &mut arena);
    let defsId = try registerModule(&mut MODULE_GRAPH, rootId, "defs", "pub record Counter { value: i32 } pub trait Adder { fn (*mut Adder) add(n: i32) -> i32; }", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod defs; export mod impls; mod app;", &mut arena);
    let defsId = try registerModule(&mut MODULE_GRAPH, rootId, "defs", "export record Counter { value: i32 } export trait Adder { fn (*mut Adder) add(n: i32) -> i32; }", &mut arena);
    let implsId = try registerModule(&mut MODULE_GRAPH, rootId, "impls", "use root::defs; instance defs::Adder for defs::Counter { fn (c: *mut defs::Counter) add(n: i32) -> i32 { c.value = c.value + n; return c.value; } }", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::defs; fn test() -> i32 { let mut c = defs::Counter { value: 10 }; let a: *mut opaque defs::Adder = &mut c; return a.add(5); }", &mut arena);

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

/// a constant from another module via scope access.
@test fn testCrossModuleConstExpr() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "pub mod consts; mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "pub const BASE: i32 = 100;", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export const BASE: i32 = 100;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; const DERIVED: i32 = consts::BASE + 50;", &mut arena);

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

/// Test cross-module constant expression used as array size.
@test fn testCrossModuleConstExprArraySize() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "pub mod consts; mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "pub const WIDTH: u32 = 8; pub const HEIGHT: u32 = 4;", &mut arena);
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export const WIDTH: u32 = 8; export const HEIGHT: u32 = 4;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; const TOTAL: u32 = consts::WIDTH * consts::HEIGHT; static BUF: [u8; TOTAL] = undefined;", &mut arena);

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

lib/std/lang/scanner.rad +13 -14


/// Token kinds representing all lexical elements in Radiance.
///
/// This enum covers operators, keywords, literals, and structural
/// elements used by the parser to build the AST.
pub union TokenKind {
export union TokenKind {
    /// Special end of file token generated when the input is exhausted.
    Eof,
    /// Special invalid token.
    Invalid,



    // Module-related tokens.
    Mod, Use, Super,

    // Type or function attributes.
    Pub, Export, Static,
    Export, Static,

    // Trait-related tokens.
    Trait, Instance,

    // Type-related tokens.

    /// Corresponding token.
    tok: TokenKind,
}

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

    { name: "nil", tok: TokenKind::Nil },
    { name: "not", tok: TokenKind::Not },
    { name: "opaque", tok: TokenKind::Opaque },
    { name: "or", tok: TokenKind::Or },
    { name: "panic", tok: TokenKind::Panic },
    { name: "pub", tok: TokenKind::Pub },
    { name: "record", tok: TokenKind::Record },
    { name: "return", tok: TokenKind::Return },
    { name: "static", tok: TokenKind::Static },
    { name: "super", tok: TokenKind::Super },
    { name: "throw", tok: TokenKind::Throw },

    { name: "use", tok: TokenKind::Use },
    { name: "while", tok: TokenKind::While },
];

/// Describes where source code originated from.
pub union SourceLoc {
export union SourceLoc {
    /// Source loaded from a file at the given path.
    File(*[u8]),
    /// Source provided as an inline string (no file path).
    String,
}

/// Lexical scanner state for tokenizing Radiance source code.
///
/// Maintains position information and source buffer reference.
pub record Scanner {
export record Scanner {
    /// Origin of the source being scanned.
    sourceLoc: SourceLoc,
    /// Source buffer.
    source: *[u8],
    /// Offset of current token into buffer.


/// Individual token with kind, source text, and position.
///
/// Represents a single lexical element extracted from source,
/// including its original text and byte offset for error reporting.
pub record Token {
export record Token {
    /// Token kind.
    kind: TokenKind,
    /// Token source string.
    source: *[u8],
    /// Byte offset of `source` in input buffer.

}

/// Source code location with line/column information.
///
/// Used for error reporting and debugging.
pub record Location {
export record Location {
    /// Origin of the source.
    source: SourceLoc,
    /// Line number.
    line: u16,
    /// Column number.
    col: u16,
}

/// Create a new scanner object.
pub fn scanner(sourceLoc: SourceLoc, source: *[u8], pool: *mut strings::Pool) -> Scanner {
export fn scanner(sourceLoc: SourceLoc, source: *[u8], pool: *mut strings::Pool) -> Scanner {
    // Intern built-in functions and attributes.
    strings::intern(pool, "@sizeOf");
    strings::intern(pool, "@alignOf");
    strings::intern(pool, "@sliceOf");
    strings::intern(pool, "@default");


    return Scanner { sourceLoc, source, token: 0, cursor: 0, pool };
}

/// Check if we've reached the end of input.
pub fn isEof(s: *Scanner) -> bool {
export fn isEof(s: *Scanner) -> bool {
    return s.cursor >= s.source.len;
}

/// Get the current character, if any.
pub fn current(s: *Scanner) -> ?u8 {
export fn current(s: *Scanner) -> ?u8 {
    if isEof(s) {
        return nil;
    }
    return s.source[s.cursor];
}

fn tok(s: *Scanner, kind: TokenKind) -> Token {
    return Token { kind, source: &s.source[s.token..s.cursor], offset: s.token };
}

/// Create an invalid token with the given message.
pub fn invalid(offset: u32, message: *[u8]) -> Token {
export fn invalid(offset: u32, message: *[u8]) -> Token {
    return Token { kind: TokenKind::Invalid, source: message, offset };
}

/// Skip whitespace characters and line comments.
fn skipWhitespace(s: *mut Scanner) {

    }
    return tok(s, kind);
}

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

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

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

/// Get the source code location from a byte offset.
pub fn getLocation(sourceLoc: SourceLoc, source: *[u8], offset: u32) -> ?Location {
export fn getLocation(sourceLoc: SourceLoc, source: *[u8], offset: u32) -> ?Location {
    let mut l: u16 = 1;
    let mut c: u16 = 1;

    if offset >= source.len {
        return nil;

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


use std::io;
use std::lang::alloc;

/// Output target for S-expression printing.
pub union Output {
export union Output {
    /// Print to stdout.
    Stdout,
    /// Write to a buffer, tracking position.
    Buffer { buf: *mut [u8], pos: *mut u32 },
}

/// An S-expression element.
pub union Expr {
export union Expr {
    /// An empty expression.
    Null,
    /// A symbol/identifier.
    Sym(*[u8]),
    /// A quoted string literal.

    /// A block with a name, inline items, and child statements on separate lines.
    Block { name: *[u8], items: *[Expr], children: *[Expr] },
}

/// Allocate an array of Expr in the arena.
pub fn allocExprs(arena: *mut alloc::Arena, len: u32) -> *mut [Expr] throws (alloc::AllocError) {
export fn allocExprs(arena: *mut alloc::Arena, len: u32) -> *mut [Expr] throws (alloc::AllocError) {
    if len == 0 {
        throw alloc::AllocError::OutOfMemory;
    }
    let ptr = try alloc::allocSlice(arena, @sizeOf(Expr), @alignOf(Expr), len);
    return ptr as *mut [Expr];
}

/// Allocate and copy items into the arena.
pub fn allocItems(a: *mut alloc::Arena, items: *[Expr]) -> *[Expr] {
export fn allocItems(a: *mut alloc::Arena, items: *[Expr]) -> *[Expr] {
    if items.len == 0 {
        return &[];
    }
    let buf = try! allocExprs(a, items.len);
    for item, i in items {

    }
    return buf;
}

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

/// Shorthand for creating a string literal.
pub fn str(s: *[u8]) -> Expr {
export fn str(s: *[u8]) -> Expr {
    return Expr::Str(s);
}

/// Shorthand for creating a list.
pub fn list(a: *mut alloc::Arena, head: *[u8], tail: *[Expr]) -> Expr {
export fn list(a: *mut alloc::Arena, head: *[u8], tail: *[Expr]) -> Expr {
    return Expr::List { head, tail: allocItems(a, tail), multiline: false };
}

/// Shorthand for creating a bracket-delimited vector.
pub fn vec(a: *mut alloc::Arena, items: *[Expr]) -> Expr {
export fn vec(a: *mut alloc::Arena, items: *[Expr]) -> Expr {
    return Expr::Vec { items: allocItems(a, items) };
}

/// Shorthand for creating a block with inline items and child expressions.
pub fn block(a: *mut alloc::Arena, name: *[u8], items: *[Expr], children: *[Expr]) -> Expr {
export fn block(a: *mut alloc::Arena, name: *[u8], items: *[Expr], children: *[Expr]) -> Expr {
    return Expr::Block { name, items: allocItems(a, items), children: allocItems(a, children) };
}

/// Write a string to the output target.
pub fn write(out: *mut Output, s: *[u8]) {
export fn write(out: *mut Output, s: *[u8]) {
    match *out {
        case Output::Stdout => io::print(s),
        case Output::Buffer { buf, pos } => {
            let remaining = buf.len - *pos;
            let toWrite = remaining if s.len > remaining else s.len;

        write(out, "  ");
    }
}

/// Print a single character with escaping to the output target.
pub fn printEscapedTo(out: *mut Output, c: u8) {
export fn printEscapedTo(out: *mut Output, c: u8) {
    match c {
        case '\n' => write(out, "\\n"),
        case '\r' => write(out, "\\r"),
        case '\t' => write(out, "\\t"),
        case '\\' => write(out, "\\\\"),

        else => write(out, &[c]),
    }
}

/// Print a quoted string with escape sequences to the output target.
pub fn printStringTo(out: *mut Output, s: *[u8]) {
export fn printStringTo(out: *mut Output, s: *[u8]) {
    write(out, "\"");
    for i in 0..s.len {
        printEscapedTo(out, s[i]);
    }
    write(out, "\"");
}

/// Print a character literal with escape sequences to the output target.
pub fn printCharTo(out: *mut Output, c: u8) {
export fn printCharTo(out: *mut Output, c: u8) {
    write(out, "'");
    printEscapedTo(out, c);
    write(out, "'");
}

/// Print an S-expression to the given output target at the given depth.
pub fn printTo(expr: Expr, depth: u32, out: *mut Output) {
export fn printTo(expr: Expr, depth: u32, out: *mut Output) {
    match expr {
        case Expr::Null => {},
        case Expr::Sym(s) => write(out, s),
        case Expr::Str(s) => printStringTo(out, s),
        case Expr::Char(c) => printCharTo(out, c),

        }
    }
}

/// Print an S-expression to stdout at the given indentation depth.
pub fn print(expr: Expr, depth: u32) {
export fn print(expr: Expr, depth: u32) {
    let mut out = Output::Stdout;
    printTo(expr, depth, &mut out);
}

/// Emit indentation for `depth` levels to stdout.
pub fn indent(depth: u32) {
export fn indent(depth: u32) {
    let mut out = Output::Stdout;
    indentTo(&mut out, depth);
}


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


/// String interning pool using open-addressed hash table.
///
/// Each unique string content is stored only once, allowing pointer equality
/// to be used instead of content comparison for symbol lookups and module names.
pub record Pool {
export record Pool {
    /// Hash table slots.
    table: [*[u8]; TABLE_SIZE],
    /// Number of strings currently in the pool.
    count: u32,
}

    }
}

/// Look up a string in the pool.
/// Returns the canonical interned pointer if the string exists.
pub fn find(sp: *Pool, str: *[u8]) -> ?*[u8] {
export fn find(sp: *Pool, str: *[u8]) -> ?*[u8] {
    match lookup(sp, str) {
        case Lookup::Found(entry) => return entry,
        case Lookup::Empty(_) => return nil,
    }
}

/// Intern a string, returning a canonical pointer for equality comparison.
///
/// If the string content already exists in the pool, returns the existing pointer.
/// Otherwise, adds the string pointer to the pool and returns it.
pub fn intern(sp: *mut Pool, str: *[u8]) -> *[u8] {
export fn intern(sp: *mut Pool, str: *[u8]) -> *[u8] {
    match lookup(sp, str) {
        case Lookup::Found(entry) => return entry,
        case Lookup::Empty(idx) => {
            assert sp.count < TABLE_SIZE / 2, "intern: string pool is full";
            sp.table[idx] = str;

lib/std/mem.rad +7 -7

    /// Buffer is too small.
    BufferTooSmall,
}

/// Copy bytes between two slices. Returns the number of bytes copied.
pub fn copy(into: *mut [u8], from: *[u8]) -> u32 throws (MemoryError) {
export fn copy(into: *mut [u8], from: *[u8]) -> u32 throws (MemoryError) {
    if into.len < from.len {
        throw MemoryError::BufferTooSmall;
    }
    for x, i in from {
        into[i] = x;

    return from.len;
}

/// Strip a byte-level prefix from the input, and return the suffix.
/// Returns `nil` if the prefix wasn't found.
pub fn stripPrefix(prefix: *[u8], input: *[u8]) -> ?*[u8] {
export fn stripPrefix(prefix: *[u8], input: *[u8]) -> ?*[u8] {
    if prefix.len == 0 {
        return input;
    }
    if prefix.len > input.len {
        return nil;

    }
    return &input[prefix.len..];
}

/// Align value up to alignment boundary.
pub fn alignUp(value: u32, alignment: u32) -> u32 {
export fn alignUp(value: u32, alignment: u32) -> u32 {
    return (value + alignment - 1) & ~(alignment - 1);
}

/// Align signed value up to alignment boundary.
pub fn alignUpI32(value: i32, alignment: i32) -> i32 {
export fn alignUpI32(value: i32, alignment: i32) -> i32 {
    return (value + alignment - 1) & ~(alignment - 1);
}

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

/// Check whether two byte slices have the same length and contents.
pub fn eq(a: *[u8], b: *[u8]) -> bool {
export fn eq(a: *[u8], b: *[u8]) -> bool {
    if a.len != b.len {
        return false;
    }
    for i in 0..a.len {
        if a[i] != b[i] {

}

/// Compare two byte slices lexicographically.
///
/// Returns `-1` when `a < b`, `1` when `a > b`, and `0` when equal.
pub fn cmp(a: *[u8], b: *[u8]) -> i32 {
export fn cmp(a: *[u8], b: *[u8]) -> i32 {
    let aLen = a.len;
    let bLen = b.len;

    let common = bLen if bLen < aLen else aLen;
    for i in 0..common {

lib/std/sys.rad +2 -2

//! System utilities.
pub mod unix;
export mod unix;

/// Process environment passed to the program entry point.
pub record Env {
export record Env {
    /// Command-line arguments.
    args: *[*[u8]],
}

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

//! Unix-specific system calls and utilities.
use std::intrinsics;

/// File access modes.
pub record OpenFlags(i64);
export record OpenFlags(i64);

/// Open file for reading only.
pub const O_RDONLY: OpenFlags = OpenFlags(0);
export const O_RDONLY: OpenFlags = OpenFlags(0);

/// Open file for writing only.
pub const O_WRONLY: OpenFlags = OpenFlags(1);
export const O_WRONLY: OpenFlags = OpenFlags(1);

/// Open file for reading and writing.
pub const O_RDWR: OpenFlags = OpenFlags(2);
export const O_RDWR: OpenFlags = OpenFlags(2);

/// Create file if it doesn't exist.
pub const O_CREAT: OpenFlags = OpenFlags(64);
export const O_CREAT: OpenFlags = OpenFlags(64);

/// Truncate file to zero length.
pub const O_TRUNC: OpenFlags = OpenFlags(512);
export const O_TRUNC: OpenFlags = OpenFlags(512);

/// Standard file descriptor for stdin.
pub const STDIN: i64 = 0;
export const STDIN: i64 = 0;

/// Standard file descriptor for stdout.
pub const STDOUT: i64 = 1;
export const STDOUT: i64 = 1;

/// Standard file descriptor for stderr.
pub const STDERR: i64 = 2;
export const STDERR: i64 = 2;

/// Special value representing current working directory for `openat()`.
const AT_FDCWD: i64 = -100;

/// Opens a file at the given path and returns a file descriptor.
/// Returns a negative value on error.
pub fn open(path: *[u8], flags: OpenFlags) -> i64 {
export fn open(path: *[u8], flags: OpenFlags) -> i64 {
    return intrinsics::ecall(56, AT_FDCWD, path.ptr as i64, *flags, 0);
}

/// Opens a file at the given path with mode, returns a file descriptor.
pub fn openOpts(path: *[u8], flags: OpenFlags, mode: i64) -> i64 {
export fn openOpts(path: *[u8], flags: OpenFlags, mode: i64) -> i64 {
    return intrinsics::ecall(56, AT_FDCWD, path.ptr as i64, *flags, mode);
}

/// Reads from a file descriptor into the provided buffer.
/// Returns the number of bytes read, or a negative value on error.
pub fn read(fd: i64, buf: *mut [u8]) -> i64 {
export fn read(fd: i64, buf: *mut [u8]) -> i64 {
    return intrinsics::ecall(63, fd, buf.ptr as i64, buf.len as i64, 0);
}

/// Reads from a file descriptor until EOF or buffer is full.
/// Returns the total number of bytes read, or a negative value on error.
pub fn readToEnd(fd: i64, buf: *mut [u8]) -> i64 {
export fn readToEnd(fd: i64, buf: *mut [u8]) -> i64 {
    let mut total: u32 = 0;
    while total < buf.len {
        let chunk = &mut buf[total..];
        let n = read(fd, chunk);


    return total as i64;
}

/// Writes to a file descriptor from the provided buffer.
/// Returns the number of bytes written, or a negative value on error.
pub fn write(fd: i64, buf: *[u8]) -> i64 {
export fn write(fd: i64, buf: *[u8]) -> i64 {
    return intrinsics::ecall(64, fd, buf.ptr as i64, buf.len as i64, 0);
}

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

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

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

/// Exit the current process with the given status code.
pub fn exit(status: i64) {
export fn exit(status: i64) {
    intrinsics::ecall(93, status, 0, 0, 0);
}

/// Writes the entire contents of a buffer to a file at the given path.
/// Creates the file if it doesn't exist, truncates if it does.
/// Returns `true` on success.
pub fn writeFile(path: *[u8], data: *[u8]) -> bool {
export fn writeFile(path: *[u8], data: *[u8]) -> bool {
    let flags = OpenFlags(*O_WRONLY | *O_CREAT | *O_TRUNC);
    let fd = openOpts(path, flags, 420); // 0644 in octal.
    if fd < 0 {
        return false;
    }

lib/std/testing.rad +7 -7

    passed: u32,
    failed: u32,
}

/// Error thrown when a test assertion fails.
pub union TestError {
export union TestError {
    Failed,
}

/// Descriptor for a single test case, holding its module path, name, and entry point.
pub record TestInfo {
export record TestInfo {
    module: *[u8],
    name: *[u8],
    func: fn() throws (TestError),
}

/// Construct a [`TestInfo`]. Used by the compiler's synthetic test harness.
pub fn test(module: *[u8], name: *[u8], func: fn() throws (TestError)) -> TestInfo {
export fn test(module: *[u8], name: *[u8], func: fn() throws (TestError)) -> TestInfo {
    return TestInfo { module, name, func };
}

/// Run all tests and return `0` on success or `1` if any test failed.
pub fn runAllTests(tests: *[TestInfo]) -> i32 {
export fn runAllTests(tests: *[TestInfo]) -> i32 {
    let mut ctx: Ctx = Ctx { passed: 0, failed: 0 };

    io::print("Running ");
    io::printU32(tests.len);
    io::print(" test(s)...\n\n");

        io::printLn(" passed; 0 failed");
    }
}

/// Assert that two byte slices are equal.
pub fn expectBytesEq(left: *[u8], right: *[u8])
export fn expectBytesEq(left: *[u8], right: *[u8])
    throws (TestError)
{
    try expect(mem::eq(left, right));
}

/// Assert that a boolean condition is true.
pub fn expect(cond: bool)
export fn expect(cond: bool)
    throws (TestError)
{
    if not cond {
        throw TestError::Failed;
    }
}

/// Assert that a boolean condition is false.
pub fn expectNot(cond: bool)
export fn expectNot(cond: bool)
    throws (TestError)
{
    if cond {
        throw TestError::Failed;
    }

lib/std/vec.rad +9 -9

//! to the element type's requirements.

/// Raw vector metadata structure.
///
/// Does not own storage, points to user-provided arena.
pub record RawVec {
export record RawVec {
    /// Pointer to user-provided byte arena.
    data: *mut [u8],
    /// Current number of elements stored.
    len: u32,
    /// Size of each element in bytes (stride between elements).

/// Create a new raw vector with external arena.
///
/// * `arena` is a pointer to static array backing storage.
/// * `stride` is the size of each element.
/// * `alignment` is the required alignment for elements.
pub fn new(arena: *mut [u8], stride: u32, alignment: u32) -> RawVec {
export fn new(arena: *mut [u8], stride: u32, alignment: u32) -> RawVec {
    assert stride > 0;
    assert alignment > 0;
    assert (arena.ptr as u32) % alignment == 0;
    assert (arena.len % stride) == 0;

    return RawVec { data: arena, len: 0, stride, alignment };
}

/// Get the current number of elements in the vector.
pub fn len(vec: *RawVec) -> u32 {
export fn len(vec: *RawVec) -> u32 {
    return vec.len;
}

/// Get the maximum capacity of the vector.
pub fn capacity(vec: *RawVec) -> u32 {
export fn capacity(vec: *RawVec) -> u32 {
    return vec.data.len / vec.stride;
}

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

/// Get a pointer to the element at the given index.
///
/// Returns nil if index is out of bounds.
pub fn get(vec: *RawVec, index: u32) -> ?*opaque {
export fn get(vec: *RawVec, index: u32) -> ?*opaque {
    if index >= vec.len {
        return nil;
    }
    let offset: u32 = index * vec.stride;
    let ptr: *u8 = &vec.data[offset];

}

/// Push an element onto the end of the vector.
///
/// Returns false if the vector is at capacity.
pub fn push(vec: *mut RawVec, elem: *opaque) -> bool {
export fn push(vec: *mut RawVec, elem: *opaque) -> bool {
    if vec.len >= capacity(vec) {
        return false;
    }
    let off: u32 = vec.len * vec.stride;
    let dst: *mut u8 = &mut vec.data[off];


/// Pop an element from the end of the vector.
///
/// Copies the element into the provided output pointer.
/// Returns false if the vector is empty.
pub fn pop(vec: *mut RawVec, out: *mut opaque) -> bool {
export fn pop(vec: *mut RawVec, out: *mut opaque) -> bool {
    if vec.len == 0 {
        return false;
    }
    vec.len -= 1;


}

/// Set the element at the given index.
///
/// Returns false if index is out of bounds.
pub fn set(vec: *mut RawVec, index: u32, elem: *opaque) -> bool {
export fn set(vec: *mut RawVec, index: u32, elem: *opaque) -> bool {
    if index >= vec.len {
        return false;
    }
    let off: u32 = index * vec.stride;
    let dst: *mut u8 = &mut vec.data[off];

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

//! returns: 0
//! Test scanner peek with optional return.

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

fn peek(s: *Scanner) -> ?u8 {
    if 0 + 0 >= s.source.len {

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

//! returns: 97
//! Test scanner current character access.

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

fn isEof(s: *Scanner) -> bool {
    return s.cursor >= s.source.len;
}

pub fn current(s: *Scanner) -> ?u8 {
export fn current(s: *Scanner) -> ?u8 {
    if isEof(s) {
        return nil;
    }
    return s.source[s.cursor];
}

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

//! returns: 0

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

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

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


record Foo {
    x: i32,
}

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

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

test/tests/union.bitfield.rad +7 -7

//! returns: 42

union Attribute {
    None = 0b0,
    Pub = 0b10,
    Export = 0b10,
    Default = 0b100,
    Extern = 0b1000,
    Test = 0b10000,
}

fn hasFlag(bits: i32, flag: i32) -> bool {
    return (bits & flag) == flag;
}

fn testCombineDefaults() -> bool {
    let combined: i32 = (Attribute::Pub as i32) | (Attribute::Default as i32);
    let combined: i32 = (Attribute::Export as i32) | (Attribute::Default as i32);

    return hasFlag(combined, Attribute::Pub as i32) and
    return hasFlag(combined, Attribute::Export as i32) and
           hasFlag(combined, Attribute::Default as i32) and
           not hasFlag(combined, Attribute::Extern as i32);
}

fn testToggleExternFlag() -> bool {
    let initial: i32 = (Attribute::Pub as i32) | (Attribute::Extern as i32);
    let initial: i32 = (Attribute::Export as i32) | (Attribute::Extern as i32);
    let toggled: i32 = initial ^ (Attribute::Extern as i32);

    return hasFlag(toggled, Attribute::Pub as i32)
    return hasFlag(toggled, Attribute::Export as i32)
        and not hasFlag(toggled, Attribute::Extern as i32);
}

fn testMaskTestFlag() -> bool {
    let mask: i32 = (Attribute::Pub as i32) | (Attribute::Test as i32);
    let mask: i32 = (Attribute::Export as i32) | (Attribute::Test as i32);
    let cleared: i32 = mask & (~(Attribute::Test as i32));

    return hasFlag(cleared, Attribute::Pub as i32)
    return hasFlag(cleared, Attribute::Export as i32)
        and not hasFlag(cleared, Attribute::Test as i32);
}

@default fn main() -> i32 {
    if testCombineDefaults()

141	141		///////////////////////
142	142		// Codegen Constants //
143	143		///////////////////////
144	144
145	145		/// Base address where read-only data is loaded.
146		-	pub const RO_DATA_BASE: u32 = 0x10000;
	146	+	export const RO_DATA_BASE: u32 = 0x10000;
147	147
148	148		/// Base address where read-write data is loaded.
149		-	pub const RW_DATA_BASE: u32 = 0xFFFFF0;
	149	+	export const RW_DATA_BASE: u32 = 0xFFFFF0;
150	150
151	151		/// Storage buffers passed from driver for code generation.
152		-	pub record Storage {
	152	+	export record Storage {
153	153		/// Buffer for data symbols.
154	154		dataSyms: *mut [data::DataSym],
155	155		/// Hash table entries for data symbol lookup.
156	156		dataSymEntries: *mut [dict::Entry],
157	157		}
158	158
159	159		/// Result of code generation.
160		-	pub record Program {
	160	+	export record Program {
161	161		/// Slice of emitted code.
162	162		code: *[u32],
163	163		/// Slice of function addresses (name + start index).
164	164		funcs: *[types::FuncAddr],
165	165		/// Number of read-only data bytes emitted.

169	169		/// Debug entries mapping PCs to source locations. Empty when debug is off.
170	170		debugEntries: *[types::DebugEntry],
171	171		}
172	172
173	173		/// Generate code for an IL program.
174		-	pub fn generate(
	174	+	export fn generate(
175	175		program: *il::Program,
176	176		storage: Storage,
177	177		roDataBuf: *mut [u8],
178	178		rwDataBuf: *mut [u8],
179	179		arena: *mut alloc::Arena,

101	101		/////////////////////////
102	102		// Decoded Instruction //
103	103		/////////////////////////
104	104
105	105		/// Decoded RV64 instruction.
106		-	pub union Instr {
	106	+	export union Instr {
107	107		// R-type ALU.
108	108		Add { rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg },
109	109		Sub { rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg },
110	110		Sll { rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg },
111	111		Slt { rd: gen::Reg, rs1: gen::Reg, rs2: gen::Reg },

193	193		// Unknown/invalid instruction.
194	194		Unknown { bits: u32 },
195	195		}
196	196
197	197		/// Decode a 32-bit instruction word into an [`Instr`].
198		-	pub fn decode(instr: u32) -> Instr {
	198	+	export fn decode(instr: u32) -> Instr {
199	199		let op = opcode(instr);
200	200		let f3 = funct3(instr);
201	201		let f7 = funct7(instr);
202	202		let rd = super::reg(rd(instr));
203	203		let rs1 = super::reg(rs1(instr));

111	111		/// Number of debug entries recorded.
112	112		debugEntriesLen: u32,
113	113		}
114	114
115	115		/// Computed stack frame layout for a function.
116		-	pub record Frame {
	116	+	export record Frame {
117	117		/// Total frame size in bytes (aligned).
118	118		totalSize: i32,
119	119		/// Callee-saved registers and their offsets.
120	120		// TODO: Use constant length when language supports it.
121	121		savedRegs: [SavedReg; super::NUM_SAVED_REGISTERS],

1	1		//! The Radiance Standard Library.
2	2
3		-	pub mod io;
4		-	pub mod collections;
5		-	pub mod lang;
6		-	pub mod sys;
7		-	pub mod arch;
8		-	pub mod fmt;
9		-	pub mod mem;
10		-	pub mod vec;
11		-	pub mod intrinsics;
	3	+	export mod io;
	4	+	export mod collections;
	5	+	export mod lang;
	6	+	export mod sys;
	7	+	export mod arch;
	8	+	export mod fmt;
	9	+	export mod mem;
	10	+	export mod vec;
	11	+	export mod intrinsics;
12	12
13	13		// Test modules.
14		-	@test pub mod testing;
15		-	@test pub mod tests;
	14	+	@test export mod testing;
	15	+	@test export mod tests;

8	8		//! * decode: Instruction decoding (for disassembly/printing)
9	9		//! * emit: Binary emission context and branch patching
10	10		//! * isel: Instruction selection (IL to RV64 instructions)
11	11		//! * printer: Assembly text output
12	12
13		-	pub mod encode;
14		-	pub mod decode;
15		-	pub mod emit;
16		-	pub mod isel;
17		-	pub mod printer;
	13	+	export mod encode;
	14	+	export mod decode;
	15	+	export mod emit;
	16	+	export mod isel;
	17	+	export mod printer;
18	18
19	19		@test mod tests;
20	20
21	21		use std::mem;
22	22		use std::collections::dict;

30	30
31	31		////////////////
32	32		// Registers //
33	33		////////////////
34	34
35		-	pub const ZERO: gen::Reg = gen::Reg(0); /// Hard-wired zero.
36		-	pub const RA: gen::Reg = gen::Reg(1); /// Return address.
37		-	pub const SP: gen::Reg = gen::Reg(2); /// Stack pointer.
38		-	pub const GP: gen::Reg = gen::Reg(3); /// Global pointer.
39		-	pub const TP: gen::Reg = gen::Reg(4); /// Thread pointer.
40		-	pub const T0: gen::Reg = gen::Reg(5); /// Temporary/alternate link register.
41		-	pub const T1: gen::Reg = gen::Reg(6); /// Temporary.
42		-	pub const T2: gen::Reg = gen::Reg(7); /// Temporary.
43		-	pub const S0: gen::Reg = gen::Reg(8); /// Saved register/frame pointer.
44		-	pub const FP: gen::Reg = gen::Reg(8); /// Frame pointer (alias for S0).
45		-	pub const S1: gen::Reg = gen::Reg(9); /// Saved register.
46		-	pub const A0: gen::Reg = gen::Reg(10); /// Function argument/return.
47		-	pub const A1: gen::Reg = gen::Reg(11); /// Function argument/return.
48		-	pub const A2: gen::Reg = gen::Reg(12); /// Function argument.
49		-	pub const A3: gen::Reg = gen::Reg(13); /// Function argument.
50		-	pub const A4: gen::Reg = gen::Reg(14); /// Function argument.
51		-	pub const A5: gen::Reg = gen::Reg(15); /// Function argument.
52		-	pub const A6: gen::Reg = gen::Reg(16); /// Function argument.
53		-	pub const A7: gen::Reg = gen::Reg(17); /// Function argument.
54		-	pub const S2: gen::Reg = gen::Reg(18); /// Saved register.
55		-	pub const S3: gen::Reg = gen::Reg(19); /// Saved register.
56		-	pub const S4: gen::Reg = gen::Reg(20); /// Saved register.
57		-	pub const S5: gen::Reg = gen::Reg(21); /// Saved register.
58		-	pub const S6: gen::Reg = gen::Reg(22); /// Saved register.
59		-	pub const S7: gen::Reg = gen::Reg(23); /// Saved register.
60		-	pub const S8: gen::Reg = gen::Reg(24); /// Saved register.
61		-	pub const S9: gen::Reg = gen::Reg(25); /// Saved register.
62		-	pub const S10: gen::Reg = gen::Reg(26); /// Saved register.
63		-	pub const S11: gen::Reg = gen::Reg(27); /// Saved register.
64		-	pub const T3: gen::Reg = gen::Reg(28); /// Temporary.
65		-	pub const T4: gen::Reg = gen::Reg(29); /// Temporary.
66		-	pub const T5: gen::Reg = gen::Reg(30); /// Temporary.
67		-	pub const T6: gen::Reg = gen::Reg(31); /// Temporary.
	35	+	export const ZERO: gen::Reg = gen::Reg(0); /// Hard-wired zero.
	36	+	export const RA: gen::Reg = gen::Reg(1); /// Return address.
	37	+	export const SP: gen::Reg = gen::Reg(2); /// Stack pointer.
	38	+	export const GP: gen::Reg = gen::Reg(3); /// Global pointer.
	39	+	export const TP: gen::Reg = gen::Reg(4); /// Thread pointer.
	40	+	export const T0: gen::Reg = gen::Reg(5); /// Temporary/alternate link register.
	41	+	export const T1: gen::Reg = gen::Reg(6); /// Temporary.
	42	+	export const T2: gen::Reg = gen::Reg(7); /// Temporary.
	43	+	export const S0: gen::Reg = gen::Reg(8); /// Saved register/frame pointer.
	44	+	export const FP: gen::Reg = gen::Reg(8); /// Frame pointer (alias for S0).
	45	+	export const S1: gen::Reg = gen::Reg(9); /// Saved register.
	46	+	export const A0: gen::Reg = gen::Reg(10); /// Function argument/return.
	47	+	export const A1: gen::Reg = gen::Reg(11); /// Function argument/return.
	48	+	export const A2: gen::Reg = gen::Reg(12); /// Function argument.
	49	+	export const A3: gen::Reg = gen::Reg(13); /// Function argument.
	50	+	export const A4: gen::Reg = gen::Reg(14); /// Function argument.
	51	+	export const A5: gen::Reg = gen::Reg(15); /// Function argument.
	52	+	export const A6: gen::Reg = gen::Reg(16); /// Function argument.
	53	+	export const A7: gen::Reg = gen::Reg(17); /// Function argument.
	54	+	export const S2: gen::Reg = gen::Reg(18); /// Saved register.
	55	+	export const S3: gen::Reg = gen::Reg(19); /// Saved register.
	56	+	export const S4: gen::Reg = gen::Reg(20); /// Saved register.
	57	+	export const S5: gen::Reg = gen::Reg(21); /// Saved register.
	58	+	export const S6: gen::Reg = gen::Reg(22); /// Saved register.
	59	+	export const S7: gen::Reg = gen::Reg(23); /// Saved register.
	60	+	export const S8: gen::Reg = gen::Reg(24); /// Saved register.
	61	+	export const S9: gen::Reg = gen::Reg(25); /// Saved register.
	62	+	export const S10: gen::Reg = gen::Reg(26); /// Saved register.
	63	+	export const S11: gen::Reg = gen::Reg(27); /// Saved register.
	64	+	export const T3: gen::Reg = gen::Reg(28); /// Temporary.
	65	+	export const T4: gen::Reg = gen::Reg(29); /// Temporary.
	66	+	export const T5: gen::Reg = gen::Reg(30); /// Temporary.
	67	+	export const T6: gen::Reg = gen::Reg(31); /// Temporary.
68	68
69	69		/// Create a register from a number. Panics if `n > 31`.
70		-	pub fn reg(n: u8) -> gen::Reg {
	70	+	export fn reg(n: u8) -> gen::Reg {
71	71		assert n < 32;
72	72		return gen::Reg(n);
73	73		}
74	74
75	75		////////////////////////////
76	76		// Architecture constants //
77	77		////////////////////////////
78	78
79	79		/// Total number of general-purpose registers.
80		-	pub const NUM_REGISTERS: u8 = 32;
	80	+	export const NUM_REGISTERS: u8 = 32;
81	81		/// Number of saved registers.
82		-	pub const NUM_SAVED_REGISTERS: u8 = 11;
	82	+	export const NUM_SAVED_REGISTERS: u8 = 11;
83	83		/// Word size in bytes (32-bit).
84		-	pub const WORD_SIZE: i32 = 4;
	84	+	export const WORD_SIZE: i32 = 4;
85	85		/// Doubleword size in bytes (64-bit).
86		-	pub const DWORD_SIZE: i32 = 8;
	86	+	export const DWORD_SIZE: i32 = 8;
87	87		/// Instruction size in bytes.
88		-	pub const INSTR_SIZE: i32 = 4;
	88	+	export const INSTR_SIZE: i32 = 4;
89	89		/// Stack alignment requirement in bytes.
90		-	pub const STACK_ALIGNMENT: i32 = 16;
	90	+	export const STACK_ALIGNMENT: i32 = 16;
91	91
92	92		/// Minimum blit size (in bytes) to use a loop instead of inline copy.
93	93		/// Blits below this threshold are fully unrolled as LD/SD pairs.
94		-	pub const BLIT_LOOP_THRESHOLD: i32 = 256;
	94	+	export const BLIT_LOOP_THRESHOLD: i32 = 256;
95	95
96	96		/////////////////////////
97	97		// Codegen Allocation //
98	98		/////////////////////////
99	99
100	100		/// Argument registers for function calls.
101		-	pub const ARG_REGS: [gen::Reg; 8] = [A0, A1, A2, A3, A4, A5, A6, A7];
	101	+	export const ARG_REGS: [gen::Reg; 8] = [A0, A1, A2, A3, A4, A5, A6, A7];
102	102
103	103		/// Scratch register for code gen. Never allocated to user values.
104		-	pub const SCRATCH1: gen::Reg = T5;
	104	+	export const SCRATCH1: gen::Reg = T5;
105	105
106	106		/// Second scratch register for operations needing two temporaries.
107		-	pub const SCRATCH2: gen::Reg = T6;
	107	+	export const SCRATCH2: gen::Reg = T6;
108	108
109	109		/// Dedicated scratch for address offset adjustment. Never allocated to user
110	110		/// values and never used for operand materialization, so it can never
111	111		/// conflict with `rd`, `rs`, or `base` in load/store helpers.
112		-	pub const ADDR_SCRATCH: gen::Reg = T4;
	112	+	export const ADDR_SCRATCH: gen::Reg = T4;
113	113
114	114		/// Callee-saved registers that need save/restore if used.
115		-	pub const CALLEE_SAVED: [gen::Reg; NUM_SAVED_REGISTERS] = [S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11];
	115	+	export const CALLEE_SAVED: [gen::Reg; NUM_SAVED_REGISTERS] = [S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11];
116	116
117	117		/// Maximum 12-bit signed immediate value.
118		-	pub const MAX_IMM: i32 = 2047;
	118	+	export const MAX_IMM: i32 = 2047;
119	119
120	120		/// Minimum 12-bit signed immediate value.
121		-	pub const MIN_IMM: i32 = -2048;
	121	+	export const MIN_IMM: i32 = -2048;
122	122
123	123		/// Allocatable registers for register allocation.
124	124		const ALLOCATABLE_REGS: [gen::Reg; 23] = [
125	125		T0, T1, T2, T3, // Temporaries
126	126		A0, A1, A2, A3, A4, A5, A6, A7, // Arguments
127	127		S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, // Saved
128	128		];
129	129
130	130		/// Get target configuration for register allocation.
131	131		// TODO: This should be a constant variable.
132		-	pub fn targetConfig() -> regalloc::TargetConfig {
	132	+	export fn targetConfig() -> regalloc::TargetConfig {
133	133		return regalloc::TargetConfig {
134	134		allocatable: &ALLOCATABLE_REGS[..],
135	135		argRegs: &ARG_REGS[..],
136	136		calleeSaved: &CALLEE_SAVED[..],
137	137		slotSize: DWORD_SIZE,

8	8		///////////////////////
9	9		// Field Extraction //
10	10		///////////////////////
11	11
12	12		/// Extract opcode (bits 6:0).
13		-	pub fn opcode(instr: u32) -> u32 {
	13	+	export fn opcode(instr: u32) -> u32 {
14	14		return instr & 0x7F;
15	15		}
16	16
17	17		/// Extract rd (bits 11:7).
18		-	pub fn rd(instr: u32) -> u8 {
	18	+	export fn rd(instr: u32) -> u8 {
19	19		return ((instr >> 7) & 0x1F) as u8;
20	20		}
21	21
22	22		/// Extract funct3 (bits 14:12).
23		-	pub fn funct3(instr: u32) -> u32 {
	23	+	export fn funct3(instr: u32) -> u32 {
24	24		return (instr >> 12) & 0x07;
25	25		}
26	26
27	27		/// Extract rs1 (bits 19:15).
28		-	pub fn rs1(instr: u32) -> u8 {
	28	+	export fn rs1(instr: u32) -> u8 {
29	29		return ((instr >> 15) & 0x1F) as u8;
30	30		}
31	31
32	32		/// Extract rs2 (bits 24:20).
33		-	pub fn rs2(instr: u32) -> u8 {
	33	+	export fn rs2(instr: u32) -> u8 {
34	34		return ((instr >> 20) & 0x1F) as u8;
35	35		}
36	36
37	37		/// Extract funct7 (bits 31:25).
38		-	pub fn funct7(instr: u32) -> u32 {
	38	+	export fn funct7(instr: u32) -> u32 {
39	39		return instr >> 25;
40	40		}
41	41
42	42		//////////////////////////
43	43		// Immediate Extraction //
44	44		//////////////////////////
45	45
46	46		/// Extract I-type immediate (sign-extended).
47		-	pub fn immI(instr: u32) -> i32 {
	47	+	export fn immI(instr: u32) -> i32 {
48	48		let imm = instr >> 20;
49	49		if (imm & 0x800) != 0 {
50	50		return (imm \| 0xFFFFF000) as i32;
51	51		}
52	52		return imm as i32;
53	53		}
54	54
55	55		/// Extract S-type immediate (sign-extended).
56		-	pub fn immS(instr: u32) -> i32 {
	56	+	export fn immS(instr: u32) -> i32 {
57	57		let lo = (instr >> 7) & 0x1F;
58	58		let hi = (instr >> 25) & 0x7F;
59	59		let imm = (hi << 5) \| lo;
60	60		if (imm & 0x800) != 0 {
61	61		return (imm \| 0xFFFFF000) as i32;
62	62		}
63	63		return imm as i32;
64	64		}
65	65
66	66		/// Extract B-type immediate (sign-extended).
67		-	pub fn immB(instr: u32) -> i32 {
	67	+	export fn immB(instr: u32) -> i32 {
68	68		let imm11 = (instr >> 7) & 0x1;
69	69		let imm4_1 = (instr >> 8) & 0xF;
70	70		let imm10_5 = (instr >> 25) & 0x3F;
71	71		let imm12 = (instr >> 31) & 0x1;
72	72		let imm = (imm12 << 12) \| (imm11 << 11) \| (imm10_5 << 5) \| (imm4_1 << 1);

75	75		}
76	76		return imm as i32;
77	77		}
78	78
79	79		/// Extract J-type immediate (sign-extended).
80		-	pub fn immJ(instr: u32) -> i32 {
	80	+	export fn immJ(instr: u32) -> i32 {
81	81		let imm19_12 = (instr >> 12) & 0xFF;
82	82		let imm11 = (instr >> 20) & 0x1;
83	83		let imm10_1 = (instr >> 21) & 0x3FF;
84	84		let imm20 = (instr >> 31) & 0x1;
85	85		let imm = (imm20 << 20) \| (imm19_12 << 12) \| (imm11 << 11) \| (imm10_1 << 1);

88	88		}
89	89		return imm as i32;
90	90		}
91	91
92	92		/// Extract U-type immediate (upper 20 bits, sign-extended).
93		-	pub fn immU(instr: u32) -> i32 {
	93	+	export fn immU(instr: u32) -> i32 {
94	94		let imm = instr >> 12;
95	95		if (imm & 0x80000) != 0 {
96	96		return (imm \| 0xFFF00000) as i32;
97	97		}
98	98		return imm as i32;

26	26		//////////////////////
27	27		// Emission Context //
28	28		//////////////////////
29	29
30	30		/// Branch/jump that needs offset patching after all blocks are emitted.
31		-	pub record PendingBranch {
	31	+	export record PendingBranch {
32	32		/// Index into code buffer where the branch instruction is.
33	33		index: u32,
34	34		/// Target block index.
35	35		target: u32,
36	36		/// Type of branch for re-encoding.
37	37		kind: BranchKind,
38	38		}
39	39
40	40		/// Type of branch instruction.
41		-	pub union BranchKind {
	41	+	export union BranchKind {
42	42		/// Conditional branch (B-type encoding).
43	43		Cond { op: il::CmpOp, rs1: gen::Reg, rs2: gen::Reg },
44	44		/// Inverted conditional branch (B-type encoding with negated condition).
45	45		InvertedCond { op: il::CmpOp, rs1: gen::Reg, rs2: gen::Reg },
46	46		/// Unconditional jump (J-type encoding).
47	47		Jump,
48	48		}
49	49
50	50		/// Function call that needs offset patching.
51		-	pub record PendingCall {
	51	+	export record PendingCall {
52	52		/// Index in code buffer where the call was emitted.
53	53		index: u32,
54	54		/// Target function name.
55	55		target: *[u8],
56	56		}
57	57
58	58		/// Function address load that needs offset patching.
59	59		/// Used when taking a function's address as a value.
60		-	pub record PendingAddrLoad {
	60	+	export record PendingAddrLoad {
61	61		/// Index in code buffer where the load was emitted.
62	62		index: u32,
63	63		/// Target function name.
64	64		target: *[u8],
65	65		/// Destination register.
66	66		rd: gen::Reg,
67	67		}
68	68
69	69		/// Adjusted base register and offset for addressing.
70		-	pub record AdjustedOffset {
	70	+	export record AdjustedOffset {
71	71		/// Base register.
72	72		base: gen::Reg,
73	73		/// Byte offset from register.
74	74		offset: i32,
75	75		}
76	76
77	77		/// Callee-saved register with its stack offset.
78		-	pub record SavedReg {
	78	+	export record SavedReg {
79	79		/// Register to save/restore.
80	80		reg: gen::Reg,
81	81		/// Offset from SP.
82	82		offset: i32,
83	83		}
84	84
85	85		/// Emission context. Tracks state during code generation.
86		-	pub record Emitter {
	86	+	export record Emitter {
87	87		/// Emitted instructions storage.
88	88		code: *mut [u32],
89	89		/// Current number of emitted instructions.
90	90		codeLen: u32,
91	91		/// Local branches needing offset patching.

130	130		/// When false, SP never changes after the prologue.
131	131		isDynamic: bool,
132	132		}
133	133
134	134		/// Compute frame layout from local size and used callee-saved registers.
135		-	pub fn computeFrame(localSize: i32, usedCalleeSaved: u32, epilogueBlock: u32, isLeaf: bool, isDynamic: bool) -> Frame {
	135	+	export fn computeFrame(localSize: i32, usedCalleeSaved: u32, epilogueBlock: u32, isLeaf: bool, isDynamic: bool) -> Frame {
136	136		let mut frame = Frame {
137	137		totalSize: 0,
138	138		savedRegs: undefined,
139	139		savedRegsLen: 0,
140	140		epilogueBlock,

170	170		}
171	171		return frame;
172	172		}
173	173
174	174		/// Create a new emitter.
175		-	pub fn emitter(arena: *mut alloc::Arena, debug: bool) -> Emitter throws (alloc::AllocError) {
	175	+	export fn emitter(arena: *mut alloc::Arena, debug: bool) -> Emitter throws (alloc::AllocError) {
176	176		let code = try alloc::allocSlice(arena, @sizeOf(u32), @alignOf(u32), MAX_INSTRS);
177	177		let pendingBranches = try alloc::allocSlice(arena, @sizeOf(PendingBranch), @alignOf(PendingBranch), MAX_PENDING);
178	178		let pendingCalls = try alloc::allocSlice(arena, @sizeOf(PendingCall), @alignOf(PendingCall), MAX_PENDING);
179	179		let pendingAddrLoads = try alloc::allocSlice(arena, @sizeOf(PendingAddrLoad), @alignOf(PendingAddrLoad), MAX_PENDING);
180	180		let blockOffsets = try alloc::allocSlice(arena, @sizeOf(i32), @alignOf(i32), labels::MAX_BLOCKS_PER_FN);

207	207		///////////////////////
208	208		// Emission Helpers //
209	209		///////////////////////
210	210
211	211		/// Emit a single instruction.
212		-	pub fn emit(e: *mut Emitter, instr: u32) {
	212	+	export fn emit(e: *mut Emitter, instr: u32) {
213	213		assert e.codeLen < e.code.len, "emit: code buffer full";
214	214		e.code[e.codeLen] = instr;
215	215		e.codeLen += 1;
216	216		}
217	217
218	218		/// Compute branch offset to a function by name.
219		-	pub fn branchOffsetToFunc(e: Emitter, srcIndex: u32, name: [u8]) -> i32 {
	219	+	export fn branchOffsetToFunc(e: Emitter, srcIndex: u32, name: [u8]) -> i32 {
220	220		return labels::branchToFunc(&e.labels, srcIndex, name, super::INSTR_SIZE);
221	221		}
222	222
223	223		/// Patch an instruction at a given index.
224		-	pub fn patch(e: *mut Emitter, index: u32, instr: u32) {
	224	+	export fn patch(e: *mut Emitter, index: u32, instr: u32) {
225	225		e.code[index] = instr;
226	226		}
227	227
228	228		/// Record a block's address for branch resolution.
229		-	pub fn recordBlock(e: *mut Emitter, blockIdx: u32) {
	229	+	export fn recordBlock(e: *mut Emitter, blockIdx: u32) {
230	230		assert e.codeLen <= MAX_CODE_LEN;
231	231		labels::recordBlock(&mut e.labels, blockIdx, e.codeLen as i32 * super::INSTR_SIZE);
232	232		}
233	233
234	234		/// Record a function's code offset for call resolution.
235		-	pub fn recordFuncOffset(e: mut Emitter, name: [u8]) {
	235	+	export fn recordFuncOffset(e: mut Emitter, name: [u8]) {
236	236		assert e.codeLen <= MAX_CODE_LEN;
237	237		dict::insert(&mut e.labels.funcs, name, e.codeLen as i32 * super::INSTR_SIZE);
238	238		}
239	239
240	240		/// Record a function's start position for printing.
241		-	pub fn recordFunc(e: mut Emitter, name: [u8]) {
	241	+	export fn recordFunc(e: mut Emitter, name: [u8]) {
242	242		assert e.funcsLen < e.funcs.len, "recordFunc: funcs buffer full";
243	243		e.funcs[e.funcsLen] = types::FuncAddr { name, index: e.codeLen };
244	244		e.funcsLen += 1;
245	245		}
246	246
247	247		/// Record a local branch needing later patching.
248	248		/// Unconditional jumps use a single slot (J-type, +-1MB range).
249	249		/// Conditional branches use two slots (B-type has only +-4KB range,
250	250		/// so large functions may need the inverted-branch + JAL fallback).
251		-	pub fn recordBranch(e: *mut Emitter, targetBlock: u32, kind: BranchKind) {
	251	+	export fn recordBranch(e: *mut Emitter, targetBlock: u32, kind: BranchKind) {
252	252		assert e.pendingBranchesLen < e.pendingBranches.len, "recordBranch: buffer full";
253	253		e.pendingBranches[e.pendingBranchesLen] = PendingBranch {
254	254		index: e.codeLen,
255	255		target: targetBlock,
256	256		kind: kind,

673	673		};
674	674		e.debugEntriesLen += 1;
675	675		}
676	676
677	677		/// Get debug entries as a slice.
678		-	pub fn getDebugEntries(e: Emitter) -> [types::DebugEntry] {
	678	+	export fn getDebugEntries(e: Emitter) -> [types::DebugEntry] {
679	679		return &e.debugEntries[..e.debugEntriesLen];
680	680		}

302	302		}
303	303		return ReserveInfo { size: offset, isDynamic };
304	304		}
305	305
306	306		/// Select instructions for a function.
307		-	pub fn selectFn(
	307	+	export fn selectFn(
308	308		e: *mut emit::Emitter,
309	309		dataSymMap: *data::DataSymMap,
310	310		ralloc: *regalloc::AllocResult,
311	311		func: *il::Fn
312	312		) {

266	266		}
267	267
268	268		/// Record a function call needing later patching.
269	269		/// Emits placeholder instructions that will be patched later.
270	270		/// Uses two slots to support long-distance calls.
271		-	pub fn recordCall(e: mut Emitter, target: [u8]) {
	271	+	export fn recordCall(e: mut Emitter, target: [u8]) {
272	272		assert e.pendingCallsLen < e.pendingCalls.len, "recordCall: buffer full";
273	273		e.pendingCalls[e.pendingCallsLen] = PendingCall {
274	274		index: e.codeLen,
275	275		target,
276	276		};

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

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

357	357		}
358	358		}
359	359
360	360		/// Patch all pending function calls.
361	361		/// Called after all functions have been generated.
362		-	pub fn patchCalls(e: *mut Emitter) {
	362	+	export fn patchCalls(e: *mut Emitter) {
363	363		for i in 0..e.pendingCallsLen {
364	364		let p = e.pendingCalls[i];
365	365		let offset = branchOffsetToFunc(e, p.index, p.target);
366	366		let s = splitImm(offset);
367	367

373	373		}
374	374
375	375		/// Patch all pending function address loads.
376	376		/// Called after all functions have been generated.
377	377		/// Uses PC-relative addresses up to 2GB away.
378		-	pub fn patchAddrLoads(e: *mut Emitter) {
	378	+	export fn patchAddrLoads(e: *mut Emitter) {
379	379		for i in 0..e.pendingAddrLoadsLen {
380	380		let p = e.pendingAddrLoads[i];
381	381		let offset = branchOffsetToFunc(e, p.index, p.target);
382	382		let s = splitImm(offset);
383	383

391	391		/////////////////////////
392	392		// Immediate Handling //
393	393		/////////////////////////
394	394
395	395		/// Split immediate into `hi` and `lo` bits.
396		-	pub record SplitImm {
	396	+	export record SplitImm {
397	397		/// Upper 20 bits.
398	398		hi: i32,
399	399		/// Lower 12 bits.
400	400		lo: i32,
401	401		}
402	402
403	403		/// Split a 32-bit immediate for `AUIPC, ADDI` / `JALR` sequences.
404	404		/// Handles sign extension: if lo is negative, increment hi.
405		-	pub fn splitImm(imm: i32) -> SplitImm {
	405	+	export fn splitImm(imm: i32) -> SplitImm {
406	406		let lo = imm & 0xFFF;
407	407		let mut hi = (imm >> 12) & 0xFFFFF;
408	408		// If `lo`'s sign bit is set, it will be sign-extended to negative.
409	409		// Compensate by incrementing `hi`.
410	410		if (lo & 0x800) != 0 {

433	433		/// Load an immediate value into a register.
434	434		/// Handles the full range of 64-bit immediates.
435	435		/// For values fitting in 12 bits, uses a single `ADDI`.
436	436		/// For values fitting in 32 bits, uses `LUI` + `ADDIW`.
437	437		/// For wider values, loads upper and lower halves then combines with shift and add.
438		-	pub fn loadImm(e: *mut Emitter, rd: gen::Reg, imm: i64) {
	438	+	export fn loadImm(e: *mut Emitter, rd: gen::Reg, imm: i64) {
439	439		let immMin = super::MIN_IMM as i64;
440	440		let immMax = super::MAX_IMM as i64;
441	441
442	442		if imm >= immMin and imm <= immMax {
443	443		emit(e, encode::addi(rd, super::ZERO, imm as i32));

472	472		emit(e, encode::slli(rd, rd, 10));
473	473		emit(e, encode::addi(rd, rd, lower & 0x3FF));
474	474		}
475	475
476	476		/// Emit add-immediate, handling large immediates.
477		-	pub fn emitAddImm(e: *mut Emitter, rd: gen::Reg, rs: gen::Reg, imm: i32) {
	477	+	export fn emitAddImm(e: *mut Emitter, rd: gen::Reg, rs: gen::Reg, imm: i32) {
478	478		if imm >= super::MIN_IMM and imm <= super::MAX_IMM {
479	479		emit(e, encode::addi(rd, rs, imm));
480	480		} else {
481	481		loadImm(e, super::SCRATCH1, imm as i64);
482	482		emit(e, encode::add(rd, rs, super::SCRATCH1));

486	486		////////////////////////
487	487		// Load/Store Helpers //
488	488		////////////////////////
489	489
490	490		/// Emit unsigned load with automatic offset adjustment.
491		-	pub fn emitLoad(e: *mut Emitter, rd: gen::Reg, base: gen::Reg, offset: i32, typ: il::Type) {
	491	+	export fn emitLoad(e: *mut Emitter, rd: gen::Reg, base: gen::Reg, offset: i32, typ: il::Type) {
492	492		let adj = adjustOffset(e, base, offset);
493	493		match typ {
494	494		case il::Type::W8 => emit(e, encode::lbu(rd, adj.base, adj.offset)),
495	495		case il::Type::W16 => emit(e, encode::lhu(rd, adj.base, adj.offset)),
496	496		case il::Type::W32 => emit(e, encode::lwu(rd, adj.base, adj.offset)),
497	497		case il::Type::W64 => emit(e, encode::ld(rd, adj.base, adj.offset)),
498	498		}
499	499		}
500	500
501	501		/// Emit signed load with automatic offset adjustment.
502		-	pub fn emitSload(e: *mut Emitter, rd: gen::Reg, base: gen::Reg, offset: i32, typ: il::Type) {
	502	+	export fn emitSload(e: *mut Emitter, rd: gen::Reg, base: gen::Reg, offset: i32, typ: il::Type) {
503	503		let adj = adjustOffset(e, base, offset);
504	504		match typ {
505	505		case il::Type::W8 => emit(e, encode::lb(rd, adj.base, adj.offset)),
506	506		case il::Type::W16 => emit(e, encode::lh(rd, adj.base, adj.offset)),
507	507		case il::Type::W32 => emit(e, encode::lw(rd, adj.base, adj.offset)),
508	508		case il::Type::W64 => emit(e, encode::ld(rd, adj.base, adj.offset)),
509	509		}
510	510		}
511	511
512	512		/// Emit store with automatic offset adjustment.
513		-	pub fn emitStore(e: *mut Emitter, rs: gen::Reg, base: gen::Reg, offset: i32, typ: il::Type) {
	513	+	export fn emitStore(e: *mut Emitter, rs: gen::Reg, base: gen::Reg, offset: i32, typ: il::Type) {
514	514		let adj = adjustOffset(e, base, offset);
515	515		match typ {
516	516		case il::Type::W8 => emit(e, encode::sb(rs, adj.base, adj.offset)),
517	517		case il::Type::W16 => emit(e, encode::sh(rs, adj.base, adj.offset)),
518	518		case il::Type::W32 => emit(e, encode::sw(rs, adj.base, adj.offset)),
519	519		case il::Type::W64 => emit(e, encode::sd(rs, adj.base, adj.offset)),
520	520		}
521	521		}
522	522
523	523		/// Emit 64-bit load with automatic offset adjustment.
524		-	pub fn emitLd(e: *mut Emitter, rd: gen::Reg, base: gen::Reg, offset: i32) {
	524	+	export fn emitLd(e: *mut Emitter, rd: gen::Reg, base: gen::Reg, offset: i32) {
525	525		let adj = adjustOffset(e, base, offset);
526	526		emit(e, encode::ld(rd, adj.base, adj.offset));
527	527		}
528	528
529	529		/// Emit 64-bit store with automatic offset adjustment.
530		-	pub fn emitSd(e: *mut Emitter, rs: gen::Reg, base: gen::Reg, offset: i32) {
	530	+	export fn emitSd(e: *mut Emitter, rs: gen::Reg, base: gen::Reg, offset: i32) {
531	531		let adj = adjustOffset(e, base, offset);
532	532		emit(e, encode::sd(rs, adj.base, adj.offset));
533	533		}
534	534
535	535		/// Emit 32-bit load with automatic offset adjustment.
536		-	pub fn emitLw(e: *mut Emitter, rd: gen::Reg, base: gen::Reg, offset: i32) {
	536	+	export fn emitLw(e: *mut Emitter, rd: gen::Reg, base: gen::Reg, offset: i32) {
537	537		let adj = adjustOffset(e, base, offset);
538	538		emit(e, encode::lw(rd, adj.base, adj.offset));
539	539		}
540	540
541	541		/// Emit 32-bit store with automatic offset adjustment.
542		-	pub fn emitSw(e: *mut Emitter, rs: gen::Reg, base: gen::Reg, offset: i32) {
	542	+	export fn emitSw(e: *mut Emitter, rs: gen::Reg, base: gen::Reg, offset: i32) {
543	543		let adj = adjustOffset(e, base, offset);
544	544		emit(e, encode::sw(rs, adj.base, adj.offset));
545	545		}
546	546
547	547		/// Emit 8-bit load with automatic offset adjustment.
548		-	pub fn emitLb(e: *mut Emitter, rd: gen::Reg, base: gen::Reg, offset: i32) {
	548	+	export fn emitLb(e: *mut Emitter, rd: gen::Reg, base: gen::Reg, offset: i32) {
549	549		let adj = adjustOffset(e, base, offset);
550	550		emit(e, encode::lb(rd, adj.base, adj.offset));
551	551		}
552	552
553	553		/// Emit 8-bit store with automatic offset adjustment.
554		-	pub fn emitSb(e: *mut Emitter, rs: gen::Reg, base: gen::Reg, offset: i32) {
	554	+	export fn emitSb(e: *mut Emitter, rs: gen::Reg, base: gen::Reg, offset: i32) {
555	555		let adj = adjustOffset(e, base, offset);
556	556		emit(e, encode::sb(rs, adj.base, adj.offset));
557	557		}
558	558
559	559		//////////////////////////
560	560		// Prologue / Epilogue //
561	561		//////////////////////////
562	562
563	563		/// Emit function prologue.
564	564		/// Allocates stack frame, saves RA/FP, saves callee-saved registers.
565		-	pub fn emitPrologue(e: mut Emitter, frame: Frame) {
	565	+	export fn emitPrologue(e: mut Emitter, frame: Frame) {
566	566		// Fast path: leaf function with no locals.
567	567		if frame.totalSize == 0 {
568	568		return;
569	569		}
570	570		let totalSize = frame.totalSize;

594	594		emitSd(e, sr.reg, super::SP, sr.offset);
595	595		}
596	596		}
597	597
598	598		/// Emit a return: jump to epilogue, or emit `ret` directly for leaf functions.
599		-	pub fn emitReturn(e: mut Emitter, frame: Frame) {
	599	+	export fn emitReturn(e: mut Emitter, frame: Frame) {
600	600		if frame.totalSize == 0 {
601	601		// Leaf function: no frame to tear down, emit ret directly.
602	602		emit(e, encode::ret());
603	603		return;
604	604		}
605	605		recordBranch(e, frame.epilogueBlock, BranchKind::Jump);
606	606		}
607	607
608	608		/// Emit function epilogue.
609	609		/// Restores callee-saved registers, `RA/FP`, deallocates frame, returns.
610		-	pub fn emitEpilogue(e: mut Emitter, frame: Frame) {
	610	+	export fn emitEpilogue(e: mut Emitter, frame: Frame) {
611	611		// Record epilogue block address for return jumps.
612	612		recordBlock(e, frame.epilogueBlock);
613	613
614	614		// Fast path: leaf function with no locals.
615	615		if frame.totalSize == 0 {

642	642		//////////////////
643	643		// Code Access //
644	644		//////////////////
645	645
646	646		/// Get emitted code as a slice.
647		-	pub fn getCode(e: Emitter) -> [u32] {
	647	+	export fn getCode(e: Emitter) -> [u32] {
648	648		return &e.code[..e.codeLen];
649	649		}
650	650
651	651		/// Get function addresses for printing.
652		-	pub fn getFuncs(e: Emitter) -> [types::FuncAddr] {
	652	+	export fn getFuncs(e: Emitter) -> [types::FuncAddr] {
653	653		return &e.funcs[..e.funcsLen];
654	654		}
655	655
656	656		/// Record a debug entry mapping the current PC to a source location.
657	657		/// Deduplicates consecutive entries with the same location.
658		-	pub fn recordSrcLoc(e: *mut Emitter, loc: il::SrcLoc) {
	658	+	export fn recordSrcLoc(e: *mut Emitter, loc: il::SrcLoc) {
659	659		let pc = e.codeLen * super::INSTR_SIZE as u32;
660	660
661	661		// Skip if this is the same location as the previous entry.
662	662		if e.debugEntriesLen > 0 {
663	663		let prev = &e.debugEntries[e.debugEntriesLen - 1];

6	6
7	7		//////////////////////
8	8		// Opcode Constants //
9	9		//////////////////////
10	10
11		-	pub const OP_LOAD: u32 = 0x03;
12		-	pub const OP_STORE: u32 = 0x23;
13		-	pub const OP_BRANCH: u32 = 0x63;
14		-	pub const OP_JALR: u32 = 0x67;
15		-	pub const OP_JAL: u32 = 0x6F;
16		-	pub const OP_OP: u32 = 0x33;
17		-	pub const OP_IMM: u32 = 0x13;
18		-	pub const OP_AUIPC: u32 = 0x17;
19		-	pub const OP_LUI: u32 = 0x37;
20		-	pub const OP_SYSTEM: u32 = 0x73;
21		-	pub const OP_OP32: u32 = 0x3B; // RV64: 32-bit operations
22		-	pub const OP_IMM32: u32 = 0x1B; // RV64: 32-bit immediate operations
	11	+	export const OP_LOAD: u32 = 0x03;
	12	+	export const OP_STORE: u32 = 0x23;
	13	+	export const OP_BRANCH: u32 = 0x63;
	14	+	export const OP_JALR: u32 = 0x67;
	15	+	export const OP_JAL: u32 = 0x6F;
	16	+	export const OP_OP: u32 = 0x33;
	17	+	export const OP_IMM: u32 = 0x13;
	18	+	export const OP_AUIPC: u32 = 0x17;
	19	+	export const OP_LUI: u32 = 0x37;
	20	+	export const OP_SYSTEM: u32 = 0x73;
	21	+	export const OP_OP32: u32 = 0x3B; // RV64: 32-bit operations
	22	+	export const OP_IMM32: u32 = 0x1B; // RV64: 32-bit immediate operations
23	23
24	24		//////////////////////
25	25		// Funct3 Constants //
26	26		//////////////////////
27	27
28	28		// Memory operations
29	29
30		-	pub const F3_BYTE: u32 = 0x0; // LB/SB
31		-	pub const F3_HALF: u32 = 0x1; // LH/SH
32		-	pub const F3_WORD: u32 = 0x2; // LW/SW
33		-	pub const F3_DWORD: u32 = 0x3; // LD/SD (RV64)
34		-	pub const F3_BYTE_U: u32 = 0x4; // LBU
35		-	pub const F3_HALF_U: u32 = 0x5; // LHU
36		-	pub const F3_WORD_U: u32 = 0x6; // LWU (RV64)
	30	+	export const F3_BYTE: u32 = 0x0; // LB/SB
	31	+	export const F3_HALF: u32 = 0x1; // LH/SH
	32	+	export const F3_WORD: u32 = 0x2; // LW/SW
	33	+	export const F3_DWORD: u32 = 0x3; // LD/SD (RV64)
	34	+	export const F3_BYTE_U: u32 = 0x4; // LBU
	35	+	export const F3_HALF_U: u32 = 0x5; // LHU
	36	+	export const F3_WORD_U: u32 = 0x6; // LWU (RV64)
37	37
38	38		// ALU operations
39	39
40		-	pub const F3_ADD: u32 = 0x0; // ADD/SUB/ADDI
41		-	pub const F3_SLL: u32 = 0x1; // SLL/SLLI
42		-	pub const F3_SLT: u32 = 0x2; // SLT/SLTI
43		-	pub const F3_SLTU: u32 = 0x3; // SLTU/SLTIU
44		-	pub const F3_XOR: u32 = 0x4; // XOR/XORI
45		-	pub const F3_SRL: u32 = 0x5; // SRL/SRA/SRLI/SRAI
46		-	pub const F3_OR: u32 = 0x6; // OR/ORI
47		-	pub const F3_AND: u32 = 0x7; // AND/ANDI
	40	+	export const F3_ADD: u32 = 0x0; // ADD/SUB/ADDI
	41	+	export const F3_SLL: u32 = 0x1; // SLL/SLLI
	42	+	export const F3_SLT: u32 = 0x2; // SLT/SLTI
	43	+	export const F3_SLTU: u32 = 0x3; // SLTU/SLTIU
	44	+	export const F3_XOR: u32 = 0x4; // XOR/XORI
	45	+	export const F3_SRL: u32 = 0x5; // SRL/SRA/SRLI/SRAI
	46	+	export const F3_OR: u32 = 0x6; // OR/ORI
	47	+	export const F3_AND: u32 = 0x7; // AND/ANDI
48	48
49	49		// Branch operations
50	50
51		-	pub const F3_BEQ: u32 = 0x0;
52		-	pub const F3_BNE: u32 = 0x1;
53		-	pub const F3_BLT: u32 = 0x4;
54		-	pub const F3_BGE: u32 = 0x5;
55		-	pub const F3_BLTU: u32 = 0x6;
56		-	pub const F3_BGEU: u32 = 0x7;
	51	+	export const F3_BEQ: u32 = 0x0;
	52	+	export const F3_BNE: u32 = 0x1;
	53	+	export const F3_BLT: u32 = 0x4;
	54	+	export const F3_BGE: u32 = 0x5;
	55	+	export const F3_BLTU: u32 = 0x6;
	56	+	export const F3_BGEU: u32 = 0x7;
57	57
58	58		//////////////////////
59	59		// Funct7 Constants //
60	60		//////////////////////
61	61
62		-	pub const F7_NORMAL: u32 = 0b0000000;
63		-	pub const F7_SUB: u32 = 0b0100000; // Bit 5 set
64		-	pub const F7_SRA: u32 = 0b0100000; // Bit 5 set
65		-	pub const F7_MUL: u32 = 0b0000001; // Bit 0 set
	62	+	export const F7_NORMAL: u32 = 0b0000000;
	63	+	export const F7_SUB: u32 = 0b0100000; // Bit 5 set
	64	+	export const F7_SRA: u32 = 0b0100000; // Bit 5 set
	65	+	export const F7_MUL: u32 = 0b0000001; // Bit 0 set
66	66
67	67		/////////////////////////
68	68		// Validation Helpers //
69	69		/////////////////////////
70	70
71	71		/// Returns `true` if the value fits in a signed 12-bit immediate.
72		-	pub fn isSmallImm(value: i32) -> bool {
	72	+	export fn isSmallImm(value: i32) -> bool {
73	73		return value >= super::MIN_IMM and value <= super::MAX_IMM;
74	74		}
75	75
76	76		/// Returns `true` if a 64-bit value fits in a 12-bit signed immediate.
77		-	pub fn isSmallImm64(value: i64) -> bool {
	77	+	export fn isSmallImm64(value: i64) -> bool {
78	78		return value >= (super::MIN_IMM as i64) and value <= (super::MAX_IMM as i64);
79	79		}
80	80
81	81		/// Returns `true` if the value is valid for branch immediates.
82	82		/// Branch immediates are 13-bit signed, even aligned.
83		-	pub fn isBranchImm(value: i32) -> bool {
	83	+	export fn isBranchImm(value: i32) -> bool {
84	84		return value >= -(1 << 12) and value <= ((1 << 12) - 2) and (value & 1) == 0;
85	85		}
86	86
87	87		/// Returns `true` if the value is valid for jump immediates (JAL).
88	88		/// Jump immediates are 21-bit signed, even aligned.
89		-	pub fn isJumpImm(value: i32) -> bool {
	89	+	export fn isJumpImm(value: i32) -> bool {
90	90		return value >= -(1 << 20) and value <= ((1 << 20) - 2) and (value & 1) == 0;
91	91		}
92	92
93	93		//////////////////////
94	94		// Format Encoders //

71	71		union ShiftOp { Sll, Srl, Sra }
72	72		/// Compare operation.
73	73		union CmpOp { Slt, Ult }
74	74
75	75		/// Selector errors.
76		-	pub union SelectorError {
	76	+	export union SelectorError {
77	77		Internal,
78	78		}
79	79
80	80		/// A pending spill store to be flushed after instruction selection.
81	81		record PendingSpill {

88	88		////////////////////
89	89		// Selector State //
90	90		////////////////////
91	91
92	92		/// Instruction selector state.
93		-	pub record Selector {
	93	+	export record Selector {
94	94		/// Emitter for outputting instructions.
95	95		e: *mut emit::Emitter,
96	96		/// Register allocation result.
97	97		ralloc: *regalloc::AllocResult,
98	98		/// Hash-indexed data symbol map.

162	162		writeMnem(out, m);
163	163		writeDelim(out, &[regNameR(rs1), formatI32(a, imm)]);
164	164		}
165	165
166	166		/// Print a single instruction to output buffer.
167		-	pub fn printInstr(out: mut sexpr::Output, a: mut alloc::Arena, instr: u32) {
	167	+	export fn printInstr(out: mut sexpr::Output, a: mut alloc::Arena, instr: u32) {
168	168		let decoded = decode::decode(instr);
169	169
170	170		match decoded {
171	171		case decode::Instr::Lui { rd, imm } => fmtRI(out, a, "lui", rd, imm),
172	172		case decode::Instr::Auipc { rd, imm } => fmtRI(out, a, "auipc", rd, imm),

304	304		},
305	305		}
306	306		}
307	307
308	308		/// Print code with labels to the given output.
309		-	pub fn printCodeTo(out: mut sexpr::Output, pkgName: [u8], code: [u32], funcs: [types::FuncAddr], arena: *mut alloc::Arena) {
	309	+	export fn printCodeTo(out: mut sexpr::Output, pkgName: [u8], code: [u32], funcs: [types::FuncAddr], arena: *mut alloc::Arena) {
310	310		// Package header.
311	311		write(out, "# package `");
312	312		write(out, pkgName);
313	313		write(out, "`\n\n");
314	314

4	4		//! of two and is provided by the caller via arena-allocated storage.
5	5
6	6		use std::mem;
7	7
8	8		/// Hash map entry.
9		-	pub record Entry {
	9	+	export record Entry {
10	10		/// Key.
11	11		key: *[u8],
12	12		/// Associated value.
13	13		value: i32,
14	14		}
15	15
16	16		/// Open-addressed hash map with caller-provided storage.
17		-	pub record Dict {
	17	+	export record Dict {
18	18		/// Hash table entries.
19	19		entries: *mut [Entry],
20	20		/// Number of occupied entries.
21	21		count: u32,
22	22		}
23	23
24	24		/// Create a dict backed by the given entry storage.
25	25		/// The storage length must be a power of two.
26		-	pub fn init(entries: *mut [Entry]) -> Dict {
	26	+	export fn init(entries: *mut [Entry]) -> Dict {
27	27		for i in 0..entries.len {
28	28		entries[i] = Entry { key: &[], value: 0 };
29	29		}
30	30		return Dict { entries, count: 0 };
31	31		}
32	32
33	33		/// Insert or update a key-value pair. Panics if the table exceeds 50% load.
34		-	pub fn insert(m: mut Dict, key: [u8], value: i32) {
	34	+	export fn insert(m: mut Dict, key: [u8], value: i32) {
35	35		let mask = m.entries.len - 1;
36	36		let mut idx = hash(key) & mask;
37	37
38	38		loop {
39	39		let entry = m.entries[idx];

50	50		idx = (idx + 1) & mask;
51	51		}
52	52		}
53	53
54	54		/// Look up a value by key. Returns `nil` if not found.
55		-	pub fn get(m: Dict, key: [u8]) -> ?i32 {
	55	+	export fn get(m: Dict, key: [u8]) -> ?i32 {
56	56		let mask = m.entries.len - 1;
57	57		let mut idx = hash(key) & mask;
58	58
59	59		loop {
60	60		let entry = m.entries[idx];

67	67		idx = (idx + 1) & mask;
68	68		}
69	69		}
70	70
71	71		/// DJB2 hash function.
72		-	pub fn hash(str: *[u8]) -> u32 {
	72	+	export fn hash(str: *[u8]) -> u32 {
73	73		let mut h: u32 = 5381;
74	74		for b in str {
75	75		h = ((h << 5) + h) + b as u32;
76	76		}
77	77		return h;

1	1		//! Formatting utilities for converting values to strings.
2	2		use super::mem;
3	3
4	4		/// Maximum string length for a formatted u32 (eg. "4294967295").
5		-	pub const U32_STR_LEN: u32 = 10;
	5	+	export const U32_STR_LEN: u32 = 10;
6	6		/// Maximum string length for a formatted i32 (eg. "-2147483648").
7		-	pub const I32_STR_LEN: u32 = U32_STR_LEN + 1;
	7	+	export const I32_STR_LEN: u32 = U32_STR_LEN + 1;
8	8		/// Maximum string length for a formatted u64 (eg. "18446744073709551615").
9		-	pub const U64_STR_LEN: u32 = 20;
	9	+	export const U64_STR_LEN: u32 = 20;
10	10		/// Maximum string length for a formatted i64 (eg. "-9223372036854775808").
11		-	pub const I64_STR_LEN: u32 = 20;
	11	+	export const I64_STR_LEN: u32 = 20;
12	12		/// Maximum string length for a formatted bool (eg. "false").
13		-	pub const BOOL_STR_LEN: u32 = 5;
	13	+	export const BOOL_STR_LEN: u32 = 5;
14	14
15	15		/// Format a u32 by writing it to the provided buffer.
16		-	pub fn formatU32(val: u32, buffer: mut [u8]) -> [u8] {
	16	+	export fn formatU32(val: u32, buffer: mut [u8]) -> [u8] {
17	17		assert buffer.len >= U32_STR_LEN;
18	18
19	19		let mut x: u32 = val;
20	20		let mut i: u32 = buffer.len;
21	21