radiance · commit

compiler/radiance.rad +9 -9

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

/// Compiler error.
union Error {
union Error: Copy {
    Other,
}

/// What to dump during compilation.
union Dump {
union Dump: Copy {
    /// Don't dump anything.
    None,
    /// Dump the parsed AST before semantic analysis.
    Ast,
    /// Dump the module graph.

    /// Dump the generated assembly.
    Asm,
}

/// A discovered test function.
record TestDesc {
record TestDesc: Copy {
    /// Full module qualified path segments (eg. ["std", "tests"]).
    modPath: *[*[u8]],
    /// Test function name (eg. "testFoo").
    fnName: *[u8],
}

/// Source inputs belonging to one command-line package.
record PackageInput {
record PackageInput: Copy {
    /// Package name from the `-pkg` argument.
    name: *[u8],
    /// Optional startup assembly emitted before generated text.
    startupPath: ?*[u8],
    /// Radiance source paths for this package.

    /// Number of assembly source paths.
    asmPathCount: u32,
}

/// Compilation context.
record CompileContext {
record CompileContext: Copy {
    /// Array of packages to compile.
    packages: [package::Package; MAX_PACKAGES],
    /// Driver inputs for each package slot.
    inputs: [PackageInput; MAX_PACKAGES],
    /// Number of packages.

    /// Whether to emit debug info (.debug file).
    debug: bool,
}

/// Root module info for a package.
record RootModule {
record RootModule: Copy {
    entry: *module::ModuleEntry,
    ast: *mut ast::Node,
}

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

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

/// Options controlling streamed lowering and code generation.
record CodegenOptions {
record CodegenOptions: Copy {
    /// Optional output path used for progress logging.
    logPath: ?*[u8],
    /// Whether to emit debug source locations.
    debug: bool,
    /// How the generated program should handle entry.

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

export fn imageHeader(codeBytes: u32, roDataBytes: u32, rwDataBytes: u32) -> [u32; 5] {
    return [IMAGE_MAGIC, IMAGE_VERSION, codeBytes, roDataBytes, rwDataBytes];
}

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

/// Result of code generation.
export record Program {
export record Program: Copy {
    /// 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],
}

/// Entry jump patching requested for the generated program.
export union EntryPatch {
export union EntryPatch: Copy {
    /// No entry jump is emitted.
    None,
    /// Reserve code slot zero for a jump to the default function.
    Reserved(?*[u8]),
}

/// Options controlling incremental RV64 program generation.
export record ProgramOptions {
export record ProgramOptions: Copy {
    /// Entry jump patching mode.
    entryPatch: EntryPatch,
    /// Whether to emit debug source locations.
    debug: bool,
}

/// State for incremental RV64 program generation.
///
/// The generator owns global codegen state that must survive across function
/// emission. Function-local scratch stays outside this record so callers can
/// reclaim it after each function.
export record Generator {
export record Generator: Copy {
    /// Binary emitter and relocation state.
    e: emit::Emitter,
    /// Entry jump patching state.
    entryPatch: EntryPatch,
}

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

/// consumes the program, [`rv64::addAssembly`] appends the text words to the
/// generated text stream and registers text labels at their relocated offsets.
/// The driver copies `data` into the final read-only data prefix; the data
/// base supplied to [`assemble`] lets the assembler resolve data addresses as
/// they will appear in that final layout.
export record Program {
export record Program: Copy {
    /// Encoded instructions in the text section.
    text: *[u32],
    /// Raw bytes in the data section.
    data: *[u8],
    /// Symbols defined by the source.

    /// Text references resolved by the whole-program emitter.
    externalFixups: *[Fixup],
}

/// Errors reported while assembling source text.
export union Error {
export union Error: Copy {
    /// Invalid syntax or operand form at a source offset.
    Invalid { offset: u32, message: *[u8] },
    /// The source emitted more text words than the caller-provided buffer holds.
    TextOverflow,
    /// The source emitted more data bytes than the caller-provided buffer holds.
    DataOverflow,
}

/// Active output section.
export union Section {
export union Section: Copy {
    /// Instruction section.
    Text,
    /// Data byte section.
    Data,
}

/// Branch opcode that needs fixup.
export union BranchOp {
export union BranchOp: Copy {
    /// Branch if equal.
    Beq,
    /// Branch if not equal.
    Bne,
    /// Branch if less than, signed.

    /// Branch if greater than, signed pseudo-instruction.
    Bgt,
}

/// Parser and encoder behavior for one instruction mnemonic.
export union InstructionEncoder {
export union InstructionEncoder: Copy {
    /// No-operand instruction encoded by a fixed encoder.
    NoOperand { enc: fn() -> u32 },
    /// Load-immediate pseudo-instruction.
    Li,
    /// Load-address pseudo-instruction.

    /// Upper-immediate operand form.
    Upper { enc: fn(gen::Reg, i32) -> u32 },
}

/// Classified directive name.
export union DirectiveKind {
export union DirectiveKind: Copy {
    /// `.align` directive.
    Align,
    /// `.ascii` directive.
    Ascii,
    /// `.byte` directive.

    /// `.word` directive.
    Word,
}

/// Instruction descriptor table row.
record InstructionEntry {
record InstructionEntry: Copy {
    /// Assembly mnemonic text.
    name: *[u8],
    /// Operand parser and encoder behavior.
    encoder: InstructionEncoder,
}

/// Directive descriptor table row.
record DirectiveEntry {
record DirectiveEntry: Copy {
    /// Directive name without the leading `.`.
    name: *[u8],
    /// Parser behavior for the directive.
    kind: DirectiveKind,
}

/// Register descriptor table row.
record RegisterEntry {
record RegisterEntry: Copy {
    /// Register alias text without the leading `%`.
    name: *[u8],
    /// Numeric register selected by the alias.
    reg: gen::Reg,
}

/// CSR descriptor table row.
record CsrEntry {
record CsrEntry: Copy {
    /// CSR name text.
    name: *[u8],
    /// Numeric CSR address.
    csr: u32,
}

/// Width of an integer data directive.
export union DataWidth {
export union DataWidth: Copy {
    /// 32-bit data value.
    Word,
    /// 64-bit data value.
    Dword,
}

    { name: "mtval",    csr: 0x343 },
    { name: "mtvec",    csr: 0x305 },
];

/// Recorded symbol definition.
export record Symbol {
export record Symbol: Copy {
    /// Symbol name.
    name: *[u8],
    /// Section the symbol belongs to.
    section: Section,
    /// Byte offset within the section.

    /// Whether `.export` exported this symbol outside its assembly fragment.
    isExported: bool,
}

/// Information needed to resolve a pending symbol reference.
export union FixupInfo {
export union FixupInfo: Copy {
    /// Branch to a text label.
    Branch { op: BranchOp, rs1: gen::Reg, rs2: gen::Reg, index: u32 },
    /// JAL-like jump to a text label.
    Jal { rd: gen::Reg, index: u32 },
    /// Absolute address materialization into a register.

    /// A 64-bit data word referring to a symbol offset.
    Dword { offset: u32 },
}

/// Pending symbol reference.
export record Fixup {
export record Fixup: Copy {
    /// Referenced symbol.
    symbol: *[u8],
    /// Fixup payload.
    info: FixupInfo,
}

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

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


use super::emit;
use super::scanner;

/// Parsed memory operand with base register and signed byte offset.
record MemOperand {
record MemOperand: Copy {
    /// Base register inside the memory operand parentheses.
    base: gen::Reg,
    /// Signed byte offset preceding the base register.
    offset: i32,
}

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


use std::char;
use std::lang::strings;

/// Token kinds recognized by the assembler scanner.
export union TokenKind {
export union TokenKind: Copy {
    /// Special end-of-file token generated when the input is exhausted.
    Eof,
    /// Special invalid token carrying an error message in [`Token::source`].
    Invalid,


    /// Integer literal token.
    Number,
}

/// Describes where assembler source originated from.
export union SourceKind {
export union SourceKind: Copy {
    /// Source loaded from a file at the given path.
    File { path: *[u8] },
    /// Source provided as an inline string.
    String,
}

/// Lexical scanner state for assembler source.
export record Scanner {
export record Scanner: Copy {
    /// Origin of the source being scanned.
    sourceKind: SourceKind,
    /// Source buffer.
    source: *[u8],
    /// Offset of the current token in `source`.

    /// Intern pool for identifier-shaped token text.
    pool: *mut strings::Pool,
}

/// Individual token with kind, source text, and byte offset.
export record Token {
export record Token: Copy {
    /// Token kind.
    kind: TokenKind,
    /// Token source text.
    source: *[u8],
    /// Byte offset of `source` in the input buffer.

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

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

/// Decoded RV64 instruction.
export union Instr {
export union Instr: Copy {
    // 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 },

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

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

/// Branch/jump that needs offset patching after all blocks are emitted.
export record PendingBranch {
export record PendingBranch: Copy {
    /// 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.
export union BranchKind {
export union BranchKind: Copy {
    /// 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.
export record PendingCall {
export record PendingCall: Copy {
    /// Index in code buffer where the call was emitted.
    index: u32,
    /// Target function name.
    target: *[u8],
}

/// Assembly jump that needs offset patching after all text is emitted.
export record PendingJump {
export record PendingJump: Copy {
    /// Index in code buffer where the jump was emitted.
    index: u32,
    /// Target function name.
    target: *[u8],
    /// Destination register.
    rd: gen::Reg,
}

/// Address load that needs patching after layout is known.
export record PendingAddrLoad {
export record PendingAddrLoad: Copy {
    /// Index in code buffer where the load was emitted.
    index: u32,
    /// Target function or data symbol name.
    target: *[u8],
    /// Destination register.

    /// Whether this is an absolute data symbol address.
    isData: bool,
}

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

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

/// Emission context. Tracks state during code generation.
export record Emitter {
export record Emitter: Copy {
    /// Allocator for growing append-backed emitter lists.
    allocator: alloc::Allocator,
    /// Emitted instructions storage.
    code: *mut [u32],
    /// Current number of emitted instructions.

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

/// Computed stack frame layout for a function.
export record Frame {
export record Frame: Copy {
    /// 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],

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

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

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

constant U8_MAX: i64 = 255;
constant U16_MAX: i64 = 65535;
constant U32_MAX: i64 = 4294967295;

/// Binary operation.
union BinOp { Add, And, Or, Xor }
union BinOp: Copy { Add, And, Or, Xor }
/// Shift operation.
union ShiftOp { Sll, Srl, Sra }
union ShiftOp: Copy { Sll, Srl, Sra }
/// Compare operation.
union CmpOp { Slt, Ult }
union CmpOp: Copy { Slt, Ult }

/// A pending spill store to be flushed after instruction selection.
record PendingSpill {
record PendingSpill: Copy {
    /// The SSA register that was spilled.
    ssa: il::Reg,
    /// The physical register holding the value to store.
    rd: gen::Reg,
}

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

/// Instruction selector state.
export record Selector {
export record Selector: Copy {
    /// Emitter for outputting instructions.
    e: *mut emit::Emitter,
    /// Register allocation result.
    ralloc: *regalloc::AllocResult,
    /// Total stack frame size.

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

/// Pre-scan result for reserve analysis.
record ReserveInfo {
record ReserveInfo: Copy {
    /// Total size needed for constant-sized reserves.
    size: i32,
    /// Whether any dynamic-sized reserves exist.
    isDynamic: bool,
}

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

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

use std::mem;

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

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

lib/std/fmt.rad +3 -3

export constant I64_STR_LEN: u32 = 20;
/// Maximum string length for a formatted bool (eg. "false").
export constant BOOL_STR_LEN: u32 = 5;

/// Radix/base of a parsed integer literal.
export union Radix {
export union Radix: Copy {
    /// Binary literal (0b...).
    Binary,
    /// Decimal literal.
    Decimal,
    /// Hexadecimal literal (0x...).
    Hex,
}

/// Errors reported while parsing literal text.
export union ParseError {
export union ParseError: Copy {
    /// Literal text was empty or missing required digits.
    Invalid,
    /// Literal contained an invalid digit for its radix.
    InvalidDigit,
    /// Literal value exceeded the supported range.
    Overflow,
}

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

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

@test mod tests;

use std::mem;

/// Error thrown by allocator.
export union AllocError {
export union AllocError: Copy {
    /// 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`].
export record Arena {
export record Arena: Copy {
    /// Backing storage.
    data: *mut [u8],
    /// Current allocation offset in bytes.
    offset: u32,
}

/// 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.
export record Allocator {
export record Allocator: Copy {
    /// Allocation function. Returns a pointer to `size` bytes
    /// aligned to `alignment`, or panics on failure.
    func: fn(*mut opaque, u32, u32) -> *mut opaque,
    /// Opaque context pointer passed to `func`.
    ctx: *mut opaque,

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

export constant MAX_TRAIT_METHODS: u32 = 8;

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


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

/// Attribute bit set applied to declarations or fields.
export union Attribute {
export union Attribute: Copy {
    /// Public visibility attribute.
    Export = 0b1,
    /// Default implementation attribute.
    Default = 0b10,
    /// Extern linkage attribute.

