pub mod io;

pub mod collections;

pub mod lang;

pub mod sys;

pub mod arch;

pub mod fmt;

pub mod mem;

pub mod vec;

pub mod intrinsics;

pub mod isel;

pub mod printer;

@test mod tests;

use std::mem;

use std::lang::il;

use std::lang::alloc;

use std::lang::gen::labels;

use std::lang::gen::regalloc;

pub const T5:   Reg = { n: 30 };  /// Temporary.

pub const T6:   Reg = { n: 31 };  /// Temporary.

/// Create a register from a number. Panics if `n > 31`.

pub fn reg(n: u8) -> Reg {

    return Reg { n };

}

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

// Architecture constants //

//! RV64 binary emission.

//!

//! Emits RV64 machine code as `u32` list.

use std::lang::il;

use std::lang::alloc;

use std::lang::gen::labels;

use std::collections::dict;

use std::mem;

    e.code[index] = instr;

}

/// Record a block's address for branch resolution.

pub fn recordBlock(e: *mut Emitter, blockIdx: u32) {

    labels::recordBlock(&mut e.labels, blockIdx, e.codeLen as i32 * super::INSTR_SIZE);

}

/// Record a function's code offset for call resolution.

pub fn recordFuncOffset(e: *mut Emitter, name: *[u8]) {

    dict::insert(&mut e.labels.funcs, name, e.codeLen as i32 * super::INSTR_SIZE);

}

/// Record a function's start position for printing.

pub fn recordFunc(e: *mut Emitter, name: *[u8]) {

//! RISC-V RV64I+M instruction encoding.

//!

//! Provides type-safe functions for encoding RV64 instructions.

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

// Opcode Constants //

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

pub const OP_LOAD:   u32 = 0x03;

         | ((funct7       & 0x7F) << 25);

}

/// Encode an I-type instruction.

fn encodeI(opcode: u32, rd: super::Reg, rs1: super::Reg, funct3: u32, imm: i32) -> u32 {

    return (opcode        & 0x7F)

         | ((rd.n  as u32 & 0x1F)  << 7)

         | ((funct3       & 0x07)  << 12)

         | ((rs1.n as u32 & 0x1F)  << 15)

         | ((imm as u32   & 0xFFF) << 20);

}

/// Encode an S-type instruction.

fn encodeS(opcode: u32, rs1: super::Reg, rs2: super::Reg, funct3: u32, imm: i32) -> u32 {

    return (opcode  & 0x7F)

         | ((imm as u32        & 0x1F) << 7)

         | ((funct3            & 0x07) << 12)

         | ((rs1.n as u32      & 0x1F) << 15)

         | ((imm as u32 >> 5   & 0x7F) << 25);

}

/// Encode a B-type (branch) instruction.

fn encodeB(opcode: u32, rs1: super::Reg, rs2: super::Reg, funct3: u32, imm: i32) -> u32 {

    let imm11   = (imm as u32 >> 11) & 0x1;

    let imm4_1  = (imm as u32 >> 1)  & 0xF;

    let imm10_5 = (imm as u32 >> 5)  & 0x3F;

    let imm12   = (imm as u32 >> 12) & 0x1;

         | ((imm as u32  & 0xFFFFF) << 12);

}

/// Encode a J-type (jump) instruction.

fn encodeJ(opcode: u32, rd: super::Reg, imm: i32) -> u32 {

    let imm20    = (imm as u32 >> 20) & 0x1;

    let imm10_1  = (imm as u32 >> 1)  & 0x3FF;

    let imm11    = (imm as u32 >> 11) & 0x1;

    let imm19_12 = (imm as u32 >> 12) & 0xFF;

    return encodeI(OP_IMM, rd, rs1, F3_AND, imm);

}

/// Shift left logical immediate: `rd = rs1 << shamt`.

pub fn slli(rd: super::Reg, rs1: super::Reg, shamt: i32) -> u32 {

    return encodeI(OP_IMM, rd, rs1, F3_SLL, shamt & 0x3F);

}

/// Shift right logical immediate: `rd = rs1 >> shamt` (zero-extend).

pub fn srli(rd: super::Reg, rs1: super::Reg, shamt: i32) -> u32 {

    return encodeI(OP_IMM, rd, rs1, F3_SRL, shamt & 0x3F);

}

/// Shift right arithmetic immediate: `rd = rs1 >> shamt` (sign-extend).

