radiance · commit

compiler/radiance.rad +14 -14

use std::sys;
use std::sys::unix;
use std::collections::dict;

/// Maximum number of modules we can load per package.
const MAX_LOADED_MODULES: u32 = 64;
constant MAX_LOADED_MODULES: u32 = 64;
/// Maximum number of packages we can compile.
const MAX_PACKAGES: u32 = 4;
constant MAX_PACKAGES: u32 = 4;
/// Total module entries across all packages.
const MAX_TOTAL_MODULES: u32 = 192;
constant MAX_TOTAL_MODULES: u32 = 192;
/// Source code buffer arena (2 MB).
const MAX_SOURCES_SIZE: u32 = 2097152;
constant MAX_SOURCES_SIZE: u32 = 2097152;
/// Maximum number of test functions we can discover.
const MAX_TESTS: u32 = 1024;
constant MAX_TESTS: u32 = 1024;

/// Temporary arena size (32 MB) - retains all parsed AST until resolution.
/// Used for: AST during parsing, then codegen scratch space.
const TEMP_ARENA_SIZE: u32 = 33554432;
constant TEMP_ARENA_SIZE: u32 = 33554432;
/// Main arena size (128 MB) - lives throughout compilation.
/// Used for: resolver data, types, symbols, lowered IL.
const MAIN_ARENA_SIZE: u32 = 134217728;
constant MAIN_ARENA_SIZE: u32 = 134217728;

/// Temporary storage arena - reusable between phases.
static TEMP_ARENA: [u8; TEMP_ARENA_SIZE] = undefined;
/// Main storage arena - persists throughout compilation.
static MAIN_ARENA: [u8; MAIN_ARENA_SIZE] = undefined;

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

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

/// Read-only data file extension.
const RO_DATA_EXT: *[u8] = ".ro.data";
constant RO_DATA_EXT: *[u8] = ".ro.data";
/// Read-write data file extension.
const RW_DATA_EXT: *[u8] = ".rw.data";
constant RW_DATA_EXT: *[u8] = ".rw.data";
/// Maximum rodata size (1MB).
const MAX_RO_DATA_SIZE: u32 = 1048576;
constant MAX_RO_DATA_SIZE: u32 = 1048576;
/// Maximum rwdata size (1MB).
const MAX_RW_DATA_SIZE: u32 = 1048576;
constant MAX_RW_DATA_SIZE: u32 = 1048576;
/// Maximum path length.
const MAX_PATH_LEN: u32 = 256;
constant MAX_PATH_LEN: u32 = 256;
/// Read-only data buffer.
static RO_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = undefined;
/// Read-write data buffer.
static RW_DATA_BUF: [u8; MAX_RW_DATA_SIZE] = undefined;

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

/// Compiler error.
union Error {
    Other,

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

/// Storage buffers passed from driver for code generation.
export record Storage {
    /// Buffer for data symbols.
    dataSyms: *mut [data::DataSym],

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

use std::mem;

use super::encode;

/// Maximum number of instructions in code buffer.
const MAX_INSTRS: u32 = 2097152;
constant MAX_INSTRS: u32 = 2097152;
/// Maximum code length before byte offset overflows signed 32-bits.
const MAX_CODE_LEN: u32 = 0x7FFFFFFF / super::INSTR_SIZE as u32;
constant MAX_CODE_LEN: u32 = 0x7FFFFFFF / super::INSTR_SIZE as u32;
/// Maximum number of pending branches awaiting patching.
const MAX_PENDING: u32 = 65536;
constant MAX_PENDING: u32 = 65536;
/// Maximum number of function entries.
const MAX_FUNCS: u32 = 4096;
constant MAX_FUNCS: u32 = 4096;
/// Maximum number of debug entries.
const MAX_DEBUG_ENTRIES: u32 = 524288;
constant MAX_DEBUG_ENTRIES: u32 = 524288;

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


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


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

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

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

// Memory operations

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

// ALU operations

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

// Branch operations

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

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

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

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


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

///////////////
// Constants //
///////////////

/// Shift amount for byte sign/zero extension.
const SHIFT_W8: i32 = 64 - 8;
constant SHIFT_W8: i32 = 64 - 8;
/// Shift amount for halfword sign/zero extension.
const SHIFT_W16: i32 = 64 - 16;
constant SHIFT_W16: i32 = 64 - 16;
/// Shift amount for word sign/zero extension.
const SHIFT_W32: i32 = 64 - 32;
constant SHIFT_W32: i32 = 64 - 32;
/// Mask for extracting byte value.
const MASK_W8: i32 = 0xFF;
constant MASK_W8: i32 = 0xFF;
/// Maximum number of block arguments supported.
const MAX_BLOCK_ARGS: u32 = 16;
constant MAX_BLOCK_ARGS: u32 = 16;

/// Signed integer range limits.
const I8_MIN: i64 = -128;
const I8_MAX: i64 = 127;
const I16_MIN: i64 = -32768;
const I16_MAX: i64 = 32767;
const I32_MIN: i64 = -2147483648;
const I32_MAX: i64 = 2147483647;
constant I8_MIN: i64 = -128;
constant I8_MAX: i64 = 127;
constant I16_MIN: i64 = -32768;
constant I16_MAX: i64 = 32767;
constant I32_MIN: i64 = -2147483648;
constant I32_MAX: i64 = 2147483647;

/// Unsigned integer range limits.
const U8_MAX: i64 = 255;
const U16_MAX: i64 = 65535;
const U32_MAX: i64 = 4294967295;
constant U8_MAX: i64 = 255;
constant U16_MAX: i64 = 65535;
constant U32_MAX: i64 = 4294967295;

/// Binary operation.
union BinOp { Add, And, Or, Xor }
/// Shift operation.
union ShiftOp { Sll, Srl, Sra }

            }
        },
        case il::Instr::Ecall { dst, num, a0, a1, a2, a3 } => {
            // Move arguments using parallel move.
            // TODO: Can't use slice literals here because the lowerer doesn't
            // support const-evaluating struct/union values in them.
            // support constant-evaluating struct/union values in them.
            let ecallDsts: [gen::Reg; 5] = [super::A7, super::A0, super::A1, super::A2, super::A3];
            let ecallArgs: [il::Val; 5] = [num, a0, a1, a2, a3];

            emitParallelMoves(s, &ecallDsts[..], &ecallArgs[..]);
            emit::emit(s.e, encode::ecall());

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

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

///////////////////////////////
// Instruction Printing      //
///////////////////////////////

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

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

lib/std/fmt.rad +5 -5

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

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

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


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


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

/// Maximum number of trait methods.
export const MAX_TRAIT_METHODS: u32 = 8;
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 {

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

                toExprOrNull(a, decl.type),
                toExpr(a, decl.value)
            ]);
        }
        case super::NodeValue::ConstDecl(decl) =>
            return sexpr::list(a, "const", &[toExpr(a, decl.ident), toExpr(a, decl.type), toExpr(a, decl.value)]),
            return sexpr::list(a, "constant", &[toExpr(a, decl.ident), toExpr(a, decl.type), toExpr(a, decl.value)]),
        case super::NodeValue::StaticDecl(decl) =>
            return sexpr::list(a, "static", &[toExpr(a, decl.ident), toExpr(a, decl.type), toExpr(a, decl.value)]),
        case super::NodeValue::Assign(a_) =>
            return sexpr::list(a, "assign", &[toExpr(a, a_.left), toExpr(a, a_.right)]),
        case super::NodeValue::Return { value } =>

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