    /// Declaration may perform unsafe pointer operations.
    Unsafe = 0b100000,
}

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

/// Check if an attributes list contains an attribute.
export fn attributesContains(self: *Attributes, attr: Attribute) -> bool {

export fn hasAttribute(attrs: u32, attr: Attribute) -> bool {
    return (attrs & (attr as u32)) <> 0;
}

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

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

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

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

/// Builtin function kind.
export union Builtin {
export union Builtin: Copy {
    /// 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.
export record Span {
export record Span: Copy {
    /// Byte offset from the start of the source file.
    offset: u32,
    /// Length of the node in bytes.
    length: u32,
}

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

        mutable: bool,
    },
}

/// Function signature.
export record FnSig {
export record FnSig: Copy {
    /// 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.
export record AddressOf {
export record AddressOf: Copy {
    /// Target expression being referenced.
    target: *Node,
    /// Indicates whether the reference is mutable.
    mutable: bool,
}

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

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

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

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

/// While loop with an optional alternate branch.
export record While {
export record While: Copy {
    /// 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.
export record WhileLet {
export record WhileLet: Copy {
    /// 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.
export record Try {
export record Try: Copy {
    /// 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.
export record CatchClause {
export record CatchClause: Copy {
    /// 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.
export record For {
export record For: Copy {
    /// 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.
export record If {
export record If: Copy {
    /// 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>`).
export record CondExpr {
export record CondExpr: Copy {
    /// 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).
export union PatternKind {
export union PatternKind: Copy {
    /// Case pattern match.
    Case,
    /// Binding pattern match.
    Binding,
}

/// Prong arm.
export union ProngArm {
export union ProngArm: Copy {
    /// 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`.
export record PatternMatch {
export record PatternMatch: Copy {
    /// 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.
export record IfLet {
export record IfLet: Copy {
    /// 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.
export record LetElse {
export record LetElse: Copy {
    /// Pattern matching structure.
    pattern: PatternMatch,
    /// Else branch executed if match fails (must diverge).
    elseBranch: *Node,
}

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

/// `match` prong metadata.
export record MatchProng {
export record MatchProng: Copy {
    /// 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.
export record Let {
export record Let: Copy {
    /// Identifier bound by the declaration.
    ident: *Node,
    /// Declared type annotation.
    type: ?*Node,
    /// Initializer expression.

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

/// Constant declaration.
export record ConstDecl {
export record ConstDecl: Copy {
    /// 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.
export record StaticDecl {
export record StaticDecl: Copy {
    /// 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.
export record FnParam {
export record FnParam: Copy {
    /// Parameter identifier.
    name: *Node,
    /// Parameter type annotation.
    type: *Node,
}

/// Record literal expression metadata.
export record RecordLit {
export record RecordLit: Copy {
    /// 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.
export record RecordDecl {
export record RecordDecl: Copy {
    /// 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.
export record UnionDecl {
export record UnionDecl: Copy {
    /// 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.
export record UnionDeclVariant {
export record UnionDeclVariant: Copy {
    /// Identifier naming the variant.
    name: *Node,
    /// Variant index.
    index: u32,
    /// Explicit discriminant value, if provided.

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

/// Function declaration.
export record FnDecl {
export record FnDecl: Copy {
    /// 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.
export record ArrayRepeatLit {
export record ArrayRepeatLit: Copy {
    /// Expression providing the repeated value.
    item: *Node,
    /// Expression providing the repetition count.
    count: *Node,
}

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

/// Use declaration for importing modules.
export record Use {
export record Use: Copy {
    /// 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.
export record Access {
export record Access: Copy {
    /// Expression providing the container or namespace.
    parent: *Node,
    /// Expression identifying the member, scope element, or index.
    child: *Node,
}

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

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

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

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

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

        attrs: ?Attributes,
    },
}

/// Full AST node with shared metadata and variant-specific payload.
export record Node {
export record Node: Copy {
    /// Unique identifier for this node.
    id: u32,
    /// Source span describing where the node originated.
    span: Span,
    /// Variant-specific payload for the 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 {
record SynthFnMod: Copy {
    /// The module block.
    modBody: *Node,
    /// The function block.
    fnBody: *Node
}

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

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

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

export fn wordsFor(n: u32) -> u32 {
    return (n + 31) / 32;
}

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

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

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

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

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

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

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

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

export constant MAX_FUNCS: u32 = 8192;
/// Size of the function hash table. Must be a power of two.
export constant FUNC_TABLE_SIZE: u32 = MAX_FUNCS * 2;

/// Label tracking for code emission.
export record Labels {
export record Labels: Copy {
    /// Block offsets indexed by block index.
    /// Per-function, reset each function.
    blockOffsets: *mut [i32],
    /// Number of blocks recorded in current function.
    blockCount: u32,

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


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

/// Target configuration for register allocation.
export record TargetConfig {
export record TargetConfig: Copy {
    /// 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.
export record AllocResult {
export record AllocResult: Copy {
    /// SSA register to physical register mapping.
    assignments: *[?super::Reg],
    /// Spill slot information.
    spill: spill::SpillInfo,
    /// Bitmask of used callee-saved registers.

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

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

/// Register mapping at a program point.
/// Maps SSA registers to physical registers.
export record RegMap {
export record RegMap: Copy {
    /// 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.
export record AssignInfo {
export record AssignInfo: Copy {
    /// SSA register -> physical register mapping.
    assignments: *mut [?gen::Reg],
    /// Bitmask of used callee-saved registers.
    usedCalleeSaved: u32,
}

/// Per-instruction context for freeing and allocating register uses.
record InstrCtx {
record InstrCtx: Copy {
    current: *mut RegMap,
    usedRegs: *mut bitset::Bitset,
    func: *il::Fn,
    live: *liveness::LiveInfo,
    blockIdx: u32,

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


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

/// Liveness information for a function.
export record LiveInfo {
export record LiveInfo: Copy {
    /// 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).

    /// Maximum register number used.
    maxReg: u32,
}

/// Context for collecting defs and uses during block analysis.
record DefsUses {
record DefsUses: Copy {
    defs: *bitset::Bitset,
    uses: *mut bitset::Bitset,
}

/// Context for searching for a specific register in an instruction.
record FindCtx {
record FindCtx: Copy {
    target: u32,
    found: bool,
}

/// Compute liveness information for a function.

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

constant MAX_CANDIDATES: u32 = 256;
/// Maximum loop depth for cost weighting (2^10 = 1024).
constant MAX_LOOP_WEIGHT: u32 = 10;

/// Spill cost for a single SSA register.
record SpillCost {
record SpillCost: Copy {
    /// Number of definitions (weighted by loop depth).
    defs: u32,
    /// Number of uses (weighted by loop depth).
    uses: u32,
}

/// Spill decision for a function.
export record SpillInfo {
export record SpillInfo: Copy {
    /// 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.

    /// Maximum SSA register number.
    maxReg: u32,
}

/// Candidate buffer for spill decisions.
record Candidates {
record Candidates: Copy {
    entries: [CostEntry; 256],
    n: u32,
}

/// Entry for cost sorting.
record CostEntry {
record CostEntry: Copy {
    reg: u32,
    cost: u32,
}

/// Context for counting register uses.
record CountCtx {
record CountCtx: Copy {
    costs: *mut [SpillCost],
    weight: u32,
}

/// Analyze a function and determine which values need spill slots.

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.
export record FuncAddr {
export record FuncAddr: Copy {
    /// Function name.
    name: *[u8],
    /// Instruction index where this function starts.
    index: u32,
}

/// Debug entry mapping an instruction to a source location.
export record DebugEntry {
export record DebugEntry: Copy {
    /// 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 +16 -16


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

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

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

        case Type::W64 => return 8,
    }
}

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

/// Instruction value.
export union Val {
export union Val: Copy {
    /// 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.
export union CmpOp { Eq, Ne, Slt, Ult }
export union CmpOp: Copy { Eq, Ne, Slt, Ult }

/// Binary ALU operation kind.
export union BinOp {
export union BinOp: Copy {
    // 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.
export union UnOp {
export union UnOp: Copy {
    Neg, Not,
}

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

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

/// Switch case mapping a constant value to a branch target.
export record SwitchCase {
export record SwitchCase: Copy {
    /// 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`.
export union Instr {
export union Instr: Copy {
    ///////////////////////
    // 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.
export record Block {
export record Block: Copy {
    /// 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.
export record Fn {
export record Fn: Copy {
    /// Qualified function name (e.g. `$mod$path$func`).
    name: *[u8],
    /// Function parameters.
    params: *[Param],
    /// Return type.

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

/// Data initializer item.
export union DataItem {
export union DataItem: Copy {
    /// 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.
export record DataValue {
export record DataValue: Copy {
    /// The item contained in the value.
    item: DataItem,
    /// The number of times the item should be repeated.
    count: u32,
}

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

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

/// An IL program (compilation unit).
export record Program {
export record Program: Copy {
    /// Global data.
    data: *[Data],
    /// Functions.
    fns: *[*Fn],
}

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

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

/// Lowering errors are typically unrecoverable since they indicate bugs in
/// the resolver or malformed AST that should have been caught earlier.
export union LowerError {
export union LowerError: Copy {
    /// 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.

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

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

/// Role of a lowered function in the final program.
export union FnRole {
export union FnRole: Copy {
    /// Regular function.
    Normal,
    /// Program entry function marked with `@default`.
    Default,
}

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

/// Destination for functions produced by the lowerer.
export union FnOutput {
export union FnOutput: Copy {
    /// Store lowered functions in the provided slice.
    Accumulate(*mut [*il::Fn]),
    /// Send lowered functions to an external consumer immediately.
    Stream(FnSink),
}

/// Module-level lowering context. Shared across all function lowerings.
/// Holds global state like the data section (strings, constants) and provides
/// access to the resolver for type queries.
export record Lowerer {
export record Lowerer: Copy {
    /// Arena for persistent lowering state, including data and symbol names.
    arena: *mut alloc::Arena,
    /// Arena for allocations owned by the function currently being lowered.
    fnArena: *mut alloc::Arena,
    /// Allocator backed by the arena.

    /// Lowering options.
    options: LowerOptions,
}

/// Entry mapping a function symbol to its qualified name.
record FnSymEntry {
record FnSymEntry: Copy {
    sym: *resolver::Symbol,
    qualName: *[u8],
}

/// Entry in the global error tag table.
record ErrTagEntry {
record ErrTagEntry: Copy {
    /// The type of this error, identified by its interned pointer.
    ty: resolver::Type,
    /// The globally unique tag assigned to this error type (non-zero).
    tag: u32,
}

    }
    return FnRole::Normal;
}

/// Builder for accumulating data values during constant lowering.
record DataValueBuilder {
record DataValueBuilder: Copy {
    allocator: alloc::Allocator,
    values: *mut [il::DataValue],
    /// Whether all pushed values can be represented by zero-filled memory.
    zeroInit: bool,
}

/// Result of lowering constant data.
record ConstDataResult {
record ConstDataResult: Copy {
    values: *[il::DataValue],
    zeroInit: bool,
}

/// Create a new builder.

// 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.
export record Var(u32);
export record Var: Copy(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

///
/// Per-block SSA values are tracked separately in [`BlockData::vars`] as [`?il::Val`],
/// where `nil` means "not yet assigned in this block". Together they implement
/// SSA construction.
///
record VarData {
record VarData: Copy {
    /// Variable name, used by [`lookupVarByName`] to resolve identifiers.
    /// Nil for anonymous variables (e.g., internal loop counters).
    name: ?*[u8],
    /// IL type of this variable. Set at declaration time and used when
    /// generating loads, stores, and type-checking assignments.

    addressTaken: bool,
}

/// Links a function parameter to its corresponding variable for the entry block.
/// After creating the entry block, we iterate through these to define initial values.
record FnParamBinding {
record FnParamBinding: Copy {
    /// The variable that receives this parameter's value.
    var: Var,
    /// SSA register containing the parameter value from the caller.
    reg: il::Reg,
}

// 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.
export record BlockId(u32);
export record BlockId: Copy(u32);

/// Internal block state during construction.
///
/// The key invariants:
///
/// - A block is "open" if it has no terminator; instructions can be added.
/// - A block is "sealed" when all predecessor edges are known.
/// - Sealing is required before SSA construction can insert block parameters.
///
/// This differs from the final [`il::Block`] which is immutable and fully formed.
record BlockData {
record BlockData: Copy {
    /// Block label for debugging and IL printing.
    label: *[u8],
    /// Block parameters for merging values at control flow joins. These
    /// receive values from predecessor edges when control flow merges.
    params: *mut [il::Param],

///
/// A block is "unsealed" while its predecessors are still being discovered.
/// During this time, variables used before being defined locally are tracked.
/// Once all predecessors are known, the block is sealed and those variables
/// are resolved via [`resolveBlockArgs`].
union Sealed {
union Sealed: Copy {
    /// Block is unsealed; predecessors may still be added.
    No { incompleteVars: *mut [u32] },
    /// Block is sealed; all predecessors are known.
    Yes,
}

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

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

/// Logical operator.
union LogicalOp { And, Or }
union LogicalOp: Copy { And, Or }

/// Iterator state for for-loop lowering.
union ForIter {
union ForIter: Copy {
    /// Range iterator: `for i in 0..n`.
    Range {
        valVar: Var,
        indexVar: ?Var,
        endVal: il::Val,

// - Optional aggregates: tag checked then payload extracted.
// - Unions: tag compared against variant indices.

/// Cached information about a match subject. Computed once and reused across
/// all arms to avoid redundant lowering and type queries.
record MatchSubject {
record MatchSubject: Copy {
    /// The lowered subject value.
    val: il::Val,
    /// Source-level type from the resolver.
    type: resolver::Type,
    /// IL-level type for code generation.

    /// How bindings are created: by value, or by reference.
    by: resolver::MatchBy,
}

/// Classifies a match subject by how it should be compared and destructured.
union MatchSubjectKind {
union MatchSubjectKind: Copy {
    /// Regular value: direct equality comparison.
    Regular,
    /// Optional with null pointer optimization: `?*T`, `?*[T]`.
    OptionalPtr,
    /// Optional aggregate `?T`: tagged union with payload.

//////////////////////////
// Field Access Support //
//////////////////////////

/// Result of resolving a place expression to a memory location.
record FieldRef {
record FieldRef: Copy {
    /// Base pointer register (points to the container).
    base: il::Reg,
    /// Byte offset of the value within the container.
    offset: i32,
    /// Type of the value held at that location.

}

/// Result of computing an element pointer for array/slice subscript operations.
/// Used by [`lowerElemPtr`] to return both the element address register and
/// the element type for subsequent load or address-of operations.
record ElemPtrResult {
record ElemPtrResult: Copy {
    /// Register holding the computed element address.
    elemReg: il::Reg,
    /// Source-level type of the element.
    elemType: resolver::Type,
}

/// Result of resolving a slice range to a data pointer and element count.
record SliceRangeResult {
record SliceRangeResult: Copy {
    dataReg: il::Reg,
    count: il::Val,
}

/////////////////////////////
// Function Lowering State //
/////////////////////////////

/// Per-function lowering state. Created fresh for each function and contains
/// all the mutable state needed during function body lowering.
record FnLowerer {
record FnLowerer: Copy {
    /// Reference to the module-level lowerer.
    low: *mut Lowerer,
    /// Allocator for IL allocations.
    allocator: alloc::Allocator,
    /// Type signature of the function being lowered.

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

constant PATH_SEP: u8 = '/';
/// Source file extension handled by the loader.
constant SOURCE_EXT: *[u8] = ".rad";

/// Lifecycle state for modules in the dependency graph.
export union ModuleState {
export union ModuleState: Copy {
    /// 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.
export union ModuleError {
export union ModuleError: Copy {
    /// 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.
export record ModuleEntry {
export record ModuleEntry: Copy {
    /// 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.
export record ModuleGraph {
export record ModuleGraph: Copy {
    entries: *mut [ModuleEntry],
    entriesLen: u32,
    pool: *mut strings::Pool,
    /// Arena used for all AST node allocations.
    arena: ?*ast::NodeArena,

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


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

/// A compilation unit.
export record Package {
export record Package: Copy {
    /// 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.

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


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

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

/// Represents a parsed name-type-value triple.
///
/// Used for record field declarations, variable declarations,
/// and record field initializations.
record NameTypeValue {
record NameTypeValue: Copy {
    /// The identifier name.
    name: *ast::Node,
    /// The optional type annotation.
    type: ?*ast::Node,
    /// The optional initialization value.

    /// The optional alignment specifier.
    alignment: ?*ast::Node,
}

/// Behavioural differences when parsing record field lists.
union RecordFieldMode {
union RecordFieldMode: Copy {
    /// Labeled fields, allows for default values.
    Labeled,
    /// Unlabeled fields.
    Unlabeled,
}

/// Parser context differentiates between regular expressions and
/// conditional contexts where `{` begins a block.
union Context {
union Context: Copy {
    /// Normal expression context where `{` may start a record literal
    /// and `if` may start a conditional expression.
    Normal,
    /// Pattern context where `{` may start a record literal
    /// but `if` is reserved for guards.

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

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

/// List of parser errors encountered during parsing.
record ErrorList {
record ErrorList: Copy {
    /// Fixed-size array of error records.
    list: [Error; MAX_ERRORS],
    /// Number of errors currently in the list.
    count: u32,
}

/// Snapshot of parser state for speculative parsing.
record SavedState {
record SavedState: Copy {
    parser: Parser,
    arena: u32,
    nextId: u32,
}

/// Operator metadata for precedence climbing.
record OpInfo {
record OpInfo: Copy {
    op: ast::BinaryOp,
    prec: i32,
}

/// Get operator info for a token kind using match-based dispatch.

            return nil,
    }
}

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

lib/std/lang/resolver.rad +231 -114

constant MAX_LINEAR_BINDINGS: u32 = 32;
/// Maximum nesting depth tracked for loops.
constant MAX_LINEAR_LOOP_DEPTH: u32 = 16;

/// Trait definition stored in the resolver.
export record TraitType {
export record TraitType: Copy {
    /// 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.
export record TraitMethod {
export record TraitMethod: Copy {
    /// 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.
export record InstanceEntry {
export record InstanceEntry: Copy {
    /// 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.
export record MethodEntry {
export record MethodEntry: Copy {
    /// Concrete type that owns the method.
    concreteType: Type,
    /// Name of the concrete type.
    concreteTypeName: *[u8],
    /// Method name.


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

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

/// Information about a union variant.
record UnionVariant {
record UnionVariant: Copy {
    name: *[u8],
    valueType: Type,
    symbol: *mut Symbol,
}

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

/// Record nominal type.
export record RecordType {
export record RecordType: Copy {
    fields: *[RecordField],
    labeled: bool,
    /// Cached layout.
    layout: Layout,
    /// Whether the declaration explicitly carries the `Linear` marker.
    declaredLinear: bool,
    /// Whether the declaration explicitly carries the `Copy` marker.
    declaredCopy: bool,
}

/// Union nominal type.
export record UnionType {
export record UnionType: Copy {
    variants: *[UnionVariant],
    /// Cached layout.
    layout: Layout,
    /// Cached payload offset within the union aggregate.
    valOffset: u32,
    /// If all variants have void payloads.
    isAllVoid: bool,
    /// Whether the declaration explicitly carries the `Linear` marker.
    declaredLinear: bool,
    /// Whether the declaration explicitly carries the `Copy` marker.
    declaredCopy: bool,
}

/// Metadata for user-defined types.
export union NominalType {
export union NominalType: Copy {
    /// 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.
export union Coercion {
export union Coercion: Copy {
    /// 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.

        inst: *InstanceEntry,
    },
}

/// Result of resolving a module path.
record ResolvedModule {
record ResolvedModule: Copy {
    /// Module entry in the graph.
    entry: *module::ModuleEntry,
    /// Scope containing the module's declarations.
    scope: *mut Scope,
}

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

/// Computed union layout parameters.
record UnionLayoutInfo {
record UnionLayoutInfo: Copy {
    layout: Layout,
    valOffset: u32,
    isAllVoid: bool,
}

/// Pre-computed metadata for slice range expressions.
/// Used by the lowerer.
export record SliceRangeInfo {
export record SliceRangeInfo: Copy {
    /// 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.
export union ForLoopInfo {
export union ForLoopInfo: Copy {
    /// 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.
export record FnType {
export record FnType: Copy {
    paramTypes: *[*Type],
    returnType: *Type,
    throwList: *[*Type],
    /// Whether calling this function requires an unsafe context.
    isUnsafe: bool,
    localCount: u32,
}

/// Describes a type computed during semantic analysis.
export union Type {
export union Type: Copy {
    /// 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.
export record TypeMismatch {
export record TypeMismatch: Copy {
    expected: Type,
    actual: Type,
}

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

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

/// Detailed payload attached to a symbol, specialized per symbol kind.
export union SymbolData {
export union SymbolData: Copy {
    /// 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.
export record Symbol {
export record Symbol: Copy {
    /// 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.
export record ConstInt {
export record ConstInt: Copy {
    /// 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.
export union ConstValue {
export union ConstValue: Copy {
    Bool(bool),
    Char(u8),
    String(*[u8]),
    Int(ConstInt),
}

/// Integer range metadata for primitive integer types.
union IntegerRange {
union IntegerRange: Copy {
    Signed {
        bits: u8,
        min: i64,
        max: i64,
        lim: u64,

        max: u64,
    },
}

/// Diagnostic emitted by the analyzer.
export record Error {
export record Error: Copy {
    /// 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.
export union ErrorKind {
export union ErrorKind: Copy {
    /// 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.

    FnThrowOverflow(CountMismatch),
    /// Trait declaration has too many methods.
    TraitMethodOverflow(CountMismatch),
    /// Instance declaration is missing a required supertrait instance.
    MissingSupertraitInstance(*[u8]),
    /// An affine binding was used after it moved.
    AffineUseAfterMove(*[u8]),
    /// Linear binding was consumed more than once.
    LinearUseAfterConsume(*[u8]),
    /// Linear binding remains available at an exit.
    LinearNotConsumed(*[u8]),
    /// A case-pattern `let-else` fallback must terminate control flow.

    LinearDiscard,
    /// Assignment would overwrite a live linear value.
    LinearOverwrite,
    /// `undefined` cannot initialize a linear type.
    LinearUndefined,
    /// A `Copy` declaration contains a non-copy field or variant.
    CopyContainsNonCopy,
    /// A declaration carries both `Copy` and `Linear`.
    ConflictingOwnershipMarkers,
    /// A reference appears in a storable or escaping position.
    InvalidRefPosition,
    /// A reference cannot be bound to a local.
    RefBinding,
    /// Call arguments contain overlapping incompatible loans.

    /// Internal error.
    Internal,
}

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

/// Call context.
union CallCtx {
union CallCtx: Copy {
    /// Normal function call.
    Normal,
    /// Fallible function call, ie. `try f()`.
    Try,
}

/// Result of resolving a record literal's type name.
record ResolvedRecordLitType {
record ResolvedRecordLitType: Copy {
    /// The record nominal type to use for field checking.
    recordType: *NominalType,
    /// The result type of the literal (record type or union type for variants).
    resultType: Type,
}

/// Result of checking for a `super` path prefix.
record SuperAccessResult {
record SuperAccessResult: Copy {
    scope: *mut Scope,
    child: *ast::Node,
}

/// Node-specific resolver metadata.
export union NodeExtra {
export union NodeExtra: Copy {
    /// 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.
export record NodeData {
export record NodeData: Copy {
    /// Resolved type for this node.
    ty: Type,
    /// Coercion plan applied to this node.
    coercion: Coercion,
    /// Symbol associated with this node.

    /// Node-specific extra data.
    extra: NodeExtra,
}

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

/// Lexical scope.
export record Scope {
export record Scope: Copy {
    /// 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.

    /// Number of live symbols.
    symbolsLen: u32,
}

/// An object used by the enter and exit functions for module scopes.
record ModuleScope {
record ModuleScope: Copy {
    /// Module root node.
    root: *ast::Node,
    /// Module entry in graph.
    entry: *module::ModuleEntry,
    /// The newly entered scope.

    /// The previous module.
    prevMod: u16,
}

/// Loop context for tracking control flow within loops.
record LoopCtx {
record LoopCtx: Copy {
    /// Whether a reachable break was encountered in this loop.
    /// This is used to determine whether a loop diverges.
    hasBreak: bool,
}

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

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

/// State of a match statement being resolved.
// TODO: This is only used because of the maximum function param limitation.
record MatchState {
record MatchState: Copy {
    /// Is the match catch-all?
    catchAll: bool,
    /// Is the match constant?
    isConst: bool
}

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

/// How an expression uses a linear result.
union LinearUse {
union LinearUse: Copy {
    /// Consume the value and end its availability.
    Consume,
    /// Read the value without consuming it.
    Observe,
    /// Borrow the value through a reference.

    /// Use the value as an assignment target.
    Place,
}

/// Per-control-flow-path ownership state.
record LinearEnv {
record LinearEnv: Copy {
    /// Symbols tracked on this control-flow path.
    symbols: [?*mut Symbol; MAX_LINEAR_BINDINGS],
    /// Bit set for each binding that remains available.
    available: u64,
    /// Number of entries in `symbols`.

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

/// Function-local exact-use checker state.
record LinearChecker {
record LinearChecker: Copy {
    /// Resolver that owns the symbols and diagnostics.
    resolver: *mut Resolver,
    /// Binding count at entry to each active loop.
    loopMarks: [u32; MAX_LINEAR_LOOP_DEPTH],
    /// Available bindings at entry to each active loop.

    }
    return MatchSubject { effectiveTy: ty, by: MatchBy::Value };
}

/// Global resolver state.
export record Resolver {
export record Resolver: Copy {
    /// 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.
export union ResolveError {
export union ResolveError: Copy {
    Failure,
}

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

/// Allocate and intern a type in the arena, returning a pointer for deduplication.

    }
    return nil;
}

/// Storage buffers used by the analyzer.
export record ResolverStorage {
export record ResolverStorage: Copy {
    /// 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.
export record Pkg {
export record Pkg: Copy {
    /// Root module entry.
    rootEntry: *module::ModuleEntry,
    /// Root AST node.
    rootAst: *ast::Node,
}

        case Type::Nominal(_) => return false,
        else => return false,
    }
}

/// Return whether a type is exact-linear.
export fn isLinear(ty: Type) -> bool {
/// Return whether `ty` may be duplicated implicitly.
export fn isCopy(ty: Type) -> bool {
    match ty {
        case Type::Pointer { class: types::PointerClass::Owned, .. },
             Type::Slice { class: types::PointerClass::Owned, .. },
             Type::TraitObject { class: types::PointerClass::Owned, .. } => return true,
        case Type::Pointer { class: types::PointerClass::Ref, .. },
             Type::Pointer { class: types::PointerClass::Unsafe, .. },
             Type::Slice { class: types::PointerClass::Ref, .. },
             Type::Slice { class: types::PointerClass::Unsafe, .. },
             Type::TraitObject { class: types::PointerClass::Ref, .. },
             Type::TraitObject { class: types::PointerClass::Unsafe, .. } => return false,
        case Type::Array(array) => return isCopy(*array.item),
        case Type::Optional(inner) => return isCopy(*inner),
        case Type::Nominal(NominalType::Record(recInfo)) => return recInfo.declaredCopy,
        case Type::Nominal(NominalType::Union(unionType)) => return unionType.declaredCopy,
        case Type::Nominal(NominalType::Placeholder(_)) => return false,
        else => return true,
    }
}

/// Return whether a type must be consumed exactly once.
export fn isLinear(ty: Type) -> bool {
    match ty {
        case Type::Array(array) => return isLinear(*array.item),
        case Type::Optional(inner) => return isLinear(*inner),
        case Type::Nominal(NominalType::Record(recInfo)) => {
            if recInfo.declaredLinear {
                return true;

        }
        else => return false,
    }
}

/// Return whether a by-value use moves `ty`.
fn isMoveOnly(ty: Type) -> bool {
    return not isCopy(ty);
}

/// Return whether `ty` is a direct unsafe pointer-like value.
fn isUnsafePointerType(ty: Type) -> bool {
    match ty {
        case Type::Pointer { class: types::PointerClass::Unsafe, .. },
             Type::Slice { class: types::PointerClass::Unsafe, .. },

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

    let _ = try bindValueIdent(self, param.name, node, ty, false, 0, 0);

    return ty;
}

/// Resolve the compiler-known `Linear` marker from a derive list.
fn resolveLinearDerive(self: *mut Resolver, derives: *mut [*ast::Node]) -> bool
/// Compiler-known ownership markers carried by a composite declaration.
record OwnershipMarkers: Copy {
    /// The declaration requires exact consumption.
    linear: bool,
    /// The declaration permits implicit copies.
    copy: bool,
}

/// Resolve compiler-known ownership markers from a derive list.
fn resolveOwnershipMarkers(self: *mut Resolver, derives: *mut [*ast::Node]) -> OwnershipMarkers
    throws (ResolveError)
{
    let mut linear = false;
    let mut result = OwnershipMarkers { linear: false, copy: false };
    for derive in derives {
        let name = try nodeName(self, derive);
        if mem::eq(name, "Linear") {
            if linear {
            if result.linear {
                throw emitError(self, derive, ErrorKind::DuplicateBinding(name));
            }
            if result.copy {
                throw emitError(self, derive, ErrorKind::ConflictingOwnershipMarkers);
            }
            set result.linear = true;
        } else if mem::eq(name, "Copy") {
            if result.copy {
                throw emitError(self, derive, ErrorKind::DuplicateBinding(name));
            }
            set linear = true;
            if result.linear {
                throw emitError(self, derive, ErrorKind::ConflictingOwnershipMarkers);
            }
            set result.copy = true;
        } else {
            // Resolve an ordinary trait derive.
            try infer(self, derive);
        }
    }
    return linear;
    return result;
}

/// Resolve record fields from a node list.
fn resolveRecordFields(self: *mut Resolver, node: *ast::Node, fields: *mut [*ast::Node], labeled: bool) -> RecordType
    throws (ResolveError)

    return RecordType {
        fields: &result[..],
        labeled,
        layout: recordLayout,
        declaredLinear: false,
        declaredCopy: false,
    };
}

/// Resolve record field types for a named record declaration.
fn resolveRecordBody(self: *mut Resolver, node: *ast::Node, decl: ast::RecordDecl)


    // Skip if already resolved.
    if let case NominalType::Record(_) = *nominalTy {
        return;
    }
    let declaredLinear = try resolveLinearDerive(self, decl.derives);
    let markers = try resolveOwnershipMarkers(self, decl.derives);
    let mut recordType = try resolveRecordFields(self, node, decl.fields, decl.labeled);
    set recordType.declaredLinear = declaredLinear;
    if markers.copy {
        for field in recordType.fields {
            if not isCopy(field.fieldType) {
                throw emitError(self, node, ErrorKind::CopyContainsNonCopy);
            }
        }
    }
    set recordType.declaredLinear = markers.linear;
    set recordType.declaredCopy = markers.copy;

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

/// Bind a type name.

    if retTy <> Type::Void and bodyTy <> Type::Never {
        exitFn(self);
        if isUnsafe { set self.unsafeDepth -= 1; }
        throw emitError(self, body, ErrorKind::FnMissingReturn);
    }
    try checkLinearFn(self, receiverName, sig.params, body) catch e {
        exitFn(self);
        if isUnsafe { set self.unsafeDepth -= 1; }
        throw e;
    };
    exitFn(self);
    if isUnsafe {
        set self.unsafeDepth -= 1;
    }
}

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

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

    assert decl.variants.len <= MAX_UNION_VARIANTS, "resolveUnionBody: maximum union variants exceeded";
    let mut iota: u32 = 0;
    for variantNode, i in decl.variants {

            name: variantName,
            valueType: variantType,
            symbol: variantSym,
        }, a);
    }
    if markers.copy {
        for variant in variants {
            if not isCopy(variant.valueType) {
                throw emitError(self, node, ErrorKind::CopyContainsNonCopy);
            }
        }
    }
    let info = computeUnionLayout(&variants[..]);

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

/// Check if a module should be analyzed based on its attributes and build configuration.
fn shouldAnalyzeModule(self: *Resolver, attrs: ?ast::Attributes) -> bool {


    return setNodeType(self, node, unifyBranches(thenTy, elseTy));
}

/// Controls how bare identifiers are handled in case patterns.
union IdentMode {
union IdentMode: Copy {
    /// Identifier is a value to compare against.
    Compare,
    /// Identifier introduces a new binding.
    Bind,
}

        case ast::TypeSig::Nominal(name) => {
            let ty = try resolveTypeName(self, name);
            return Type::Nominal(ty);
        }
        case ast::TypeSig::Record { fields, labeled } => {
            let recordType = try resolveRecordFields(self, node, fields, labeled);
            let mut recordType = try resolveRecordFields(self, node, fields, labeled);
            set recordType.declaredCopy = true;
            for field in recordType.fields {
                if not isCopy(field.fieldType) {
                    set recordType.declaredCopy = false;
                }
            }
            let nominalTy = allocNominalType(self, NominalType::Record(recordType));
            return Type::Nominal(nominalTy);
        }
        case ast::TypeSig::Fn(t) => {
            let a = alloc::arenaAllocator(&mut self.arena);

/// Return whether a tracked binding is still available.
fn linearBindingAvailable(env: *LinearEnv, index: u32) -> bool {
    return (env.available & ((1 as u64) << (index as u64))) <> 0;
}

/// Add a local binding when its resolved type is linear.
/// Add a local binding when its resolved type moves by value.
fn addLinearBinding(checker: *mut LinearChecker, env: *mut LinearEnv, node: *ast::Node)
    throws (ResolveError)
{
    let sym = symbolFor(checker.resolver, node) else return;
    let case SymbolData::Value { type: ty, .. } = sym.data else return;
    if not isLinear(ty) {
    if not isMoveOnly(ty) {
        return;
    }
    if env.len >= MAX_LINEAR_BINDINGS {
        throw emitError(checker.resolver, node, ErrorKind::Internal);
    }
    set env.symbols[env.len] = sym;
    set env.available |= (1 as u64) << (env.len as u64);
    set env.len += 1;
}

/// Require all bindings introduced after `start` to have been consumed.
/// Mark a tracked binding as uninitialized.
fn markLinearBindingUnavailable(self: *mut Resolver, env: *mut LinearEnv, node: *ast::Node) {
    let sym = symbolFor(self, node) else return;
    let index = findLinearBinding(env, sym) else return;
    set env.available &= ~((1 as u64) << (index as u64));
}

/// Require exact-use bindings introduced after `start` to be consumed.
fn finishLinearScope(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
    start: u32,
) throws (ResolveError) {
    if not env.terminated {
        for i in start..env.len {
            if linearBindingAvailable(env, i) {
                let sym = env.symbols[i] else panic "finishLinearScope: missing symbol";
                throw emitError(
                    checker.resolver,
                    sym.node,
                    ErrorKind::LinearNotConsumed(sym.name),
                );
                let case SymbolData::Value { type: ty, .. } = sym.data
                    else panic "finishLinearScope: expected value symbol";
                if isLinear(ty) {
                    throw emitError(
                        checker.resolver,
                        sym.node,
                        ErrorKind::LinearNotConsumed(sym.name),
                    );
                }
            }
        }
    }
    set env.len = start;
}

/// Consume a tracked identifier exactly once.
/// Move or consume a tracked identifier once.
fn consumeLinearIdent(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
    node: *ast::Node,
) throws (ResolveError) {
    let sym = symbolFor(checker.resolver, node) else return;
    let index = findLinearBinding(env, sym) else return;
    if not linearBindingAvailable(env, index) {
        throw emitError(
            checker.resolver,
            node,
            ErrorKind::LinearUseAfterConsume(sym.name),
        );
        let case SymbolData::Value { type: ty, .. } = sym.data
            else panic "consumeLinearIdent: expected value symbol";
        let kind = ErrorKind::LinearUseAfterConsume(sym.name) if isLinear(ty)
            else ErrorKind::AffineUseAfterMove(sym.name);
        throw emitError(checker.resolver, node, kind);
    }
    set env.available &= ~((1 as u64) << (index as u64));
}

/// Verify that two live branches agree on every outer binding.
/// Merge ownership availability across two live branches.
fn joinLinearBranches(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
    left: LinearEnv,
    right: LinearEnv,

    if right.terminated {
        set *env = left;
        return;
    }
    assert left.len == right.len, "joinLinearBranches: scope mismatch";
    let mut result = left;
    for i in 0..left.len {
        if linearBindingAvailable(&left, i) <> linearBindingAvailable(&right, i) {
            let sym = left.symbols[i] else panic "joinLinearBranches: missing symbol";
            throw emitError(
                checker.resolver,
                node,
                ErrorKind::LinearBranchMismatch(sym.name),
            );
            let case SymbolData::Value { type: ty, .. } = sym.data
                else panic "joinLinearBranches: expected value symbol";
            if isLinear(ty) {
                throw emitError(
                    checker.resolver,
                    node,
                    ErrorKind::LinearBranchMismatch(sym.name),
                );
            }
            set result.available &= ~((1 as u64) << (i as u64));
        }
    }
    set *env = left;
    set *env = result;
}

/// Require all current bindings to be consumed at a function exit.
/// Require all available exact-use bindings to be consumed at a function exit.
fn finishLinearExit(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
) throws (ResolveError) {
    for i in 0..env.len {
        if linearBindingAvailable(env, i) {
            let sym = env.symbols[i] else panic "finishLinearExit: missing symbol";
            throw emitError(
                checker.resolver,
                sym.node,
                ErrorKind::LinearNotConsumed(sym.name),
            );
            let case SymbolData::Value { type: ty, .. } = sym.data
                else panic "finishLinearExit: expected value symbol";
            if isLinear(ty) {
                throw emitError(
                    checker.resolver,
                    sym.node,
                    ErrorKind::LinearNotConsumed(sym.name),
                );
            }
        }
    }
    set env.terminated = true;
}


            case ast::ProngArm::Binding(binding) => {
                try addLinearPatternBindings(checker, &mut branch, binding);
            }
            case ast::ProngArm::Else => {}
        }
        if prong.guard <> nil and branch.len > bindingsStart {
            throw emitError(checker.resolver, prongNode, ErrorKind::LinearDiscard);
        if prong.guard <> nil {
            for i in bindingsStart..branch.len {
                let sym = branch.symbols[i] else panic "checkLinearMatch: missing symbol";
                let case SymbolData::Value { type: ty, .. } = sym.data
                    else panic "checkLinearMatch: expected value symbol";
                if isLinear(ty) {
                    throw emitError(checker.resolver, prongNode, ErrorKind::LinearDiscard);
                }
            }
        }
        if let guard = prong.guard {
            try checkLinearNode(checker, &mut branch, guard, LinearUse::Consume);
        }
        try checkLinearNode(checker, &mut branch, prong.body, LinearUse::Discard);

    env: *mut LinearEnv,
    node: *ast::Node,
    call: ast::Call,
) throws (ResolveError) {
    try checkLinearNode(checker, env, call.callee, LinearUse::Observe);
    let calleeTy = typeFor(checker.resolver, call.callee) else {
        throw emitError(checker.resolver, call.callee, ErrorKind::Internal);
    };
    let case Type::Fn(info) = calleeTy else {
    let mut fnInfo: ?*FnType = nil;
    match checker.resolver.nodeData.entries[node.id].extra {
        case NodeExtra::TraitMethodCall { traitInfo, methodIndex } =>
            set fnInfo = traitInfo.methods[methodIndex].fnType,
        case NodeExtra::MethodCall { method } => set fnInfo = method.fnType,
        else => {
            if let calleeTy = typeFor(checker.resolver, call.callee) {
                if let case Type::Fn(info) = calleeTy {
                    set fnInfo = info;
                }
            }
        }
    }
    let info = fnInfo else {
        for arg in call.args {
            try checkLinearNode(checker, env, arg, LinearUse::Consume);
        }
        return;
    };

    }

    for arg, i in call.args {
        let expected = *info.paramTypes[i];
        let root = linearRootSymbol(checker.resolver, arg);
        let mut argExclusive = isLinear(expected);
        let mut argExclusive = isMoveOnly(expected);
        if let case Type::Pointer { class: types::PointerClass::Ref, mutable, .. } = expected {
            set argExclusive = mutable;
        } else if let case Type::Slice { class: types::PointerClass::Ref, mutable, .. } = expected {
            set argExclusive = mutable;
        } else if let case Type::TraitObject {

            }
            try checkLinearNode(checker, env, expr, LinearUse::Consume);
        }
        case ast::NodeValue::Block(_) => try checkLinearBlock(checker, env, node),
        case ast::NodeValue::Let(binding) => {
            let mut isUndefined = false;
            if let case ast::NodeValue::Undef = binding.value.value {
                set isUndefined = true;
            }
            if isUndefined {
                if let bindingTy = typeFor(checker.resolver, binding.ident);
                    isLinear(bindingTy)
                {
                    throw emitError(
                        checker.resolver,

                    );
                }
            }
            try checkLinearNode(checker, env, binding.value, LinearUse::Consume);
            try addLinearBinding(checker, env, node);
            if isUndefined {
                markLinearBindingUnavailable(checker.resolver, env, node);
            }
        }
        case ast::NodeValue::Assign(assign) => {
            let mut target: ?u32 = nil;
            let mut targetLinear = false;
            if let leftTy = typeFor(checker.resolver, assign.left) {
                if isLinear(leftTy) {
                if isMoveOnly(leftTy) {
                    set targetLinear = isLinear(leftTy);
                    if let case ast::NodeValue::Ident(_) = assign.left.value {
                        if let sym = symbolFor(checker.resolver, assign.left) {
                            set target = findLinearBinding(env, sym);
                        }
                    }

                }
            }
            try checkLinearNode(checker, env, assign.left, LinearUse::Place);
            try checkLinearNode(checker, env, assign.right, LinearUse::Consume);
            if let index = target {
                if linearBindingAvailable(env, index) {
                if targetLinear and linearBindingAvailable(env, index) {
                    throw emitError(
                        checker.resolver,
                        assign.left,
                        ErrorKind::LinearOverwrite,
                    );

        case ast::NodeValue::AddressOf(addr) => {
            try checkLinearNode(checker, env, addr.target, LinearUse::Borrow);
        }
        case ast::NodeValue::Deref(target) => {
            if let resultTy = typeFor(checker.resolver, node) {
                if isLinear(resultTy) and usage == LinearUse::Consume {
                if isMoveOnly(resultTy) and usage == LinearUse::Consume {
                    throw emitError(checker.resolver, node, ErrorKind::LinearPartialMove);
                }
            }
            try checkLinearNode(checker, env, target, LinearUse::Observe);
        }
        case ast::NodeValue::FieldAccess(access) => {
            if let resultTy = typeFor(checker.resolver, node) {
                if isLinear(resultTy) and usage == LinearUse::Consume {
                if isMoveOnly(resultTy) and usage == LinearUse::Consume {
                    throw emitError(checker.resolver, node, ErrorKind::LinearPartialMove);
                }
            }
            try checkLinearNode(checker, env, access.parent, LinearUse::Observe);
        }
        case ast::NodeValue::ScopeAccess(_) => {}
        case ast::NodeValue::Subscript { container, index } => {
            if let resultTy = typeFor(checker.resolver, node) {
                if isLinear(resultTy) and usage == LinearUse::Consume {
                if isMoveOnly(resultTy) and usage == LinearUse::Consume {
                    throw emitError(checker.resolver, node, ErrorKind::LinearPartialMove);
                }
            }
            try checkLinearNode(checker, env, container, LinearUse::Observe);
            try checkLinearNode(checker, env, index, LinearUse::Consume);

                try checkLinearNode(checker, env, item, LinearUse::Consume);
            }
        }
        case ast::NodeValue::ArrayRepeatLit(repeat) => {
            if let itemTy = typeFor(checker.resolver, repeat.item) {
                if isLinear(itemTy) {
                if not isCopy(itemTy) {
                    throw emitError(
                        checker.resolver,
                        repeat.item,
                        ErrorKind::LinearDiscard,
                    );

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

        case super::ErrorKind::TraitMethodOverflow(m) =>
            printMismatch("too many trait methods", "maximum", m),
        case super::ErrorKind::MissingSupertraitInstance(name) => {
            printQuoted("missing instance for supertrait '", name);
        }
        case super::ErrorKind::AffineUseAfterMove(name) => {
            printQuoted("affine value used after move: '", name);
        }
        case super::ErrorKind::LinearUseAfterConsume(name) => {
            printQuoted("linear value used after consumption: '", name);
        }
        case super::ErrorKind::LinearNotConsumed(name) => {
            printQuoted("linear value is not consumed: '", name);

            io::print("assignment would overwrite a linear value");
        }
        case super::ErrorKind::LinearUndefined => {
            io::print("linear values cannot be undefined");
        }
        case super::ErrorKind::CopyContainsNonCopy => {
            io::print("`Copy` composite contains a non-copy value");
        }
        case super::ErrorKind::ConflictingOwnershipMarkers => {
            io::print("a composite cannot be both `Copy` and `Linear`");
        }
        case super::ErrorKind::InvalidRefPosition => {
            io::print("reference type is only allowed as a function parameter");
        }
        case super::ErrorKind::RefBinding => {
            io::print("references cannot be bound to locals");

lib/std/lang/resolver/tests.rad +57 -1

    "Second", "Opt", "x",
    "value", "idx"
];

/// Resolver result with AST, used by test helpers.
record TestResult {
record TestResult: Copy {
    diagnostics: super::Diagnostics,
    root: *ast::Node,
}

/// Create isolated storage for tests to avoid conflicts with global resolver storage.

        if let case super::ErrorKind::MissingSupertraitInstance(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::AffineUseAfterMove(expectedName) = expected {
        if let case super::ErrorKind::AffineUseAfterMove(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::LinearUseAfterConsume(expectedName) = expected {
        if let case super::ErrorKind::LinearUseAfterConsume(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;

    let program = "record Value { number: i32 } trait Read { fn (&Read) get() -> i32; } instance Read for Value { fn (value: *Value) get() -> i32 { return value.number; } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TraitReceiverMismatch);
}

/// Unmarked composite values may be discarded.
@test fn testAffineCompositeMayBeDiscarded() throws (testing::TestError) {
    let program = "record Value { number: u32 } fn run() { let value = Value { number: 1 }; }";
    try expectAnalyzeOk(program);
}

/// A by-value use moves an unmarked composite value.
@test fn testAffineCompositeUseAfterMoveRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Value { number: u32 } fn take(value: Value) {} fn run() { let value = Value { number: 1 }; take(value); take(value); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::AffineUseAfterMove("value"));
}

/// Affine values may move on only one branch when not used later.
@test fn testAffineConditionalMoveMayBeDiscarded() throws (testing::TestError) {
    let program = "record Value { number: u32 } fn take(value: Value) {} fn run(condition: bool) { let value = Value { number: 1 }; if condition { take(value); } }";
    try expectAnalyzeOk(program);
}

/// A `Copy` composite remains available after a by-value use.
@test fn testCopyCompositeMayBeReused() throws (testing::TestError) {
    let program = "record Value: Copy { number: u32 } fn take(value: Value) {} fn run() { let value = Value { number: 1 }; take(value); take(value); }";
    try expectAnalyzeOk(program);
}

/// A `Copy` composite may contain only copy values.
@test fn testCopyCompositeRejectsAffineField() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Inner { number: u32 } record Outer: Copy { inner: Inner }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::CopyContainsNonCopy);
}

/// A composite cannot carry conflicting ownership markers.
@test fn testConflictingOwnershipMarkersRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Value: Copy + Linear { number: u32 }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ConflictingOwnershipMarkers);
}

/// Linear composites still require one consuming use.
@test fn testLinearCompositeMustBeConsumed() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Token: Linear { number: u32 } fn run() { let token = Token { number: 1 }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::LinearNotConsumed("token"));
}

/// The compiler-known marker cannot be derived more than once.
@test fn testDuplicateLinearMarkerRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Token: Linear + Linear { value: u32 }";
    let result = try resolveProgramStr(&mut a, program);

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


/// 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.
export union TokenKind {
export union TokenKind: Copy {
    /// Special end of file token generated when the input is exhausted.
    Eof,
    /// Special invalid token.
    Invalid,


    I8, I16, I32, I64, U8, U16, U32, U64,
    Opaque, Fn, Bool, Union, Record, As, Unsafe
}

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

    { name: "use", tok: TokenKind::Use },
    { name: "while", tok: TokenKind::While },
];

/// Describes where source code originated from.
export union SourceLoc {
export union SourceLoc: Copy {
    /// 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.
export record Scanner {
export record Scanner: Copy {
    /// 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.
export record Token {
export record Token: Copy {
    /// 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.
export record Location {
export record Location: Copy {
    /// Origin of the source.
    source: SourceLoc,
    /// Line number.
    line: u16,
    /// Column number.

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


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

/// Output target for S-expression printing.
export union Output {
export union Output: Copy {
    /// Print to stdout.
    Stdout,
    /// Write to a buffer, tracking position.
    Buffer { buf: *mut [u8], pos: *mut u32 },
}

/// An S-expression element.
export union Expr {
export union Expr: Copy {
    /// An empty expression.
    Null,
    /// A symbol/identifier.
    Sym(*[u8]),
    /// A quoted string literal.

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


/// 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.
export record Pool {
export record Pool: Copy {
    /// Hash table slots.
    table: [*[u8]; TABLE_SIZE],
    /// Number of strings currently in the pool.
    count: u32,
}

/// Lookup result.
union Lookup {
union Lookup: Copy {
    /// Found.
    Found(*[u8]),
    /// Not found, contains empty slot index.
    Empty(u32),
}

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

//! Shared Radiance language types.

/// Ownership and safety class for pointer-like types.
export union PointerClass {
export union PointerClass: Copy {
    /// Owned pointer, eg. `*T`.
    Owned,
    /// Reference, borrowed pointer, eg. `&T`.
    Ref,
    /// Unsafe, raw pointer, eg. `*unsafe T`.

lib/std/mem.rad +1 -1

/// Memory error.
union MemoryError {
union MemoryError: Copy {
    /// Buffer is too small.
    BufferTooSmall,
}

/// Copy bytes between two slices. Returns the number of bytes copied.

lib/std/sys.rad +1 -1

//! System utilities.
export mod unix;

/// Process environment passed to the program entry point.
export record Env {
export record Env: Copy {
    /// Command-line arguments.
    args: *[*[u8]],
}

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

//! Unix-specific system calls and utilities.
use std::intrinsics;

/// File access modes.
export record OpenFlags(i64);
export record OpenFlags: Copy(i64);

/// Open file for reading only.
export constant O_RDONLY: OpenFlags = OpenFlags(0);

/// Open file for writing only.

lib/std/testing.rad +3 -3


use std::mem;
use std::io;

/// Internal state for tracking test pass/fail counts.
record Ctx {
record Ctx: Copy {
    passed: u32,
    failed: u32,
}

/// Error thrown when a test assertion fails.
export union TestError {
export union TestError: Copy {
    Failed,
}

/// Descriptor for a single test case, holding its module path, name, and entry point.
export record TestInfo {
export record TestInfo: Copy {
    module: *[u8],
    name: *[u8],
    func: fn() throws (TestError),
}


lib/std/tests.rad +1 -1

6	6		use std::testing;
7	7		use std::sys::unix;
8	8
9	9		// Data types //////////////////////////////////////////////////////////////////
10	10
11		-	record Point {
	11	+	record Point: Copy {
12	12		x: i32,
13	13		y: i32,
14	14		}
15	15
16	16		// fmt /////////////////////////////////////////////////////////////////////////

lib/std/vec.rad +1 -1

//! to the element type's requirements.

/// Raw vector metadata structure.
///
/// Does not own storage, points to user-provided arena.
export record RawVec {
export record RawVec: Copy {
    /// 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).

seed/radiance.rv64 +0 -0

Binary file changed.

seed/radiance.rv64.git +1 -1

1		-	d024ed30c27cc671d9371988d0155b3e08ff004582cf59f1b7eac8ffdf3e3467
	1	+	1e2fdea952350036a4172f567442e608555094b9e18fa69f1fb615453d5352b6

test/tests/abi.sizes.rad +5 -5

//! returns: 0
//! Test size-based ABI: small aggregates (<= 8 bytes) are passed/returned
//! by value in registers, while larger aggregates use hidden pointers.

record Byte {
record Byte: Copy {
    x: u8,
}

record Short {
record Short: Copy {
    x: u16,
}

record Word {
record Word: Copy {
    x: u32,
}

record Pair {
record Pair: Copy {
    a: u32,
    b: u32,
}

record Triple {
record Triple: Copy {
    x: u32,
    y: u32,
    z: u32,
}


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

//! returns: 0
//! Test that returning aggregate types via hidden return buffer does not
//! corrupt the caller's stack. Modifying a returned aggregate must not affect
//! other locals or previously returned values.

record Pair {
record Pair: Copy {
    a: u32,
    b: u32,
}

record Triple {
record Triple: Copy {
    x: u32,
    y: u32,
    z: u32,
}


test/tests/array.aggregate.stride.rad +1 -1

/// Tests for correct stride calculation with aggregate array elements.
/// This is important because aggregate types (records, arrays) are larger
/// than a single word and require correct stride (not just 4 bytes).

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

/// Array of records (8 bytes per element).
fn arrayOfRecords(arr: [Point; 3], idx: u32) -> i32 {
    return arr[idx].x;
}

test/tests/array.record.elements.rad +1 -1

//! returns: 50
//! Test arrays with record elements.

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

fn calculateDistance(p1: Point, p2: Point) -> i32 {

test/tests/assign.mutable.rad +2 -2

//! returns: 0
//! Test suite for stack memory allocation and aliasing behavior.
//! Tests variable aliasing, mutations, and stack frame management.

record Person {
record Person: Copy {
    age: i32,
    score: i32,
}

record Container {
record Container: Copy {
    values: [i32; 3],
    count: i32,
}

/// Basic variable aliasing and mutation.

test/tests/bool.comparison.nested.gen.rad +2 -2

//! returns: 0
//! Test nested record equality.

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

record Circle {
record Circle: Copy {
    center: Point,
    radius: u32,
}

fn testNestedEqual() -> bool {

test/tests/bool.comparison.record.gen.rad +2 -2

//! returns: 0

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

record Rect {
record Rect: Copy {
    width: u32,
    height: u32,
}

fn testPointEqual() -> bool {

test/tests/bool.comparison.record.rad +2 -2

//! returns: 1

// A packed record. 8 bytes.
record Packed {
record Packed: Copy {
    x: i32,
    y: i32
}

// A record with padding. 17 bytes.
record Padded {
record Padded: Copy {
    a: u8,
    b: u32,
    c: u16,
    d: u32,
    e: u8,

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

//! returns: 0

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

record Line {
record Line: Copy {
    points: *[Point],
}

fn pointsEqual(a: *[Point], b: *[Point]) -> bool {
    if a.len <> b.len {

test/tests/bool.comparison.slice.union.gen.rad +3 -3

//! returns: 0

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

record Size {
record Size: Copy {
    width: u32,
    height: u32,
}

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

fn pointsEqual(a: *[Point], b: *[Point]) -> bool {

test/tests/bool.comparison.union.ctor.rad +1 -1

//! returns: 0
//! Test comparing a void union variable against a constructor literal.

union Op {
union Op: Copy {
    Add,
    Sub,
    Mul,
}


test/tests/bool.comparison.union.gen.rad +1 -1

//! returns: 0

union Status {
union Status: Copy {
    pending,
    running(u32),
    completed(bool),
}


test/tests/bool.comparison.union.record.gen.rad +3 -3

//! returns: 0

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

record Size {
record Size: Copy {
    width: u32,
    height: u32,
}

union Shape {
union Shape: Copy {
    circle(u32),
    point(Point),
    rect(Size),
}


test/tests/bool.comparison.union.simple.gen.rad +1 -1

//! returns: 0
//! Test equality on simple enum without payloads.
union Color {
union Color: Copy {
    red,
    green,
    blue,
}


test/tests/builtin.alignof.rad +1 -1

/// A simple record with mixed field sizes for alignment testing.
record Mixed {
record Mixed: Copy {
    a: u8,
    b: u32,
}

/// Returns the alignment of a u8.

test/tests/builtin.size.align.rad +1 -1

//! returns: 0
record Foo {
record Foo: Copy {
    x: u8,
    y: u32,
}

@default fn main() -> u8 {

test/tests/builtin.sizeof.rad +1 -1

/// A simple record with mixed field sizes for alignment testing.
record Mixed {
record Mixed: Copy {
    a: u8,
    b: u32,
}

/// Returns the size of a u8.

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

//! returns: 0
//! Aggregate call arguments must capture their value when evaluated, before
//! later arguments run and mutate the source object.

record Pair {
record Pair: Copy {
    x: i32,
    y: i32,
}

fn mutate(pair: *mut Pair) -> i32 {

test/tests/compound.assign.field.rad +1 -1

//! returns: 0
/// Test compound assignment on record fields.
record Point {
record Point: Copy {
    x: i32,
    y: i32,
}

@default fn main() -> i32 {

test/tests/cond.expr.aggregate.rad +1 -1

//! returns: 0
//! Test conditional expression with aggregate types (tagged unions, optionals).

union Val {
union Val: Copy {
    Reg(u32),
    Imm(i64),
}

fn pickVal(flag: bool, reg: u32) -> Val {

test/tests/cond.expr.rad +1 -1


fn pick(cond: bool, a: i32, b: i32) -> i32 {
    return a if cond else b;
}

union Color { Red, Green, Blue }
union Color: Copy { Red, Green, Blue }

fn colorPick(isRed: bool) -> Color {
    return Color::Red if isRed else Color::Blue;
}


test/tests/cond.if.case.rad +1 -1

//! returns: 1
//! Test if-let-case with union variants.

union Response {
union Response: Copy {
    success(i32),
    failure,
    offline,
}


test/tests/cond.match.guard.rad +1 -1

//! returns: 0

union OptionNum {
union OptionNum: Copy {
    Some(i32),
    Other(i32),
    None,
}


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

//! `case Kind::Name(name) if name.len > 0` creates a block ordering where
//! the case body has a lower index than its predecessor (the guard block).
//! Without RPO-based register allocation, the name payload pointer can be
//! overwritten by the bounds check in the case body.

union Kind {
union Kind: Copy {
    Num(i32),
    Name(*[u8]),
    Pair { a: i32, b: i32 },
}

record Node {
record Node: Copy {
    id: u32,
    span1: u32,
    span2: u32,
    kind: Kind,
}

test/tests/const.array.record.ident.rad +1 -1

/// Test constant array containing references to other record constants.
/// This tests that identifiers referencing record constants work in constant arrays.

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

constant P1: Point = Point { x: 1, y: 2 };

test/tests/const.array.repeat.record.rad +1 -1

/// Test constant array repeat with record elements.
record Point { x: i32, y: i32 }
record Point: Copy { x: i32, y: i32 }

constant POINTS: [Point; 3] = [Point { x: 1, y: 2 }; 3];

fn getSum() -> i32 {
    return POINTS[0].x + POINTS[1].y + POINTS[2].x;

test/tests/const.record.array.rad +1 -1

//! returns: 129
//! Test array of record constants.

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

// A constant array of structs

test/tests/const.record.array.simple.rad +1 -1

//! returns: 0
// Test array of record constants.

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

// Define an array of record constants

test/tests/const.record.ctor.rad +1 -1

//! returns: 0
//! Constant unlabeled record constructor.
record Pair(i32, i32);
record Pair: Copy(i32, i32);

constant P: Pair = Pair(40, 2);

@default fn main() -> i32 {
    assert P == Pair(40, 2);

test/tests/const.record.fn.rad +1 -1

//! returns: 7
//! Test record constants passed to functions.

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

constant ORIGIN: Point = Point { x: 3, y: 4 };

test/tests/const.record.mutcopy.rad +1 -1

/// Test that accessing an aggregate constant produces a mutable copy
/// (via Reserve + Blit) so that code can safely assign through the pointer.

record Reg { n: u8 }
record Reg: Copy { n: u8 }

constant SCRATCH1: Reg = { n: 30 };
constant SCRATCH2: Reg = { n: 31 };

/// Returns a scratch register, avoiding the one already used by `rs`.

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

/// Test constant nested record lowering with padding.
record Inner {
record Inner: Copy {
    a: u8,
    b: i32,
}

record Outer {
record Outer: Copy {
    x: u8,
    inner: Inner,
    y: u8,
}


test/tests/const.record.packed.rad +1 -1

/// Test constant record with multiple sub-word fields.
record Packed {
record Packed: Copy {
    a: u8,
    b: u8,
    c: u8,
}


test/tests/const.record.padded.rad +1 -1

/// Test constant record with padding between fields.
record Padded {
record Padded: Copy {
    a: u8,
    b: i32,
    c: u8,
}


test/tests/const.record.rad +1 -1

//! returns: 0
// Test record constants.

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

constant ORIGIN: Point = Point { x: 3, y: 4 };

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

/// Test constant array of records containing union variant fields.
/// This is similar to scanner.rad's KEYWORDS constant.
union TokenKind {
union TokenKind: Copy {
    Fn,
    Let,
    If,
}

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

constant KEYWORDS: [Keyword; 3] = [

test/tests/const.union.payload.ctor.rad +1 -1

//! returns: 0
//! Constant union payload constructor call.
union Value {
union Value: Copy {
    Int(i32),
    Bool(bool),
    None,
}


test/tests/const.union.payload.fn.array.rad +3 -3

//! returns: 0
//! Constant array of records containing union variants with throwing function payloads.

union TestError {
union TestError: Copy {
    Fail,
}

fn add(a: i32, b: i32) -> i32 throws (TestError) {
    return a + b;


fn sub(a: i32, b: i32) -> i32 throws (TestError) {
    return a - b;
}

union Handler {
union Handler: Copy {
    Binary { op: fn(i32, i32) -> i32 throws (TestError) },
    None,
}

record Entry {
record Entry: Copy {
    handler: Handler,
}

constant ENTRIES: [Entry; 3] = [
    Entry { handler: Handler::None },

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

//! returns: 0
//! Constant array of records containing union variants with record payloads.

union InstrSpec {
union InstrSpec: Copy {
    Empty,
    Small { flag: bool },
    Imm { opcode: u32, funct3: u32, imm: i32 },
    Reg { opcode: u32, funct3: u32, funct7: u32 },
}

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

constant ENTRIES: [Entry; 4] = [

test/tests/const.union.record.literal.rad +1 -1

//! returns: 0
//! Constant union record payload literal.
union Expr {
union Expr: Copy {
    Nil,
    Pair { first: i32, second: i32 },
}

constant E: Expr = Expr::Pair { first: 20, second: 22 };

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

//! returns: 0
//! Test read-only data access for `record` types.
record Point {
record Point: Copy {
    x: i32,
    y: i32,
}

record Mixed {
record Mixed: Copy {
    a: u8,
    b: u16,
    c: u32,
    d: bool,
}

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

//! returns: 0
//! Test read-only data access for `union` types.
union Color {
union Color: Copy {
    Red,
    Green,
    Blue,
}

union Value {
union Value: Copy {
    None,
    Small,
    Large,
}


test/tests/debug.tag.rad +1 -1

//! returns: 0

union Huge {
union Huge: Copy {
    Small(u32),
    Large {
        payload: [u32; 32],
        flag: u32,
    },

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

//! returns: 0
//! Test scanner peek with optional return.

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

fn peek(s: *Scanner) -> ?u8 {
    if 0 + 0 >= s.source.len {

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

//! returns: 97
//! Test scanner current character access.

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

fn isEof(s: *Scanner) -> bool {

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

//! returns: 0

union Signedness {
union Signedness: Copy {
    Signed,
    Unsigned,
}

union TypeSig {
union TypeSig: Copy {
    Integer {
        width: u8,
        sign: Signedness,
    },
}

union NodeValue {
union NodeValue: Copy {
    TypeSig(TypeSig),
}

record Node {
record Node: Copy {
    value: NodeValue,
}

fn node(nodes: *mut Node, count: *mut u32, value: NodeValue) -> *Node {
    let index = *count;

test/tests/edge.cases.5.rad +9 -9

//! returns: 0

union TestError {
union TestError: Copy {
    Fail,
}

record Derives {
record Derives: Copy {
    len: i32,
    list: [[u8; 8]; 2],
}

record StructField {
record StructField: Copy {
    typeSize: i32,
    isSigned: bool,
    value: ?i32,
}

record FieldNode {
record FieldNode: Copy {
    value: FieldValue,
}

record FieldList {
record FieldList: Copy {
    len: i32,
    list: [FieldNode; 2],
}

record StructDecl {
record StructDecl: Copy {
    derives: Derives,
    fields: FieldList,
}

record Node {
record Node: Copy {
    value: NodeValue,
}

union FieldValue {
union FieldValue: Copy {
    StructField(StructField),
    Other(i32),
}

union NodeValue {
union NodeValue: Copy {
    StructDecl(StructDecl),
    Other(i32),
}

fn expectIntType(a: i32, b: i32, c: bool, d: bool) throws (TestError) {}

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

//! returns: 0
//! Standalone repro: writing a record into a static slice clobbers the slice header.

record Entry {
record Entry: Copy {
    a: u32,
    b: u32,
    c: u32,
    d: u32,
    e: u32,

    r: u32,
    s: u32,
    t: u32,
}

record Analyzer {
record Analyzer: Copy {
    pad0: u32,
    pad1: u32,
    entries: *mut [Entry],
    len: u32,
}

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

//! returns: 42

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

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

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

//! returns: 0
//! When a nested record field from a static variable is passed by value,
//! we only the base address and ignores the offset,
//! causing the function to receive the wrong data.

record Inner {
record Inner: Copy {
    value: i32,
}

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

static global: Outer = undefined;

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

//! returns: 0

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

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

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

//! returns: 0

union MyError { A, B, C }
union MyError: Copy { A, B, C }

@default fn main() -> u32 {
    let err: MyError = MyError::B;

    if err == MyError::B {

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

//! returns: 0

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

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

test/tests/error.catch.return.rad +1 -1

/// Error type for fallible functions.
union Error { Boom }
union Error: Copy { Boom }

/// Return a value or throw an error based on the flag.
fn fallible(flag: bool) -> i32 throws (Error) {
    if flag {
        throw Error::Boom();

test/tests/error.multi.basic.rad +2 -2

//! returns: 0
//! Test basic multi-error throw and catch.

union ErrA { A }
union ErrB { B }
union ErrA: Copy { A }
union ErrB: Copy { B }

fn failA() -> i32 throws (ErrA, ErrB) {
    throw ErrA::A();
}


test/tests/error.multi.catch.rad +2 -2

//! returns: 0
//! Test catch {} (no binding) with multi-error callee.

union ErrA { A }
union ErrB { B }
union ErrA: Copy { A }
union ErrB: Copy { B }

fn failA() -> i32 throws (ErrA, ErrB) {
    throw ErrA::A();
}


test/tests/error.multi.catch.typed.binding.rad +2 -2

//! returns: 0
//! Test typed multi-catch with payload extraction via bindings.

union ErrA { A(i32) }
union ErrB { B(i32) }
union ErrA: Copy { A(i32) }
union ErrB: Copy { B(i32) }

fn failA(v: i32) -> i32 throws (ErrA, ErrB) {
    throw ErrA::A(v);
}


test/tests/error.multi.catch.typed.catchall.rad +3 -3

//! returns: 0
//! Test typed catch with a catch-all fallback.

union ErrA { A(i32) }
union ErrB { B(i32) }
union ErrC { C }
union ErrA: Copy { A(i32) }
union ErrB: Copy { B(i32) }
union ErrC: Copy { C }

fn failA() -> i32 throws (ErrA, ErrB, ErrC) {
    throw ErrA::A(10);
}


test/tests/error.multi.catch.typed.rad +2 -2

//! returns: 0
//! Test typed multi-catch: catch e as ErrA {} catch e as ErrB {}.

union ErrA { A(i32) }
union ErrB { B(i32) }
union ErrA: Copy { A(i32) }
union ErrB: Copy { B(i32) }

fn failA() -> i32 throws (ErrA, ErrB) {
    throw ErrA::A(10);
}


test/tests/error.multi.propagate.multi.rad +2 -2

//! returns: 0
//! Test propagating a multi-throw callee via plain `try`.

union ErrA { A }
union ErrB { B }
union ErrA: Copy { A }
union ErrB: Copy { B }

fn inner(flag: i32) -> i32 throws (ErrA, ErrB) {
    if flag == 1 {
        throw ErrA::A();
    }

test/tests/error.multi.propagate.rad +2 -2

//! returns: 0
//! Test error propagation with multi-error and subset throw lists.

union ErrA { A }
union ErrB { B }
union ErrA: Copy { A }
union ErrB: Copy { B }

fn innerA() -> i32 throws (ErrA) {
    throw ErrA::A();
}


test/tests/error.multi.try.optional.rad +2 -2

//! returns: 0
//! Test try? with multi-error callee.

union ErrA { A }
union ErrB { B }
union ErrA: Copy { A }
union ErrB: Copy { B }

fn failA() -> i32 throws (ErrA, ErrB) {
    throw ErrA::A();
}


test/tests/error.try.bang.success.rad +1 -1

//! returns: 0

union PanicError { Boom }
union PanicError: Copy { Boom }

fn makeOk(value: u32) -> u32 throws (PanicError) {
    return value;
}


test/tests/error.try.catch.binding.rad +1 -1

//! returns: 0

union TestError { Boom, Bust }
union TestError: Copy { Boom, Bust }

@default fn main() -> u32 {
    // Test catching and using the error value.
    let mut caught: u32 = 0;
    try failWithBoom() catch e {

test/tests/error.try.optional.rad +2 -2

//! returns: 0
//! Test try? expressions converting errors to optionals.

union TestError { Boom, Bust }
union TestError: Copy { Boom, Bust }

fn returnsOk() -> u32 throws (TestError) {
    return 42;
}

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

record Point {
record Point: Copy {
    x: u32,
    y: u32,
}

fn returnsOkPoint() -> Point throws (TestError) {

test/tests/error.try.rad +2 -2

//! returns: 0
//! Test result-based error handling with try/throw.

union TestError { Boom, Bust }
union TestError: Copy { Boom, Bust }

record ResultSink {
record ResultSink: Copy {
    last: u32,
    count: u32,
}

fn returnsOk() -> u32 throws (TestError) {

test/tests/field.aggregate.rad +5 -5

/// Test field access where the field is an aggregate type.
/// Tests record, union, and slice fields.

record Inner { x: i32, y: i32 }
union MaybeInt { None, Some(i32) }
record Inner: Copy { x: i32, y: i32 }
union MaybeInt: Copy { None, Some(i32) }

record HasRecord { inner: Inner, z: i32 }
record HasUnion { maybe: MaybeInt, z: i32 }
record HasSlice { data: *[i32], z: i32 }
record HasRecord: Copy { inner: Inner, z: i32 }
record HasUnion: Copy { maybe: MaybeInt, z: i32 }
record HasSlice: Copy { data: *[i32], z: i32 }

/// Access a record field and read from it.
fn accessRecordField() -> i32 {
    let r = HasRecord { inner: Inner { x: 10, y: 20 }, z: 30 };
    return r.inner.y;

test/tests/fn.callback.nested.rad +2 -2

//! Test for callback with nested function call inside.
//! This exercises the register save/restore logic when a callback makes
//! a function call that uses caller-saved registers.
//! returns: 0

record Reg { n: u32 }
record Reg: Copy { n: u32 }

union Val {
union Val: Copy {
    Reg(Reg),
    Imm(i32),
}

fn maxRegNum(n: u32, current: u32) -> u32 {

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

//! returns: 0
//! Test `else continue` in a for loop with let-else.

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

fn findField(fields: *[Field], target: *[u8]) -> ?i32 {

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

//!
//! 2. Blit (memcpy) offset overflow: copying structs larger than ~2047 bytes
//!    caused the offset in the load/store loop to exceed the 12-bit immediate.
//!    Fixed by periodically advancing the base registers in the blit loop.

record Big {
record Big: Copy {
    a: [u8; 2200],
    tag: i32,
}

/// Store at offset 2200 (> MAX_IMM) into a record field.

test/tests/let.copy.semantics.rad +2 -2

/// Tests for copy semantics in let bindings.
/// Aggregates with storage (variables, field access, subscript, deref) need copying.
/// Temporaries (literals, call results) can be adopted directly.

record Point { x: i32, y: i32 }
record Outer { inner: Point, z: i32 }
record Point: Copy { x: i32, y: i32 }
record Outer: Copy { inner: Point, z: i32 }

/// Returns an aggregate - caller should NOT copy.
fn makePoint() -> Point {
    return Point { x: 1, y: 2 };
}

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

//! returns: 1

union Response {
union Response: Copy {
    success(i32),
    failure,
    other { message: *[u8] },
}


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

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

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

test/tests/load.u32.high.rad +1 -1

//! Regression test: `lw` sign-extends on RV64, producing a negative
//! 64-bit value for u32 values >= 0x80000000. The correct instruction
//! is `lwu` which zero-extends.

/// A u32 value with bit 31 set, stored in a struct to force a memory load.
record Pair {
record Pair: Copy {
    lo: u32,
    hi: u32,
}

/// Test that a u32 field with bit 31 set compares correctly.

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

//! returns: 0
//! Test that LOC_ADDR values with non-zero offsets work correctly
//! for pass-by-ref types (structs).

record Inner {
record Inner: Copy {
    value: i32,
}

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

static outer: Outer = undefined;

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

//! returns: 0
//! Test assigning one optional to another when destination is LOC_ADDR
//! with offset.

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

static container: Container = undefined;

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

//! returns: 0
//! Test assigning to an optional field stored at LOC_ADDR with offset.

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

static container: Container = undefined;

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

//! returns: 0
//! Test assigning to a record field that is itself a record
//! when the parent is stored at LOC_ADDR (static).

record Inner {
record Inner: Copy {
    value: i32,
}

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

static outer: Outer = undefined;

test/tests/loop.complex.flow.rad +1 -1

//! returns: 0
//! Test loop with complex control flow inside the body.
//! This mirrors patterns in the lowerer where loops contain
//! match statements, function calls, error handling, etc.

union Result {
union Result: Copy {
    Ok(i32),
    Err(i32),
}

fn maybeAdd(x: i32, y: i32) -> Result {

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

/// Simple union for testing while-let with payload binding.
union Option { None, Some(u32) }
union Option: Copy { None, Some(u32) }

/// Sum values from a linked iteration using while-let case with binding.
fn sumWhileLet(x: Option) -> u32 {
    let mut opt = x;
    let mut sum: u32 = 0;

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

record Reg(u8);
record Reg: Copy(u8);

constant A0: Reg = Reg(10);
constant A1: Reg = Reg(11);

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

constant ENTRIES: [Entry; 2] = [

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

union Kind {
union Kind: Copy {
    A,
    B,
}

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

constant ENTRIES: [Entry; 2] = [

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

record Reg(u8);
record Reg: Copy(u8);

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

constant ENTRIES: [Entry; 2] = [

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

        }
    }
}

/// Array pattern nested inside union variant.
union Shape {
union Shape: Copy {
    Point { coords: [i32; 2] },
    Line { start: [i32; 2], end: [i32; 2] },
    None,
}


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

        else => { return 0; }
    }
}

/// Character pattern nested inside a union variant field.
union Token {
union Token: Copy {
    Punct { ch: u8, pos: i32 },
    Eof,
}

fn tokenVal(t: Token) -> i32 {

test/tests/match.multi.seal.rad +1 -1

//! Regression test: intermediate arm blocks in multi-pattern matches must be
//! sealed so that SSA variables flow correctly through single-predecessor
//! optimization. Without sealing, block parameters are created but never
//! resolved, causing values to be read from wrong registers.

union Kind { A, B, C, D, E }
union Kind: Copy { A, B, C, D, E }

fn classify(k: Kind, y: i32) -> i32 {
    match k {
        case Kind::A, Kind::B, Kind::C => {
            return y + 10;

test/tests/match.multi.survive.rad +2 -2

//! the fall-through (else) path.
//!
//! This test catches the bug by requiring a value (`state`) to survive
//! through multiple match arms and into the `else` branch.

union Kind {
union Kind: Copy {
    Alpha,
    Beta,
    Gamma,
    Delta,
    Epsilon,
}

record State {
record State: Copy {
    value: i32,
    kind: Kind,
}

fn classify(s: State) -> i32 {

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

//! returns: 0
//! Test pushing items through a mutable reference obtained via match.

record U32List {
record U32List: Copy {
    data: *mut [u32],
    len: u32,
}

union Sealed {
union Sealed: Copy {
    No { items: U32List },
    Yes,
}

fn pushItem(list: *mut U32List, value: u32) {

test/tests/match.mutref.union.rad +2 -2

//! returns: 0
//! Test matching on a mutable reference to a union field and mutating
//! the payload in place.

union State {
union State: Copy {
    A { count: u32 },
    B,
}

record Data {
record Data: Copy {
    state: State,
    value: u32,
}

fn process(d: *mut Data) -> u32 {

test/tests/match.nested.call.rad +3 -3

//! returns: 0
//! Test nested patterns with tuple-style (Call) union variants.

union Dir { North, South }
union Opt { Some(i32), None }
union Dir: Copy { North, South }
union Opt: Copy { Some(i32), None }

/// Tuple-style variant with integer literal nested pattern.
fn checkOpt(o: Opt) -> i32 {
    match o {
        case Opt::Some(42) => {

        else { return -1; };
    return x;
}

/// Nested union inside tuple-style variant.
union Wrapper { Wrap(Dir), Empty }
union Wrapper: Copy { Wrap(Dir), Empty }

fn extractDir(w: Wrapper) -> i32 {
    match w {
        case Wrapper::Wrap(Dir::North) => {
            return 10;

test/tests/match.nested.deep.rad +6 -6

//! returns: 0
//! Test deeply nested patterns: three levels of record nesting,
//! and nested unions inside records inside unions.

record Leaf {
record Leaf: Copy {
    val: i32,
}

record Branch {
record Branch: Copy {
    leaf: Leaf,
    extra: i32,
}

union Tree {
union Tree: Copy {
    Node { branch: Branch, tag: i32 },
    Empty,
}

/// Three levels deep: union -> record -> record -> record.

        }
    }
}

/// Nested union inside a record inside a union.
union Color { Red, Green, Blue }
union Color: Copy { Red, Green, Blue }

record Pixel {
record Pixel: Copy {
    color: Color,
    brightness: i32,
}

union Canvas {
union Canvas: Copy {
    Filled { pixel: Pixel },
    Blank,
}

fn getColor(cv: Canvas) -> i32 {

test/tests/match.nested.deref.rad +6 -6

//! returns: 0
//! Test nested patterns through pointer dereferences (auto-deref).

union Inner {
union Inner: Copy {
    A(i32),
    B,
}

union Outer {
union Outer: Copy {
    Some(*Inner),
    None,
}

/// Match nested union variant through pointer dereference in match/case.

        else { return -1; };
    return x;
}

/// Record with pointer field and nested pattern through deref.
record Container {
record Container: Copy {
    inner: *Inner,
    tag: i32,
}

union Boxed {
union Boxed: Copy {
    Some { c: Container },
    None,
}

/// Nested record with auto-deref on a pointer field.

    }
    return 0;
}

/// Auto-deref through pointer to record in a record field.
record Point {
record Point: Copy {
    x: i32,
    y: i32,
}

union Holder {
union Holder: Copy {
    Ptr { p: *Point, z: i32 },
    Empty,
}

fn derefRecordField(h: Holder) -> i32 {

test/tests/match.nested.guard.rad +4 -4

//! returns: 0
//! Test nested patterns combined with guards.

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

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

/// Nested pattern with guard on bound variable.

        }
    }
}

/// Nested union with guard.
union Tag { X, Y }
union Tag: Copy { X, Y }

union Box {
union Box: Copy {
    Item { tag: Tag, val: i32 },
    Empty,
}

fn guardedNested(bx: Box) -> i32 {

test/tests/match.nested.iflet.guard.rad +4 -4

//! returns: 0
//! Test nested patterns combined with guards in if-let-case.

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

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

/// Nested record pattern with guard on bound variable.

    }
    return -1;
}

/// Nested union variant with guard.
union Dir { North, South }
union Dir: Copy { North, South }

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

fn fastNorth(c: Command) -> i32 {

test/tests/match.nested.iflet.rad +4 -4

//! returns: 0
//! Test nested patterns in if-let-case and let-else contexts.

record Inner {
record Inner: Copy {
    x: i32,
    y: i32,
}

union Wrapper {
union Wrapper: Copy {
    Some { inner: Inner, z: i32 },
    None,
}

/// Nested if-let-case.

    }
    return -1;
}

/// Nested union variant in if-let-case.
union Kind { A, B }
union Kind: Copy { A, B }

union Tagged {
union Tagged: Copy {
    Item { kind: Kind, val: i32 },
    Empty,
}

fn ifLetNestedUnion(t: Tagged) -> i32 {

test/tests/match.nested.letelse.rad +2 -2

//! returns: 0
//! Test nested patterns in let-else statements.

record Inner {
record Inner: Copy {
    x: i32,
    y: i32,
}

union Wrapper {
union Wrapper: Copy {
    Some { inner: Inner, z: i32 },
    None,
}

/// Nested record destructuring in let-else.

test/tests/match.nested.letelse.union.rad +5 -5

//! returns: 0
//! Test nested union variant patterns in let-else statements.

union Dir { North, South }
union Dir: Copy { North, South }

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

/// Nested union variant in let-else.

        else { return -1; };
    return speed;
}

/// Nested union variant in let-else, deeper nesting.
record Inner {
record Inner: Copy {
    x: i32,
    y: i32,
}

union Wrapper {
union Wrapper: Copy {
    Some { inner: Inner, z: i32 },
    None,
}

union Box {
union Box: Copy {
    Filled { w: Wrapper, tag: i32 },
    Empty,
}

fn extractInner(b: Box) -> i32 {

test/tests/match.nested.literal.rad +2 -2

//! returns: 0
//! Test literal patterns (integers, booleans) nested inside union variant fields.

union Action {
union Action: Copy {
    Set { code: i32, value: i32 },
    Toggle { flag: bool },
    None,
}


    }
    return false;
}

/// Multiple literal fields in the same pattern.
union Pair {
union Pair: Copy {
    Both { a: i32, b: i32 },
    Empty,
}

fn matchBothLiterals(p: Pair) -> i32 {

test/tests/match.nested.multi.rad +3 -3

//! returns: 0
//! Test multiple nested refining fields in the same record pattern.

union Dir { North, South, East }
union Mode { Fast, Slow }
union Dir: Copy { North, South, East }
union Mode: Copy { Fast, Slow }

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

/// Two union-typed fields refined simultaneously.

test/tests/match.nested.pattern.rad +12 -12

//! returns: 0
//! Test nested patterns in match/case statements.

record Inner {
record Inner: Copy {
    x: i32,
    y: i32,
}

union Outer {
union Outer: Copy {
    A { inner: Inner, z: i32 },
    B,
}

/// Match a union variant and destructure its nested record field.

        }
    }
}

/// Multi-level nesting: three records deep.
record Deep {
record Deep: Copy {
    val: i32,
}

record Mid {
record Mid: Copy {
    deep: Deep,
    extra: i32,
}

union Wrapper {
union Wrapper: Copy {
    W { mid: Mid, tag: i32 },
    Empty,
}

fn testDeepNesting(w: Wrapper) -> i32 {

        }
    }
}

/// Nested union inside a union variant.
union Direction {
union Direction: Copy {
    North,
    South,
}

union Command {
union Command: Copy {
    Move { dir: Direction, speed: i32 },
    Stop,
}

fn testNestedUnionLiteral(c: Command) -> i32 {

        }
    }
}

/// Mixed record and union nesting with multiple fields.
record Point {
record Point: Copy {
    x: i32,
    y: i32,
}

union Shape {
union Shape: Copy {
    Circle { center: Point, radius: i32 },
    Rect { origin: Point, size: Point },
    None,
}


        }
    }
}

/// Nested union variant pattern inside record field.
union Pair {
union Pair: Copy {
    Val { a: i32, b: i32 },
    Empty,
}

record Container {
record Container: Copy {
    pair: Pair,
    label: i32,
}

union Boxed {
union Boxed: Copy {
    Some { c: Container },
    None,
}

fn testNestedUnionInRecord(bx: Boxed) -> i32 {

test/tests/match.nested.record.rad +3 -3

//! returns: 0
//! Test nested record destructuring inside union variant patterns.

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

record Rect {
record Rect: Copy {
    origin: Point,
    size: Point,
}

union Shape {
union Shape: Copy {
    Circle { center: Point, radius: i32 },
    Rectangle { rect: Rect },
    None,
}


test/tests/match.nested.union.rad +2 -2

//! returns: 0
//! Test nested union variant patterns inside record fields.

union Dir { North, South, East, West }
union Dir: Copy { North, South, East, West }

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


test/tests/match.nested.whilelet.rad +4 -4

//! returns: 0
//! Test nested patterns in while-let loops.

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

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

fn get(items: *[Opt], idx: u32) -> Opt {

        set i = i + 1;
    }
    return sum;
}

union Dir { North, South }
union Dir: Copy { North, South }

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

fn getCmd(items: *[Command], idx: u32) -> Command {

test/tests/match.record.pattern.rad +1 -1

/// Match on union variant with record payload and bind fields.
union Expr {
union Expr: Copy {
    Null,
    Pair { first: i32, second: i32 },
}

/// Extract the first field from a Pair variant.

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

        }
    }
}

/// String pattern nested inside a union variant field.
union Cmd {
union Cmd: Copy {
    Say { msg: *[u8], count: i32 },
    Quit,
}

fn dispatch(c: Cmd) -> i32 {

test/tests/match.value.copy.rad +3 -3

//!
//! The bug: when pattern-matching a union by value, the lowerer returns a
//! pointer into the original union's payload instead of copying it. If the
//! source is overwritten, the binding reads garbage.

record Pair {
record Pair: Copy {
    a: u32,
    b: u32,
}

union Data {
union Data: Copy {
    Some { pair: Pair },
    None,
}

record Box {
record Box: Copy {
    data: Data,
}

/// Test let-case on an aggregate union payload.
/// The Pair inside the union is an aggregate - its binding will be a pointer

test/tests/match.void.then.or.rad +2 -2

//! returns: 0
//! Regression test: match on void union followed by 'or' equality check
//! in the else branch.

union Op {
union Op: Copy {
    Add,
    Sub,
    Mul,
    Div,
    And,

    Xor,
    Eq,
    Ne,
}

record Expr {
record Expr: Copy {
    op: Op,
    left: i32,
    right: i32,
}


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

//! returns: 0
//! Test for result memzero overrun: success payload is tiny, error payload
//! is large, and a guard word sits immediately after the return slot.

union Err {
union Err: Copy {
    Big([u32; 3]), // 12-byte error payload, forces a large result container
}

fn fallible(ok: bool) throws (Err) {
    if ok {

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

//! returns: 0
//! Test enum with a large variant to force a payload capacity bigger than
//! the small variant we actually store.
union Payload {
union Payload: Copy {
    Big([u32; 3]), // 12-byte payload
    Small(u8),     // 1-byte payload
}

record Frame {
record Frame: Copy {
    guard1: u16,
    val: Payload,
    guard2: u32,
}


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

//! returns: 0
//! Basic standalone method test.

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

fn (p: *Point) sum() -> i32 {

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

//! returns: 0
//! Method chaining via mutable pointer returns.

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

fn (b: *mut Builder) setX(x: i32) -> *mut Builder {

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

//! returns: 0
//! Multiple methods on the same type.

record Vec2 {
record Vec2: Copy {
    x: i32,
    y: i32,
}

fn (v: *Vec2) magnitudeSq() -> i32 {

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

//! returns: 0
//! Methods called via various pointer indirections.

record Counter {
record Counter: Copy {
    value: i32,
}

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

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

//! returns: 0
//! Public attribute on standalone methods.

record Foo {
record Foo: Copy {
    x: i32,
}

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

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

//! returns: 0
//! Methods returning various types and records.

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

fn (p: *Pair) sum() -> i32 {

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

//! returns: 0
//! Methods that throw errors.

union ParseError {
union ParseError: Copy {
    Invalid,
}

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

fn (p: *mut Parser) advance() throws (ParseError) {

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

//! returns: 0
//! Standalone methods on union types.

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

fn (s: *Shape) isCircle() -> bool {

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

//! returns: 0
//! Standalone methods coexisting with trait instances on the same type.

record Widget {
record Widget: Copy {
    x: i32,
    y: i32,
}

// Standalone method.

test/tests/multi.throw.basic.rad +2 -2

/// Multi-throw: function that can throw two different error types.
union ErrA { A }
union ErrB { B }
union ErrA: Copy { A }
union ErrB: Copy { B }

fn fallible(flag: i32) -> i32 throws (ErrA, ErrB) {
    if flag == 1 {
        throw ErrA::A();
    }

test/tests/multi.throw.catch.typed.rad +2 -2

/// Multi-error typed catch: switch dispatch on error tag.
union ErrA { A }
union ErrB { B }
union ErrA: Copy { A }
union ErrB: Copy { B }

fn fallible(flag: i32) -> i32 throws (ErrA, ErrB) {
    if flag == 1 {
        throw ErrA::A();
    }

test/tests/multi.throw.propagate.rad +2 -2

/// Multi-throw propagation: caller propagates errors from callee with subset throw list.
union ErrA { A }
union ErrB { B }
union ErrA: Copy { A }
union ErrB: Copy { B }

fn inner(flag: bool) -> i32 throws (ErrA) {
    if flag {
        throw ErrA::A();
    }

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

//! returns: 0
//! Mutable borrow through a field access on a call result.

record Box {
record Box: Copy {
    x: i32,
}

fn idBox(b: *mut Box) -> *mut Box {
    return b;

test/tests/opt.record.eq.rad +2 -2

//! returns: 1
//! Test equality comparison of optional records.

record Inner {
record Inner: Copy {
    start: i32,
    end: i32,
}

record Outer {
record Outer: Copy {
    item: ?Inner,
}

@default fn main() -> bool {
    let outerA = Outer { item: Inner { start: 3, end: 9 } };

test/tests/opt.record.eq.rev.rad +1 -1

/// Tests equality between an optional record and a record (?T == T).

record Id { n: u32 }
record Id: Copy { n: u32 }

/// Wraps a record in an optional.
fn makeOpt(id: Id) -> ?Id {
    return id;
}

test/tests/opt.record.rad +2 -2

//! returns: 28
//! Test optional records with if-let.

record Vector {
record Vector: Copy {
    x: i32,
    y: i32,
    z: i32,
}

record Wrapper {
record Wrapper: Copy {
    opt: ?i32,
}

fn takeOptional(x: ?i32) -> i32 {
    if let value = x {

test/tests/opt.return.nested.rad +1 -1

//! returns: 99

record Pair {
record Pair: Copy {
    x: u32,
    y: u32,
}

fn pick(flag: bool) -> ?Pair {

test/tests/opt.return.record.rad +1 -1

//! returns: 99
//! Test returning optional records from functions.

record Vector {
record Vector: Copy {
    x: i32,
    y: i32,
    z: i32
}


test/tests/optional.aggregate.eq.rad +1 -1

// Test optional aggregate equality (non-pointer optionals)

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

fn optPairEq(a: ?Pair, b: ?Pair) -> bool {

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

//! returns: 0
//! Matching an optional record against a record value must compile and compare structurally.

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

fn classify(value: ?Pair) -> i32 {

test/tests/parser.call.record.argument.rad +1 -1

//! returns: 0

record Box { value: i32 }
record Box: Copy { value: i32 }

fn isOne(box: Box) -> bool {
    return box.value == 1;
}


test/tests/parser.condition.array.record.rad +1 -1

//! returns: 0
//! Bracketed array elements may contain record literals in a condition.

record Box { value: i32 }
record Box: Copy { value: i32 }

@default fn main() -> i32 {
    if [Box { value: 1 }][0].value == 1 {
        return 0;
    }

test/tests/parser.condition.subscript.record.rad +1 -1

//! returns: 0
//! Bracketed subscript expressions may contain record literals in a condition.

record Index { value: u32 }
record Index: Copy { value: u32 }

@default fn main() -> i32 {
    let values: [i32; 1] = [7];
    if values[Index { value: 0 }.value] == 7 {
        return 0;

test/tests/pointer.copy.edge.case.rad +4 -4

//! returns: 0

union NodeKind {
union NodeKind: Copy {
    Placeholder,
    Bool(bool),
}

record Span {
record Span: Copy {
    length: u32,
}

record Node {
record Node: Copy {
    span: Span,
    kind: NodeKind,
}

record Parser {
record Parser: Copy {
    nodes: [Node; 1],
    count: u32,
}

fn makeNode(p: *mut Parser, kind: NodeKind) -> *mut Node {

test/tests/pointer.slice.index.rad +1 -1

//! returns: 0

record Holder {
record Holder: Copy {
    ptr: *[i32],
    zero: u32,
}

// Test that pointer-to-slice indexing correctly dereferences the slice header.

test/tests/pointer.slice.store.rad +3 -3

//! returns: 0
//! Test storing through a pointer to a slice in static storage.

record Entry {
record Entry: Copy {
    a: u32,
    b: u32,
    c: u32,
    d: u32,
    e: u32,
}

record Table {
record Table: Copy {
    entries: *mut [Entry],
    len: u32,
}

record PtrBox {
record PtrBox: Copy {
    ptr: *mut *mut [Entry],
}

static STORAGE: [Entry; 2] = undefined;
static TABLE: Table = undefined;

test/tests/prog.cordic.rad +1 -1


/// Pi/2 in Q16.16.
constant HALF_PI: i32 = 102944;

/// Result record for cos and sin.
record CosSin {
record CosSin: Copy {
    cos: i32,
    sin: i32,
}

/// CORDIC rotation mode: compute cos(angle) and sin(angle).

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

//! and a min-heap priority queue. Reconstruct paths and verify distances.

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

record HeapEntry {
record HeapEntry: Copy {
    dist: u32,
    node: u32,
}

record Graph {
record Graph: Copy {
    adj: *mut [[u32; 16]],
    dist: *mut [u32],
    prev: *mut [i32],
    visited: *mut [bool],
    numNodes: u32,

test/tests/prog.eval.rad +4 -4

//! of tagged union nodes. Build expression trees, evaluate them recursively,
//! and verify results.

/// An expression node. Leaf nodes hold a number. Interior nodes hold an
/// operator and indices (into the nodes array) of their left and right children.
union Expr {
union Expr: Copy {
    Num(i32),
    Add(BinOp),
    Sub(BinOp),
    Mul(BinOp),
    Div(BinOp),
    Neg(u32),
}

/// Binary operator: indices of left and right child nodes.
record BinOp {
record BinOp: Copy {
    left: u32,
    right: u32,
}

/// A pool of expression nodes with a count of allocated nodes.
record Pool {
record Pool: Copy {
    nodes: [Expr; 64],
    count: u32,
}

/// Evaluation error.
union EvalError {
union EvalError: Copy {
    DivByZero
}

/// Allocate a new node, returning its index.
fn newNode(pool: *mut Pool, expr: Expr) -> u32 {

test/tests/prog.hanoi.rad +3 -3

constant NUM_DISKS: u32 = 6;
/// 2^6 - 1 = 63 moves.
constant MAX_MOVES: u32 = 63;

/// A single move: move a disk from one peg to another.
record Move {
record Move: Copy {
    disk: u32,
    from: u32,
    to: u32,
}

/// Log of all moves performed.
record MoveLog {
record MoveLog: Copy {
    moves: [Move; 63],
    count: u32,
}

/// Record a move.

    return 0;
}

/// Peg state: array of 3 pegs, each holding up to NUM_DISKS disks.
/// top[p] = number of disks currently on peg p.
record Pegs {
record Pegs: Copy {
    stacks: [[u32; 6]; 3],
    top: [u32; 3],
}

fn pegPush(pegs: *mut Pegs, peg: u32, disk: u32) -> bool {

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

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

/// A node in the Huffman tree.
union HNodeKind {
union HNodeKind: Copy {
    /// Leaf node with a symbol index.
    Leaf(u32),
    /// Interior node (no symbol).
    Interior,
}

record HNode {
record HNode: Copy {
    freq: u32,
    kind: HNodeKind,
    left: u32,
    right: u32,
}

constant NIL: u32 = 0xFFFFFFFF;

record HuffState {
record HuffState: Copy {
    nodes: *mut [HNode],
    nodeCount: u32,
    heap: *mut [u32],
    heapSize: u32,
    codeBits: *mut [u32],

test/tests/prog.linkedlist.rad +2 -2

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

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

/// A linked list backed by a pool of pre-allocated nodes.
record List {
record List: Copy {
    pool: [Node; 64],
    free: u32,
    head: ?u32,
}


test/tests/prog.lzw.rad +2 -2

constant MAX_DICT: u32 = 512;
constant INIT_DICT: u32 = 258;
constant CLEAR_CODE: u32 = 256;
constant EOI_CODE: u32 = 257;

record DictEntry {
record DictEntry: Copy {
    prefix: u32,
    suffix: u8,
}

record LzwState {
record LzwState: Copy {
    encDict: *mut [DictEntry],
    encDictSize: u32,
    decDict: *mut [DictEntry],
    decDictSize: u32,
    encoded: *mut [u32],

test/tests/prog.matmul.rad +1 -1

//! a known expected output. Classic benchmark kernel.

constant N: u32 = 4;

/// A 4x4 integer matrix (row-major).
record Mat4 {
record Mat4: Copy {
    rows: [[i32; 4]; 4],
}

/// Perform matrix multiplication: c = a * b.
fn matmul(c: *mut Mat4, a: *Mat4, b: *Mat4) {

test/tests/prog.mersenne.rad +1 -1

constant M: u32 = 397;
constant MATRIX_A: u32 = 0x9908B0DF;
constant UPPER_MASK: u32 = 0x80000000;
constant LOWER_MASK: u32 = 0x7FFFFFFF;

record MtState {
record MtState: Copy {
    mt: *mut [u32],
    mti: u32,
}

fn mtInit(s: *mut MtState, seed: u32) {

test/tests/prog.nqueens.rad +1 -1

//! Solve the N-Queens problem using backtracking. Count all valid placements
//! for boards of size 1 through 8 and verify against known solution counts.

constant MAX_N: u32 = 8;

record Board {
record Board: Copy {
    queens: *mut [i32],
    solutionCount: u32,
    boardSize: u32,
}


test/tests/prog.rbtree.rad +2 -2

constant NIL: u32 = 0;

constant RED: u32 = 0;
constant BLACK: u32 = 1;

record RBNode {
record RBNode: Copy {
    key: i32,
    color: u32,
    left: u32,
    right: u32,
    parent: u32,
}

record RBTree {
record RBTree: Copy {
    pool: *mut [RBNode],
    poolNext: u32,
    root: u32,
    inorder: *mut [i32],
    inorderCount: u32,

test/tests/prog.regex.rad +3 -3


constant TRANS_CHAR: u32 = 0;
constant TRANS_EPSILON: u32 = 1;
constant TRANS_DOT: u32 = 2;

record Trans {
record Trans: Copy {
    kind: u32,
    ch: u8,
    to: u32,
}

record Frag {
record Frag: Copy {
    start: u32,
    endState: u32,
}

record NfaState {
record NfaState: Copy {
    trans: *mut [Trans],
    transCount: u32,
    stateFirst: *mut [u32],
    transNext: *mut [u32],
    stateCount: u32,

test/tests/prog.sha256.rad +1 -1

//! SHA-256 (single block).
//! Implement the SHA-256 compression function for a single 512-bit block.
//! Verify against a known hash of a short message.

/// SHA-256 mutable state: hash values and message schedule.
record Sha256 {
record Sha256: Copy {
    h: [u32; 8],
    w: [u32; 64],
}

/// SHA-256 initial hash values (first 32 bits of fractional parts of square

test/tests/prog.symtab.rad +3 -3

constant MAX_SCOPES: u32 = 16;
constant HASH_SIZE: u32 = 64;
constant NIL: u32 = 0xFFFFFFFF;

/// A symbol entry in the table.
record Symbol {
record Symbol: Copy {
    /// Name of the symbol (hash for comparison).
    nameHash: u32,
    /// The value associated with this symbol.
    value: i32,
    /// Scope depth at which this symbol was defined.

    /// Previous symbol with the same name (for shadowing).
    shadow: u32,
}

/// A scope boundary marker.
record ScopeMarker {
record ScopeMarker: Copy {
    /// Number of symbols when scope was entered.
    symbolCount: u32,
}

/// The symbol table.
record SymTab {
record SymTab: Copy {
    symbols: *mut [Symbol],
    symbolCount: u32,
    scopes: *mut [ScopeMarker],
    scopeDepth: u32,
    buckets: *mut [u32],

test/tests/prog.tokenizer.rad +7 -7

//! then parses and evaluates them. Exercises: tagged unions with payloads,
//! match statements, optionals, if-let, while-let, for-in loops, records
//! with slice fields, and complex control flow.

/// Token types produced by the lexer.
union Token {
union Token: Copy {
    /// Integer literal with its value.
    Number(i32),
    /// +
    Plus,
    /// -

    /// Invalid character.
    Invalid(u8),
}

/// A lexer state over a byte slice.
record Lexer {
record Lexer: Copy {
    source: *[u8],
    pos: u32,
}

/// A list of tokens with a fixed-size backing store.
record TokenList {
record TokenList: Copy {
    tokens: *mut [Token],
    count: u32,
}

/// AST node for parsed expressions.
union Expr {
union Expr: Copy {
    Num(i32),
    BinOp(BinOpData),
    Neg(u32),
}

/// Binary operation data.
record BinOpData {
record BinOpData: Copy {
    op: u8,
    left: u32,
    right: u32,
}

/// Pool of AST nodes.
record ExprPool {
record ExprPool: Copy {
    nodes: *mut [Expr],
    count: u32,
}

/// Parser state.
record Parser {
record Parser: Copy {
    tokens: *[Token],
    tokenCount: u32,
    pos: u32,
    pool: *mut ExprPool,
}

test/tests/prog.vm.rad +4 -4

constant MAX_CODE: u32 = 256;
constant MAX_LOCALS: u32 = 16;
constant MAX_FRAMES: u32 = 8;

/// Bytecode instructions.
union Op {
union Op: Copy {
    /// Push an immediate value.
    Push(i32),
    /// Pop top two, push sum.
    Add,
    /// Pop top two, push difference (second - first).

    /// Halt execution, top of stack is result.
    Halt,
}

/// A call frame for function calls.
record Frame {
record Frame: Copy {
    returnAddr: u32,
    localBase: u32,
}

/// The VM state.
record VM {
record VM: Copy {
    code: *[Op],
    codeLen: u32,
    stack: *mut [i32],
    sp: u32,
    locals: *mut [i32],

    frameCount: u32,
    pc: u32,
}

/// VM error types.
union VmError {
union VmError: Copy {
    /// Stack underflow error.
    StackUnderflow,
    /// Stack overflow error.
    StackOverflow,
    /// Division by zero.

test/tests/ptr.addressof.field.rad +1 -1

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

/// Takes the address of a record field.
fn addressOfField(p: *Point) -> *i32 {
    return &p.y;
}

test/tests/ptr.addressof.local.rad +1 -1

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

/// Address of a record local (aggregate) - value is already a pointer.
fn addressOfRecordLocal() -> *Point {
    let p = Point { x: 1, y: 2 };
    return &p;

test/tests/ptr.deref.record.rad +1 -1

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

/// Dereferences a record pointer and accesses a field.
fn derefField(p: *Point) -> i32 {
    return (*p).x;
}

test/tests/ptr.eq.rad +1 -1

//! returns: 0

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

// Test that pointer equality uses address comparison, not value comparison.

test/tests/record.access.rad +1 -1

//! returns: 0

record Vector {
record Vector: Copy {
    x: i32,
    y: i32,
    z: i32,
    w: i32,
}

test/tests/record.alignment.rad +1 -1

//! returns: 0
//! Test record alignment computation.

record R {
record R: Copy {
    a: i32,
    b: i32,
}

@default fn main() -> i32 {

test/tests/record.array.elements.rad +2 -2

//! returns: 115
// Testing structs with array elements.

record Vector {
record Vector: Copy {
    data: [i32; 4],
}

record Matrix {
record Matrix: Copy {
    rows: [Vector; 3],
}

fn vectorSum(vec: Vector) -> i32 {
    let mut sum: i32 = 0;

test/tests/record.assign.blit.rad +1 -1

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

fn copy() {
    let p = Point { x: 1, y: 2 };
    let mut q = p;
    set q = p;

test/tests/record.copy.rad +1 -1

//! returns: 0
//! Test record value semantics through copying, mutation, and function calls.
record S {
record S: Copy {
    x: i16,
    y: i16,
    z: i16,
}


test/tests/record.ctor.tuple.rad +1 -1

record Pair(i32, i32);
record Pair: Copy(i32, i32);

fn make() -> Pair {
    return Pair(1, 2);
}

test/tests/record.empty.eq.rad +1 -1

// Test empty record equality

record Empty {}
record Empty: Copy {}

fn emptyEq(a: Empty, b: Empty) -> bool {
    return a == b;
}


test/tests/record.eq.rad +1 -1

// Holds two integer fields for equality comparisons.
record Pair {
record Pair: Copy {
    left: i32,
    right: i32,
}

// Returns true when the two records have identical fields.

test/tests/record.field.assign.rad +1 -1

//! returns: 0

record Vector { x: i32, y: i32 }
record Vector: Copy { x: i32, y: i32 }

@default fn main() -> i32 {
    let mut v: Vector = Vector { x: 3, y: 2 };

    set v.x = 40;

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

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

fn get() -> i32 {
    let p = Point { x: 1, y: 2 };
    return p.x;
}

test/tests/record.mixed.layout.rad +1 -1

record Mixed { a: i8, b: i32, c: i16 }
record Mixed: Copy { a: i8, b: i32, c: i16 }

fn get() -> i16 {
    let m = Mixed { a: 1, b: 2, c: 3 };
    return m.c;
}

test/tests/record.nested.calls.2.rad +1 -1

//! returns: 0
//! Test nested record function calls with scaling and addition.

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

fn add(p1: Point, p2: Point) -> Point {

test/tests/record.nested.calls.3.rad +1 -1

//! returns: 0
//! Test record passing through multiple nested function calls.

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

fn id(x: i32) -> i32 {

test/tests/record.nested.eq.rad +2 -2

// Test nested aggregate equality

record Inner {
record Inner: Copy {
    x: i32,
    y: i32,
}

record Outer {
record Outer: Copy {
    a: Inner,
    b: i32,
}

fn innerEq(a: Inner, b: Inner) -> bool {

test/tests/record.nested.lit.rad +2 -2

record Inner { a: i32, b: i32 }
record Outer { inner: Inner, c: i32 }
record Inner: Copy { a: i32, b: i32 }
record Outer: Copy { inner: Inner, c: i32 }

fn get() -> i32 {
    let o = Outer { inner: Inner { a: 1, b: 2 }, c: 3 };
    return o.inner.b;
}

test/tests/record.param.lit.rad +2 -2

//! returns: 0
// Test passing record literals directly into a function.

record Vector {
record Vector: Copy {
    x: i32,
    y: i32,
    z: i32
}

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

fn compute(v: Vector, p: Point) -> i32 {

test/tests/record.ptr.access.rad +1 -1

//! returns: 0

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

@default fn main() -> i32 {

test/tests/record.ptr.mutate.rad +1 -1

//! returns: 42

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

fn mutate(p: *mut Point) {

test/tests/record.shorthand.rad +2 -2

//! returns: 1
//! Test shorthand field syntax in record literals and patterns.

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

union Shape {
union Shape: Copy {
    circle(i32),
    rectangle { width: i32, height: i32 },
}

/// Test shorthand record literal construction.

test/tests/record.unlabeled.deref.rad +4 -4

//! returns: 0
// Test deref behavior for single-field unlabeled records.

record Wrap(i32);
record WrapBool(bool);
record WrapU8(u8);
record WrapU64(u64);
record Wrap: Copy(i32);
record WrapBool: Copy(bool);
record WrapU8: Copy(u8);
record WrapU64: Copy(u64);

fn getInner(w: Wrap) -> i32 {
    return *w;
}


test/tests/record.unlabeled.rad +2 -2

//! returns: 1
// TODO: Test destructuring.

record S(i32);
record R(bool, u8);
record S: Copy(i32);
record R: Copy(bool, u8);

fn passS(s: S) -> S {
    return s;
}


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

//! returns: 0
record Pair { a: i32, b: i32 }
record Pair: Copy { a: i32, b: i32 }

@default fn main() -> i32 {
    let mut total: i32 = 0;
    let mut i: i32 = 0;
    while i < 10000 {

test/tests/result.void.success.rad +1 -1

//! returns: 0
//! Test that no-result success returns work correctly.

union TestError {
union TestError: Copy {
    Failed,
}

fn voidSuccess() throws (TestError) {
    return;

test/tests/set.keyword.rad +1 -1

//! returns: 0
//! Test the `set` keyword for assignment statements.

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

@default fn main() -> i32 {

test/tests/slice.append.rad +2 -2

//! returns: 0
//! Test slice .append() method with inline allocator.

/// Simple bump allocator for testing.
record Arena {
record Arena: Copy {
    data: *mut [u8],
    offset: u32,
}

fn newArena(data: *mut [u8]) -> Arena {


    return base as *mut opaque;
}

/// Allocator record matching the compiler's expected layout.
record Allocator {
record Allocator: Copy {
    func: fn(*mut opaque, u32, u32) -> *mut opaque,
    ctx: *mut opaque,
}

fn arenaAllocFn(ctx: *mut opaque, size: u32, al: u32) -> *mut opaque {

test/tests/spill.blockarg.clobber.rad +1 -1


fn ssig1(x: u32) -> u32 {
    return rotr(x, 17) ^ rotr(x, 19) ^ (x >> 10);
}

record State {
record State: Copy {
    h: [u32; 8],
    w: [u32; 64],
}

fn prepareSchedule(s: *mut State, block: *[u32]) {

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

//! returns: 0
//! Test register spilling in a loop with many live values.
//! Computes record layout from field tags, exercising alignment and offset
//! calculations that require multiple simultaneously live registers.

record Layout {
record Layout: Copy {
    size: u32,
    alignment: u32,
}

fn getLayout(tag: u8) -> Layout {

test/tests/static.record.array.rad +1 -1

//! returns: 0
//! Test mutating a static record containing an array.

record Record {
record Record: Copy {
    values: [i32; 4],
    bias: i32,
}

static TABLE: Record = Record {

test/tests/static.slice.index.assign.rad +2 -2

//! returns: 42

record Inner {
record Inner: Copy {
    value: i32,
}

record Container {
record Container: Copy {
    pad: i32,
    items: [Inner; 3],
}

static container: Container = undefined;

test/tests/static.slice.offset.rad +2 -2

//! returns: 0
//! Test slice indexing into a static table with offsets.

record Entry {
record Entry: Copy {
    a: i32,
    b: i32,
}

record Table {
record Table: Copy {
    scratch: *mut [Entry],
    entries: *mut [Entry],
    len: u32,
}


test/tests/static.zero.bss.rad +2 -2

//! returns: 0
//! rw-data-size: 0

/// Static pool used to verify that partially initialized zero data is BSS.
record Pool {
record Pool: Copy {
    /// Undefined slice table.
    table: [*[u8]; 32],
    /// Explicitly initialized count.
    count: u32,
}

/// Padded record used to verify that zero fields plus undefined padding are BSS.
record Padded {
record Padded: Copy {
    /// Leading byte.
    tag: u8,
    /// Field that forces padding after `tag`.
    value: u32,
}

test/tests/switch.blockargs.clobber.rad +1 -1

//! In the isel, `emitBlockArgs` for case 0 writes `1` (the merge arg) to the
//! merge block's parameter register.  If the register allocator assigned that
//! parameter register to the same physical register as the switch value, the
//! tag is clobbered before subsequent case comparisons run.

union Val {
union Val: Copy {
    none,
    empty,
    data(i32),
}


test/tests/trait.aggregate.ret.rad +3 -3

//! Test trait methods returning aggregate types.
//!
//! Exercises: trait methods that return structs (both small and larger
//! than pointer size) and optionals via v-table dispatch.

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

record Vec3 {
record Vec3: Copy {
    x: i32,
    y: i32,
    z: i32,
}


    fn (*Geometry) origin() -> Point;
    fn (*Geometry) center() -> Vec3;
    fn (*Geometry) maybe() -> ?i32;
}

record Circle {
record Circle: Copy {
    cx: i32,
    cy: i32,
    radius: i32,
}


test/tests/trait.array.optional.rad +2 -2

//! Test trait objects stored in arrays and used as optional values.
//!
//! Exercises: arrays of trait objects dispatched in loops,
//! and optional trait object values.

record Adder {
record Adder: Copy {
    n: i32,
}

record Multiplier {
record Multiplier: Copy {
    n: i32,
}

trait Transform {
    fn (*Transform) apply(x: i32) -> i32;

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

//! returns: 0
//! Basic trait object dispatch test.
record Counter {
record Counter: Copy {
    value: i32,
}

trait Adder {
    fn (*mut Adder) add(n: i32) -> i32;

test/tests/trait.control.flow.rad +1 -1

//!
//! Exercises: trait method calls inside loops and conditionals,
//! verifying that vtable dispatch works correctly when interleaved
//! with branching and iteration.

record Counter {
record Counter: Copy {
    value: i32,
}

trait Stepper {
    fn (*mut Stepper) step() -> i32;

test/tests/trait.dispatch.rad +1 -1

record Acc {
record Acc: Copy {
    n: i32,
}

trait Ops {
    fn (*Ops) get() -> i32;

test/tests/trait.fn.param.rad +2 -2

//! Test passing trait objects as function parameters.
//!
//! Exercises: trait objects passed to non-method functions, including
//! both mutable and immutable trait object pointers as arguments.

record Circle {
record Circle: Copy {
    radius: i32,
}

record Square {
record Square: Copy {
    side: i32,
}

trait Shape {
    fn (*Shape) area() -> i32;

test/tests/trait.multiple.methods.rad +1 -1

//!
//! Exercises: a trait declaring multiple methods with void, bool, and
//! integer return types. Verifies vtable layout with more than one
//! entry and correct dispatch for each method.

record Accumulator {
record Accumulator: Copy {
    total: i32,
}

trait Collector {
    fn (*mut Collector) add(n: i32) -> i32;

test/tests/trait.multiple.traits.rad +1 -1

//!
//! Exercises: a single concrete type that provides instances for
//! two different traits. Each trait object dispatches independently
//! through its own vtable.

record Counter {
record Counter: Copy {
    value: i32,
}

trait Incrementable {
    fn (*mut Incrementable) inc() -> i32;

test/tests/trait.multiple.types.rad +2 -2

//!
//! Exercises: two different concrete types implementing the same trait,
//! coerced to the same trait object type. Also tests immutable `*Trait`
//! receivers. Verifies each type dispatches through its own vtable.

record Dog {
record Dog: Copy {
    age: i32,
}

record Cat {
record Cat: Copy {
    lives: i32,
}

trait Speaker {
    fn (*Speaker) speak() -> i32;

test/tests/trait.object.rad +1 -1

record Counter {
record Counter: Copy {
    value: i32,
}

trait Adder {
    fn (*mut Adder) add(n: i32) -> i32;

test/tests/trait.supertrait.forward.rad +1 -1


trait Parent {
    fn (*Parent) parent() -> i32;
}

record Value {
record Value: Copy {
    n: i32,
}

instance Parent for Value {
    fn (self: *Value) parent() -> i32 {

test/tests/trait.supertrait.rad +1 -1


trait ReadWriter: Reader + Writer {
    fn (*mut ReadWriter) flush() -> i32;
}

record Socket {
record Socket: Copy {
    rbuf: [u8; 32],
    rpos: i32,
    rlen: i32,
    wbuf: [u8; 32],
    wpos: i32,

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

//! returns: 0
//! Test trait methods with throws clauses.

union ParseError {
union ParseError: Copy {
    InvalidInput,
    Overflow,
}

record StrictParser {
record StrictParser: Copy {
    limit: i32,
}

trait Parser {
    fn (*Parser) parse(n: i32) -> i32 throws (ParseError);

test/tests/trait.writer.rad +2 -2

    fn (*mut Writer) write(data: *[u8]) -> i32;
    fn (*Writer) total() -> i32;
}

/// Writes bytes into a fixed-size buffer.
record BufferWriter {
record BufferWriter: Copy {
    buf: [u8; 64],
    pos: i32,
}

instance Writer for BufferWriter {

        return w.pos;
    }
}

/// Counts bytes written through it, forwarding to an inner writer.
record CountingWriter {
record CountingWriter: Copy {
    inner: *mut opaque Writer,
    count: i32,
}

instance Writer for CountingWriter {

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

/// Error type for fallible functions.
union Error { Boom }
union Error: Copy { Boom }

/// Return a value or throw an error based on the flag.
fn fallible(flag: bool) -> i32 throws (Error) {
    if flag {
        throw Error::Boom();

test/tests/try.catch.rad +1 -1

/// Ensure `try` with catch block diverges from the error path.
union Error { Boom }
union Error: Copy { Boom }

fn fallible(flag: bool) -> i32 throws (Error) {
    if flag {
        throw Error::Boom();
    }

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

/// Error type for fallible functions.
union Error { Boom }
union Error: Copy { Boom }

/// Return a value or throw an error based on the flag.
fn fallible(flag: bool) -> i32 throws (Error) {
    if flag {
        throw Error::Boom();

test/tests/try.panic.rad +1 -1

/// Error type for fallible functions.
union Error { Boom }
union Error: Copy { Boom }

/// Return a value or throw an error based on the flag.
fn fallible(flag: bool) -> i32 throws (Error) {
    if flag {
        throw Error::Boom();

test/tests/undefined.aggregate.rad +1 -1

/// Test lowering of undefined for aggregate types.
record Point { x: i32, y: i32 }
record Point: Copy { x: i32, y: i32 }

fn test() -> i32 {
    let p: Point = undefined;
    return p.x;
}

test/tests/undefined.record.field.rad +3 -3

///
/// The fix skips stores for `undefined` fields entirely, leaving the
/// memory uninitialised.  Covers both named-field syntax (lowerRecordFields)
/// and positional constructor syntax (lowerRecordCtor).

record Small {
record Small: Copy {
    x: i32,
    y: i32,
}

record WithArray {
record WithArray: Copy {
    data: [i32; 4],
    len: i32,
}

/// Construct a record with one field `undefined` (named-field syntax).

fn fullInit() -> i32 {
    let s = Small { x: 10, y: 20 };
    return s.x + s.y;
}

union Tagged {
union Tagged: Copy {
    A { data: [i32; 4], tag: i32 },
    B,
}

/// Union variant with record payload containing an `undefined` field.

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

//! returns: 0
//! Test that union variant tags are stored correctly for unions with many variants.

union BigUnion {
union BigUnion: Copy {
    V0,
    V1,
    V2,
    V3,
    V4,

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

//! returns: 42

union Attribute {
union Attribute: Copy {
    None = 0b0,
    Export = 0b10,
    Default = 0b100,
    Extern = 0b1000,
    Test = 0b10000,

test/tests/union.ctor.rad +2 -2

/// Union with tag-only variants.
union Color { Red, Green, Blue }
union Color: Copy { Red, Green, Blue }

/// Union with and without payload variants.
union MaybeInt { None, Some(i32) }
union MaybeInt: Copy { None, Some(i32) }

/// Builds a tag-only union variant.
fn makeRed() -> Color {
    return Color::Red;
}

test/tests/union.discriminant.cast.rad +1 -1

//! returns: 0
//! Casting a void-union variant to `i32` should produce its explicit tag value.

union U {
union U: Copy {
    A = 7,
    B = 42,
    C = 255,
}


test/tests/union.edge.case.2.rad +1 -1

//! returns: 0

union NodeValue {
union NodeValue: Copy {
    Placeholder,
    Nil,
    Bool(bool),
}


test/tests/union.edge.case.3.rad +2 -2

//! returns: 0
//! Test union match through pointer dereference.

union Node {
union Node: Copy {
    Placeholder(u8),
    Nil(u8),
    Bool(bool),
}

record Parser {
record Parser: Copy {
    root: Node,
}

fn node(p: *mut Parser, value: Node) -> *Node {
    set p.root = value;

test/tests/union.eq.rad +4 -4

/// Void union - only tag comparison needed.
union Color { Red, Green, Blue }
union Color: Copy { Red, Green, Blue }

/// Union with one payload variant.
union MaybeInt { None, Some(i32) }
union MaybeInt: Copy { None, Some(i32) }

/// Union with multiple different payload types.
union Value { Empty, Int(i32), Byte(u8) }
union Value: Copy { Empty, Int(i32), Byte(u8) }

/// Union with multi-field record payload.
union Shape { None, Point { x: i32, y: i32 } }
union Shape: Copy { None, Point { x: i32, y: i32 } }

/// Compare void unions (tags only).
fn colorEq(a: Color, b: Color) -> bool {
    return a == b;
}

test/tests/union.eq.void.ctor.rad +1 -1

//! Regression test: comparing a void union variable against a constructor
//! literal must compare tag scalars directly, not load through a pointer.

union Op { Add, Sub, Mul }
union Op: Copy { Add, Sub, Mul }

/// Compare void union against constructor literal.
fn isAdd(op: Op) -> bool {
    return op == Op::Add;
}

116	116		/// Dump the generated assembly.
117	117		Asm,
118	118		}
119	119
120	120		/// A discovered test function.
121		-	record TestDesc {
	121	+	record TestDesc: Copy {
122	122		/// Full module qualified path segments (eg. ["std", "tests"]).
123	123		modPath: [[u8]],
124	124		/// Test function name (eg. "testFoo").
125	125		fnName: *[u8],
126	126		}
127	127
128	128		/// Source inputs belonging to one command-line package.
129		-	record PackageInput {
	129	+	record PackageInput: Copy {
130	130		/// Package name from the `-pkg` argument.
131	131		name: *[u8],
132	132		/// Optional startup assembly emitted before generated text.
133	133		startupPath: ?*[u8],
134	134		/// Radiance source paths for this package.

140	140		/// Number of assembly source paths.
141	141		asmPathCount: u32,
142	142		}
143	143
144	144		/// Compilation context.
145		-	record CompileContext {
	145	+	record CompileContext: Copy {
146	146		/// Array of packages to compile.
147	147		packages: [package::Package; MAX_PACKAGES],
148	148		/// Driver inputs for each package slot.
149	149		inputs: [PackageInput; MAX_PACKAGES],
150	150		/// Number of packages.

162	162		/// Whether to emit debug info (.debug file).
163	163		debug: bool,
164	164		}
165	165
166	166		/// Root module info for a package.
167		-	record RootModule {
	167	+	record RootModule: Copy {
168	168		entry: *module::ModuleEntry,
169	169		ast: *mut ast::Node,
170	170		}
171	171
172	172		/// State carried by the streaming lowerer/codegen callback.
173		-	record CodegenSinkContext {
	173	+	record CodegenSinkContext: Copy {
174	174		/// RV64 generator receiving lowered functions.
175	175		generator: *mut rv64::Generator,
176	176		/// Arena holding the current function's lowered IL.
177	177		fnArena: *mut alloc::Arena,
178	178		}
179	179
180	180		/// Entry handling for streamed code generation.
181		-	union CodegenEntryMode {
	181	+	union CodegenEntryMode: Copy {
182	182		/// Do not reserve an entry jump.
183	183		None,
184	184		/// Reserve and patch an entry jump to the `@default` function.
185	185		DefaultEntry,
186	186		}
187	187
188	188		/// Options controlling streamed lowering and code generation.
189		-	record CodegenOptions {
	189	+	record CodegenOptions: Copy {
190	190		/// Optional output path used for progress logging.
191	191		logPath: ?*[u8],
192	192		/// Whether to emit debug source locations.
193	193		debug: bool,
194	194		/// How the generated program should handle entry.

159	159		export fn imageHeader(codeBytes: u32, roDataBytes: u32, rwDataBytes: u32) -> [u32; 5] {
160	160		return [IMAGE_MAGIC, IMAGE_VERSION, codeBytes, roDataBytes, rwDataBytes];
161	161		}
162	162
163	163		/// Storage buffers passed from driver for code generation.
164		-	export record Storage {
	164	+	export record Storage: Copy {
165	165		/// Buffer for data symbols.
166	166		dataSyms: *mut [data::DataSym],
167	167		/// Hash table entries for data symbol lookup.
168	168		dataSymEntries: *mut [dict::Entry],
169	169		}
170	170
171	171		/// Result of code generation.
172		-	export record Program {
	172	+	export record Program: Copy {
173	173		/// Slice of emitted code.
174	174		code: *[u32],
175	175		/// Slice of function addresses (name + start index).
176	176		funcs: *[types::FuncAddr],
177	177		/// Number of read-only data bytes emitted.

181	181		/// Debug entries mapping PCs to source locations. Empty when debug is off.
182	182		debugEntries: *[types::DebugEntry],
183	183		}
184	184
185	185		/// Entry jump patching requested for the generated program.
186		-	export union EntryPatch {
	186	+	export union EntryPatch: Copy {
187	187		/// No entry jump is emitted.
188	188		None,
189	189		/// Reserve code slot zero for a jump to the default function.
190	190		Reserved(?*[u8]),
191	191		}
192	192
193	193		/// Options controlling incremental RV64 program generation.
194		-	export record ProgramOptions {
	194	+	export record ProgramOptions: Copy {
195	195		/// Entry jump patching mode.
196	196		entryPatch: EntryPatch,
197	197		/// Whether to emit debug source locations.
198	198		debug: bool,
199	199		}

97	97		/// Usage string.
98	98		constant USAGE: *[u8] =
99	99		"usage: radiance -pkg <name> [-start <input.ras>] -mod <input>.. [-pkg <name> -mod <input>..] -entry <pkg> -o <output>\n";
100	100
101	101		/// Compiler error.
102		-	union Error {
	102	+	union Error: Copy {
103	103		Other,
104	104		}
105	105
106	106		/// What to dump during compilation.
107		-	union Dump {
	107	+	union Dump: Copy {
108	108		/// Don't dump anything.
109	109		None,
110	110		/// Dump the parsed AST before semantic analysis.
111	111		Ast,
112	112		/// Dump the module graph.

201	201		/// State for incremental RV64 program generation.
202	202		///
203	203		/// The generator owns global codegen state that must survive across function
204	204		/// emission. Function-local scratch stays outside this record so callers can
205	205		/// reclaim it after each function.
206		-	export record Generator {
	206	+	export record Generator: Copy {
207	207		/// Binary emitter and relocation state.
208	208		e: emit::Emitter,
209	209		/// Entry jump patching state.
210	210		entryPatch: EntryPatch,
211	211		}

71	71		/// consumes the program, [`rv64::addAssembly`] appends the text words to the
72	72		/// generated text stream and registers text labels at their relocated offsets.
73	73		/// The driver copies `data` into the final read-only data prefix; the data
74	74		/// base supplied to [`assemble`] lets the assembler resolve data addresses as
75	75		/// they will appear in that final layout.
76		-	export record Program {
	76	+	export record Program: Copy {
77	77		/// Encoded instructions in the text section.
78	78		text: *[u32],
79	79		/// Raw bytes in the data section.
80	80		data: *[u8],
81	81		/// Symbols defined by the source.

83	83		/// Text references resolved by the whole-program emitter.
84	84		externalFixups: *[Fixup],
85	85		}
86	86
87	87		/// Errors reported while assembling source text.
88		-	export union Error {
	88	+	export union Error: Copy {
89	89		/// Invalid syntax or operand form at a source offset.
90	90		Invalid { offset: u32, message: *[u8] },
91	91		/// The source emitted more text words than the caller-provided buffer holds.
92	92		TextOverflow,
93	93		/// The source emitted more data bytes than the caller-provided buffer holds.
94	94		DataOverflow,
95	95		}
96	96
97	97		/// Active output section.
98		-	export union Section {
	98	+	export union Section: Copy {
99	99		/// Instruction section.
100	100		Text,
101	101		/// Data byte section.
102	102		Data,
103	103		}
104	104
105	105		/// Branch opcode that needs fixup.
106		-	export union BranchOp {
	106	+	export union BranchOp: Copy {
107	107		/// Branch if equal.
108	108		Beq,
109	109		/// Branch if not equal.
110	110		Bne,
111	111		/// Branch if less than, signed.

121	121		/// Branch if greater than, signed pseudo-instruction.
122	122		Bgt,
123	123		}
124	124
125	125		/// Parser and encoder behavior for one instruction mnemonic.
126		-	export union InstructionEncoder {
	126	+	export union InstructionEncoder: Copy {
127	127		/// No-operand instruction encoded by a fixed encoder.
128	128		NoOperand { enc: fn() -> u32 },
129	129		/// Load-immediate pseudo-instruction.
130	130		Li,
131	131		/// Load-address pseudo-instruction.

163	163		/// Upper-immediate operand form.
164	164		Upper { enc: fn(gen::Reg, i32) -> u32 },
165	165		}
166	166
167	167		/// Classified directive name.
168		-	export union DirectiveKind {
	168	+	export union DirectiveKind: Copy {
169	169		/// `.align` directive.
170	170		Align,
171	171		/// `.ascii` directive.
172	172		Ascii,
173	173		/// `.byte` directive.

187	187		/// `.word` directive.
188	188		Word,
189	189		}
190	190
191	191		/// Instruction descriptor table row.
192		-	record InstructionEntry {
	192	+	record InstructionEntry: Copy {
193	193		/// Assembly mnemonic text.
194	194		name: *[u8],
195	195		/// Operand parser and encoder behavior.
196	196		encoder: InstructionEncoder,
197	197		}
198	198
199	199		/// Directive descriptor table row.
200		-	record DirectiveEntry {
	200	+	record DirectiveEntry: Copy {
201	201		/// Directive name without the leading `.`.
202	202		name: *[u8],
203	203		/// Parser behavior for the directive.
204	204		kind: DirectiveKind,
205	205		}
206	206
207	207		/// Register descriptor table row.
208		-	record RegisterEntry {
	208	+	record RegisterEntry: Copy {
209	209		/// Register alias text without the leading `%`.
210	210		name: *[u8],
211	211		/// Numeric register selected by the alias.
212	212		reg: gen::Reg,
213	213		}
214	214
215	215		/// CSR descriptor table row.
216		-	record CsrEntry {
	216	+	record CsrEntry: Copy {
217	217		/// CSR name text.
218	218		name: *[u8],
219	219		/// Numeric CSR address.
220	220		csr: u32,
221	221		}
222	222
223	223		/// Width of an integer data directive.
224		-	export union DataWidth {
	224	+	export union DataWidth: Copy {
225	225		/// 32-bit data value.
226	226		Word,
227	227		/// 64-bit data value.
228	228		Dword,
229	229		}

416	416		{ name: "mtval", csr: 0x343 },
417	417		{ name: "mtvec", csr: 0x305 },
418	418		];
419	419
420	420		/// Recorded symbol definition.
421		-	export record Symbol {
	421	+	export record Symbol: Copy {
422	422		/// Symbol name.
423	423		name: *[u8],
424	424		/// Section the symbol belongs to.
425	425		section: Section,
426	426		/// Byte offset within the section.

428	428		/// Whether `.export` exported this symbol outside its assembly fragment.
429	429		isExported: bool,
430	430		}
431	431
432	432		/// Information needed to resolve a pending symbol reference.
433		-	export union FixupInfo {
	433	+	export union FixupInfo: Copy {
434	434		/// Branch to a text label.
435	435		Branch { op: BranchOp, rs1: gen::Reg, rs2: gen::Reg, index: u32 },
436	436		/// JAL-like jump to a text label.
437	437		Jal { rd: gen::Reg, index: u32 },
438	438		/// Absolute address materialization into a register.

442	442		/// A 64-bit data word referring to a symbol offset.
443	443		Dword { offset: u32 },
444	444		}
445	445
446	446		/// Pending symbol reference.
447		-	export record Fixup {
	447	+	export record Fixup: Copy {
448	448		/// Referenced symbol.
449	449		symbol: *[u8],
450	450		/// Fixup payload.
451	451		info: FixupInfo,
452	452		}
453	453
454	454		/// Parser and emission state.
455		-	export record Assembler {
	455	+	export record Assembler: Copy {
456	456		/// Allocation arena for temporary assembler state.
457	457		arena: *mut alloc::Arena,
458	458		/// Assembler lexical scanner.
459	459		scan: scanner::Scanner,
460	460		/// Output text buffer.

11	11
12	12		use super::emit;
13	13		use super::scanner;
14	14
15	15		/// Parsed memory operand with base register and signed byte offset.
16		-	record MemOperand {
	16	+	record MemOperand: Copy {
17	17		/// Base register inside the memory operand parentheses.
18	18		base: gen::Reg,
19	19		/// Signed byte offset preceding the base register.
20	20		offset: i32,
21	21		}

3	3
4	4		use std::char;
5	5		use std::lang::strings;
6	6
7	7		/// Token kinds recognized by the assembler scanner.
8		-	export union TokenKind {
	8	+	export union TokenKind: Copy {
9	9		/// Special end-of-file token generated when the input is exhausted.
10	10		Eof,
11	11		/// Special invalid token carrying an error message in [`Token::source`].
12	12		Invalid,
13	13

40	40		/// Integer literal token.
41	41		Number,
42	42		}
43	43
44	44		/// Describes where assembler source originated from.
45		-	export union SourceKind {
	45	+	export union SourceKind: Copy {
46	46		/// Source loaded from a file at the given path.
47	47		File { path: *[u8] },
48	48		/// Source provided as an inline string.
49	49		String,
50	50		}
51	51
52	52		/// Lexical scanner state for assembler source.
53		-	export record Scanner {
	53	+	export record Scanner: Copy {
54	54		/// Origin of the source being scanned.
55	55		sourceKind: SourceKind,
56	56		/// Source buffer.
57	57		source: *[u8],
58	58		/// Offset of the current token in `source`.

66	66		/// Intern pool for identifier-shaped token text.
67	67		pool: *mut strings::Pool,
68	68		}
69	69
70	70		/// Individual token with kind, source text, and byte offset.
71		-	export record Token {
	71	+	export record Token: Copy {
72	72		/// Token kind.
73	73		kind: TokenKind,
74	74		/// Token source text.
75	75		source: *[u8],
76	76		/// Byte offset of `source` in the input buffer.

101	101		/////////////////////////
102	102		// Decoded Instruction //
103	103		/////////////////////////
104	104
105	105		/// Decoded RV64 instruction.
106		-	export union Instr {
	106	+	export union Instr: Copy {
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 },

29	29		//////////////////////
30	30		// Emission Context //
31	31		//////////////////////
32	32
33	33		/// Branch/jump that needs offset patching after all blocks are emitted.
34		-	export record PendingBranch {
	34	+	export record PendingBranch: Copy {
35	35		/// Index into code buffer where the branch instruction is.
36	36		index: u32,
37	37		/// Target block index.
38	38		target: u32,
39	39		/// Type of branch for re-encoding.
40	40		kind: BranchKind,
41	41		}
42	42
43	43		/// Type of branch instruction.
44		-	export union BranchKind {
	44	+	export union BranchKind: Copy {
45	45		/// Conditional branch (B-type encoding).
46	46		Cond { op: il::CmpOp, rs1: gen::Reg, rs2: gen::Reg },
47	47		/// Inverted conditional branch (B-type encoding with negated condition).
48	48		InvertedCond { op: il::CmpOp, rs1: gen::Reg, rs2: gen::Reg },
49	49		/// Unconditional jump (J-type encoding).
50	50		Jump,
51	51		}
52	52
53	53		/// Function call that needs offset patching.
54		-	export record PendingCall {
	54	+	export record PendingCall: Copy {
55	55		/// Index in code buffer where the call was emitted.
56	56		index: u32,
57	57		/// Target function name.
58	58		target: *[u8],
59	59		}
60	60
61	61		/// Assembly jump that needs offset patching after all text is emitted.
62		-	export record PendingJump {
	62	+	export record PendingJump: Copy {
63	63		/// Index in code buffer where the jump was emitted.
64	64		index: u32,
65	65		/// Target function name.
66	66		target: *[u8],
67	67		/// Destination register.
68	68		rd: gen::Reg,
69	69		}
70	70
71	71		/// Address load that needs patching after layout is known.
72		-	export record PendingAddrLoad {
	72	+	export record PendingAddrLoad: Copy {
73	73		/// Index in code buffer where the load was emitted.
74	74		index: u32,
75	75		/// Target function or data symbol name.
76	76		target: *[u8],
77	77		/// Destination register.

79	79		/// Whether this is an absolute data symbol address.
80	80		isData: bool,
81	81		}
82	82
83	83		/// Adjusted base register and offset for addressing.
84		-	export record AdjustedOffset {
	84	+	export record AdjustedOffset: Copy {
85	85		/// Base register.
86	86		base: gen::Reg,
87	87		/// Byte offset from register.
88	88		offset: i32,
89	89		}
90	90
91	91		/// Callee-saved register with its stack offset.
92		-	export record SavedReg {
	92	+	export record SavedReg: Copy {
93	93		/// Register to save/restore.
94	94		reg: gen::Reg,
95	95		/// Offset from SP.
96	96		offset: i32,
97	97		}
98	98
99	99		/// Emission context. Tracks state during code generation.
100		-	export record Emitter {
	100	+	export record Emitter: Copy {
101	101		/// Allocator for growing append-backed emitter lists.
102	102		allocator: alloc::Allocator,
103	103		/// Emitted instructions storage.
104	104		code: *mut [u32],
105	105		/// Current number of emitted instructions.

121	121		/// Number of debug entries recorded.
122	122		debugEntriesLen: u32,
123	123		}
124	124
125	125		/// Computed stack frame layout for a function.
126		-	export record Frame {
	126	+	export record Frame: Copy {
127	127		/// Total frame size in bytes (aligned).
128	128		totalSize: i32,
129	129		/// Callee-saved registers and their offsets.
130	130		// TODO: Use constant length when language supports it.
131	131		savedRegs: [SavedReg; super::NUM_SAVED_REGISTERS],

453	453		/////////////////////////
454	454		// Immediate Handling //
455	455		/////////////////////////
456	456
457	457		/// Split immediate into `hi` and `lo` bits.
458		-	export record SplitImm {
	458	+	export record SplitImm: Copy {
459	459		/// Upper 20 bits.
460	460		hi: i32,
461	461		/// Lower 12 bits.
462	462		lo: i32,
463	463		}

63	63		constant U8_MAX: i64 = 255;
64	64		constant U16_MAX: i64 = 65535;
65	65		constant U32_MAX: i64 = 4294967295;
66	66
67	67		/// Binary operation.
68		-	union BinOp { Add, And, Or, Xor }
	68	+	union BinOp: Copy { Add, And, Or, Xor }
69	69		/// Shift operation.
70		-	union ShiftOp { Sll, Srl, Sra }
	70	+	union ShiftOp: Copy { Sll, Srl, Sra }
71	71		/// Compare operation.
72		-	union CmpOp { Slt, Ult }
	72	+	union CmpOp: Copy { Slt, Ult }
73	73
74	74		/// A pending spill store to be flushed after instruction selection.
75		-	record PendingSpill {
	75	+	record PendingSpill: Copy {
76	76		/// The SSA register that was spilled.
77	77		ssa: il::Reg,
78	78		/// The physical register holding the value to store.
79	79		rd: gen::Reg,
80	80		}

82	82		////////////////////
83	83		// Selector State //
84	84		////////////////////
85	85
86	86		/// Instruction selector state.
87		-	export record Selector {
	87	+	export record Selector: Copy {
88	88		/// Emitter for outputting instructions.
89	89		e: *mut emit::Emitter,
90	90		/// Register allocation result.
91	91		ralloc: *regalloc::AllocResult,
92	92		/// Total stack frame size.

263	263		////////////////////////
264	264		// Instruction Select //
265	265		////////////////////////
266	266
267	267		/// Pre-scan result for reserve analysis.
268		-	record ReserveInfo {
	268	+	record ReserveInfo: Copy {
269	269		/// Total size needed for constant-sized reserves.
270	270		size: i32,
271	271		/// Whether any dynamic-sized reserves exist.
272	272		isDynamic: bool,
273	273		}

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		-	export record Entry {
	9	+	export record Entry: Copy {
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		-	export record Dict {
	17	+	export record Dict: Copy {
18	18		/// Hash table entries.
19	19		entries: *mut [Entry],
20	20		/// Number of occupied entries.
21	21		count: u32,
22	22		}

13	13		export constant I64_STR_LEN: u32 = 20;
14	14		/// Maximum string length for a formatted bool (eg. "false").
15	15		export constant BOOL_STR_LEN: u32 = 5;
16	16
17	17		/// Radix/base of a parsed integer literal.
18		-	export union Radix {
	18	+	export union Radix: Copy {
19	19		/// Binary literal (0b...).
20	20		Binary,
21	21		/// Decimal literal.
22	22		Decimal,
23	23		/// Hexadecimal literal (0x...).
24	24		Hex,
25	25		}
26	26
27	27		/// Errors reported while parsing literal text.
28		-	export union ParseError {
	28	+	export union ParseError: Copy {
29	29		/// Literal text was empty or missing required digits.
30	30		Invalid,
31	31		/// Literal contained an invalid digit for its radix.
32	32		InvalidDigit,
33	33		/// Literal value exceeded the supported range.
34	34		Overflow,
35	35		}
36	36
37	37		/// Parsed integer literal metadata.
38		-	export record IntLiteral {
	38	+	export record IntLiteral: Copy {
39	39		/// Raw characters that comprised the literal.
40	40		text: *[u8],
41	41		/// Magnitude parsed from the literal.
42	42		magnitude: u64,
43	43		/// Radix used by the literal.

7	7		@test mod tests;
8	8
9	9		use std::mem;
10	10
11	11		/// Error thrown by allocator.
12		-	export union AllocError {
	12	+	export union AllocError: Copy {
13	13		/// Allocator is out of memory.
14	14		OutOfMemory,
15	15		}
16	16
17	17		/// Bump allocator backed by a byte slice.
18	18		///
19	19		/// Allocations are made by advancing an offset pointer. Individual allocations
20	20		/// cannot be freed; instead, the entire arena is reset at once via [`reset`].
21		-	export record Arena {
	21	+	export record Arena: Copy {
22	22		/// Backing storage.
23	23		data: *mut [u8],
24	24		/// Current allocation offset in bytes.
25	25		offset: u32,
26	26		}

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

10	10		export constant MAX_TRAIT_METHODS: u32 = 8;
11	11
12	12		/// Arena for all parser allocations.
13	13		///
14	14		/// Uses a bump allocator for both AST nodes and node pointer arrays.
15		-	export record NodeArena {
	15	+	export record NodeArena: Copy {
16	16		/// Bump allocator for all allocations.
17	17		arena: alloc::Arena,
18	18		/// Next node ID to assign. Incremented on each node allocation.
19	19		nextId: u32,
20	20		}

36	36
37	37		return @sliceOf(ptr.ptr as mut Node, 0, capacity);
38	38		}
39	39
40	40		/// Attribute bit set applied to declarations or fields.
41		-	export union Attribute {
	41	+	export union Attribute: Copy {
42	42		/// Public visibility attribute.
43	43		Export = 0b1,
44	44		/// Default implementation attribute.
45	45		Default = 0b10,
46	46		/// Extern linkage attribute.

52	52		/// Declaration may perform unsafe pointer operations.
53	53		Unsafe = 0b100000,
54	54		}
55	55
56	56		/// Ordered collection of attribute nodes applied to a declaration.
57		-	export record Attributes {
	57	+	export record Attributes: Copy {
58	58		list: mut [Node],
59	59		}
60	60
61	61		/// Check if an attributes list contains an attribute.
62	62		export fn attributesContains(self: *Attributes, attr: Attribute) -> bool {

72	72		export fn hasAttribute(attrs: u32, attr: Attribute) -> bool {
73	73		return (attrs & (attr as u32)) <> 0;
74	74		}
75	75
76	76		/// Signedness of an integer type.
77		-	export union Signedness {
	77	+	export union Signedness: Copy {
78	78		/// Signed, eg. `i8`.
79	79		Signed,
80	80		/// Unsigned, eg. `u32`.
81	81		Unsigned,
82	82		}
83	83
84	84		/// Binary operator kinds used in numeric expressions.
85		-	export union BinaryOp {
	85	+	export union BinaryOp: Copy {
86	86		/// Addition (`+`).
87	87		Add,
88	88		/// Subtraction (`-`).
89	89		Sub,
90	90		/// Multiplication (`*`).