pub fn srai(rd: super::Reg, rs1: super::Reg, shamt: i32) -> u32 {

    // SRAI has bit 10 set in immediate field (becomes bit 30 in instruction)

    return encodeI(OP_IMM, rd, rs1, F3_SRL, (shamt & 0x3F) | 0b10000000000);

}

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

    return encodeI(OP_IMM32, rd, rs1, F3_ADD, imm);

}

/// Shift left logical immediate word: `rd = sign_ext((rs1 << shamt)[31:0])`.

pub fn slliw(rd: super::Reg, rs1: super::Reg, shamt: i32) -> u32 {

    return encodeI(OP_IMM32, rd, rs1, F3_SLL, shamt & 0x1F);

}

/// Shift right logical immediate word: `rd = sign_ext((rs1[31:0] >> shamt))`.

pub fn srliw(rd: super::Reg, rs1: super::Reg, shamt: i32) -> u32 {

    return encodeI(OP_IMM32, rd, rs1, F3_SRL, shamt & 0x1F);

}

/// Shift right arithmetic immediate word: `rd = sign_ext((rs1[31:0] >> shamt))` (sign-extended).

pub fn sraiw(rd: super::Reg, rs1: super::Reg, shamt: i32) -> u32 {

    return encodeI(OP_IMM32, rd, rs1, F3_SRL, (shamt & 0x1F) | 0b10000000000);

}

/// Add word: `rd = sign_ext((rs1 + rs2)[31:0])`.

pub fn addw(rd: super::Reg, rs1: super::Reg, rs2: super::Reg) -> u32 {

//!   loadVal(rd, val) -> Reg

//!     Force an [`il::Val`] into a specific register `rd`. Built on [`resolveVal`] + [`emitMv`].

//!     Used when the instruction requires the value in `rd` (e.g. `sub rd, rd, rs2`).

use std::mem;

use std::lang::il;

use std::lang::gen::regalloc;

use std::lang::gen::labels;

use super::encode;

                    emit::emit(s.e, encode::sub(super::SP, super::SP, rs));

                    if alignment > 1 {

                        let mask = 0 - alignment as i32;

                        emit::emit(s.e, encode::andi(super::SP, super::SP, mask));

                    }

                    emit::emit(s.e, encode::mv(rd, super::SP));

                },

union TestError { Boom, Bust }

@default fn main() -> u32 {

    // Test catching and using the error value.

    let mut caught: u32 = 0;

            caught = 1;

        } else {

            caught = 2;

        }

    };

    // Test catching a different error variant.

    caught = 0;

    try failWithBust() catch e {

        if (e == TestError::Bust) {

            caught = 10;

        } else {

            caught = 20;

        }

    };

    // Test that success path doesn't execute catch block.

    caught = 0;

    try succeed() catch e {

        caught = 99;

    };

    // Test catch block that returns early from function.

    let early: u32 = testCatchReturn();

    // Test using success value when catch diverges.

    let success: u32 = testCatchDiverges();

    // Test error value is correctly bound.

    let errVal: u32 = testErrorValue();

    return 0;

}

fn failWithBoom() throws (TestError) {

//! Test string escape sequences.

@default fn main() -> i32 {

    let s1: *[u8] = "Hello\tWorld!\n";

    let s2: *[u8] = "\"";

    let s3: *[u8] = "\"\\\"";

    return 0;

}

record Pair {

    left: bool,

    right: bool,

}

    return 5;

}

@default fn main() -> i32 {

    let inferredFlag = alwaysTrue();

    let mut counter = returnsCount();

    counter += 1;

    let pair = loadPair();

    let left = pair.left;

    let copy = inferredFlag;

    return 0;

}

//! Formatting utilities for converting values to strings.

use super::mem;

/// Maximum string length for a formatted u32 (eg. "4294967295").

pub const U32_STR_LEN: u32 = 10;

/// Maximum string length for a formatted i32 (eg. "-2147483648").

pub const I32_STR_LEN: u32 = 11;

/// Maximum string length for a formatted bool (eg. "false").

pub const BOOL_STR_LEN: u32 = 5;

/// Format a u32 by writing it to the provided buffer.

pub fn formatU32(val: u32, buffer: *mut [u8]) -> *[u8] {

    let mut x: u32 = val;

    let mut i: u32 = buffer.len;

    // Handle the zero case separately to ensure a single '0' is written.

    return &buffer[i..];

}

/// Format a i32 by writing it to the provided buffer.

pub fn formatI32(val: i32, buffer: *mut [u8]) -> *[u8] {

    let neg: bool = val < 0;

    let mut x: u32 = -val as u32 if neg else val as u32;

    let mut i: u32 = buffer.len;

    // Handle the zero case separately to ensure a single '0' is written.

    return &buffer[i..];

}