/// Count trailing zeros in a 32-bit value.
/// Returns the bit position of the lowest set bit (0-31).
/// Behavior is undefined if `x` is 0.
fn ctz(x: u32) -> u32 {
    // De Bruijn sequence for 32-bit CTZ.
    const DEBRUIJN: u32 = 0x077CB531;
    const TABLE: [u8; 32] = [
    constant DEBRUIJN: u32 = 0x077CB531;
    constant TABLE: [u8; 32] = [
         0,  1, 28,  2, 29, 14, 24,  3, 30, 22, 20, 15, 25, 17,  4,  8,
        31, 27, 13, 23, 21, 19, 16,  7, 26, 12, 18,  6, 11,  5, 10,  9,
    ];
    // Isolate lowest set bit, multiply by de Bruijn constant, look up.
    let isolated = x & (~x + 1);

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

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

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

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

/// Data symbol entry mapping name to address.
export record DataSym {
    /// Symbol name.
    name: *[u8],

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

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

use std::collections::dict;

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

/// Label tracking for code emission.
export record Labels {
    /// Block offsets indexed by block index.
    /// Per-function, reset each function.

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

use std::lang::gen::bitset;
use std::lang::gen::regalloc::liveness;
use std::lang::gen::regalloc::spill;

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

/// Register mapping at a program point.
/// Maps SSA registers to physical registers.
export record RegMap {
    /// SSA (virtual) registers that have mappings.

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

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

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

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

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

use std::lang::alloc;
use std::lang::gen::bitset;
use std::lang::gen::regalloc::liveness;

/// Maximum number of candidates for spill sorting.
const MAX_CANDIDATES: u32 = 256;
constant MAX_CANDIDATES: u32 = 256;
/// Maximum loop depth for cost weighting (2^10 = 1024).
const MAX_LOOP_WEIGHT: u32 = 10;
constant MAX_LOOP_WEIGHT: u32 = 10;

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

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

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

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

/// Format a qualified symbol name: `pkg::mod::path::name`.
export fn formatQualifiedName(arena: *mut alloc::Arena, path: *[*[u8]], name: *[u8]) -> *[u8] {
    let mut totalLen: u32 = name.len;
    for segment in path {

    /// Size in bytes.
    size: u32,
    /// Alignment requirement.
    alignment: u32,
    /// Whether this is read-only data.
    /// Typically, `const` declaration are read-only, while `static`
    /// Typically, `constant` declaration are read-only, while `static`
    /// declarations are not.
    readOnly: bool,
    /// Whether the data is entirely undefined.
    /// Undefined data doesn't need to be written since memory is zero-initialized.
    isUndefined: bool,

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

///////////////
// Constants //
///////////////

/// Maximum nesting depth of loops.
const MAX_LOOP_DEPTH: u32 = 16;
constant MAX_LOOP_DEPTH: u32 = 16;
/// Maximum number of `catch` clauses per `try`.
const MAX_CATCH_CLAUSES: u32 = 32;
constant MAX_CATCH_CLAUSES: u32 = 32;

// Slice Layout
//
// A slice is a fat pointer consisting of a data pointer and length.
// `{ ptr: u32, len: u32 }`.

/// Slice data pointer offset.
const SLICE_PTR_OFFSET: i32 = 0;
constant SLICE_PTR_OFFSET: i32 = 0;
/// Offset of slice length in slice data structure.
const SLICE_LEN_OFFSET: i32 = resolver::PTR_SIZE as i32;
constant SLICE_LEN_OFFSET: i32 = resolver::PTR_SIZE as i32;
/// Offset of slice capacity in slice data structure.
const SLICE_CAP_OFFSET: i32 = resolver::PTR_SIZE as i32 + 4;
constant SLICE_CAP_OFFSET: i32 = resolver::PTR_SIZE as i32 + 4;

// Trait Object Layout
//
// A trait object is a fat pointer consisting of a data pointer and a
// v-table pointer. `{ data: *T, vtable: *VTable }`.

/// Trait object data pointer offset.
const TRAIT_OBJ_DATA_OFFSET: i32 = 0;
constant TRAIT_OBJ_DATA_OFFSET: i32 = 0;
/// Trait object v-table pointer offset.
const TRAIT_OBJ_VTABLE_OFFSET: i32 = resolver::PTR_SIZE as i32;
constant TRAIT_OBJ_VTABLE_OFFSET: i32 = resolver::PTR_SIZE as i32;

// Tagged Value Layout (optionals, tagged unions)
//
// Optionals and unions use 1-byte tags. Results use 8-byte tags.
//

// When `T` is a pointer, the entire optional is stored as a single pointer.
//
// Tagged unions have a payload the size of the maximum variant size.

/// Offset of tag in tagged value data structure.
const TVAL_TAG_OFFSET: i32 = 0;
constant TVAL_TAG_OFFSET: i32 = 0;
/// Offset of value in result data structure (8-byte tag).
const RESULT_VAL_OFFSET: i32 = resolver::PTR_SIZE as i32;
constant RESULT_VAL_OFFSET: i32 = resolver::PTR_SIZE as i32;

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



///////////////////////////////
// Data Section Construction //
///////////////////////////////

// Functions for building the data section from const/static
// Functions for building the data section from constant/static
// declarations and inline literals.

/// Convert a constant integer payload to a signed 64-bit value.
fn constIntToI64(intVal: resolver::ConstInt) -> i64 {
    return (0 - intVal.magnitude as i64) if intVal.negative else intVal.magnitude as i64;

        irTyp = ilType(self, typ);
    }
    return il::DataItem::Val { typ: irTyp, val: constToScalar(val) };
}

/// Lower a const or static declaration to the data section.
/// Lower a constant or static declaration to the data section.
fn lowerDataDecl(
    self: *mut Lowerer,
    node: *ast::Node,
    value: *ast::Node,
    readOnly: bool

        }
    }
    return nil;
}

/// Find existing const data entry with matching content.
/// Find existing constant data entry with matching content.
/// Handles both string data and slice data.
fn findConstData(self: *Lowerer, values: *[il::DataValue], alignment: u32) -> ?*[u8] {
    // Fast path for strings.
    if values.len == 1 and alignment == 1 {
        if let case il::DataItem::Str(s) = values[0].item {

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

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

/// Maximum number of modules tracked in a single compilation graph.
export const MAX_MODULES: u32 = 128;
export constant MAX_MODULES: u32 = 128;
/// Maximum number of characters for a module path.
const MAX_PATH_LEN: u32 = 256;
constant MAX_PATH_LEN: u32 = 256;
/// Maximum number of components that make up a logical module path.
const MAX_MODULE_PATH_DEPTH: u32 = 16;
constant MAX_MODULE_PATH_DEPTH: u32 = 16;
/// Filesystem separator used when constructing child paths.
const PATH_SEP: u8 = '/';
constant PATH_SEP: u8 = '/';
/// Source file extension handled by the loader.
const SOURCE_EXT: *[u8] = ".rad";
constant SOURCE_EXT: *[u8] = ".rad";

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

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

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

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

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

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

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

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

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

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

            p.current.kind == scanner::TokenKind::Fn or
            p.current.kind == scanner::TokenKind::Union or
            p.current.kind == scanner::TokenKind::Record or
            p.current.kind == scanner::TokenKind::Mod or
            p.current.kind == scanner::TokenKind::Static or
            p.current.kind == scanner::TokenKind::Const or
            p.current.kind == scanner::TokenKind::Constant or
            p.current.kind == scanner::TokenKind::Use or
            p.current.kind == scanner::TokenKind::Trait;

        if not allowed {
            throw failParsing(p, "attributes are not allowed in this context");

            if consume(p, scanner::TokenKind::Mut) {
                return try parseLet(p, true);
            }
            return try parseLet(p, false);
        }
        case scanner::TokenKind::Const => {
        case scanner::TokenKind::Constant => {
            return try parseConst(p, attrs);
        }
        case scanner::TokenKind::Static => {
            return try parseStatic(p, attrs);
        }


/// Parse a constant declaration.
fn parseConst(p: *mut Parser, attrs: ?ast::Attributes) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Const, "expected `const`");
    try expect(p, scanner::TokenKind::Constant, "expected `constant`");

    let ident = try parseIdent(p, "expected identifier in const declaration");
    let ident = try parseIdent(p, "expected identifier in constant declaration");
    try expect(p, scanner::TokenKind::Colon, "expected `:` after identifier");

    let type = try parseType(p);
    try expect(p, scanner::TokenKind::Equal, "expected `=` in const declaration");
    try expect(p, scanner::TokenKind::Equal, "expected `=` in constant declaration");

    let value = try parseExpr(p);

    return node(p, ast::NodeValue::ConstDecl(
        ast::ConstDecl { ident, type, value, attrs }

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

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

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


    try expectType(type, ast::TypeSig::Integer {
        width: 4, sign: ast::Signedness::Signed
    });
}

/// Test parsing a `const` declaration.
/// Test parsing a `constant` declaration.
@test fn testParseConst() throws (testing::TestError) {
    let node = try! parseStmtStr("const ANSWER: i32 = 42;");
    let node = try! parseStmtStr("constant ANSWER: i32 = 42;");
    let case ast::NodeValue::ConstDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.ident, "ANSWER");
    try expectType(decl.type, ast::TypeSig::Integer {

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

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

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

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

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

/// Trait definition stored in the resolver.
export record TraitType {
    /// Trait name.
    name: *[u8],

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

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

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

/// Minimum `i8` value.
const I8_MIN: i32 = -128;
constant I8_MIN: i32 = -128;
/// Maximum `i8` value.
const I8_MAX: i32 = 127;
constant I8_MAX: i32 = 127;
/// Minimum `i16` value.
const I16_MIN: i32 = -32768;
constant I16_MIN: i32 = -32768;
/// Maximum `i16` value.
const I16_MAX: i32 = 32767;
constant I16_MAX: i32 = 32767;

/// Minimum `i32` value.
const I32_MIN: i32 = -2147483648;
constant I32_MIN: i32 = -2147483648;
/// Maximum `i32` value.
const I32_MAX: i32 = 2147483647;
constant I32_MAX: i32 = 2147483647;
/// Minimum `i64` value: -(2^63).
const I64_MIN: i64 = -9223372036854775808;
constant I64_MIN: i64 = -9223372036854775808;
/// Maximum `i64` value: 2^63 - 1.
const I64_MAX: i64 = 9223372036854775807;
constant I64_MAX: i64 = 9223372036854775807;

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

/// Information about a record or tuple field.
export record RecordField {
    /// Field name, `nil` for positional fields.
    name: ?*[u8],

            actual: args.len,
        }));
    }
}

/// Helper for analyzing `const` and `static` declarations.
/// Helper for analyzing `constant` and `static` declarations.
fn resolveConstOrStatic(
    self: *mut Resolver,
    node: *ast::Node,
    ident: *ast::Node,
    typeNode: *ast::Node,

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

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

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

static AST_ARENA: [u8; 2097152] = undefined;
static ARENA_STORAGE: [u8; 2097152] = undefined;
static NODE_DATA_STORAGE: [super::NodeData; 256] = undefined;
static ERROR_STORAGE: [super::Error; 16] = undefined;

static MODULE_ARENA_STORAGE: [u8; 4096] = undefined;
static MODULE_ARENA: ast::NodeArena = undefined;
static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };

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

    try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("x"));
}

@test fn testResolveConstLiteralValue() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "const ANSWER: i32 = 42;";
    let program = "constant ANSWER: i32 = 42;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let constNode = try getBlockStmt(result.root, 0);
    let sym = super::symbolFor(&a, constNode)

    try testing::expect(constType == super::Type::I32);
}

@test fn testResolveConstRequiresConstantExpr() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn value() -> i32 { return 1 } fn main() { const ANSWER: i32 = value(); }";
    let program = "fn value() -> i32 { return 1 } fn main() { constant ANSWER: i32 = value(); }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectErrorKind(&result, super::ErrorKind::ConstExprRequired);

    let errNode = err.node
        else throw testing::TestError::Failed;

    }
}

@test fn testResolveArrayLenConstValue() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [i32; 3] = [1, 2, 3]; const LEN: u32 = xs.len;";
    let program = "let xs: [i32; 3] = [1, 2, 3]; constant LEN: u32 = xs.len;";
    let result = try resolveBlockStr(&mut a, program);
    try expectNoErrors(&result);

    let constStmt = try getBlockStmt(result.root, 1);
    let case ast::NodeValue::ConstDecl(decl) = constStmt.value

    try expectAnalyzeOk("let x: u16 = 0xFFFF;");
    try expectAnalyzeOk("let x: i32 = 2147483647;");
    try expectAnalyzeOk("let x: i32 = -2147483648;");
    try expectAnalyzeOk("let x: u32 = 0xFFFFFFFF;");

    try expectAnalyzeOk("const LIMIT: u8 = 0xFF;");
    try expectAnalyzeOk("constant LIMIT: u8 = 0xFF;");

    try expectIntMismatch("let x: i8 = 128;", super::Type::I8);
    try expectIntMismatch("let x: i8 = -129;", super::Type::I8);
    try expectIntMismatch("let x: i8 = 0x80;", super::Type::I8);
    try expectIntMismatch("let x: i8 = 0b10000000;", super::Type::I8);

    try expectIntMismatch("let x: i32 = 2147483648;", super::Type::I32);
    try expectIntMismatch("let x: i32 = -2147483649;", super::Type::I32);
    try expectIntMismatch("let x: i32 = 0xFFFFFFFF;", super::Type::I32);
    try expectIntMismatch("let x: u32 = -1;", super::Type::U32);
    try expectIntMismatch("let x: u32 = 0x100000000;", super::Type::U32);
    try expectIntMismatch("const LIMIT: u8 = 512;", super::Type::U8);
    try expectIntMismatch("const LIMIT: u8 = -5;", super::Type::U8);
    try expectIntMismatch("constant LIMIT: u8 = 512;", super::Type::U8);
    try expectIntMismatch("constant LIMIT: u8 = -5;", super::Type::U8);
}

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

}

/// Test that arrays of anonymous records with labeled fields are allowed.
@test fn testResolveAnonRecordArray() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } const ARR: [Pt; 2] = [{ x: 1, y: 2 }, { x: 3, y: 4 }];";
    let program = "record Pt { x: i32, y: i32 } constant ARR: [Pt; 2] = [{ x: 1, y: 2 }, { x: 3, y: 4 }];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that arrays of anonymous records with extra fields cause count mismatch.
@test fn testResolveAnonRecordArrayMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } const ARR: [Pt; 2] = [{ x: 1, y: 2 }, { x: 3, y: 4, z: 5 }];";
    let program = "record Pt { x: i32, y: i32 } constant ARR: [Pt; 2] = [{ x: 1, y: 2 }, { x: 3, y: 4, z: 5 }];";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::RecordFieldCountMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

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

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

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


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

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


}

/// Test that a constant array can use another constant as its length.
@test fn testConstArrayWithConstLength() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "const LEN: u32 = 3; const ARR: [i32; LEN] = [1, 2, 3];";
    let program = "constant LEN: u32 = 3; constant ARR: [i32; LEN] = [1, 2, 3];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    // Verify the array constant has the correct type with length 3.
    let arrStmt = try getBlockStmt(result.root, 1);

}

/// Test that a record field can use a constant as its array length.
@test fn testRecordFieldWithConstArrayLength() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "const SIZE: u32 = 4; record Buffer { data: [i32; SIZE], }";
    let program = "constant SIZE: u32 = 4; record Buffer { data: [i32; SIZE], }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that a constant can have a record literal value (lazy record body resolution).
@test fn testConstWithRecordLiteral() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Point { x: i32, y: i32 } const ORIGIN: Point = Point { x: 0, y: 0 };";
    let program = "record Point { x: i32, y: i32 } constant ORIGIN: Point = Point { x: 0, y: 0 };";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that a constant can have a union variant value (lazy union body resolution).
@test fn testConstWithUnionVariant() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Color { Red, Green, Blue } const DEFAULT: Color = Color::Red;";
    let program = "union Color { Red, Green, Blue } constant DEFAULT: Color = Color::Red;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that record field types can reference imported types.

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

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export const SIZE: u32 = 8;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export constant SIZE: u32 = 8;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; static BUFFER: [u8; consts::SIZE] = undefined;", &mut arena);

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

    try testing::expect(intVal.magnitude == expected);
}

/// Test arithmetic constant folding: add, sub, mul, div.
@test fn testConstExprArithmetic() throws (testing::TestError) {
    try expectConstFold("const A: i32 = 10; const B: i32 = 20; const C: i32 = A + B;", 2, 30);
    try expectConstFold("const A: i32 = 50; const B: i32 = 20; const C: i32 = A - B;", 2, 30);
    try expectConstFold("const A: i32 = 6; const B: i32 = 7; const C: i32 = A * B;", 2, 42);
    try expectConstFold("const A: i32 = 100; const B: i32 = 5; const C: i32 = A / B;", 2, 20);
    try expectConstFold("constant A: i32 = 10; constant B: i32 = 20; constant C: i32 = A + B;", 2, 30);
    try expectConstFold("constant A: i32 = 50; constant B: i32 = 20; constant C: i32 = A - B;", 2, 30);
    try expectConstFold("constant A: i32 = 6; constant B: i32 = 7; constant C: i32 = A * B;", 2, 42);
    try expectConstFold("constant A: i32 = 100; constant B: i32 = 5; constant C: i32 = A / B;", 2, 20);
}

/// Test bitwise constant folding: and, or, xor.
@test fn testConstExprBitwise() throws (testing::TestError) {
    try expectConstFold("const A: i32 = 0xFF; const B: i32 = 0x0F; const C: i32 = A & B;", 2, 0x0F);
    try expectConstFold("const A: i32 = 0xF0; const B: i32 = 0x0F; const C: i32 = A | B;", 2, 0xFF);
    try expectConstFold("const A: i32 = 0xFF; const B: i32 = 0x0F; const C: i32 = A ^ B;", 2, 0xF0);
    try expectConstFold("constant A: i32 = 0xFF; constant B: i32 = 0x0F; constant C: i32 = A & B;", 2, 0x0F);
    try expectConstFold("constant A: i32 = 0xF0; constant B: i32 = 0x0F; constant C: i32 = A | B;", 2, 0xFF);
    try expectConstFold("constant A: i32 = 0xFF; constant B: i32 = 0x0F; constant C: i32 = A ^ B;", 2, 0xF0);
}

/// Test shift constant folding.
@test fn testConstExprShift() throws (testing::TestError) {
    try expectConstFold("const A: i32 = 1; const B: i32 = A << 4;", 1, 16);
    try expectConstFold("const A: i32 = 32; const B: i32 = A >> 2;", 1, 8);
    try expectConstFold("constant A: i32 = 1; constant B: i32 = A << 4;", 1, 16);
    try expectConstFold("constant A: i32 = 32; constant B: i32 = A >> 2;", 1, 8);
}

/// Test chained constant expressions (C depends on A + B, D depends on C).
@test fn testConstExprChained() throws (testing::TestError) {
    try expectConstFold("const A: i32 = 10; const B: i32 = 20; const C: i32 = A + B; const D: i32 = C * 2;", 3, 60);
    try expectConstFold("constant A: i32 = 10; constant B: i32 = 20; constant C: i32 = A + B; constant D: i32 = C * 2;", 3, 60);
}