/// Format a u64 by writing it to the provided buffer.

pub fn formatU64(val: u64, buffer: *mut [u8]) -> *[u8] {

    let mut x: u64 = val;

    let mut i: u32 = buffer.len;

    if x == 0 {

    return &buffer[i..];

}

/// Format a i64 by writing it to the provided buffer.

pub fn formatI64(val: i64, buffer: *mut [u8]) -> *[u8] {

    let neg: bool = val < 0;

    let mut x: u64 = -val as u64 if neg else val as u64;

    let mut i: u32 = buffer.len;

    if x == 0 {

//! byte buffer. Memory is never freed individually - the entire arena is

//! reset at once. This is ideal for compiler passes where all allocations

//! have the same lifetime.

@test mod tests;

use std::mem;

/// Error thrown by allocator.

pub union AllocError {

    /// Allocator is out of memory.

///

/// Returns an opaque pointer to the allocated memory. Throws `AllocError` if

/// the arena is exhausted. The caller is responsible for casting to the

/// appropriate type and initializing the memory.

pub fn alloc(arena: *mut Arena, size: u32, alignment: u32) -> *mut opaque throws (AllocError) {

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

    let newOffset = aligned + size;

    if newOffset > arena.data.len as u32 {

//! Radiance AST modules.

pub mod printer;

use std::io;

use std::lang::alloc;

/// Maximum number of trait methods.

pub const MAX_TRAIT_METHODS: u32 = 8;

    return self.list.len;

}

/// Fetch the attribute node at the specified index.

pub fn attributesGet(self: *Attributes, index: u32) -> *Node {

    return self.list.list[index];

}

/// Check if an attributes list contains an attribute.

pub fn attributesContains(self: *Attributes, attr: Attribute) -> bool {

//!       ↓

//!   il::DataValue

//!       ↓

//!   il::Data

//!

use std::fmt;

use std::io;

use std::lang::alloc;

use std::mem;

use std::lang::ast;

    } else {

        func.returnType = ilType(self, *fnType.returnType);

    }

    let body = decl.body else {

        // Extern functions have no body.

        return func;

    };

    func.blocks = try lowerFnBody(&mut fnLow, body);

    return func;

    switchToBlock(self, target);

}

/// Emit a conditional branch based on `cond`.

fn emitBr(self: *mut FnLowerer, cond: il::Reg, thenBlock: BlockId, elseBlock: BlockId) throws (LowerError) {

    emit(self, il::Instr::Br {

        op: il::CmpOp::Ne,

        typ: il::Type::W32,

        a: il::Val::Reg(cond),

        b: il::Val::Imm(0),

    a: il::Val,

    b: il::Val,

    thenBlock: BlockId,

    elseBlock: BlockId

) throws (LowerError) {

    emit(self, il::Instr::Br {

        op, typ, a, b,

        thenTarget: thenBlock.n, thenArgs: &mut [],

        elseTarget: elseBlock.n, elseArgs: &mut [],

    });

                try emitBr(self, eqReg, matchBlock, fallthrough);

            }

        }

        case MatchSubjectKind::Union(unionInfo) => {

            let case resolver::NodeExtra::UnionVariant { tag: variantTag, .. } =

                resolver::nodeData(self.low.resolver, pattern).extra

            else {

                throw LowerError::ExpectedVariant;

                try emitBrCmp(self, il::CmpOp::Eq, il::Type::W8, il::Val::Reg(tagReg), il::Val::Imm(variantTag as i64), matchBlock, fallthrough);

            }

        }

        else => { // Scalar comparison.

            let pattVal = try lowerExpr(self, pattern);

            try emitBrCmp(self, il::CmpOp::Eq, subject.ilType, subject.val, pattVal, matchBlock, fallthrough);

        }

    }

}

    subject: *MatchSubject,

    patterns: ast::NodeList,

    matchBlock: BlockId,

    fallthrough: BlockId

) throws (LowerError) {

    for i in 0..(patterns.len - 1) {

        let pattern = patterns.list[i];

        let nextArm = try createBlock(self, "arm");

        try emitPatternMatch(self, subject, pattern, matchBlock, nextArm);

/// Define (write) a variable. Record the SSA value of a variable in the

/// current block. Called when a variable is assigned or initialized (`let`

/// bindings, assignments, loop updates). When [`useVar`] is later called,

/// it will retrieve this value.

fn defVar(self: *mut FnLowerer, v: Var, val: il::Val) {

    getBlockMut(self, currentBlock(self)).vars[v.id] = val;

}

/// Use (read) the current value of a variable in the current block.

/// May insert block parameters if the value must come from predecessors.

/// Given a variable and a block where it's used, this function finds the

/// correct [`il::Val`] that holds the variable's value at that program point.

/// When control flow merges from multiple predecessors with different

/// definitions, it creates a block parameter to unify them.

fn useVarInBlock(self: *mut FnLowerer, block: BlockId, v: Var) -> il::Val throws (LowerError) {

    let blk = getBlockMut(self, block);

    if let val = blk.vars[v.id] {

        return val;

    }

    self.varsLen = savedVarsLen;

}

/// Get the metadata for a variable.

fn getVar(self: *FnLowerer, v: Var) -> *VarData {

    return &self.vars[v.id];

}

/// Create a block parameter to merge a variable's value from multiple

/// control flow paths.

    let offset: u32 = 1 if self.returnReg != nil else 0;

    let totalLen = fnType.paramTypesLen + offset;

    if totalLen == 0 {

        return &[];

    }

    let params = try! alloc::allocSlice(

        self.low.arena, @sizeOf(il::Param), @alignOf(il::Param), totalLen

    ) as *mut [il::Param];

///       jmp else#0;                     // guard failed, fallthrough to `else`

///   else#0:

///       ret 0;                          // `else` body

///

fn lowerMatch(self: *mut FnLowerer, node: *ast::Node, m: ast::Match) throws (LowerError) {

    let prongs = &m.prongs;

    // Lower the subject expression once; reused across all arms.

    let subject = try lowerMatchSubject(self, m.subject);

    // Merge block created lazily if any arm needs it (i.e., doesn't diverge).

    let tagBlock = try createBlock(self, "eq#tag");

    // Compare tags: if they differ, jump to merge with `false`; otherwise check payloads.

    let falseArgs = try allocVal(self, il::Val::Imm(0));

    // TODO: Use the helper once the compiler supports more than eight function params.

    emit(self, il::Instr::Br {

        op: il::CmpOp::Eq, typ: il::Type::W8, a: tagA, b: tagB,

        thenTarget: tagBlock.n, thenArgs: &mut [],

    try emitRetVal(self, val);

}

/// Lower a throw statement.

fn lowerThrowStmt(self: *mut FnLowerer, expr: *ast::Node) throws (LowerError) {

    let errType = resolver::typeFor(self.low.resolver, expr) else {

        throw LowerError::MissingType(expr);

    };

    let tag = getOrAssignErrorTag(self.low, errType) as i64;

pub mod printer;

@test mod tests;

use std::mem;

use std::lang::alloc;

use std::lang::ast;

use std::lang::strings;

/// Maximum number of modules tracked in a single compilation graph.

    graph: *mut ModuleGraph,

    parentId: u16,

    name: *[u8],

    filePath: *[u8]

) -> u16 throws (ModuleError) {

    let parent = getMut(graph, parentId)

        else throw ModuleError::NotFound(parentId);

    // If the child already exists under this parent, return it.

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

}

/// Return the identifier of the child stored at `index`.

pub fn childAt(m: *ModuleEntry, index: u32) -> u16 {

    return m.children[index];

}

/// Public accessor for a module's directory prefix.

pub fn moduleDir(m: *ModuleEntry) -> *[u8] {

    return &m.filePath[..m.dirLen];

}

/// Public accessor to the logical module path segments.

pub fn moduleQualifiedPath(m: *ModuleEntry) -> *[*[u8]] {

    return &m.path[..m.pathDepth];

}

/// Update the recorded lifecycle state for `id`.

pub fn setState(graph: *mut ModuleGraph, id: u16, state: ModuleState) throws (ModuleError) {

    m.source = source;

}

/// Look up a child module by name under the given parent.

pub fn findChild(graph: *ModuleGraph, name: *[u8], parentId: u16) -> ?*ModuleEntry {

    let parent = &graph.entries[parentId as u32];

    for i in 0..parent.childrenLen {

        let childId = parent.children[i];

        let child = &graph.entries[childId as u32];

    // Split on '/' to extract all but the last component.

    for i in 0..filePath.len {

        if filePath[i] == PATH_SEP {

            if i > last {

                components[count] = &filePath[last..i];

                count += 1;

            }

            last = i + 1;

        }

    if last >= filePath.len {

        return nil; // Path ends with separator or is empty.

    }

    // Handle the last component by removing extension.

    if let name = trimExtension(&filePath[last..]) {

        components[count] = name;

    } else {

        return nil;

    };

//! Recursive descent parser for the Radiance programming language.

@test pub mod tests;

use std::mem;

use std::io;

use std::lang::alloc;

use std::lang::ast;

use std::lang::strings;

use std::lang::scanner;

    return node(p, ast::NodeValue::Bool(value));

}

/// Convert a single ASCII digit into its numeric value for the given radix.

pub fn digitFromAscii(ch: u8, radix: u32) -> ?u32 {

    // Default to an out-of-range value so non-digits fall through to `nil`.

    let mut value: u32 = 36;

    if ch >= '0' and ch <= '9' {

    }

}

/// Report a parser error.

fn reportError(p: *mut Parser, token: scanner::Token, message: *[u8]) {

    // Ignore errors once the error list is full.

    if p.errors.count < p.errors.list.len {

        p.errors.list[p.errors.count] = Error { message, token };

        p.errors.count += 1;

// TODO: When a function declaration fails to typecheck, it should still "exist".

// TODO: `ensureNominalResolved` should just run when you call `typeFor`.

// TODO: Have different types for positional vs. named field records.

use std::mem;

use std::io;

use std::lang::alloc;

use std::lang::ast;

use std::lang::parser;

use std::lang::module;

    if let a = decl.alignment {

        let case ast::NodeValue::Align { value } = a.value

            else panic "resolveLet: expected Align node";

        alignment = try checkSizeInt(self, value);

    }

    // Alignment must be zero or a power of two.

    if alignment != 0 and (alignment & (alignment - 1)) != 0 {

        throw emitError(self, decl.value, ErrorKind::InvalidAlignmentValue(alignment));

    }

    // Validate it fits within u32 range.

    if not validateConstIntRange(value, Type::U32) {

        throw emitError(self, node, ErrorKind::NumericLiteralOverflow);

    }

    try setNodeType(self, node, Type::U32);

    return int.magnitude as u32;

}

            expected: info.paramTypesLen,

            actual: call.args.len,

        }));

    }

    for i in 0..call.args.len {

        let argNode = call.args.list[i];

        let expectedTy = *info.paramTypes[i];

        try checkAssignable(self, argNode, expectedTy);

        expectedTy = *ary.item;

    };

    for i in 0..length {

        let itemNode = items.list[i];

        let itemTy = try visit(self, itemNode, expectedTy);

        // Set the expected type to the first type we encounter.

        if expectedTy == Type::Unknown {

            expectedTy = itemTy;

        } else {

    throws (ResolveError)

{

    let targetTy = try infer(self, expr.type);

    let sourceTy = try visit(self, expr.value, targetTy);

    if isValidCast(sourceTy, targetTy) {

        return try setNodeType(self, node, targetTy);

    }

    throw emitError(self, node, ErrorKind::InvalidAsCast(InvalidAsCast {

    let case ast::NodeValue::Block(block) = node.value

        else panic "resolvePackage: expected block for module root";

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

    try resolveModuleGraph(self, &block) catch {

        return Diagnostics { errors: self.errors };

    };

    // Declaration phase: bind all names and analyze top-level declarations.

    try resolveModuleDecls(self, &block) catch {

    };

    if self.errors.listLen > 0 {

        return Diagnostics { errors: self.errors };

    }

    // Definition phase: analyze function bodies and sub-module definitions.

    try resolveModuleDefs(self, &block) catch {

    };

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

    return Diagnostics { errors: self.errors };

}

//!

//! This module implements a hand-written scanner that tokenizes Radiance

//! source code into a stream of tokens for consumption by the parser.

@test mod tests;

use std::mem;

use std::lang::strings;

/// Token kinds representing all lexical elements in Radiance.

///

//!

//! Users provide their own arena (static array) and the vector manages

//! element count within that arena. The arena should be aligned according

//! to the element type's requirements.

/// Raw vector metadata structure.

///

/// Does not own storage, points to user-provided arena.

pub record RawVec {

    /// Pointer to user-provided byte arena.

///

/// * `arena` is a pointer to static array backing storage.

/// * `stride` is the size of each element.

/// * `alignment` is the required alignment for elements.

pub fn new(arena: *mut [u8], stride: u32, alignment: u32) -> RawVec {

    return RawVec { data: arena, len: 0, stride, alignment };

}

/// Get the current number of elements in the vector.

lib/std/fmt.rad

lib/std/mem.rad

lib/std/vec.rad

lib/std/io.rad

lib/std/intrinsics.rad

lib/std/sys.rad

lib/std/collections.rad

lib/std/collections/dict.rad

lib/std/sys/unix.rad

lib/std/arch.rad