/// Test constant expression used as array size.
@test fn testConstExprAsArraySize() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "const A: u32 = 2; const B: u32 = 3; const SIZE: u32 = A + B; const ARR: [i32; SIZE] = [1, 2, 3, 4, 5];";
    let program = "constant A: u32 = 2; constant B: u32 = 3; constant SIZE: u32 = A + B; constant ARR: [i32; SIZE] = [1, 2, 3, 4, 5];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let arrStmt = try getBlockStmt(result.root, 3);
    let sym = super::symbolFor(&a, arrStmt)

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

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export const BASE: i32 = 100;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; const DERIVED: i32 = consts::BASE + 50;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export constant BASE: i32 = 100;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; constant DERIVED: i32 = consts::BASE + 50;", &mut arena);

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


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

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export const WIDTH: u32 = 8; export const HEIGHT: u32 = 4;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; const TOTAL: u32 = consts::WIDTH * consts::HEIGHT; static BUF: [u8; TOTAL] = undefined;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export constant WIDTH: u32 = 8; export constant HEIGHT: u32 = 4;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; constant TOTAL: u32 = consts::WIDTH * consts::HEIGHT; static BUF: [u8; TOTAL] = undefined;", &mut arena);

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

/// Test that non-constant expressions in const declarations are still rejected.
/// Test that non-constant expressions in constant declarations are still rejected.
@test fn testConstExprNonConstRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn value() -> i32 { return 1; } const BAD: i32 = value() + 1;";
    let program = "fn value() -> i32 { return 1; } constant BAD: i32 = value() + 1;";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::ConstExprRequired = err.kind
        else throw testing::TestError::Failed;
}

/// Test unary negation in constant expressions.
@test fn testConstExprUnaryNeg() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "const A: i32 = 10; const B: i32 = -A;";
    let program = "constant A: i32 = 10; constant B: i32 = -A;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test unary not in constant expressions.
@test fn testConstExprUnaryNot() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "const A: bool = true; const B: bool = not A;";
    let program = "constant A: bool = true; constant B: bool = not A;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test `as` casts in constant expressions: widening, narrowing, sign changes, chaining.
@test fn testConstExprCast() throws (testing::TestError) {
    try expectConstFold("const A: i32 = 42; const B: u64 = A as u64;", 1, 42);
    try expectConstFold("const A: u64 = 10; const B: u8 = A as u8;", 1, 10);
    try expectConstFold("const A: i32 = 7; const B: u32 = A as u32;", 1, 7);
    try expectConstFold("const A: u32 = 100; const B: i32 = A as i32;", 1, 100);
    try expectConstFold("const A: u8 = 5; const B: u64 = (A as u32) as u64;", 1, 5);
    try expectConstFold("const A: u8 = 3; const B: u8 = 4; const C: i32 = (A as i32) + (B as i32);", 2, 7);
    try expectConstFold("constant A: i32 = 42; constant B: u64 = A as u64;", 1, 42);
    try expectConstFold("constant A: u64 = 10; constant B: u8 = A as u8;", 1, 10);
    try expectConstFold("constant A: i32 = 7; constant B: u32 = A as u32;", 1, 7);
    try expectConstFold("constant A: u32 = 100; constant B: i32 = A as i32;", 1, 100);
    try expectConstFold("constant A: u8 = 5; constant B: u64 = (A as u32) as u64;", 1, 5);
    try expectConstFold("constant A: u8 = 3; constant B: u8 = 4; constant C: i32 = (A as i32) + (B as i32);", 2, 7);
    // Cast of unsuffixed literal arithmetic.
    try expectConstFold("const A: u32 = (3 + 4) as u32;", 0, 7);
    try expectConstFold("const A: u32 = ((3 + 4) as u64) as u32;", 0, 7);
    try expectConstFold("const A: u32 = (3 + 4) as u32 + 1;", 0, 8);
    try expectConstFold("const A: i32 = (2 as i32) * (3 + 4);", 0, 14);
    try expectConstFold("constant A: u32 = (3 + 4) as u32;", 0, 7);
    try expectConstFold("constant A: u32 = ((3 + 4) as u64) as u32;", 0, 7);
    try expectConstFold("constant A: u32 = (3 + 4) as u32 + 1;", 0, 8);
    try expectConstFold("constant A: i32 = (2 as i32) * (3 + 4);", 0, 14);
}

/// Test `as` cast in constant expressions used as array size.
@test fn testConstExprCastAsArraySize() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "const LEN: u64 = 4; const SIZE: u32 = LEN as u32; const ARR: [i32; SIZE] = [1, 2, 3, 4];";
    let program = "constant LEN: u64 = 4; constant SIZE: u32 = LEN as u32; constant ARR: [i32; SIZE] = [1, 2, 3, 4];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let arrStmt = try getBlockStmt(result.root, 2);
    let sym = super::symbolFor(&a, arrStmt)

    try testing::expect(arrType.length == 4);
}

/// Test unsuffixed integer literals in constant expressions.
@test fn testConstExprUnsuffixedLiterals() throws (testing::TestError) {
    try expectConstFold("const A: u32 = 4 * 4;", 0, 16);
    try expectConstFold("const B: u32 = 10; const C: u32 = B * 2;", 1, 20);
    try expectConstFold("const D: u32 = 3 + 7;", 0, 10);
    try expectConstFold("const E: u32 = 2 * 3 + 4;", 0, 10);
    try expectConstFold("const F: i32 = -(3 + 4);", 0, 7);
    try expectConstFold("constant A: u32 = 4 * 4;", 0, 16);
    try expectConstFold("constant B: u32 = 10; constant C: u32 = B * 2;", 1, 20);
    try expectConstFold("constant D: u32 = 3 + 7;", 0, 10);
    try expectConstFold("constant E: u32 = 2 * 3 + 4;", 0, 10);
    try expectConstFold("constant F: i32 = -(3 + 4);", 0, 7);
}

lib/std/lang/scanner.rad +3 -4

    Continue, While, For, In,
    Loop, Match, Case, Try, Catch,
    Throw, Throws, Panic, Assert,

    // Variable binding tokens.
    Let, Mut, Const, Align,
    Let, Mut, Constant, Align,

    // Module-related tokens.
    Mod, Use, Super,

    // Type or function attributes.

    /// Corresponding token.
    tok: TokenKind,
}

/// Sorted keyword table for binary search.
const KEYWORDS: [Keyword; 51] = [
constant KEYWORDS: [Keyword; 50] = [
    { name: "align", tok: TokenKind::Align },
    { name: "and", tok: TokenKind::And },
    { name: "as", tok: TokenKind::As },
    { name: "assert", tok: TokenKind::Assert },
    { name: "bool", tok: TokenKind::Bool },
    { name: "break", tok: TokenKind::Break },
    { name: "case", tok: TokenKind::Case },
    { name: "catch", tok: TokenKind::Catch },
    { name: "const", tok: TokenKind::Const },
    { name: "constant", tok: TokenKind::Const },
    { name: "constant", tok: TokenKind::Constant },
    { name: "continue", tok: TokenKind::Continue },
    { name: "else", tok: TokenKind::Else },
    { name: "export", tok: TokenKind::Export },
    { name: "false", tok: TokenKind::False },
    { name: "fn", tok: TokenKind::Fn },

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


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

/// Table size.
const TABLE_SIZE: u32 = 8192;
constant TABLE_SIZE: u32 = 8192;

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

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


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

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

/// Open file for writing only.
export const O_WRONLY: OpenFlags = OpenFlags(1);
export constant O_WRONLY: OpenFlags = OpenFlags(1);

/// Open file for reading and writing.
export const O_RDWR: OpenFlags = OpenFlags(2);
export constant O_RDWR: OpenFlags = OpenFlags(2);

/// Create file if it doesn't exist.
export const O_CREAT: OpenFlags = OpenFlags(64);
export constant O_CREAT: OpenFlags = OpenFlags(64);

/// Truncate file to zero length.
export const O_TRUNC: OpenFlags = OpenFlags(512);
export constant O_TRUNC: OpenFlags = OpenFlags(512);

/// Standard file descriptor for stdin.
export const STDIN: i64 = 0;
export constant STDIN: i64 = 0;

/// Standard file descriptor for stdout.
export const STDOUT: i64 = 1;
export constant STDOUT: i64 = 1;

/// Standard file descriptor for stderr.
export const STDERR: i64 = 2;
export constant STDERR: i64 = 2;

/// Special value representing current working directory for `openat()`.
const AT_FDCWD: i64 = -100;
constant AT_FDCWD: i64 = -100;

/// Opens a file at the given path and returns a file descriptor.
/// Returns a negative value on error.
export fn open(path: *[u8], flags: OpenFlags) -> i64 {
    return intrinsics::ecall(56, AT_FDCWD, path.ptr as i64, *flags, 0);

test/runner.rad +7 -7

use std::lang::resolver;
use std::lang::strings;
use std::lang::lower;

/// Buffer size for reading source files (8 KB).
const SOURCE_BUF_SIZE: u32 = 8192;
constant SOURCE_BUF_SIZE: u32 = 8192;
/// Buffer size for reading expected IL files (32 KB).
const EXPECTED_BUF_SIZE: u32 = 32768;
constant EXPECTED_BUF_SIZE: u32 = 32768;
/// Buffer size for generated IL output (32 KB).
const OUTPUT_BUF_SIZE: u32 = 32768;
constant OUTPUT_BUF_SIZE: u32 = 32768;
/// Arena size for AST/IL allocations (512 KB).
const ARENA_SIZE: u32 = 524288;
constant ARENA_SIZE: u32 = 524288;
/// Maximum path length for expected IL file path.
const MAX_PATH_LEN: u32 = 256;
constant MAX_PATH_LEN: u32 = 256;

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

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

// Static storage for large buffers to avoid stack overflow.
// Tests run serially so sharing these is safe.
static SOURCE_BUF: [u8; SOURCE_BUF_SIZE] = undefined;
static EXPECTED_BUF: [u8; EXPECTED_BUF_SIZE] = undefined;

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

//! returns: 0

/// Test that constant expressions referencing other constants
/// can be used as array sizes.

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

static DATA: [i32; TOTAL] = undefined;

@default fn main() -> i32 {
    // Verify the array has the expected length.

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

//! returns: 0

/// Test that `as` casts work in constant expressions.

// Widening, narrowing, sign changes.
const A: i32 = 42;
const B: u64 = A as u64;
const C: u8 = 10;
const D: i32 = C as i32;
const SHIFTED: u64 = 4 as u64;
constant A: i32 = 42;
constant B: u64 = A as u64;
constant C: u8 = 10;
constant D: i32 = C as i32;
constant SHIFTED: u64 = 4 as u64;

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

// Cast of unsuffixed literal arithmetic.
const E: u32 = (3 + 4) as u32;
constant E: u32 = (3 + 4) as u32;
// Nested casts of literal arithmetic.
const F: u32 = ((3 + 4) as u64) as u32;
constant F: u32 = ((3 + 4) as u64) as u32;
// Cast + arithmetic.
const G: u32 = (3 + 4) as u32 + 1;
constant G: u32 = (3 + 4) as u32 + 1;
// Arithmetic with cast subexprs.
const H: i32 = (2 as i32) * (3 + 4);
constant H: i32 = (2 as i32) * (3 + 4);

// Cast in static data initializer.
const INIT_VAL: u8 = 0xFF;
const WIDE: u32 = INIT_VAL as u32;
constant INIT_VAL: u8 = 0xFF;
constant WIDE: u32 = INIT_VAL as u32;

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

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

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

//! returns: 0

/// Test that unsuffixed integer literals work in const expressions.
/// Test that unsuffixed integer literals work in constant expressions.

// Literal * literal.
const A: u32 = 4 * 4;
constant A: u32 = 4 * 4;
// Const * literal.
const B: u32 = 10;
const C: u32 = B * 2;
constant B: u32 = 10;
constant C: u32 = B * 2;
// Literal + literal.
const D: u32 = 3 + 7;
constant D: u32 = 3 + 7;
// Chained with literals.
const E: u32 = 2 * 3 + 4;
constant E: u32 = 2 * 3 + 4;
// Unary negation with literal.
const F: i32 = -5;
const G: i32 = F * 2;
constant F: i32 = -5;
constant G: i32 = F * 2;

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

@default fn main() -> i32 {

test/tests/const-expr-refs.rad +12 -12

//! returns: 0

/// Test that constant expressions can reference other constants,
/// including arithmetic on constants.

const A: i32 = 10;
const B: i32 = 20;
const C: i32 = A + B;
const D: i32 = C * 2;
const E: i32 = D - A;
const F: i32 = E / 5;
const G: i32 = A % 3;
const H: i32 = A | B;
const I: i32 = A & B;
const J: i32 = A ^ B;
const K: i32 = A << 2;
const L: i32 = B >> 1;
constant A: i32 = 10;
constant B: i32 = 20;
constant C: i32 = A + B;
constant D: i32 = C * 2;
constant E: i32 = D - A;
constant F: i32 = E / 5;
constant G: i32 = A % 3;
constant H: i32 = A | B;
constant I: i32 = A & B;
constant J: i32 = A ^ B;
constant K: i32 = A << 2;
constant L: i32 = B >> 1;

@default fn main() -> i32 {
    if C != 30 { return 1; }
    if D != 60 { return 2; }
    if E != 50 { return 3; }

test/tests/const.array.copy.mutate.rad +1 -1

//! returns: 22
//! Test copying and mutating constant arrays.

const SEED: [i32; 4] = [1, 2, 3, 4];
constant SEED: [i32; 4] = [1, 2, 3, 4];

fn crunch() -> i32 {
    let mut working: [i32; 4] = SEED;

    working[0] += 5;

test/tests/const.array.ident.rad +3 -3

/// Test constant array containing references to other constants.
/// This tests that identifiers referencing constants are treated as const expressions.
/// This tests that identifiers referencing constants are treated as constant expressions.

const A: i32 = 42;
const B: [i32; 1] = [A];
constant A: i32 = 42;
constant B: [i32; 1] = [A];

fn test() -> i32 {
    return B[0];
}

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

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

const NUMBERS: [i32; 4] = [1, 2, 3, 4];
constant NUMBERS: [i32; 4] = [1, 2, 3, 4];

@default fn main() -> i32 {
    let mut sum: i32 = 0;
    for n in (NUMBERS) {
        sum += n;

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

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

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

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

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

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

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

const POINTS: [Point; 3] = [Point { x: 1, y: 2 }; 3];
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.array.strings.slice.rad +1 -1

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


test/tests/const.basic.rad +3 -3

//! returns: 0
// Test constant declarations with literals only (no expressions).
const N: i32 = 3;
const MAX: i32 = 4;
const DEBUG: bool = true;
constant N: i32 = 3;
constant MAX: i32 = 4;
constant DEBUG: bool = true;

@default fn main() -> i32 {
    let n: i32 = N;
    let area: i32 = (n * 10);
    let result: i32 = MAX * 2;

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

//! returns: 0

const LETTER: u8 = 'A';
const DIGIT: u8 = '0';
constant LETTER: u8 = 'A';
constant DIGIT: u8 = '0';

@default fn main() -> u8 {
    if (DIGIT == '0') {
        return (LETTER) - 65;
    }

test/tests/const.fn.array.rad +2 -2

//! Test function pointers stored in const/static arrays.
//! Test function pointers stored in constant/static arrays.
//! Verifies that function references are properly emitted as
//! data items and can be called through the array.
//! returns: 0

fn add(a: i32, b: i32) -> i32 {


fn mul(a: i32, b: i32) -> i32 {
    return a * b;
}

const OPS: [fn(i32, i32) -> i32; 3] = [add, sub, mul];
constant OPS: [fn(i32, i32) -> i32; 3] = [add, sub, mul];

@default fn main() -> i32 {
    // add(10, 3) == 13
    let r0 = OPS[0](10, 3);
    assert r0 == 13;

test/tests/const.negative.rad +3 -3

// Test negative constant values

const NEG_ONE: i32 = -1;
const NEG_FORTY_TWO: i32 = -42;
const NEG_MAX: i32 = -2147483648;
constant NEG_ONE: i32 = -1;
constant NEG_FORTY_TWO: i32 = -42;
constant NEG_MAX: i32 = -2147483648;

fn getNegOne() -> i32 {
    return NEG_ONE;
}


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

    x: i32,
    y: i32,
}

// A constant array of structs
const POINTS: [Point; 3] = [
constant POINTS: [Point; 3] = [
    Point { x: 1, y: 2 },
    Point { x: 3, y: 4 },
    Point { x: 5, y: 6 }
];


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

    x: i32,
    y: i32,
}

// Define an array of record constants
const POINTS: [Point; 3] = [
constant POINTS: [Point; 3] = [
    Point { x: 1, y: 2 },
    Point { x: 3, y: 4 },
    Point { x: 5, y: 6 }
];


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

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

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

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

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

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

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

fn getX(p: Point) -> i32 {
    return p.x;
}


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

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

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

/// Returns a scratch register, avoiding the one already used by `rs`.
fn test(rs: Reg) -> Reg {
    let mut scratch = SCRATCH1;
    if rs.n == SCRATCH1.n {

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

8	8		x: u8,
9	9		inner: Inner,
10	10		y: u8,
11	11		}
12	12
13		-	const O: Outer = Outer { x: 1, inner: Inner { a: 2, b: 3 }, y: 4 };
	13	+	constant O: Outer = Outer { x: 1, inner: Inner { a: 2, b: 3 }, y: 4 };
14	14
15	15		fn getX() -> u8 {
16	16		return O.x;
17	17		}
18	18

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

3	3		a: u8,
4	4		b: u8,
5	5		c: u8,
6	6		}
7	7
8		-	const P: Packed = Packed { a: 1, b: 2, c: 3 };
	8	+	constant P: Packed = Packed { a: 1, b: 2, c: 3 };
9	9
10	10		fn getA() -> u8 {
11	11		return P.a;
12	12		}
13	13

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

3	3		a: u8,
4	4		b: i32,
5	5		c: u8,
6	6		}
7	7
8		-	const P: Padded = Padded { a: 1, b: 2, c: 3 };
	8	+	constant P: Padded = Padded { a: 1, b: 2, c: 3 };
9	9
10	10		fn getA() -> u8 {
11	11		return P.a;
12	12		}
13	13

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

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

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

@default fn main() -> i32 {
    return (ORIGIN.x + ORIGIN.y) - 7;
}

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

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

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


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

/// Test scalar constant lowering.
const VALUE: i32 = 42;
constant VALUE: i32 = 42;

fn getValue() -> i32 {
    return VALUE;
}

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

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

fn totalLen() -> u32 {

test/tests/const.slice.param.rad +1 -1

//! returns: 36

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

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


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

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

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

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

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

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

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

    Int(i32),
    Bool(bool),
    None,
}

const V: Value = Value::Int(42);
constant V: Value = Value::Int(42);

@default fn main() -> i32 {
    match V {
        case Value::Int(x) => {
            assert x == 42;

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

union Expr {
    Nil,
    Pair { first: i32, second: i32 },
}

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

@default fn main() -> i32 {
    match E {
        case Expr::Nil => return 1,
        case Expr::Pair { first, second } => {

test/tests/data.array.rad +7 -7

1	1		//! returns: 0
2	2		//! Test read-only data access for arrays of various types.
3		-	const U8S: [u8; 2] = [10, 20];
4		-	const U16S: [u16; 2] = [1000, 2000];
5		-	const U32S: [u32; 2] = [100000, 200000];
6		-	const I8S: [i8; 2] = [-10, 10];
7		-	const I16S: [i16; 2] = [-1000, 1000];
8		-	const I32S: [i32; 2] = [-100000, 100000];
9		-	const BOOLS: [bool; 2] = [true, false];
	3	+	constant U8S: [u8; 2] = [10, 20];
	4	+	constant U16S: [u16; 2] = [1000, 2000];
	5	+	constant U32S: [u32; 2] = [100000, 200000];
	6	+	constant I8S: [i8; 2] = [-10, 10];
	7	+	constant I16S: [i16; 2] = [-1000, 1000];
	8	+	constant I32S: [i32; 2] = [-100000, 100000];
	9	+	constant BOOLS: [bool; 2] = [true, false];
10	10
11	11		@default fn main() -> i32 {
12	12		assert U8S[0] == 10;
13	13		assert U8S[1] == 20;
14	14

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

//! returns: 0
//! Test read-only data access for `bool` type.
const T: bool = true;
const F: bool = false;
constant T: bool = true;
constant F: bool = false;

@default fn main() -> i32 {
    assert T == true;
    assert F == false;
    assert T;

test/tests/data.i16.rad +4 -4

//! returns: 0
//! Test read-only data access for `i16` type.
const A: i16 = 0;
const B: i16 = 32767;
const C: i16 = -32768;
const D: i16 = -1;
constant A: i16 = 0;
constant B: i16 = 32767;
constant C: i16 = -32768;
constant D: i16 = -1;

@default fn main() -> i32 {
    assert A == 0;
    assert B == 32767;
    assert C == -32768;

test/tests/data.i32.rad +4 -4

//! returns: 0
//! Test read-only data access for `i32` type.
const A: i32 = 0;
const B: i32 = 2147483647;
const C: i32 = -2147483648;
const D: i32 = -1;
constant A: i32 = 0;
constant B: i32 = 2147483647;
constant C: i32 = -2147483648;
constant D: i32 = -1;

@default fn main() -> i32 {
    assert A == 0;
    assert B == 2147483647;
    assert C == -2147483648;

test/tests/data.i8.rad +4 -4

//! returns: 0
//! Test read-only data access for `i8` type.
const A: i8 = 0;
const B: i8 = 127;
const C: i8 = -128;
const D: i8 = -1;
constant A: i8 = 0;
constant B: i8 = 127;
constant C: i8 = -128;
constant D: i8 = -1;

@default fn main() -> i32 {
    assert A == 0;
    assert B == 127;
    assert C == -128;

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

    b: u16,
    c: u32,
    d: bool,
}

const ORIGIN: Point = Point { x: 0, y: 0 };
const P1: Point = Point { x: 100, y: -50 };
const M1: Mixed = Mixed { a: 255, b: 1000, c: 100000, d: true };
constant ORIGIN: Point = Point { x: 0, y: 0 };
constant P1: Point = Point { x: 100, y: -50 };
constant M1: Mixed = Mixed { a: 255, b: 1000, c: 100000, d: true };

@default fn main() -> i32 {
    assert ORIGIN.x == 0;
    assert ORIGIN.y == 0;


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

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

@default fn main() -> i32 {
    if DATA[0] == 10 and
       DATA[1] == 20 and
       DATA[2] == 30 and

test/tests/data.u16.rad +3 -3

//! returns: 0
//! Test read-only data access for `u16` type.
const A: u16 = 0;
const B: u16 = 32767;
const C: u16 = 65535;
constant A: u16 = 0;
constant B: u16 = 32767;
constant C: u16 = 65535;

@default fn main() -> i32 {
    assert A == 0;
    assert B == 32767;
    assert C == 65535;

test/tests/data.u32.rad +3 -3

//! returns: 0
//! Test read-only data access for `u32` type.
const A: u32 = 0;
const B: u32 = 2147483647;
const C: u32 = 4294967295;
constant A: u32 = 0;
constant B: u32 = 2147483647;
constant C: u32 = 4294967295;

@default fn main() -> i32 {
    assert A == 0;
    assert B == 2147483647;
    assert C == 4294967295;

test/tests/data.u8.rad +3 -3

//! returns: 0
//! Test read-only data access for `u8` type.
const A: u8 = 0;
const B: u8 = 127;
const C: u8 = 255;
constant A: u8 = 0;
constant B: u8 = 127;
constant C: u8 = 255;

@default fn main() -> i32 {
    assert A == 0;
    assert B == 127;
    assert C == 255;

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

    None,
    Small,
    Large,
}

const C1: Color = Color::Red;
const C2: Color = Color::Green;
const C3: Color = Color::Blue;
constant C1: Color = Color::Red;
constant C2: Color = Color::Green;
constant C3: Color = Color::Blue;

const V1: Value = Value::None;
const V2: Value = Value::Small;
const V3: Value = Value::Large;
constant V1: Value = Value::None;
constant V2: Value = Value::Small;
constant V3: Value = Value::Large;

@default fn main() -> i32 {
    match C1 {
        case Color::Red => {},
        else => { return 1; },

test/tests/prog.ackermann.rad +2 -2

//! verify against known results. Also implements a memoized iterative
//! version and cross-checks the two.

/// Maximum memo table dimensions.
/// We memoize for m <= 3 and n <= MAX_N.
const MAX_M: u32 = 4;
const MAX_N: u32 = 128;
constant MAX_M: u32 = 4;
constant MAX_N: u32 = 128;

/// Classic recursive Ackermann function.
/// Only call with small arguments to avoid stack overflow.
fn ack(m: u32, n: u32) -> i32 {
    if m == 0 {

test/tests/prog.bignum.rad +1 -1

//! Implement multi-word unsigned integer arithmetic using arrays of u32 limbs
//! (little-endian). Operations: add, subtract, multiply, compare, shift.
//! Verify using known large-number identities and cross-checks.

/// Number of limbs per big number (128 bits = 4 x 32-bit words).
const LIMBS: u32 = 4;
constant LIMBS: u32 = 4;

/// Set a big number to a u32 value.
fn bnFromU32(dst: *mut [u32], val: u32) {
    dst[0] = val;
    let mut i: u32 = 1;

test/tests/prog.cordic.rad +5 -5

//! fixed-point arithmetic (Q16.16 format). This is a classic embedded
//! systems / DSP benchmark that stress-tests shift, multiply, and
//! table-driven computation without floating point.

/// Fixed-point scale factor: 1.0 = 65536 (Q16.16).
const SCALE: i32 = 65536;
constant SCALE: i32 = 65536;

/// Number of CORDIC iterations (more = more precision).
const ITERATIONS: u32 = 16;
constant ITERATIONS: u32 = 16;

/// CORDIC gain factor in Q16.16. After 16 iterations, the gain is
/// approximately 1/K = 1/1.6468 = 0.60725 * 65536 = 39797.
const CORDIC_GAIN: i32 = 39797;
constant CORDIC_GAIN: i32 = 39797;

/// Pi in Q16.16: 3.14159 * 65536 = 205887
const PI: i32 = 205887;
constant PI: i32 = 205887;

/// Pi/2 in Q16.16.
const HALF_PI: i32 = 102944;
constant HALF_PI: i32 = 102944;

/// Result record for cos and sin.
record CosSin {
    cos: i32,
    sin: i32,

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

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

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

record HeapEntry {
    dist: u32,
    node: u32,
}

test/tests/prog.hanoi.rad +2 -2

//! returns: 0
//! Tower of Hanoi.
//! Solve Tower of Hanoi for N disks, recording moves into an array.
//! Verify the move count and specific moves are correct.

const NUM_DISKS: u32 = 6;
constant NUM_DISKS: u32 = 6;
/// 2^6 - 1 = 63 moves.
const MAX_MOVES: u32 = 63;
constant MAX_MOVES: u32 = 63;

/// A single move: move a disk from one peg to another.
record Move {
    disk: u32,
    from: u32,

test/tests/prog.huffman.rad +4 -4

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

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

/// A node in the Huffman tree.
union HNodeKind {
    /// Leaf node with a symbol index.
    Leaf(u32),

    kind: HNodeKind,
    left: u32,
    right: u32,
}

const NIL: u32 = 0xFFFFFFFF;
constant NIL: u32 = 0xFFFFFFFF;

record HuffState {
    nodes: *mut [HNode],
    nodeCount: u32,
    heap: *mut [u32],

test/tests/prog.lzw.rad +4 -4

//! returns: 0
//! LZW compression and decompression.
//! Implement the Lempel-Ziv-Welch algorithm with a fixed-size dictionary.
//! Encode a byte buffer, decode it, and verify perfect round-trip.

const MAX_DICT: u32 = 512;
const INIT_DICT: u32 = 258;
const CLEAR_CODE: u32 = 256;
const EOI_CODE: u32 = 257;
constant MAX_DICT: u32 = 512;
constant INIT_DICT: u32 = 258;
constant CLEAR_CODE: u32 = 256;
constant EOI_CODE: u32 = 257;

record DictEntry {
    prefix: u32,
    suffix: u8,
}

test/tests/prog.matmul.rad +1 -1

//! returns: 0
//! Matrix multiplication.
//! Multiply two 4x4 integer matrices and verify the result against
//! a known expected output. Classic benchmark kernel.

const N: u32 = 4;
constant N: u32 = 4;

/// A 4x4 integer matrix (row-major).
record Mat4 {
    rows: [[i32; 4]; 4],
}

test/tests/prog.mersenne.rad +8 -8

//! returns: 0
//! Mersenne Twister PRNG with statistical testing.

const N: u32 = 624;
const M: u32 = 397;
const MATRIX_A: u32 = 0x9908B0DF;
const UPPER_MASK: u32 = 0x80000000;
const LOWER_MASK: u32 = 0x7FFFFFFF;
constant N: u32 = 624;
constant M: u32 = 397;
constant MATRIX_A: u32 = 0x9908B0DF;
constant UPPER_MASK: u32 = 0x80000000;
constant LOWER_MASK: u32 = 0x7FFFFFFF;

record MtState {
    mt: *mut [u32],
    mti: u32,
}

}

fn testChiSquared(s: *mut MtState) -> i32 {
    mtInit(s, 12345);

    const NUM_BINS: u32 = 16;
    const NUM_SAMPLES: u32 = 1600;
    const EXPECTED: u32 = 100;
    constant NUM_BINS: u32 = 16;
    constant NUM_SAMPLES: u32 = 1600;
    constant EXPECTED: u32 = 100;

    let mut bins: [u32; 16] = [0; 16];

    let mut i: u32 = 0;
    while i < NUM_SAMPLES {

test/tests/prog.nqueens.rad +1 -1

//! returns: 0
//! N-Queens solver.
//! Solve the N-Queens problem using backtracking. Count all valid placements
//! for boards of size 1 through 8 and verify against known solution counts.

const MAX_N: u32 = 8;
constant MAX_N: u32 = 8;

record Board {
    queens: *mut [i32],
    solutionCount: u32,
    boardSize: u32,

test/tests/prog.rbtree.rad +4 -4

//! returns: 0
//! Red-black tree.
//! Implement a red-black tree (balanced BST) using a stack-allocated node pool.

const POOL_SIZE: u32 = 128;
const NIL: u32 = 0;
constant POOL_SIZE: u32 = 128;
constant NIL: u32 = 0;

const RED: u32 = 0;
const BLACK: u32 = 1;
constant RED: u32 = 0;
constant BLACK: u32 = 1;

record RBNode {
    key: i32,
    color: u32,
    left: u32,

test/tests/prog.regex.rad +6 -6

//! NFA-based regex matcher.
//! Implement a simple regular expression engine using Thompson's NFA
//! construction. Supports: literal characters, '.', '*', '+', '?',
//! and concatenation.

const MAX_STATES: u32 = 128;
const MAX_TRANSITIONS: u32 = 256;
const NIL: u32 = 0xFFFFFFFF;
constant MAX_STATES: u32 = 128;
constant MAX_TRANSITIONS: u32 = 256;
constant NIL: u32 = 0xFFFFFFFF;

const TRANS_CHAR: u32 = 0;
const TRANS_EPSILON: u32 = 1;
const TRANS_DOT: u32 = 2;
constant TRANS_CHAR: u32 = 0;
constant TRANS_EPSILON: u32 = 1;
constant TRANS_DOT: u32 = 2;

record Trans {
    kind: u32,
    ch: u8,
    to: u32,

test/tests/prog.sha256.rad +1 -1

    w: [u32; 64],
}

/// SHA-256 initial hash values (first 32 bits of fractional parts of square
/// roots of the first 8 primes).
const INIT_H: [u32; 8] = [
constant INIT_H: [u32; 8] = [
    0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
    0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19
];

/// Right-rotate a 32-bit value by `n` bits.

test/tests/prog.symtab.rad +4 -4

//! Implement a multi-scope symbol table with hash-based lookup, scope
//! push/pop, and symbol resolution. Exercises: optionals, if-let,
//! while-let, let-else, for-in with indexing, records with pointer
//! fields, and complex interactions between data structures.

const MAX_SYMBOLS: u32 = 256;
const MAX_SCOPES: u32 = 16;
const HASH_SIZE: u32 = 64;
const NIL: u32 = 0xFFFFFFFF;
constant MAX_SYMBOLS: u32 = 256;
constant MAX_SCOPES: u32 = 16;
constant HASH_SIZE: u32 = 64;
constant NIL: u32 = 0xFFFFFFFF;

/// A symbol entry in the table.
record Symbol {
    /// Name of the symbol (hash for comparison).
    nameHash: u32,

test/tests/prog.vm.rad +4 -4

//! Implement a bytecode interpreter for a simple stack machine with
//! arithmetic, comparisons, jumps, local variables, and function calls.
//! Exercises: tagged unions, match, throw/try/catch, error handling,
//! records with slice fields, and complex interacting state.

const MAX_STACK: u32 = 64;
const MAX_CODE: u32 = 256;
const MAX_LOCALS: u32 = 16;
const MAX_FRAMES: u32 = 8;
constant MAX_STACK: u32 = 64;
constant MAX_CODE: u32 = 256;
constant MAX_LOCALS: u32 = 16;
constant MAX_FRAMES: u32 = 8;

/// Bytecode instructions.
union Op {
    /// Push an immediate value.
    Push(i32),

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

/// Create a slice literal with a runtime (non-const) element.
/// Create a slice literal with a runtime (non-constant) element.
fn sliceWithVar(c: u8) -> *[u8] {
    return &[c];
}

/// Create a slice literal with multiple runtime elements.

test/tests/static.local.decl.rad +2 -2

/// Test lowering of function-local static and const declarations.
/// Test lowering of function-local static and constant declarations.
fn localStaticAndConst() -> i32 {
    static LOCAL: i32 = 7;
    const ADD: i32 = 5;
    constant ADD: i32 = 5;

    LOCAL += ADD;
    return LOCAL;
}

test/tests/unsigned.compare.rad +1 -1

//! returns: 1
//! Test unsigned integer comparisons.

const MAX_U32: u32 = 0xFFFFFFFF;
constant MAX_U32: u32 = 0xFFFFFFFF;

/// Test expression-level unsigned comparisons.
fn testExpressionComparisons() -> bool {
    let zero: u32 = 0;
    let one: u32 = 1;

141	141		///////////////////////
142	142		// Codegen Constants //
143	143		///////////////////////
144	144
145	145		/// Base address where read-only data is loaded.
146		-	export const RO_DATA_BASE: u32 = 0x10000;
	146	+	export constant RO_DATA_BASE: u32 = 0x10000;
147	147
148	148		/// Base address where read-write data is loaded.
149		-	export const RW_DATA_BASE: u32 = 0xFFFFF0;
	149	+	export constant RW_DATA_BASE: u32 = 0xFFFFF0;
150	150
151	151		/// Storage buffers passed from driver for code generation.
152	152		export record Storage {
153	153		/// Buffer for data symbols.
154	154		dataSyms: *mut [data::DataSym],

750	750		}
751	751		},
752	752		case il::Instr::Ecall { dst, num, a0, a1, a2, a3 } => {
753	753		// Move arguments using parallel move.
754	754		// TODO: Can't use slice literals here because the lowerer doesn't
755		-	// support const-evaluating struct/union values in them.
	755	+	// support constant-evaluating struct/union values in them.
756	756		let ecallDsts: [gen::Reg; 5] = [super::A7, super::A0, super::A1, super::A2, super::A3];
757	757		let ecallArgs: [il::Val; 5] = [num, a0, a1, a2, a3];
758	758
759	759		emitParallelMoves(s, &ecallDsts[..], &ecallArgs[..]);
760	760		emit::emit(s.e, encode::ecall());

346	346		toExprOrNull(a, decl.type),
347	347		toExpr(a, decl.value)
348	348		]);
349	349		}
350	350		case super::NodeValue::ConstDecl(decl) =>
351		-	return sexpr::list(a, "const", &[toExpr(a, decl.ident), toExpr(a, decl.type), toExpr(a, decl.value)]),
	351	+	return sexpr::list(a, "constant", &[toExpr(a, decl.ident), toExpr(a, decl.type), toExpr(a, decl.value)]),
352	352		case super::NodeValue::StaticDecl(decl) =>
353	353		return sexpr::list(a, "static", &[toExpr(a, decl.ident), toExpr(a, decl.type), toExpr(a, decl.value)]),
354	354		case super::NodeValue::Assign(a_) =>
355	355		return sexpr::list(a, "assign", &[toExpr(a, a_.left), toExpr(a, a_.right)]),
356	356		case super::NodeValue::Return { value } =>

215	215		/// Count trailing zeros in a 32-bit value.
216	216		/// Returns the bit position of the lowest set bit (0-31).
217	217		/// Behavior is undefined if `x` is 0.
218	218		fn ctz(x: u32) -> u32 {
219	219		// De Bruijn sequence for 32-bit CTZ.
220		-	const DEBRUIJN: u32 = 0x077CB531;
221		-	const TABLE: [u8; 32] = [
	220	+	constant DEBRUIJN: u32 = 0x077CB531;
	221	+	constant TABLE: [u8; 32] = [
222	222		0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
223	223		31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9,
224	224		];
225	225		// Isolate lowest set bit, multiply by de Bruijn constant, look up.
226	226		let isolated = x & (~x + 1);

373	373		/// Size in bytes.
374	374		size: u32,
375	375		/// Alignment requirement.
376	376		alignment: u32,
377	377		/// Whether this is read-only data.
378		-	/// Typically, `const` declaration are read-only, while `static`
	378	+	/// Typically, `constant` declaration are read-only, while `static`
379	379		/// declarations are not.
380	380		readOnly: bool,
381	381		/// Whether the data is entirely undefined.
382	382		/// Undefined data doesn't need to be written since memory is zero-initialized.
383	383		isUndefined: bool,

20	20		use std::sys;
21	21		use std::sys::unix;
22	22		use std::collections::dict;
23	23
24	24		/// Maximum number of modules we can load per package.
25		-	const MAX_LOADED_MODULES: u32 = 64;
	25	+	constant MAX_LOADED_MODULES: u32 = 64;
26	26		/// Maximum number of packages we can compile.
27		-	const MAX_PACKAGES: u32 = 4;
	27	+	constant MAX_PACKAGES: u32 = 4;
28	28		/// Total module entries across all packages.
29		-	const MAX_TOTAL_MODULES: u32 = 192;
	29	+	constant MAX_TOTAL_MODULES: u32 = 192;
30	30		/// Source code buffer arena (2 MB).
31		-	const MAX_SOURCES_SIZE: u32 = 2097152;
	31	+	constant MAX_SOURCES_SIZE: u32 = 2097152;
32	32		/// Maximum number of test functions we can discover.
33		-	const MAX_TESTS: u32 = 1024;
	33	+	constant MAX_TESTS: u32 = 1024;
34	34
35	35		/// Temporary arena size (32 MB) - retains all parsed AST until resolution.
36	36		/// Used for: AST during parsing, then codegen scratch space.
37		-	const TEMP_ARENA_SIZE: u32 = 33554432;
	37	+	constant TEMP_ARENA_SIZE: u32 = 33554432;
38	38		/// Main arena size (128 MB) - lives throughout compilation.
39	39		/// Used for: resolver data, types, symbols, lowered IL.
40		-	const MAIN_ARENA_SIZE: u32 = 134217728;
	40	+	constant MAIN_ARENA_SIZE: u32 = 134217728;
41	41
42	42		/// Temporary storage arena - reusable between phases.
43	43		static TEMP_ARENA: [u8; TEMP_ARENA_SIZE] = undefined;
44	44		/// Main storage arena - persists throughout compilation.
45	45		static MAIN_ARENA: [u8; MAIN_ARENA_SIZE] = undefined;

60	60		static CODEGEN_DATA_SYMS: [data::DataSym; data::MAX_DATA_SYMS] = undefined;
61	61		/// Hash table entries for data symbol lookup.
62	62		static CODEGEN_DATA_SYM_ENTRIES: [dict::Entry; data::DATA_SYM_TABLE_SIZE] = undefined;
63	63
64	64		/// Debug info file extension.
65		-	const DEBUG_EXT: *[u8] = ".debug";
	65	+	constant DEBUG_EXT: *[u8] = ".debug";
66	66
67	67		/// Read-only data file extension.
68		-	const RO_DATA_EXT: *[u8] = ".ro.data";
	68	+	constant RO_DATA_EXT: *[u8] = ".ro.data";
69	69		/// Read-write data file extension.
70		-	const RW_DATA_EXT: *[u8] = ".rw.data";
	70	+	constant RW_DATA_EXT: *[u8] = ".rw.data";
71	71		/// Maximum rodata size (1MB).
72		-	const MAX_RO_DATA_SIZE: u32 = 1048576;
	72	+	constant MAX_RO_DATA_SIZE: u32 = 1048576;
73	73		/// Maximum rwdata size (1MB).
74		-	const MAX_RW_DATA_SIZE: u32 = 1048576;
	74	+	constant MAX_RW_DATA_SIZE: u32 = 1048576;
75	75		/// Maximum path length.
76		-	const MAX_PATH_LEN: u32 = 256;
	76	+	constant MAX_PATH_LEN: u32 = 256;
77	77		/// Read-only data buffer.
78	78		static RO_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = undefined;
79	79		/// Read-write data buffer.
80	80		static RW_DATA_BUF: [u8; MAX_RW_DATA_SIZE] = undefined;
81	81
82	82		/// Usage string.
83		-	const USAGE: *[u8] =
	83	+	constant USAGE: *[u8] =
84	84		"usage: radiance -pkg <name> -mod <input>.. [-pkg <name> -mod <input>..] -entry <pkg> -o <output>\n";
85	85
86	86		/// Compiler error.
87	87		union Error {
88	88		Other,

30	30
31	31		////////////////
32	32		// Registers //
33	33		////////////////
34	34
35		-	export const ZERO: gen::Reg = gen::Reg(0); /// Hard-wired zero.
36		-	export const RA: gen::Reg = gen::Reg(1); /// Return address.
37		-	export const SP: gen::Reg = gen::Reg(2); /// Stack pointer.
38		-	export const GP: gen::Reg = gen::Reg(3); /// Global pointer.
39		-	export const TP: gen::Reg = gen::Reg(4); /// Thread pointer.
40		-	export const T0: gen::Reg = gen::Reg(5); /// Temporary/alternate link register.
41		-	export const T1: gen::Reg = gen::Reg(6); /// Temporary.
42		-	export const T2: gen::Reg = gen::Reg(7); /// Temporary.
43		-	export const S0: gen::Reg = gen::Reg(8); /// Saved register/frame pointer.
44		-	export const FP: gen::Reg = gen::Reg(8); /// Frame pointer (alias for S0).
45		-	export const S1: gen::Reg = gen::Reg(9); /// Saved register.
46		-	export const A0: gen::Reg = gen::Reg(10); /// Function argument/return.
47		-	export const A1: gen::Reg = gen::Reg(11); /// Function argument/return.
48		-	export const A2: gen::Reg = gen::Reg(12); /// Function argument.
49		-	export const A3: gen::Reg = gen::Reg(13); /// Function argument.
50		-	export const A4: gen::Reg = gen::Reg(14); /// Function argument.
51		-	export const A5: gen::Reg = gen::Reg(15); /// Function argument.
52		-	export const A6: gen::Reg = gen::Reg(16); /// Function argument.
53		-	export const A7: gen::Reg = gen::Reg(17); /// Function argument.
54		-	export const S2: gen::Reg = gen::Reg(18); /// Saved register.
55		-	export const S3: gen::Reg = gen::Reg(19); /// Saved register.
56		-	export const S4: gen::Reg = gen::Reg(20); /// Saved register.
57		-	export const S5: gen::Reg = gen::Reg(21); /// Saved register.
58		-	export const S6: gen::Reg = gen::Reg(22); /// Saved register.
59		-	export const S7: gen::Reg = gen::Reg(23); /// Saved register.
60		-	export const S8: gen::Reg = gen::Reg(24); /// Saved register.
61		-	export const S9: gen::Reg = gen::Reg(25); /// Saved register.
62		-	export const S10: gen::Reg = gen::Reg(26); /// Saved register.
63		-	export const S11: gen::Reg = gen::Reg(27); /// Saved register.
64		-	export const T3: gen::Reg = gen::Reg(28); /// Temporary.
65		-	export const T4: gen::Reg = gen::Reg(29); /// Temporary.
66		-	export const T5: gen::Reg = gen::Reg(30); /// Temporary.
67		-	export const T6: gen::Reg = gen::Reg(31); /// Temporary.
	35	+	export constant ZERO: gen::Reg = gen::Reg(0); /// Hard-wired zero.
	36	+	export constant RA: gen::Reg = gen::Reg(1); /// Return address.
	37	+	export constant SP: gen::Reg = gen::Reg(2); /// Stack pointer.
	38	+	export constant GP: gen::Reg = gen::Reg(3); /// Global pointer.
	39	+	export constant TP: gen::Reg = gen::Reg(4); /// Thread pointer.
	40	+	export constant T0: gen::Reg = gen::Reg(5); /// Temporary/alternate link register.
	41	+	export constant T1: gen::Reg = gen::Reg(6); /// Temporary.
	42	+	export constant T2: gen::Reg = gen::Reg(7); /// Temporary.
	43	+	export constant S0: gen::Reg = gen::Reg(8); /// Saved register/frame pointer.
	44	+	export constant FP: gen::Reg = gen::Reg(8); /// Frame pointer (alias for S0).
	45	+	export constant S1: gen::Reg = gen::Reg(9); /// Saved register.
	46	+	export constant A0: gen::Reg = gen::Reg(10); /// Function argument/return.
	47	+	export constant A1: gen::Reg = gen::Reg(11); /// Function argument/return.
	48	+	export constant A2: gen::Reg = gen::Reg(12); /// Function argument.
	49	+	export constant A3: gen::Reg = gen::Reg(13); /// Function argument.
	50	+	export constant A4: gen::Reg = gen::Reg(14); /// Function argument.
	51	+	export constant A5: gen::Reg = gen::Reg(15); /// Function argument.
	52	+	export constant A6: gen::Reg = gen::Reg(16); /// Function argument.
	53	+	export constant A7: gen::Reg = gen::Reg(17); /// Function argument.
	54	+	export constant S2: gen::Reg = gen::Reg(18); /// Saved register.
	55	+	export constant S3: gen::Reg = gen::Reg(19); /// Saved register.
	56	+	export constant S4: gen::Reg = gen::Reg(20); /// Saved register.
	57	+	export constant S5: gen::Reg = gen::Reg(21); /// Saved register.
	58	+	export constant S6: gen::Reg = gen::Reg(22); /// Saved register.
	59	+	export constant S7: gen::Reg = gen::Reg(23); /// Saved register.
	60	+	export constant S8: gen::Reg = gen::Reg(24); /// Saved register.
	61	+	export constant S9: gen::Reg = gen::Reg(25); /// Saved register.
	62	+	export constant S10: gen::Reg = gen::Reg(26); /// Saved register.
	63	+	export constant S11: gen::Reg = gen::Reg(27); /// Saved register.
	64	+	export constant T3: gen::Reg = gen::Reg(28); /// Temporary.
	65	+	export constant T4: gen::Reg = gen::Reg(29); /// Temporary.
	66	+	export constant T5: gen::Reg = gen::Reg(30); /// Temporary.
	67	+	export constant T6: gen::Reg = gen::Reg(31); /// Temporary.
68	68
69	69		/// Create a register from a number. Panics if `n > 31`.
70	70		export fn reg(n: u8) -> gen::Reg {
71	71		assert n < 32;
72	72		return gen::Reg(n);

75	75		////////////////////////////
76	76		// Architecture constants //
77	77		////////////////////////////
78	78
79	79		/// Total number of general-purpose registers.
80		-	export const NUM_REGISTERS: u8 = 32;
	80	+	export constant NUM_REGISTERS: u8 = 32;
81	81		/// Number of saved registers.
82		-	export const NUM_SAVED_REGISTERS: u8 = 11;
	82	+	export constant NUM_SAVED_REGISTERS: u8 = 11;
83	83		/// Word size in bytes (32-bit).
84		-	export const WORD_SIZE: i32 = 4;
	84	+	export constant WORD_SIZE: i32 = 4;
85	85		/// Doubleword size in bytes (64-bit).
86		-	export const DWORD_SIZE: i32 = 8;
	86	+	export constant DWORD_SIZE: i32 = 8;
87	87		/// Instruction size in bytes.
88		-	export const INSTR_SIZE: i32 = 4;
	88	+	export constant INSTR_SIZE: i32 = 4;
89	89		/// Stack alignment requirement in bytes.
90		-	export const STACK_ALIGNMENT: i32 = 16;
	90	+	export constant STACK_ALIGNMENT: i32 = 16;
91	91
92	92		/// Minimum blit size (in bytes) to use a loop instead of inline copy.
93	93		/// Blits below this threshold are fully unrolled as LD/SD pairs.
94		-	export const BLIT_LOOP_THRESHOLD: i32 = 256;
	94	+	export constant BLIT_LOOP_THRESHOLD: i32 = 256;
95	95
96	96		/////////////////////////
97	97		// Codegen Allocation //
98	98		/////////////////////////
99	99
100	100		/// Argument registers for function calls.
101		-	export const ARG_REGS: [gen::Reg; 8] = [A0, A1, A2, A3, A4, A5, A6, A7];
	101	+	export constant ARG_REGS: [gen::Reg; 8] = [A0, A1, A2, A3, A4, A5, A6, A7];
102	102
103	103		/// Scratch register for code gen. Never allocated to user values.
104		-	export const SCRATCH1: gen::Reg = T5;
	104	+	export constant SCRATCH1: gen::Reg = T5;
105	105
106	106		/// Second scratch register for operations needing two temporaries.
107		-	export const SCRATCH2: gen::Reg = T6;
	107	+	export constant SCRATCH2: gen::Reg = T6;
108	108
109	109		/// Dedicated scratch for address offset adjustment. Never allocated to user
110	110		/// values and never used for operand materialization, so it can never
111	111		/// conflict with `rd`, `rs`, or `base` in load/store helpers.
112		-	export const ADDR_SCRATCH: gen::Reg = T4;
	112	+	export constant ADDR_SCRATCH: gen::Reg = T4;
113	113
114	114		/// Callee-saved registers that need save/restore if used.
115		-	export const CALLEE_SAVED: [gen::Reg; NUM_SAVED_REGISTERS] = [S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11];
	115	+	export constant CALLEE_SAVED: [gen::Reg; NUM_SAVED_REGISTERS] = [S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11];
116	116
117	117		/// Maximum 12-bit signed immediate value.
118		-	export const MAX_IMM: i32 = 2047;
	118	+	export constant MAX_IMM: i32 = 2047;
119	119
120	120		/// Minimum 12-bit signed immediate value.
121		-	export const MIN_IMM: i32 = -2048;
	121	+	export constant MIN_IMM: i32 = -2048;
122	122
123	123		/// Allocatable registers for register allocation.
124		-	const ALLOCATABLE_REGS: [gen::Reg; 23] = [
	124	+	constant ALLOCATABLE_REGS: [gen::Reg; 23] = [
125	125		T0, T1, T2, T3, // Temporaries
126	126		A0, A1, A2, A3, A4, A5, A6, A7, // Arguments
127	127		S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, // Saved
128	128		];
129	129

11	11		use std::mem;
12	12
13	13		use super::encode;
14	14
15	15		/// Maximum number of instructions in code buffer.
16		-	const MAX_INSTRS: u32 = 2097152;
	16	+	constant MAX_INSTRS: u32 = 2097152;
17	17		/// Maximum code length before byte offset overflows signed 32-bits.
18		-	const MAX_CODE_LEN: u32 = 0x7FFFFFFF / super::INSTR_SIZE as u32;
	18	+	constant MAX_CODE_LEN: u32 = 0x7FFFFFFF / super::INSTR_SIZE as u32;
19	19		/// Maximum number of pending branches awaiting patching.
20		-	const MAX_PENDING: u32 = 65536;
	20	+	constant MAX_PENDING: u32 = 65536;
21	21		/// Maximum number of function entries.
22		-	const MAX_FUNCS: u32 = 4096;
	22	+	constant MAX_FUNCS: u32 = 4096;
23	23		/// Maximum number of debug entries.
24		-	const MAX_DEBUG_ENTRIES: u32 = 524288;
	24	+	constant MAX_DEBUG_ENTRIES: u32 = 524288;
25	25
26	26		//////////////////////
27	27		// Emission Context //
28	28		//////////////////////
29	29

6	6
7	7		//////////////////////
8	8		// Opcode Constants //
9	9		//////////////////////
10	10
11		-	export const OP_LOAD: u32 = 0x03;
12		-	export const OP_STORE: u32 = 0x23;
13		-	export const OP_BRANCH: u32 = 0x63;
14		-	export const OP_JALR: u32 = 0x67;
15		-	export const OP_JAL: u32 = 0x6F;
16		-	export const OP_OP: u32 = 0x33;
17		-	export const OP_IMM: u32 = 0x13;
18		-	export const OP_AUIPC: u32 = 0x17;
19		-	export const OP_LUI: u32 = 0x37;
20		-	export const OP_SYSTEM: u32 = 0x73;
21		-	export const OP_OP32: u32 = 0x3B; // RV64: 32-bit operations
22		-	export const OP_IMM32: u32 = 0x1B; // RV64: 32-bit immediate operations
	11	+	export constant OP_LOAD: u32 = 0x03;
	12	+	export constant OP_STORE: u32 = 0x23;
	13	+	export constant OP_BRANCH: u32 = 0x63;
	14	+	export constant OP_JALR: u32 = 0x67;
	15	+	export constant OP_JAL: u32 = 0x6F;
	16	+	export constant OP_OP: u32 = 0x33;
	17	+	export constant OP_IMM: u32 = 0x13;
	18	+	export constant OP_AUIPC: u32 = 0x17;
	19	+	export constant OP_LUI: u32 = 0x37;
	20	+	export constant OP_SYSTEM: u32 = 0x73;
	21	+	export constant OP_OP32: u32 = 0x3B; // RV64: 32-bit operations
	22	+	export constant OP_IMM32: u32 = 0x1B; // RV64: 32-bit immediate operations
23	23
24	24		//////////////////////
25	25		// Funct3 Constants //
26	26		//////////////////////
27	27
28	28		// Memory operations
29	29
30		-	export const F3_BYTE: u32 = 0x0; // LB/SB
31		-	export const F3_HALF: u32 = 0x1; // LH/SH
32		-	export const F3_WORD: u32 = 0x2; // LW/SW
33		-	export const F3_DWORD: u32 = 0x3; // LD/SD (RV64)
34		-	export const F3_BYTE_U: u32 = 0x4; // LBU
35		-	export const F3_HALF_U: u32 = 0x5; // LHU
36		-	export const F3_WORD_U: u32 = 0x6; // LWU (RV64)
	30	+	export constant F3_BYTE: u32 = 0x0; // LB/SB
	31	+	export constant F3_HALF: u32 = 0x1; // LH/SH
	32	+	export constant F3_WORD: u32 = 0x2; // LW/SW
	33	+	export constant F3_DWORD: u32 = 0x3; // LD/SD (RV64)
	34	+	export constant F3_BYTE_U: u32 = 0x4; // LBU
	35	+	export constant F3_HALF_U: u32 = 0x5; // LHU
	36	+	export constant F3_WORD_U: u32 = 0x6; // LWU (RV64)
37	37
38	38		// ALU operations
39	39
40		-	export const F3_ADD: u32 = 0x0; // ADD/SUB/ADDI
41		-	export const F3_SLL: u32 = 0x1; // SLL/SLLI
42		-	export const F3_SLT: u32 = 0x2; // SLT/SLTI
43		-	export const F3_SLTU: u32 = 0x3; // SLTU/SLTIU
44		-	export const F3_XOR: u32 = 0x4; // XOR/XORI
45		-	export const F3_SRL: u32 = 0x5; // SRL/SRA/SRLI/SRAI
46		-	export const F3_OR: u32 = 0x6; // OR/ORI
47		-	export const F3_AND: u32 = 0x7; // AND/ANDI
	40	+	export constant F3_ADD: u32 = 0x0; // ADD/SUB/ADDI
	41	+	export constant F3_SLL: u32 = 0x1; // SLL/SLLI
	42	+	export constant F3_SLT: u32 = 0x2; // SLT/SLTI
	43	+	export constant F3_SLTU: u32 = 0x3; // SLTU/SLTIU
	44	+	export constant F3_XOR: u32 = 0x4; // XOR/XORI
	45	+	export constant F3_SRL: u32 = 0x5; // SRL/SRA/SRLI/SRAI
	46	+	export constant F3_OR: u32 = 0x6; // OR/ORI
	47	+	export constant F3_AND: u32 = 0x7; // AND/ANDI
48	48
49	49		// Branch operations
50	50
51		-	export const F3_BEQ: u32 = 0x0;
52		-	export const F3_BNE: u32 = 0x1;
53		-	export const F3_BLT: u32 = 0x4;
54		-	export const F3_BGE: u32 = 0x5;
55		-	export const F3_BLTU: u32 = 0x6;
56		-	export const F3_BGEU: u32 = 0x7;
	51	+	export constant F3_BEQ: u32 = 0x0;
	52	+	export constant F3_BNE: u32 = 0x1;
	53	+	export constant F3_BLT: u32 = 0x4;
	54	+	export constant F3_BGE: u32 = 0x5;
	55	+	export constant F3_BLTU: u32 = 0x6;
	56	+	export constant F3_BGEU: u32 = 0x7;
57	57
58	58		//////////////////////
59	59		// Funct7 Constants //
60	60		//////////////////////
61	61
62		-	export const F7_NORMAL: u32 = 0b0000000;
63		-	export const F7_SUB: u32 = 0b0100000; // Bit 5 set
64		-	export const F7_SRA: u32 = 0b0100000; // Bit 5 set
65		-	export const F7_MUL: u32 = 0b0000001; // Bit 0 set
	62	+	export constant F7_NORMAL: u32 = 0b0000000;
	63	+	export constant F7_SUB: u32 = 0b0100000; // Bit 5 set
	64	+	export constant F7_SRA: u32 = 0b0100000; // Bit 5 set
	65	+	export constant F7_MUL: u32 = 0b0000001; // Bit 0 set
66	66
67	67		/////////////////////////
68	68		// Validation Helpers //
69	69		/////////////////////////
70	70

40	40		///////////////
41	41		// Constants //
42	42		///////////////
43	43
44	44		/// Shift amount for byte sign/zero extension.
45		-	const SHIFT_W8: i32 = 64 - 8;
	45	+	constant SHIFT_W8: i32 = 64 - 8;
46	46		/// Shift amount for halfword sign/zero extension.
47		-	const SHIFT_W16: i32 = 64 - 16;
	47	+	constant SHIFT_W16: i32 = 64 - 16;
48	48		/// Shift amount for word sign/zero extension.
49		-	const SHIFT_W32: i32 = 64 - 32;
	49	+	constant SHIFT_W32: i32 = 64 - 32;
50	50		/// Mask for extracting byte value.
51		-	const MASK_W8: i32 = 0xFF;
	51	+	constant MASK_W8: i32 = 0xFF;
52	52		/// Maximum number of block arguments supported.
53		-	const MAX_BLOCK_ARGS: u32 = 16;
	53	+	constant MAX_BLOCK_ARGS: u32 = 16;
54	54
55	55		/// Signed integer range limits.
56		-	const I8_MIN: i64 = -128;
57		-	const I8_MAX: i64 = 127;
58		-	const I16_MIN: i64 = -32768;
59		-	const I16_MAX: i64 = 32767;
60		-	const I32_MIN: i64 = -2147483648;
61		-	const I32_MAX: i64 = 2147483647;
	56	+	constant I8_MIN: i64 = -128;
	57	+	constant I8_MAX: i64 = 127;
	58	+	constant I16_MIN: i64 = -32768;
	59	+	constant I16_MAX: i64 = 32767;
	60	+	constant I32_MIN: i64 = -2147483648;
	61	+	constant I32_MAX: i64 = 2147483647;
62	62
63	63		/// Unsigned integer range limits.
64		-	const U8_MAX: i64 = 255;
65		-	const U16_MAX: i64 = 65535;
66		-	const U32_MAX: i64 = 4294967295;
	64	+	constant U8_MAX: i64 = 255;
	65	+	constant U16_MAX: i64 = 65535;
	66	+	constant U32_MAX: i64 = 4294967295;
67	67
68	68		/// Binary operation.
69	69		union BinOp { Add, And, Or, Xor }
70	70		/// Shift operation.
71	71		union ShiftOp { Sll, Srl, Sra }

66	66		///////////////////////////////
67	67		// Instruction Printing //
68	68		///////////////////////////////
69	69
70	70		/// Mnemonic column width for alignment.
71		-	const MNEMONIC_WIDTH: u32 = 8;
	71	+	constant MNEMONIC_WIDTH: u32 = 8;
72	72
73	73		/// Write text wrapped in parentheses.
74	74		fn writeParens(out: mut sexpr::Output, s: [u8]) {
75	75		write(out, "(");
76	76		write(out, s);

1	1		//! Formatting utilities for converting values to strings.
2	2		use super::mem;
3	3
4	4		/// Maximum string length for a formatted u32 (eg. "4294967295").
5		-	export const U32_STR_LEN: u32 = 10;
	5	+	export constant U32_STR_LEN: u32 = 10;
6	6		/// Maximum string length for a formatted i32 (eg. "-2147483648").
7		-	export const I32_STR_LEN: u32 = U32_STR_LEN + 1;
	7	+	export constant I32_STR_LEN: u32 = U32_STR_LEN + 1;
8	8		/// Maximum string length for a formatted u64 (eg. "18446744073709551615").
9		-	export const U64_STR_LEN: u32 = 20;
	9	+	export constant U64_STR_LEN: u32 = 20;
10	10		/// Maximum string length for a formatted i64 (eg. "-9223372036854775808").
11		-	export const I64_STR_LEN: u32 = 20;
	11	+	export constant I64_STR_LEN: u32 = 20;
12	12		/// Maximum string length for a formatted bool (eg. "false").
13		-	export const BOOL_STR_LEN: u32 = 5;
	13	+	export constant BOOL_STR_LEN: u32 = 5;
14	14
15	15		/// Format a u32 by writing it to the provided buffer.
16	16		export fn formatU32(val: u32, buffer: mut [u8]) -> [u8] {
17	17		assert buffer.len >= U32_STR_LEN;
18	18

3	3
4	4		use std::io;
5	5		use std::lang::alloc;
6	6
7	7		/// Maximum number of trait methods.
8		-	export const MAX_TRAIT_METHODS: u32 = 8;
	8	+	export constant MAX_TRAIT_METHODS: u32 = 8;
9	9
10	10		/// Arena for all parser allocations.
11	11		///
12	12		/// Uses a bump allocator for both AST nodes and node pointer arrays.
13	13		export record NodeArena {

7	7		use std::collections::dict;
8	8		use std::lang::il;
9	9		use std::lang::gen::labels;
10	10
11	11		/// Maximum number of data symbols.
12		-	export const MAX_DATA_SYMS: u32 = 8192;
	12	+	export constant MAX_DATA_SYMS: u32 = 8192;
13	13
14	14		/// Size of the data symbol hash table. Must be a power of two
15	15		/// and at least twice the size of [`MAX_DATA_SYMS`].
16		-	export const DATA_SYM_TABLE_SIZE: u32 = MAX_DATA_SYMS * 2;
	16	+	export constant DATA_SYM_TABLE_SIZE: u32 = MAX_DATA_SYMS * 2;
17	17
18	18		/// Data symbol entry mapping name to address.
19	19		export record DataSym {
20	20		/// Symbol name.
21	21		name: *[u8],

3	3		//! Provides target-independent block/label tracking for branch resolution.
4	4
5	5		use std::collections::dict;
6	6
7	7		/// Maximum number of blocks per function.
8		-	export const MAX_BLOCKS_PER_FN: u32 = 4096;
	8	+	export constant MAX_BLOCKS_PER_FN: u32 = 4096;
9	9		/// Maximum number of functions.
10		-	export const MAX_FUNCS: u32 = 8192;
	10	+	export constant MAX_FUNCS: u32 = 8192;
11	11		/// Size of the function hash table. Must be a power of two.
12		-	export const FUNC_TABLE_SIZE: u32 = MAX_FUNCS * 2;
	12	+	export constant FUNC_TABLE_SIZE: u32 = MAX_FUNCS * 2;
13	13
14	14		/// Label tracking for code emission.
15	15		export record Labels {
16	16		/// Block offsets indexed by block index.
17	17		/// Per-function, reset each function.

12	12		use std::lang::gen::bitset;
13	13		use std::lang::gen::regalloc::liveness;
14	14		use std::lang::gen::regalloc::spill;
15	15
16	16		/// Maximum number of active register mappings.
17		-	const MAX_ACTIVE: u32 = 64;
	17	+	constant MAX_ACTIVE: u32 = 64;
18	18
19	19		/// Register mapping at a program point.
20	20		/// Maps SSA registers to physical registers.
21	21		export record RegMap {
22	22		/// SSA (virtual) registers that have mappings.

77	77		///////////////////////
78	78		// Name Formatting //
79	79		///////////////////////
80	80
81	81		/// Separator for qualified symbol names.
82		-	export const PATH_SEPARATOR: *[u8] = "::";
	82	+	export constant PATH_SEPARATOR: *[u8] = "::";
83	83
84	84		/// Format a qualified symbol name: `pkg::mod::path::name`.
85	85		export fn formatQualifiedName(arena: mut alloc::Arena, path: [[u8]], name: [u8]) -> *[u8] {
86	86		let mut totalLen: u32 = name.len;
87	87		for segment in path {

237	237		// When `T` is a pointer, the entire optional is stored as a single pointer.
238	238		//
239	239		// Tagged unions have a payload the size of the maximum variant size.
240	240
241	241		/// Offset of tag in tagged value data structure.
242		-	const TVAL_TAG_OFFSET: i32 = 0;
	242	+	constant TVAL_TAG_OFFSET: i32 = 0;
243	243		/// Offset of value in result data structure (8-byte tag).
244		-	const RESULT_VAL_OFFSET: i32 = resolver::PTR_SIZE as i32;
	244	+	constant RESULT_VAL_OFFSET: i32 = resolver::PTR_SIZE as i32;
245	245
246	246		//////////////////////////
247	247		// Core Data Structures //
248	248		//////////////////////////
249	249

1174	1174
1175	1175		///////////////////////////////
1176	1176		// Data Section Construction //
1177	1177		///////////////////////////////
1178	1178
1179		-	// Functions for building the data section from const/static
	1179	+	// Functions for building the data section from constant/static
1180	1180		// declarations and inline literals.
1181	1181
1182	1182		/// Convert a constant integer payload to a signed 64-bit value.
1183	1183		fn constIntToI64(intVal: resolver::ConstInt) -> i64 {
1184	1184		return (0 - intVal.magnitude as i64) if intVal.negative else intVal.magnitude as i64;

1215	1215		irTyp = ilType(self, typ);
1216	1216		}
1217	1217		return il::DataItem::Val { typ: irTyp, val: constToScalar(val) };
1218	1218		}
1219	1219
1220		-	/// Lower a const or static declaration to the data section.
	1220	+	/// Lower a constant or static declaration to the data section.
1221	1221		fn lowerDataDecl(
1222	1222		self: *mut Lowerer,
1223	1223		node: *ast::Node,
1224	1224		value: *ast::Node,
1225	1225		readOnly: bool

1687	1687		}
1688	1688		}
1689	1689		return nil;
1690	1690		}
1691	1691
1692		-	/// Find existing const data entry with matching content.
	1692	+	/// Find existing constant data entry with matching content.
1693	1693		/// Handles both string data and slice data.
1694	1694		fn findConstData(self: Lowerer, values: [il::DataValue], alignment: u32) -> ?*[u8] {
1695	1695		// Fast path for strings.
1696	1696		if values.len == 1 and alignment == 1 {
1697	1697		if let case il::DataItem::Str(s) = values[0].item {

12	12		use std::lang::alloc;
13	13		use std::lang::ast;
14	14		use std::lang::strings;
15	15
16	16		/// Maximum number of modules tracked in a single compilation graph.
17		-	export const MAX_MODULES: u32 = 128;
	17	+	export constant MAX_MODULES: u32 = 128;
18	18		/// Maximum number of characters for a module path.
19		-	const MAX_PATH_LEN: u32 = 256;
	19	+	constant MAX_PATH_LEN: u32 = 256;
20	20		/// Maximum number of components that make up a logical module path.
21		-	const MAX_MODULE_PATH_DEPTH: u32 = 16;
	21	+	constant MAX_MODULE_PATH_DEPTH: u32 = 16;
22	22		/// Filesystem separator used when constructing child paths.
23		-	const PATH_SEP: u8 = '/';
	23	+	constant PATH_SEP: u8 = '/';
24	24		/// Source file extension handled by the loader.
25		-	const SOURCE_EXT: *[u8] = ".rad";
	25	+	constant SOURCE_EXT: *[u8] = ".rad";
26	26
27	27		/// Lifecycle state for modules in the dependency graph.
28	28		export union ModuleState {
29	29		/// Slot unused or yet to be initialized.
30	30		Vacant,

4	4		use std::lang::ast;
5	5		use std::lang::module;
6	6		use std::lang::strings;
7	7
8	8		/// Maximum number of packages processed in a single invocation.
9		-	export const MAX_PACKAGES: u32 = 4;
	9	+	export constant MAX_PACKAGES: u32 = 4;
10	10
11	11		/// A compilation unit.
12	12		export record Package {
13	13		/// Package identifier (index in the package array).
14	14		id: u16,

7	7		use std::lang::ast;
8	8		use std::lang::strings;
9	9		use std::lang::scanner;
10	10
11	11		/// Maximum `u32` value.
12		-	export const U32_MAX: u32 = 0xFFFFFFFF;
	12	+	export constant U32_MAX: u32 = 0xFFFFFFFF;
13	13		/// Maximum representable `u64` value.
14		-	export const U64_MAX: u64 = 0xFFFFFFFFFFFFFFFF;
	14	+	export constant U64_MAX: u64 = 0xFFFFFFFFFFFFFFFF;
15	15		/// Maximum number of fields in a record.
16		-	export const MAX_RECORD_FIELDS: u32 = 32;
	16	+	export constant MAX_RECORD_FIELDS: u32 = 32;
17	17
18	18		/// Maximum number of parser errors before aborting.
19		-	const MAX_ERRORS: u32 = 8;
	19	+	constant MAX_ERRORS: u32 = 8;
20	20
21	21		/// Parser error type.
22	22		export union ParseError {
23	23		/// Encountered a token that was not expected in the current context.
24	24		UnexpectedToken,

926	926		p.current.kind == scanner::TokenKind::Fn or
927	927		p.current.kind == scanner::TokenKind::Union or
928	928		p.current.kind == scanner::TokenKind::Record or
929	929		p.current.kind == scanner::TokenKind::Mod or
930	930		p.current.kind == scanner::TokenKind::Static or
931		-	p.current.kind == scanner::TokenKind::Const or
	931	+	p.current.kind == scanner::TokenKind::Constant or
932	932		p.current.kind == scanner::TokenKind::Use or
933	933		p.current.kind == scanner::TokenKind::Trait;
934	934
935	935		if not allowed {
936	936		throw failParsing(p, "attributes are not allowed in this context");

984	984		if consume(p, scanner::TokenKind::Mut) {
985	985		return try parseLet(p, true);
986	986		}
987	987		return try parseLet(p, false);
988	988		}
989		-	case scanner::TokenKind::Const => {
	989	+	case scanner::TokenKind::Constant => {
990	990		return try parseConst(p, attrs);
991	991		}
992	992		case scanner::TokenKind::Static => {
993	993		return try parseStatic(p, attrs);
994	994		}

2119	2119
2120	2120		/// Parse a constant declaration.
2121	2121		fn parseConst(p: mut Parser, attrs: ?ast::Attributes) -> ast::Node
2122	2122		throws (ParseError)
2123	2123		{
2124		-	try expect(p, scanner::TokenKind::Const, "expected `const`");
	2124	+	try expect(p, scanner::TokenKind::Constant, "expected `constant`");
2125	2125
2126		-	let ident = try parseIdent(p, "expected identifier in const declaration");
	2126	+	let ident = try parseIdent(p, "expected identifier in constant declaration");
2127	2127		try expect(p, scanner::TokenKind::Colon, "expected `:` after identifier");
2128	2128
2129	2129		let type = try parseType(p);
2130		-	try expect(p, scanner::TokenKind::Equal, "expected `=` in const declaration");
	2130	+	try expect(p, scanner::TokenKind::Equal, "expected `=` in constant declaration");
2131	2131
2132	2132		let value = try parseExpr(p);
2133	2133
2134	2134		return node(p, ast::NodeValue::ConstDecl(
2135	2135		ast::ConstDecl { ident, type, value, attrs }

746	746		try expectType(type, ast::TypeSig::Integer {
747	747		width: 4, sign: ast::Signedness::Signed
748	748		});
749	749		}
750	750
751		-	/// Test parsing a `const` declaration.
	751	+	/// Test parsing a `constant` declaration.
752	752		@test fn testParseConst() throws (testing::TestError) {
753		-	let node = try! parseStmtStr("const ANSWER: i32 = 42;");
	753	+	let node = try! parseStmtStr("constant ANSWER: i32 = 42;");
754	754		let case ast::NodeValue::ConstDecl(decl) = node.value
755	755		else throw testing::TestError::Failed;
756	756
757	757		try expectIdent(decl.ident, "ANSWER");
758	758		try expectType(decl.type, ast::TypeSig::Integer {

19	19		use std::lang::ast;
20	20		use std::lang::parser;
21	21		use std::lang::module;
22	22
23	23		/// Maximum number of diagnostics recorded.
24		-	export const MAX_ERRORS: u32 = 64;
	24	+	export constant MAX_ERRORS: u32 = 64;
25	25
26	26		/// Synthetic function name used when wrapping a bare expression for analysis.
27		-	export const ANALYZE_EXPR_FN_NAME: *[u8] = "__expr__";
	27	+	export constant ANALYZE_EXPR_FN_NAME: *[u8] = "__expr__";
28	28		/// Synthetic function name used when wrapping a block for analysis.
29		-	export const ANALYZE_BLOCK_FN_NAME: *[u8] = "__block__";
	29	+	export constant ANALYZE_BLOCK_FN_NAME: *[u8] = "__block__";
30	30
31	31		/// Maximum number of symbols stored within a module scope.
32		-	export const MAX_MODULE_SYMBOLS: u32 = 512;
	32	+	export constant MAX_MODULE_SYMBOLS: u32 = 512;
33	33		/// Maximum number of symbols stored within a local scope.
34		-	export const MAX_LOCAL_SYMBOLS: u32 = 32;
	34	+	export constant MAX_LOCAL_SYMBOLS: u32 = 32;
35	35		/// Maximum function parameters.
36		-	export const MAX_FN_PARAMS: u32 = 8;
	36	+	export constant MAX_FN_PARAMS: u32 = 8;
37	37		/// Maximum function thrown types.
38		-	export const MAX_FN_THROWS: u32 = 8;
	38	+	export constant MAX_FN_THROWS: u32 = 8;
39	39		/// Maximum number of variants in a union.
40	40		/// Nb. This should not be raised above `255`,
41	41		/// as tags are stored using 8-bits only.
42		-	export const MAX_UNION_VARIANTS: u32 = 128;
	42	+	export constant MAX_UNION_VARIANTS: u32 = 128;
43	43		/// Maximum nesting of loops.
44		-	export const MAX_LOOP_DEPTH: u32 = 16;
	44	+	export constant MAX_LOOP_DEPTH: u32 = 16;
45	45		/// Maximum trait instances.
46		-	export const MAX_INSTANCES: u32 = 128;
	46	+	export constant MAX_INSTANCES: u32 = 128;
47	47		/// Maximum standalone methods (across all types).
48		-	export const MAX_METHODS: u32 = 256;
	48	+	export constant MAX_METHODS: u32 = 256;
49	49
50	50		/// Trait definition stored in the resolver.
51	51		export record TraitType {
52	52		/// Trait name.
53	53		name: *[u8],

98	98		/// Symbol for the method.
99	99		symbol: *mut Symbol,
100	100		}
101	101
102	102		/// Identifier for the synthetic `len` field.
103		-	export const LEN_FIELD: *[u8] = "len";
	103	+	export constant LEN_FIELD: *[u8] = "len";
104	104		/// Identifier for the synthetic `ptr` field.
105		-	export const PTR_FIELD: *[u8] = "ptr";
	105	+	export constant PTR_FIELD: *[u8] = "ptr";
106	106		/// Identifier for the synthetic `cap` field.
107		-	export const CAP_FIELD: *[u8] = "cap";
	107	+	export constant CAP_FIELD: *[u8] = "cap";
108	108
109	109		/// Maximum `u16` value.
110		-	const U16_MAX: u16 = 0xFFFF;
	110	+	constant U16_MAX: u16 = 0xFFFF;
111	111		/// Maximum `u8` value.
112		-	const U8_MAX: u16 = 0xFF;
	112	+	constant U8_MAX: u16 = 0xFF;
113	113
114	114		/// Minimum `i8` value.
115		-	const I8_MIN: i32 = -128;
	115	+	constant I8_MIN: i32 = -128;
116	116		/// Maximum `i8` value.
117		-	const I8_MAX: i32 = 127;
	117	+	constant I8_MAX: i32 = 127;
118	118		/// Minimum `i16` value.
119		-	const I16_MIN: i32 = -32768;
	119	+	constant I16_MIN: i32 = -32768;
120	120		/// Maximum `i16` value.
121		-	const I16_MAX: i32 = 32767;
	121	+	constant I16_MAX: i32 = 32767;
122	122
123	123		/// Minimum `i32` value.
124		-	const I32_MIN: i32 = -2147483648;
	124	+	constant I32_MIN: i32 = -2147483648;
125	125		/// Maximum `i32` value.
126		-	const I32_MAX: i32 = 2147483647;
	126	+	constant I32_MAX: i32 = 2147483647;
127	127		/// Minimum `i64` value: -(2^63).
128		-	const I64_MIN: i64 = -9223372036854775808;
	128	+	constant I64_MIN: i64 = -9223372036854775808;
129	129		/// Maximum `i64` value: 2^63 - 1.
130		-	const I64_MAX: i64 = 9223372036854775807;
	130	+	constant I64_MAX: i64 = 9223372036854775807;
131	131
132	132		/// Size of a pointer in bytes.
133		-	export const PTR_SIZE: u32 = 8;
	133	+	export constant PTR_SIZE: u32 = 8;
134	134
135	135		/// Information about a record or tuple field.
136	136		export record RecordField {
137	137		/// Field name, `nil` for positional fields.
138	138		name: ?*[u8],

2975	2975		actual: args.len,
2976	2976		}));
2977	2977		}
2978	2978		}
2979	2979
2980		-	/// Helper for analyzing `const` and `static` declarations.
	2980	+	/// Helper for analyzing `constant` and `static` declarations.
2981	2981		fn resolveConstOrStatic(
2982	2982		self: *mut Resolver,
2983	2983		node: *ast::Node,
2984	2984		ident: *ast::Node,
2985	2985		typeNode: *ast::Node,

22	22		static MODULE_ARENA_STORAGE: [u8; 4096] = undefined;
23	23		static MODULE_ARENA: ast::NodeArena = undefined;
24	24		static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
25	25
26	26		/// String literals used in tests.
27		-	const LITERALS: [*[u8]; 15] = [
	27	+	constant LITERALS: [*[u8]; 15] = [
28	28		"Ok", "Error", "R", "S",
29	29		"f", "Status", "Pending",
30	30		"Some", "None", "First",
31	31		"Second", "Opt", "x",
32	32		"value", "idx"

545	545		try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("x"));
546	546		}
547	547
548	548		@test fn testResolveConstLiteralValue() throws (testing::TestError) {
549	549		let mut a = testResolver();
550		-	let program = "const ANSWER: i32 = 42;";
	550	+	let program = "constant ANSWER: i32 = 42;";
551	551		let result = try resolveProgramStr(&mut a, program);
552	552		try expectNoErrors(&result);
553	553
554	554		let constNode = try getBlockStmt(result.root, 0);
555	555		let sym = super::symbolFor(&a, constNode)