radiance · commit

feat(lang): Generalize core types (WIP)

b5fc83f3c8d96e8d017850be318ee4b3a38083c97dcd5698f6401b3d851d1b7c

Use generic arrays, slices, and vectors throughout the compiler and RV64 backend. Keep slice values limited to pointer and length while vectors track initialized length and capacity.

Add bounded overlap-safe relocation, canonical cross-package generic names, and tests for vector growth, array lengths, and relocation.

Alexis Sellier committed 20 days ago 1 parent 3225bfc0

Makefile +6 -1


# A `.rad` executable test can have a same-basename `.ras` module.
$(patsubst %.ras,%.rv64,$(BIN_TEST_RAD_ASM_SRC)): %.rv64: %.ras
$(patsubst %.start.ras,%.rv64,$(BIN_TEST_RAD_START_SRC)): %.rv64: %.start.ras

# Cross-package generic tests compile with the standard library.
$(BIN_TEST_DIR)/vec.generic.rv64: $(BIN_TEST_DIR)/vec.generic.rad $(STD_LIB) $(RAD_BIN)
	@echo "radiance $(BIN_TEST_DIR)/vec.generic.rad => $@"
	@$(RADIANCE) $(STD) -pkg test -mod $< -entry test -o $@

# Compile each executable test to a binary.
$(BIN_TEST_DIR)/%.rv64: $(BIN_TEST_DIR)/%.rad $(RAD_BIN)
	@echo "radiance $< => $@"
	@$(RADIANCE) -pkg test -mod $< $(patsubst %,-mod %,$(wildcard $(@:.rv64=)/*.rad)) $(patsubst %,-start %,$(wildcard $(@:.rv64=.start.ras))) $(patsubst %,-mod %,$(wildcard $(@:.rv64=.ras))) -o $@


clean-bin-test:
	@rm -f $(BIN_RUNNER) \
		$(BIN_RUNNER:.rv64=.rv64.debug) \
		$(BIN_RUNNER:.rv64=.rv64.s) \
		$(BIN_RUNNER:.rv64=.rv64.o) \
		$(BIN_TEST_EXE_BIN) \
		$(wildcard $(BIN_TEST_DIR)/*.rv64) \
		$(wildcard $(BIN_TEST_DIR)/*.rv64.debug) \
		$(wildcard $(BIN_TEST_DIR)/*.rv64.s)

seed:
	seed/update

compiler/radiance.rad +62 -22

//! Radiance compiler front-end.
use std::mem;
use std::fmt;
use std::vec;
use std::io;
use std::lang::alloc;
use std::lang::ast;
use std::lang::parser;
use std::lang::scanner;

use std::lang::gen::types;
use std::sys;
use std::sys::unix;
use std::collections::dict;

instantiate vec::append⟨*ast::Node⟩,
            vec::viewMut⟨*ast::Node⟩,
            vec::viewMut⟨resolver::Error⟩,
            vec::view⟨il::Data⟩;

/// Maximum number of modules we can load per package.
constant MAX_LOADED_MODULES: u32 = 64;
/// Maximum number of packages we can compile.
constant MAX_PACKAGES: u32 = 4;
/// Total module entries across all packages.

    }
    set funcPath[desc.modPath.len - 1] = desc.fnName;
    let funcArg = synthScopeAccess(arena, &funcPath[..desc.modPath.len]);

    let a = alloc::arenaAllocator(&mut arena.arena);
    let args = ast::nodeSlice(arena, 3)
        .append(modArg, a)
        .append(nameArg, a)
        .append(funcArg, a);

    return ast::synthNode(arena, ast::NodeValue::Call(ast::Call { callee, args }));
    let mut args = ast::nodeVec(arena, 3);
    vec::append⟨*ast::Node⟩(&mut args, modArg, a);
    vec::append⟨*ast::Node⟩(&mut args, nameArg, a);
    vec::append⟨*ast::Node⟩(&mut args, funcArg, a);
    let argsView = vec::viewMut⟨*ast::Node⟩(&mut args);

    return ast::synthNode(arena, ast::NodeValue::Call(ast::Call {
        callee,
        args: argsView,
    }));
}

/// Inject a test runner into the entry package's root module.
///
/// Scans all parsed modules for `@test fn` declarations, then appends


/// Synthesize the test entry point.
fn synthTestMainFn(arena: *mut ast::NodeArena, tests: *[TestDesc]) -> *ast::Node {
    // Build array literal: `[testing::test(...), ...]`.
    let a = alloc::arenaAllocator(&mut arena.arena);
    let mut elements = ast::nodeSlice(arena, tests.len as u32);
    let mut elements = ast::nodeVec(arena, tests.len as u32);
    for i in 0..tests.len {
        elements.append(synthTestCall(arena, &tests[i]), a);
        vec::append⟨*ast::Node⟩(&mut elements, synthTestCall(arena, &tests[i]), a);
    }
    let arrayLit = ast::synthNode(arena, ast::NodeValue::ArrayLit(elements));
    let arrayLit = ast::synthNode(
        arena,
        ast::NodeValue::ArrayLit(vec::viewMut⟨*ast::Node⟩(&mut elements))
    );

    // Build: `&[...]`.
    let testsRef = ast::synthNode(arena, ast::NodeValue::AddressOf(ast::AddressOf {
        target: arrayLit, mutable: false,
    }));

    // Build: `testing::runAllTests(&[...])`.
    let runFn = synthScopeAccess(arena, &["testing", "runAllTests"]);
    let callArgs = ast::nodeSlice(arena, 1).append(testsRef, a);
    let mut callArgs = ast::nodeVec(arena, 1);
    vec::append⟨*ast::Node⟩(&mut callArgs, testsRef, a);
    let callExpr = ast::synthNode(arena, ast::NodeValue::Call(ast::Call {
        callee: runFn, args: callArgs,
        callee: runFn, args: vec::viewMut⟨*ast::Node⟩(&mut callArgs),
    }));

    // Build: `return testing::runAllTests(&[...]);`
    let retStmt = ast::synthNode(arena, ast::NodeValue::Return { value: callExpr });
    let bodyStmts = ast::nodeSlice(arena, 1).append(retStmt, a);
    let fnBody = ast::synthNode(arena, ast::NodeValue::Block(ast::Block { statements: bodyStmts }));
    let mut bodyStmts = ast::nodeVec(arena, 1);
    vec::append⟨*ast::Node⟩(&mut bodyStmts, retStmt, a);
    let fnBody = ast::synthNode(arena, ast::NodeValue::Block(ast::Block {
        statements: vec::viewMut⟨*ast::Node⟩(&mut bodyStmts),
    }));

    // Build: `fn #testMain() -> i32`
    let fnName = ast::synthNode(arena, ast::NodeValue::Ident(strings::intern(&mut STRING_POOL, "#testMain")));
    let returnType = ast::synthNode(arena, ast::NodeValue::TypeSig(ast::TypeSig::Integer {
        width: 4, sign: ast::Signedness::Signed,
    }));
    let fnSig = ast::FnSig {
        params: ast::nodeSlice(arena, 0),
        params: &mut [],
        returnType,
        throwList: ast::nodeSlice(arena, 0),
        throwList: &mut [],
    };

    // `@default` attribute.
    let attrNode = ast::synthNode(arena, ast::NodeValue::Attribute(ast::Attribute::Default));
    let attrList = ast::nodeSlice(arena, 1).append(attrNode, a);
    let fnAttrs = ast::Attributes { list: attrList };
    let mut attrList = ast::nodeVec(arena, 1);
    vec::append⟨*ast::Node⟩(&mut attrList, attrNode, a);
    let fnAttrs = ast::Attributes {
        list: vec::viewMut⟨*ast::Node⟩(&mut attrList),
    };

    return ast::synthNode(arena, ast::NodeValue::FnDecl(ast::FnDecl {
        name: fnName, params: ast::nodeSlice(arena, 0), sig: fnSig, body: fnBody, attrs: fnAttrs,
        name: fnName,
        params: &mut [],
        sig: fnSig,
        body: fnBody,
        attrs: fnAttrs,
    }));
}

/// Append a declaration to a block node's statement list.
fn injectIntoBlock(

    decl: *ast::Node
) {
    let case ast::NodeValue::Block(block) = blockNode.value else {
        panic "injectIntoBlock: expected Block node";
    };
    let stmts = block.statements.append(decl, alloc::arenaAllocator(&mut arena.arena));
    set blockNode.value = ast::NodeValue::Block(ast::Block { statements: stmts });
    let a = alloc::arenaAllocator(&mut arena.arena);
    let mut stmts = ast::nodeVec(arena, block.statements.len as u32 + 1);
    for stmt in block.statements {
        vec::append⟨*ast::Node⟩(&mut stmts, stmt, a);
    }
    vec::append⟨*ast::Node⟩(&mut stmts, decl, a);
    set blockNode.value = ast::NodeValue::Block(ast::Block {
        statements: vec::viewMut⟨*ast::Node⟩(&mut stmts),
    });
}

/// Write a self-contained RV64 image containing text and data sections.
fn writeImage(
    code: *[u32],

    }

    // Resolve all packages.
    // TODO: Fix this error printing dance.
    let diags = try resolver::resolve(&mut res, &ctx.graph, &resolverPkgs[..resolverPackageCount]) catch {
        let diags = resolver::Diagnostics { errors: res.errors };
        let diags = resolver::Diagnostics {
            errors: vec::viewMut⟨resolver::Error⟩(&mut res.errors),
        };
        resolver::printer::printDiagnostics(&diags, &res);
        throw Error::Other;
    };
    if not resolver::success(&diags) {
        resolver::printer::printDiagnostics(&diags, &res);

        else => {}
    }
    if let path = codegenOptions.logPath {
        pkgLog(entryPkg, &["generating code", "(", path, ")", ".."]);
    }
    return rv64::finishProgram(&mut generator, &low.data[..], storage, asmData, &mut RO_DATA_BUF[..], &mut RW_DATA_BUF[..]);
    return rv64::finishProgram(
        &mut generator,
        vec::view⟨il::Data⟩(&low.data),
        storage,
        asmData,
        &mut RO_DATA_BUF[..],
        &mut RW_DATA_BUF[..],
    );
}

/// Lower, optionally dump, and optionally generate binary output.
fn compile(
    ctx: *mut CompileContext,

lib/std.rad +3 -2

//! The Radiance Standard Library.

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

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

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

    let rwDataSize = data::emitSection(
        globalData, &dataSymMap, &generator.e.labels, codeBase, rwDataBuf, false
    );
    return Program {
        code: emit::getCode(&generator.e),
        funcs: generator.e.funcs,
        funcs: emit::getFuncs(&generator.e),
        roDataSize,
        rwDataSize,
        debugEntries: emit::getDebugEntries(&generator.e),
    };
}

lib/std/arch/rv64/asm.rad +37 -19

use std::lang::strings;
use std::lang::gen;
use std::collections::dict;
use std::arch::rv64::encode;
use std::arch::rv64;
use std::vec;

instantiate vec::view⟨u32⟩;

instantiate vec::view⟨u8⟩;

instantiate vec::view⟨Symbol⟩;

instantiate vec::view⟨Fixup⟩;

/// Assembler scanner module.
export mod scanner;
/// Assembler parser module.
export mod parser;

export record Assembler {
    /// Allocation arena for temporary assembler state.
    arena: *mut alloc::Arena,
    /// Assembler lexical scanner.
    scan: scanner::Scanner,
    /// Output text buffer.
    text: *mut [u32],
    /// Output data buffer.
    data: *mut [u8],
    /// Append-backed output text storage.
    text: vec::Vec⟨u32⟩,
    /// Append-backed output data storage.
    data: vec::Vec⟨u8⟩,
    /// Current output section.
    section: Section,
    /// Defined symbols.
    symbols: *mut [Symbol],
    /// Append-backed defined symbols.
    symbols: vec::Vec⟨Symbol⟩,
    /// Name-to-symbol index map.
    symbolMap: dict::Dict,
    /// Name-to-integer map.
    constMap: dict::Dict,
    /// Names marked by `.export`.
    exportMap: dict::Dict,
    /// Pending fixups.
    fixups: *mut [Fixup],
    /// Fixups that reference text outside this assembly fragment.
    externalFixups: *mut [Fixup],
    /// Append-backed pending fixups.
    fixups: vec::Vec⟨Fixup⟩,
    /// Append-backed fixups that reference text outside this assembly fragment.
    externalFixups: vec::Vec⟨Fixup⟩,
    /// Absolute runtime address of data-section offset zero.
    dataBase: u32,
}

/// Assemble source using `dataBase` as the runtime address of the data-section.

    let exportEntries = try! alloc::allocSlice(arena, @sizeOf(dict::Entry), @alignOf(dict::Entry), tableCap);

    let mut a = Assembler {
        arena,
        scan: scanner::scanner(sourceKind, source, pool),
        text: @sliceOf(textBuf.ptr, 0, textBuf.len),
        data: @sliceOf(dataBuf.ptr, 0, dataBuf.len),
        text: vec::Vec⟨u32⟩ { data: textBuf, len: 0 },
        data: vec::Vec⟨u8⟩ { data: dataBuf, len: 0 },
        section: Section::Text,
        symbols: @sliceOf((symbols as *mut [Symbol]).ptr, 0, (symbols as *mut [Symbol]).len),
        symbols: vec::Vec⟨Symbol⟩ {
            data: symbols as *mut [Symbol],
            len: 0,
        },
        symbolMap: dict::init(entries as *mut [dict::Entry]),
        constMap: dict::init(constEntries as *mut [dict::Entry]),
        exportMap: dict::init(exportEntries as *mut [dict::Entry]),
        fixups: @sliceOf((fixups as *mut [Fixup]).ptr, 0, (fixups as *mut [Fixup]).len),
        externalFixups: @sliceOf((externalFixups as *mut [Fixup]).ptr, 0, (externalFixups as *mut [Fixup]).len),
        fixups: vec::Vec⟨Fixup⟩ {
            data: fixups as *mut [Fixup],
            len: 0,
        },
        externalFixups: vec::Vec⟨Fixup⟩ {
            data: externalFixups as *mut [Fixup],
            len: 0,
        },
        dataBase,
    };
    // Parse assembly source and emit instructions.
    try parser::parseProgram(&mut a);
    // Resolve fixups and finalize program.
    try emit::finishProgram(&mut a);

    return Program {
        text: a.text,
        data: a.data,
        symbols: a.symbols,
        externalFixups: a.externalFixups,
        text: vec::view⟨u32⟩(&a.text),
        data: vec::view⟨u8⟩(&a.data),
        symbols: vec::view⟨Symbol⟩(&a.symbols),
        externalFixups: vec::view⟨Fixup⟩(&a.externalFixups),
    };
}

/// Return the next power of two at least as large as `value`.
fn nextPowerOfTwo(value: u32) -> u32 {

lib/std/arch/rv64/asm/emit.rad +28 -13

use std::fmt;

use std::collections::dict;
use std::lang::alloc;
use std::lang::gen;
use std::vec;

instantiate vec::append⟨super::Symbol⟩,
            vec::view⟨super::Symbol⟩;

instantiate vec::append⟨u32⟩,
            vec::viewMut⟨u32⟩;

instantiate vec::append⟨u8⟩,
            vec::viewMut⟨u8⟩;

instantiate vec::append⟨super::Fixup⟩,
            vec::view⟨super::Fixup⟩;

/// Define a symbol at the current text or data offset.
export fn defineSymbol(a: *mut super::Assembler, name: *[u8]) {
    let idx = a.symbols.len;
    let offset: i32 = a.data.len as i32
        if a.section == super::Section::Data
        else a.text.len as i32 * rv64::INSTR_SIZE;

    a.symbols.append(super::Symbol {
    vec::append⟨super::Symbol⟩(&mut a.symbols, super::Symbol {
        name,
        section: a.section,
        offset,
        isExported: dict::get(&a.exportMap, name) <> nil,
    }, alloc::arenaAllocator(a.arena));
    dict::insert(&mut a.symbolMap, name, idx as i32);
}

/// Append one encoded instruction word to the text section.
export fn emitText(a: *mut super::Assembler, word: u32) throws (super::Error) {
    a.text.append(word, alloc::arenaAllocator(a.arena));
    vec::append⟨u32⟩(&mut a.text, word, alloc::arenaAllocator(a.arena));
}

/// Append `words` no-op instructions to the text section.
export fn emitTextPadding(a: *mut super::Assembler, words: u32) throws (super::Error) {
    for _ in 0..words {

    }
}

/// Append one byte to the data section.
export fn emitByte(a: *mut super::Assembler, byte: u8) throws (super::Error) {
    a.data.append(byte, alloc::arenaAllocator(a.arena));
    vec::append⟨u8⟩(&mut a.data, byte, alloc::arenaAllocator(a.arena));
}

/// Emit a little-endian integer with `bytes` bytes.
fn emitDataInt(a: *mut super::Assembler, bits: u64, bytes: u32) throws (super::Error) {
    for i in 0..bytes {

    }
}

/// Patch a little-endian integer with `bytes` bytes.
fn patchDataInt(a: *mut super::Assembler, offset: u32, bits: u64, bytes: u32) {
    let data = vec::viewMut⟨u8⟩(&mut a.data);
    for i in 0..bytes {
        set a.data[offset + i] = ((bits >> ((i as u64) * super::BITS_PER_BYTE)) & super::BYTE_MASK) as u8;
        set data[offset + i] = ((bits >> ((i as u64) * super::BITS_PER_BYTE)) & super::BYTE_MASK) as u8;
    }
}

/// Emit an integer data directive value.
export fn emitDataValue(a: *mut super::Assembler, value: i64, width: super::DataWidth) throws (super::Error) {

    }
}

/// Record a pending symbol fixup.
fn recordFixup(a: *mut super::Assembler, symbol: *[u8], info: super::FixupInfo) {
    a.fixups.append(super::Fixup { symbol, info }, alloc::arenaAllocator(a.arena));
    vec::append⟨super::Fixup⟩(&mut a.fixups, super::Fixup { symbol, info }, alloc::arenaAllocator(a.arena));
}

/// Record a text fixup that must be resolved after all program text is known.
fn recordExternalFixup(a: *mut super::Assembler, fixup: super::Fixup) {
    a.externalFixups.append(fixup, alloc::arenaAllocator(a.arena));
    vec::append⟨super::Fixup⟩(&mut a.externalFixups, fixup, alloc::arenaAllocator(a.arena));
}

/// Record a text-section symbol fixup and reserve its instruction words.
export fn recordTextFixup(a: *mut super::Assembler, symbol: *[u8], info: super::FixupInfo, words: u32) throws (super::Error) {
    recordFixup(a, symbol, info);


/// Find a previously defined symbol by name.
fn findSymbol(a: *super::Assembler, name: *[u8]) -> ?super::Symbol {
    let idx = dict::get(&a.symbolMap, name)
        else return nil;
    return a.symbols[idx as u32];
    return vec::view⟨super::Symbol⟩(&a.symbols)[idx as u32];
}

/// Return the final address for a data symbol.
fn dataSymbolAddr(a: *super::Assembler, symbol: super::Symbol) -> i32 throws (super::Error) {
    if symbol.section <> super::Section::Data {

    return symbol.offset + (a.dataBase as i32);
}

/// Resolve final symbol references and patch all delayed output.
export fn finishProgram(a: *mut super::Assembler) throws (super::Error) {
    for i in 0..a.fixups.len {
        let fixup = a.fixups[i];
    let fixups = vec::view⟨super::Fixup⟩(&a.fixups);
    let text = vec::viewMut⟨u32⟩(&mut a.text);
    for fixup in fixups {
        let symbol = findSymbol(a, fixup.symbol) else {
            match fixup.info {
                case super::FixupInfo::Jal { .. }, super::FixupInfo::Addr { .. } => {
                    recordExternalFixup(a, fixup);
                    continue;

                if not encode::isBranchImm(rel) {
                    throw super::Error::Invalid { offset: 0, message: "branch target out of range" };
                }
                let word = encodeBranch(op, rs1, rs2, rel);

                set a.text[index] = word;
                set text[index] = word;
            }
            case super::FixupInfo::Jal { rd, index } => {
                if symbol.section <> super::Section::Text {
                    throw super::Error::Invalid { offset: 0, message: "jump target must be in text section" };
                }

                let rel = symbol.offset - srcOffset;

                if not encode::isJumpImm(rel) {
                    throw super::Error::Invalid { offset: 0, message: "jump target out of range" };
                }
                set a.text[index] = encode::jal(rd, rel);
                set text[index] = encode::jal(rd, rel);
            }
            case super::FixupInfo::Addr { rd, index } => {
                let mut addr = symbol.offset - (index as i32 * rv64::INSTR_SIZE);
                if symbol.section == super::Section::Data {
                    set addr = symbol.offset + (a.dataBase as i32);
                }
                let split = emit::splitImm(addr);
                set a.text[index] = encode::lui(rd, split.hi)
                set text[index] = encode::lui(rd, split.hi)
                    if symbol.section == super::Section::Data
                    else encode::auipc(rd, split.hi);
                set a.text[index + 1] = encode::addi(rd, rd, split.lo);
                set text[index + 1] = encode::addi(rd, rd, split.lo);
            }
            case super::FixupInfo::Word { offset } => {
                let addr = try dataSymbolAddr(a, symbol);
                patchDataInt(a, offset, addr as u64, rv64::WORD_SIZE as u32);
            }

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

use std::lang::parser;
use std::lang::gen;
use std::collections::dict;
use std::arch::rv64::encode;
use std::arch::rv64;
use std::vec;

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

instantiate vec::viewMut⟨super::Symbol⟩;

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

/// Parse a `.export` directive.
fn parseExportDirective(a: *mut super::Assembler) throws (super::Error) {
    let name = try parseLabelName(a);
    dict::insert(&mut a.exportMap, name, 1);
    if let idx = dict::get(&a.symbolMap, name) {
        set a.symbols[idx as u32].isExported = true;
        let symbols = vec::viewMut⟨super::Symbol⟩(&mut a.symbols);
        set symbols[idx as u32].isExported = true;
    }
}

/// Parse a `.space` directive.
fn parseSpaceDirective(a: *mut super::Assembler) throws (super::Error) {

lib/std/arch/rv64/emit.rad +61 -25

use std::lang::gen::data;
use std::lang::gen::labels;
use std::lang::gen::types;
use std::collections::dict;
use std::mem;
use std::vec;

use super::encode;

instantiate vec::append⟨PendingBranch⟩,
            vec::view⟨PendingBranch⟩;

instantiate vec::append⟨PendingCall⟩,
            vec::view⟨PendingCall⟩;

instantiate vec::append⟨PendingJump⟩,
            vec::view⟨PendingJump⟩;

instantiate vec::append⟨PendingAddrLoad⟩,
            vec::view⟨PendingAddrLoad⟩;

instantiate vec::append⟨types::FuncAddr⟩,
            vec::view⟨types::FuncAddr⟩;

/// Maximum number of instructions in code buffer.
constant MAX_INSTRS: u32 = 2097152;
/// Maximum code length before byte offset overflows signed 32-bits.
constant MAX_CODE_LEN: u32 = 0x7FFFFFFF / super::INSTR_SIZE as u32;
/// Maximum positive value encodable by a signed 32-bit address calculation.

    /// Emitted instructions storage.
    code: *mut [u32],
    /// Current number of emitted instructions.
    codeLen: u32,
    /// Local branches needing offset patching.
    pendingBranches: *mut [PendingBranch],
    pendingBranches: vec::Vec⟨PendingBranch⟩,
    /// Function calls needing offset patching.
    pendingCalls: *mut [PendingCall],
    pendingCalls: vec::Vec⟨PendingCall⟩,
    /// Assembly jumps needing offset patching.
    pendingJumps: *mut [PendingJump],
    pendingJumps: vec::Vec⟨PendingJump⟩,
    /// Function address loads needing offset patching.
    pendingAddrLoads: *mut [PendingAddrLoad],
    pendingAddrLoads: vec::Vec⟨PendingAddrLoad⟩,
    /// Block label tracking.
    labels: labels::Labels,
    /// Function start positions for printing.
    funcs: *mut [types::FuncAddr],
    funcs: vec::Vec⟨types::FuncAddr⟩,
    /// Debug entries mapping PCs to source locations.
    debugEntries: *mut [types::DebugEntry],
    /// Number of debug entries recorded.
    debugEntriesLen: u32,
}

    }
    return Emitter {
        allocator: alloc::arenaAllocator(arena),
        code: code as *mut [u32],
        codeLen: 0,
        pendingBranches: @sliceOf((pendingBranches as *mut [PendingBranch]).ptr, 0, MAX_PENDING),
        pendingCalls: @sliceOf((pendingCalls as *mut [PendingCall]).ptr, 0, MAX_PENDING),
        pendingJumps: @sliceOf((pendingJumps as *mut [PendingJump]).ptr, 0, MAX_PENDING),
        pendingAddrLoads: @sliceOf((pendingAddrLoads as *mut [PendingAddrLoad]).ptr, 0, MAX_PENDING),
        pendingBranches: vec::Vec⟨PendingBranch⟩ {
            data: pendingBranches as *mut [PendingBranch],
            len: 0,
        },
        pendingCalls: vec::Vec⟨PendingCall⟩ {
            data: pendingCalls as *mut [PendingCall],
            len: 0,
        },
        pendingJumps: vec::Vec⟨PendingJump⟩ {
            data: pendingJumps as *mut [PendingJump],
            len: 0,
        },
        pendingAddrLoads: vec::Vec⟨PendingAddrLoad⟩ {
            data: pendingAddrLoads as *mut [PendingAddrLoad],
            len: 0,
        },
        labels: labels::init(blockOffsets as *mut [i32], funcEntries as *mut [dict::Entry]),
        funcs: @sliceOf((funcs as *mut [types::FuncAddr]).ptr, 0, MAX_FUNCS),
        funcs: vec::Vec⟨types::FuncAddr⟩ {
            data: funcs as *mut [types::FuncAddr],
            len: 0,
        },
        debugEntries,
        debugEntriesLen: 0,
    };
}


    recordFuncAt(e, name, e.codeLen);
}

/// Record a function's start position at `index` for printing.
export fn recordFuncAt(e: *mut Emitter, name: *[u8], index: u32) {
    e.funcs.append(types::FuncAddr { name, index }, e.allocator);
    vec::append⟨types::FuncAddr⟩(&mut e.funcs, types::FuncAddr { name, index }, e.allocator);
}

/// Record a local branch needing later patching.
/// Unconditional jumps use a single slot (J-type, +-1MB range).
/// Conditional branches use two slots (B-type has only +-4KB range,
/// so large functions may need the inverted-branch + JAL fallback).
export fn recordBranch(e: *mut Emitter, targetBlock: u32, kind: BranchKind) {
    e.pendingBranches.append(PendingBranch {
    vec::append⟨PendingBranch⟩(&mut e.pendingBranches, PendingBranch {
        index: e.codeLen,
        target: targetBlock,
        kind: kind,
    }, e.allocator);



/// Record a function call needing later patching.
/// Emits placeholder instructions that will be patched later.
/// Uses two slots to support long-distance calls.
export fn recordCall(e: *mut Emitter, target: *[u8]) {
    e.pendingCalls.append(PendingCall {
    vec::append⟨PendingCall⟩(&mut e.pendingCalls, PendingCall {
        index: e.codeLen,
        target,
    }, e.allocator);

    emit(e, encode::nop()); // Placeholder for AUIPC.
    emit(e, encode::nop()); // Placeholder for JALR.
}

/// Record a jump emitted by assembly that needs whole-program patching.
export fn recordJumpAt(e: *mut Emitter, target: *[u8], rd: gen::Reg, index: u32) {
    e.pendingJumps.append(PendingJump {
    vec::append⟨PendingJump⟩(&mut e.pendingJumps, PendingJump {
        index,
        target,
        rd,
    }, e.allocator);
}

    emit(e, encode::nop()); // Placeholder for ADDI.
}

/// Record a function address load already reserved by assembly.
export fn recordAddrLoadAt(e: *mut Emitter, target: *[u8], rd: gen::Reg, index: u32) {
    e.pendingAddrLoads.append(PendingAddrLoad {
    vec::append⟨PendingAddrLoad⟩(&mut e.pendingAddrLoads, PendingAddrLoad {
        index,
        target,
        rd: rd,
        isData: false,
    }, e.allocator);
}

/// Record a data address load needing later patching.
/// Uses an absolute 32-bit load sequence matching the current data memory map.
export fn recordDataAddrLoad(e: *mut Emitter, target: *[u8], rd: gen::Reg) {
    e.pendingAddrLoads.append(PendingAddrLoad {
    vec::append⟨PendingAddrLoad⟩(&mut e.pendingAddrLoads, PendingAddrLoad {
        index: e.codeLen,
        target,
        rd: rd,
        isData: true,
    }, e.allocator);

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

                assert encode::isJumpImm(offset), "patchLocalBranches: jump offset too large";
                patch(e, p.index, encode::jal(super::ZERO, offset));
            },
        }
    }
    set e.pendingBranches = @sliceOf(e.pendingBranches.ptr, 0, e.pendingBranches.cap);
    set e.pendingBranches.len = 0;
}

/// Encode a conditional branch instruction.
fn encodeCondBranch(op: il::CmpOp, rs1: gen::Reg, rs2: gen::Reg, offset: i32) -> u32 {
    match op {

}

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

        // `AUIPC scratch, hi(offset)`.
        patch(e, p.index, encode::auipc(super::SCRATCH1, s.hi));

    }
}

/// Patch all pending assembly jumps.
export fn patchJumps(e: *mut Emitter) {
    for i in 0..e.pendingJumps.len {
        let p = e.pendingJumps[i];
    let pendingJumps = vec::view⟨PendingJump⟩(&e.pendingJumps);
    for p in pendingJumps {
        let offset = branchOffsetToFunc(e, p.index, p.target);

        assert encode::isJumpImm(offset), "patchJumps: jump offset too large";
        patch(e, p.index, encode::jal(p.rd, offset));
    }
}

/// Patch all pending function and data address loads.
/// Called after all functions have been generated and data layout is known.
export fn patchAddrLoads(e: *mut Emitter, dataSymMap: *data::DataSymMap) {
    for i in 0..e.pendingAddrLoads.len {
        let p = e.pendingAddrLoads[i];
    let pendingAddrLoads = vec::view⟨PendingAddrLoad⟩(&e.pendingAddrLoads);
    for p in pendingAddrLoads {
        if p.isData {
            let addr = data::lookupAddr(dataSymMap, p.target) else {
                panic "patchAddrLoads: data symbol not found";
            };
            assert addr <= MAX_I32_ADDR, "patchAddrLoads: data address too large";


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

/// Get function start positions as an initialized slice.
export fn getFuncs(e: *Emitter) -> *[types::FuncAddr] {
    return vec::view⟨types::FuncAddr⟩(&e.funcs);
}

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


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

@test fn testAddAssemblyExportsOnlyGlobalTextSymbols() throws (testing::TestError) {
    let mut arena = alloc::new(&mut ASSEMBLY_ARENA_STORAGE[..]);
    let symbols = try alloc::allocSlice(&mut arena, @sizeOf(asm::Symbol), @alignOf(asm::Symbol), 2) catch {
        throw testing::TestError::Failed;
    };
    let mut symbolSlice = @sliceOf((symbols as *mut [asm::Symbol]).ptr, 2, 2);
    let mut symbolSlice = @sliceOf((symbols as *mut [asm::Symbol]).ptr, 2);
    set symbolSlice[0] = asm::Symbol {
        name: "local",
        section: asm::Section::Text,
        offset: 0,
        isExported: false,

lib/std/lang.rad +2 -0

//! Radiance language implementation.
export mod alloc;
export mod slice;
export mod vec;
export mod sexpr;
export mod types;
export mod strings;
export mod scanner;
export mod ast;

lib/std/lang/ast.rad +15 -8

//! Radiance AST modules.
export mod printer;

use std::io;
use std::fmt;
use std::lang::vec;
use std::lang::slice;
use std::lang::alloc;
use std::lang::types;

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

        arena: alloc::new(data),
        nextId: 0,
    };
}

/// Create an empty `*mut [*Node]` slice with the given capacity.
export fn nodeSlice(arena: *mut NodeArena, capacity: u32) -> *mut [*Node] {
/// Create an empty node vector with arena-backed storage of the given capacity.
export fn nodeVec(arena: *mut NodeArena, capacity: u32) -> vec::Vec⟨*Node⟩ {
    if capacity == 0 {
        return &mut [];
        return vec::Vec⟨*Node⟩ { data: &mut [], len: 0 };
    }
    let ptr = try! alloc::allocSlice(&mut arena.arena, @sizeOf(*Node), @alignOf(*Node), capacity);
    let data = slice::fromRawPartsMut⟨*Node⟩(ptr.ptr as *mut *Node, capacity);

    return @sliceOf(ptr.ptr as *mut *Node, 0, capacity);
    return vec::Vec⟨*Node⟩ { data, len: 0 };
}

/// Attribute bit set applied to declarations or fields.
export union Attribute {
    /// Public visibility attribute.

export union Builtin {
    /// Size of type in bytes (`@sizeOf`).
    SizeOf,
    /// Alignment requirement of type (`@alignOf`).
    AlignOf,
    /// Construct a slice from pointer, length, and optional capacity (`@sliceOf`).
    /// Construct a slice from a pointer and initialized length (`@sliceOf`).
    SliceOf,
    /// Move typed values between mutable pointers (`@relocate`).
    Relocate,
}

/// Source extent for a node measured in bytes.
export record Span {
    /// Byte offset from the start of the source file.

    let fnSig = FnSig { params, returnType: nil, throwList };
    let fnBody = synthNode(arena, NodeValue::Block(Block { statements: bodyStmts }));
    let fnDecl = synthNode(arena, NodeValue::FnDecl(FnDecl {
        name: fnName, params: &mut [], sig: fnSig, body: fnBody, attrs: nil,
    }));
    let mut rootStmts: *mut [*Node] = &mut [];
    rootStmts.append(fnDecl, a);
    let modBody = synthNode(arena, NodeValue::Block(Block { statements: rootStmts }));
    let mut rootStmts = nodeVec(arena, 1);
    vec::append⟨*Node⟩(&mut rootStmts, fnDecl, a);
    let statements = vec::viewMut⟨*Node⟩(&mut rootStmts);
    let modBody = synthNode(arena, NodeValue::Block(Block { statements }));

    return SynthFnMod { modBody, fnBody };
}


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

fn builtinName(kind: super::Builtin) -> *[u8] {
    match kind {
        case super::Builtin::SizeOf => return "@sizeOf",
        case super::Builtin::AlignOf => return "@alignOf",
        case super::Builtin::SliceOf => return "@sliceOf",
        case super::Builtin::Relocate => return "@relocate",
    }
}

/// Return the name for an integer type.
fn intTypeName(width: u8, sign: super::Signedness) -> *[u8] {

lib/std/lang/lower.rad +337 -329

use std::mem;
use std::lang::ast;
use std::lang::il;
use std::lang::module;
use std::lang::resolver;
use std::lang::vec;

instantiate vec::append⟨ErrTagEntry⟩,
            vec::append⟨*il::Fn⟩,
            vec::append⟨il::DataValue⟩,
            vec::append⟨u8⟩,
            vec::append⟨FnSymEntry⟩,
            vec::append⟨DataSymEntry⟩,
            vec::append⟨il::Data⟩,
            vec::append⟨BlockData⟩,
            vec::append⟨il::Param⟩,
            vec::append⟨il::SrcLoc⟩,
            vec::append⟨il::Instr⟩,
            vec::append⟨u32⟩,
            vec::append⟨VarData⟩,
            vec::append⟨FnParamBinding⟩,
            vec::append⟨il::SwitchCase⟩,
            vec::view⟨ErrTagEntry⟩,
            vec::view⟨il::DataValue⟩,
            vec::view⟨*il::Fn⟩,
            vec::view⟨il::Data⟩,
            vec::view⟨u8⟩,
            vec::view⟨FnSymEntry⟩,
            vec::view⟨resolver::TraitMethod⟩,
            vec::view⟨u32⟩,
            vec::view⟨il::Param⟩,
            vec::view⟨il::SrcLoc⟩,
            vec::view⟨FnParamBinding⟩,
            vec::viewMut⟨il::Instr⟩,
            vec::viewMut⟨il::SwitchCase⟩;

// TODO: Search for all `_ as i32` to ensure that casts from u32 to i32 don't
// happen, since they are potentially truncating values.

// TODO: Support constant union lowering.

}

/// Incrementally build deterministic internal symbol names.
record NameBuilder {
    /// Accumulated name bytes.
    bytes: *mut [u8],
    bytes: vec::Vec⟨u8⟩,
    /// Allocator used to grow the name.
    allocator: alloc::Allocator,
}

/// Print a LowerError for debugging.

/// Maximum number of `catch` clauses per `try`.
constant MAX_CATCH_CLAUSES: u32 = 32;

// Slice Layout
//
// A slice is a fat pointer consisting of a data pointer, a length and a capacity.
// `{ ptr: u32, len: u32, cap: u32 }`.
// A slice is a 16-byte fat pointer consisting of a data pointer, a length and
// four bytes of padding. `{ ptr: u64, len: u32, padding: u32 }`.

/// Slice data pointer offset.
constant SLICE_PTR_OFFSET: i32 = 0;
/// Offset of slice length in slice data structure.
constant SLICE_LEN_OFFSET: i32 = resolver::PTR_SIZE as i32;
/// Offset of slice capacity in slice data structure.
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 }`.

    emitFn: fn(*mut opaque, *il::Fn, FnRole),
}

/// Destination for functions produced by the lowerer.
export union FnOutput {
    /// Store lowered functions in the provided slice.
    Accumulate(*mut [*il::Fn]),
    /// Accumulate lowered functions in arena-backed vector storage.
    Accumulate(vec::Vec⟨*il::Fn⟩),
    /// Send lowered functions to an external consumer immediately.
    Stream(FnSink),
}

/// Module-level lowering context shared across all function lowerings.

    allocator: alloc::Allocator,
    /// Fully resolved semantic metadata queried without mutation.
    resolver: *resolver::Resolver,
    /// Module graph for cross-module symbol resolution.
    moduleGraph: ?*module::ModuleGraph,
    /// Package name for qualified symbol names.
    /// Fallback package name for declarations without a module path.
    pkgName: *[u8],
    /// Current module being lowered.
    currentMod: ?u16,
    /// Rigid-to-concrete mapping for the function currently being lowered.
    specialization: ?*resolver::Substitution,
    /// Concrete generic function whose body is currently being lowered.
    genericSpecialization: ?*resolver::GenericFnSpecialization,
    /// Global data items (string literals, constants, static arrays).
    /// These become the data sections in the final binary.
    data: *mut [il::Data],
    data: vec::Vec⟨il::Data⟩,
    /// Destination for lowered functions.
    output: FnOutput,
    /// Map of function symbols to qualified names.
    fnSyms: *mut [FnSymEntry],
    fnSyms: vec::Vec⟨FnSymEntry⟩,
    /// Global error tag table keyed by persistent concrete types.
    errTags: *mut [ErrTagEntry],
    errTags: vec::Vec⟨ErrTagEntry⟩,
    /// Next error tag to assign (starts at 1; 0 = success).
    errTagCounter: u32,
    /// Lowering options.
    options: LowerOptions,
}

fn getOrAssignErrorTag(
    self: *mut Lowerer,
    errType: resolver::Type,
) -> u32 {
    assert not resolver::containsGenericParameter(errType);
    for entry in self.errTags {
    for entry in vec::view⟨ErrTagEntry⟩(&self.errTags) {
        if resolver::typesEqual(entry.ty, errType) {
            return entry.tag;
        }
    }
    let tag = self.errTagCounter;
    set self.errTagCounter += 1;
    self.errTags.append(ErrTagEntry {
    vec::append⟨ErrTagEntry⟩(&mut self.errTags, ErrTagEntry {
        ty: resolver::copyStructuralTypeToArena(errType, self.arena),
        tag,
    }, self.allocator);
    return tag;
}

/// Emit one function to the active output.
fn emitFunction(self: *mut Lowerer, func: *il::Fn, role: FnRole) {
    match self.output {
        case FnOutput::Accumulate(accumulated) => {
            let mut fns = accumulated;
            fns.append(func, self.allocator);
            vec::append⟨*il::Fn⟩(&mut fns, func, self.allocator);
            set self.output = FnOutput::Accumulate(fns);
        }
        case FnOutput::Stream(sink) => {
            sink.emitFn(sink.ctx, func, role);
        }

    return FnRole::Normal;
}

/// Builder for accumulating data values during constant lowering.
record DataValueBuilder {
    /// Allocator used to grow the value storage.
    allocator: alloc::Allocator,
    values: *mut [il::DataValue],
    /// Values accumulated in initialization order.
    values: vec::Vec⟨il::DataValue⟩,
    /// Whether all pushed values can be represented by zero-filled memory.
    zeroInit: bool,
}

/// Result of lowering constant data.

    zeroInit: bool,
}

/// Create a new builder.
fn dataBuilder(allocator: alloc::Allocator) -> DataValueBuilder {
    return DataValueBuilder { allocator, values: &mut [], zeroInit: true };
    return DataValueBuilder {
        allocator,
        values: vec::Vec⟨il::DataValue⟩ { data: &mut [], len: 0 },
        zeroInit: true,
    };
}

/// Return whether a data item can be omitted from a zero-filled image.
fn dataIsZero(item: il::DataItem) -> bool {
    match item {

    return true;
}

/// Append a data value to the builder.
fn dataBuilderPush(b: *mut DataValueBuilder, value: il::DataValue) {
    b.values.append(value, b.allocator);
    vec::append⟨il::DataValue⟩(&mut b.values, value, b.allocator);

    if value.count > 0 and not dataIsZero(value.item) {
        set b.zeroInit = false;
    }
}

/// Return the accumulated values.
fn dataBuilderFinish(b: *DataValueBuilder) -> ConstDataResult {
    return ConstDataResult {
        values: &b.values[..],
        values: vec::view⟨il::DataValue⟩(&b.values),
        zeroInit: b.zeroInit,
    };
}

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

record BlockData {
    /// Block label for debugging and IL printing.
    label: *[u8],
    /// Block parameters for merging values at control flow joins. These
    /// receive values from predecessor edges when control flow merges.
    params: *mut [il::Param],
    params: vec::Vec⟨il::Param⟩,
    /// Variable ids corresponding to each parameter. Used to map block params
    /// back to source variables when building argument lists for jumps.
    paramVars: *mut [u32],
    paramVars: vec::Vec⟨u32⟩,
    /// Instructions accumulated so far. The last instruction should eventually
    /// be a terminator.
    instrs: *mut [il::Instr],
    instrs: vec::Vec⟨il::Instr⟩,
    /// Debug source locations, one per instruction. Only populated when
    /// debug info is enabled.
    locs: *mut [il::SrcLoc],
    locs: vec::Vec⟨il::SrcLoc⟩,
    /// Predecessor block ids. Used for SSA construction to propagate values
    /// from predecessors when a variable is used before being defined locally.
    preds: *mut [u32],
    preds: vec::Vec⟨u32⟩,
    /// The current SSA value of each variable in this block. Indexed by variable
    /// id. A `nil` means the variable wasn't assigned in this block. Updated by
    /// [`defVar`], queried by [`useVarInBlock`].
    vars: *mut [?il::Val],
    /// Sealing state. Once sealed, all predecessors are known and we can resolve

/// During this time, variables used before being defined locally are tracked.
/// Once all predecessors are known, the block is sealed and those variables
/// are resolved via [`resolveBlockArgs`].
union Sealed {
    /// Block is unsealed; predecessors may still be added.
    No { incompleteVars: *mut [u32] },
    No {
        /// Variables whose block parameters must be resolved when sealed.
        incompleteVars: vec::Vec⟨u32⟩,
    },
    /// Block is sealed; all predecessors are known.
    Yes,
}

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

    /// Type signature of the function being lowered.
    fnType: *resolver::FnType,
    /// Function name, used as prefix for generated data symbols.
    fnName: *[u8],
    /// Names assigned to data declarations in this function.
    dataSyms: *mut [DataSymEntry],
    dataSyms: vec::Vec⟨DataSymEntry⟩,

    // ~ SSA variable tracking ~ //

    /// Metadata (name, type, mutability) for each variable. Indexed by variable
    /// id. Doesn't change after declaration. For the SSA value of a variable in
    /// a specific block, see [`BlockData::vars`].
    vars: *mut [VarData],
    vars: vec::Vec⟨VarData⟩,
    /// Parameter-to-variable bindings, initialized in the entry block.
    params: *mut [FnParamBinding],
    params: vec::Vec⟨FnParamBinding⟩,

    // ~ Basic block management ~ //

    /// Block storage array, indexed by block id.
    blockData: *mut [BlockData],
    blockData: vec::Vec⟨BlockData⟩,
    /// The entry block for this function.
    entryBlock: ?BlockId,
    /// The block currently receiving new instructions.
    currentBlock: ?BlockId,


        moduleGraph: nil,
        pkgName,
        currentMod: nil,
        specialization: nil,
        genericSpecialization: nil,
        data: &mut [],
        output: FnOutput::Accumulate(&mut []),
        fnSyms: &mut [],
        errTags: &mut [],
        data: vec::Vec⟨il::Data⟩ { data: &mut [], len: 0 },
        output: FnOutput::Accumulate(vec::Vec⟨*il::Fn⟩ { data: &mut [], len: 0 }),
        fnSyms: vec::Vec⟨FnSymEntry⟩ { data: &mut [], len: 0 },
        errTags: vec::Vec⟨ErrTagEntry⟩ { data: &mut [], len: 0 },
        errTagCounter: 1,
        options: LowerOptions { debug: false, buildTest: false },
    };
    try lowerDecls(&mut low, root, true);


        moduleGraph: graph,
        pkgName,
        currentMod: nil,
        specialization: nil,
        genericSpecialization: nil,
        data: &mut [],
        output: FnOutput::Accumulate(&mut []),
        fnSyms: &mut [],
        errTags: &mut [],
        data: vec::Vec⟨il::Data⟩ { data: &mut [], len: 0 },
        output: FnOutput::Accumulate(vec::Vec⟨*il::Fn⟩ { data: &mut [], len: 0 }),
        fnSyms: vec::Vec⟨FnSymEntry⟩ { data: &mut [], len: 0 },
        errTags: vec::Vec⟨ErrTagEntry⟩ { data: &mut [], len: 0 },
        errTagCounter: 1,
        options,
    };
}


    }
}

/// Finalize lowering and return the unified IL program.
export fn finalize(low: *Lowerer) -> il::Program {
    let mut fns: *mut [*il::Fn] = undefined;
    let mut fns: *[*il::Fn] = &[];
    match low.output {
        case FnOutput::Accumulate(accumulated) => {
            set fns = accumulated;
        }
        case FnOutput::Stream(_) => {
            panic "finalize: cannot finalize streaming lowerer";
        }
        case FnOutput::Accumulate(accumulated) =>
            set fns = vec::view⟨*il::Fn⟩(&accumulated),
        case FnOutput::Stream(_) =>
            panic "finalize: cannot finalize streaming lowerer",
    }
    return il::Program {
        data: &low.data[..],
        fns: &fns[..],
        data: vec::view⟨il::Data⟩(&low.data),
        fns,
    };
}

/////////////////////////////////
// Qualified Name Construction //

}

/// Append bytes to a symbol name.
fn namePush(builder: *mut NameBuilder, text: *[u8]) {
    for byte in text {
        builder.bytes.append(byte, builder.allocator);
        vec::append⟨u8⟩(&mut builder.bytes, byte, builder.allocator);
    }
}

/// Append a decimal `u32` to a symbol name.
fn namePushU32(builder: *mut NameBuilder, value: u32) {

fn namePushU64(builder: *mut NameBuilder, value: u64) {
    let mut digits: [u8; 20] = undefined;
    namePush(builder, fmt::formatU64(value, &mut digits[..]));
}

/// Append the stable, source-qualified name of a module-level declaration.
/// Append the canonical source-qualified name of a module-level declaration.
/// Non-empty module paths already begin with the defining package.
fn namePushQualified(
    self: *mut Lowerer,
    builder: *mut NameBuilder,
    modId: ?u16,
    name: *[u8],
) {
    let path = getModulePath(self, modId);
    if path.len == 0 or path[0] <> self.pkgName {
    if path.len == 0 {
        namePush(builder, self.pkgName);
        namePush(builder, "::");
    }
    for segment in path {
        namePush(builder, segment);

        }
        case resolver::Type::Array(array) => {
            namePush(builder, "[");
            namePushType(self, builder, *array.item);
            namePush(builder, "; ");
            namePushU32(builder, array.length);
            namePushType(self, builder, *array.length);
            namePush(builder, "]");
        }
        case resolver::Type::ConstArgument { value, .. } => {
            if value.negative { namePush(builder, "-"); }
            namePushU64(builder, value.magnitude);

fn specializationName(
    self: *mut Lowerer,
    specialization: *resolver::GenericFnSpecialization,
) -> *[u8] {
    let template = specialization.template;
    let mut builder = NameBuilder { bytes: &mut [], allocator: self.allocator };
    let mut builder = NameBuilder {
        bytes: vec::Vec⟨u8⟩ { data: &mut [], len: 0 },
        allocator: self.allocator,
    };
    namePushQualified(self, &mut builder, template.moduleId, template.name);
    namePush(&mut builder, "⟨");
    for arg, i in specialization.args {
        if i > 0 { namePush(&mut builder, ", "); }
        namePushType(self, &mut builder, *arg);
    }
    namePush(&mut builder, "⟩");
    return &builder.bytes[..];
    return vec::view⟨u8⟩(&builder.bytes);
}

/// Register a function symbol with its qualified name.
/// Called when lowering function declarations, so cross-package calls can find
/// the function by name.
fn registerFnSym(self: *mut Lowerer, sym: *resolver::Symbol, qualName: *[u8]) {
    self.fnSyms.append(FnSymEntry { sym, qualName }, self.allocator);
    vec::append⟨FnSymEntry⟩(
        &mut self.fnSyms,
        FnSymEntry { sym, qualName },
        self.allocator,
    );
}

/// Look up a function's qualified name by its symbol.
/// Returns `nil` if the symbol wasn't registered (e.g. callee's module is not yet lowered).
// TODO: This is kind of dubious as an optimization, if it depends on the order
// in which modules are lowered.
// TODO: Use a hash table here?
fn lookupFnSym(self: *Lowerer, sym: *resolver::Symbol) -> ?*[u8] {
    for entry in self.fnSyms {
    for entry in vec::view⟨FnSymEntry⟩(&self.fnSyms) {
        if entry.sym == sym {
            return entry.qualName;
        }
    }
    return nil;

fn registerDataSym(
    self: *mut FnLowerer,
    sym: *resolver::Symbol,
    qualName: *[u8],
) {
    self.dataSyms.append(DataSymEntry { sym, qualName }, self.allocator);
    vec::append⟨DataSymEntry⟩(
        &mut self.dataSyms,
        DataSymEntry { sym, qualName },
        self.allocator,
    );
}

/// Look up the current function's most recently registered local data name.
fn lookupDataSym(self: *FnLowerer, sym: *resolver::Symbol) -> ?*[u8] {
    let mut i = self.dataSyms.len;
    while i > 0 {
        set i -= 1;
        let entry = &self.dataSyms[i];
        let entry = &self.dataSyms.data[i];
        if entry.sym == sym {
            return entry.qualName;
        }
    }
    return nil;

    let mut fnLow = FnLowerer {
        low: self,
        allocator: alloc::arenaAllocator(self.fnArena),
        fnType: fnType,
        fnName: qualName,
        dataSyms: &mut [],
        vars: &mut [],
        params: &mut [],
        blockData: &mut [],
        dataSyms: vec::Vec⟨DataSymEntry⟩ { data: &mut [], len: 0 },
        vars: vec::Vec⟨VarData⟩ { data: &mut [], len: 0 },
        params: vec::Vec⟨FnParamBinding⟩ { data: &mut [], len: 0 },
        blockData: vec::Vec⟨BlockData⟩ { data: &mut [], len: 0 },
        entryBlock: nil,
        currentBlock: nil,
        loopStack,
        loopDepth: 0,
        labelCounter: 0,

    self: *mut Lowerer,
    concreteType: resolver::Type,
    traitInfo: ?*resolver::TraitType,
    methodName: *[u8],
) -> *[u8] {
    let mut builder = NameBuilder { bytes: &mut [], allocator: self.allocator };
    let mut builder = NameBuilder {
        bytes: vec::Vec⟨u8⟩ { data: &mut [], len: 0 },
        allocator: self.allocator,
    };
    namePushType(self, &mut builder, concreteType);
    if let traitValue = traitInfo {
        namePush(&mut builder, " ");
        namePushTrait(self, &mut builder, traitValue);
    }
    namePush(&mut builder, "::");
    namePush(&mut builder, methodName);
    return &builder.bytes[..];
    return vec::view⟨u8⟩(&builder.bytes);
}

/// Build a readable v-table name from its concrete type and trait.
fn vtableName(
    self: *mut Lowerer,
    concreteType: resolver::Type,
    traitInfo: *resolver::TraitType,
) -> *[u8] {
    let mut builder = NameBuilder { bytes: &mut [], allocator: self.allocator };
    let mut builder = NameBuilder {
        bytes: vec::Vec⟨u8⟩ { data: &mut [], len: 0 },
        allocator: self.allocator,
    };
    namePush(&mut builder, "vtable::");
    namePushType(self, &mut builder, concreteType);
    namePush(&mut builder, " ");
    namePushTrait(self, &mut builder, traitInfo);
    return &builder.bytes[..];
    return vec::view⟨u8⟩(&builder.bytes);
}

/// Lower an instance declaration (`instance Trait for Type { ... }`).
///
/// Each method in the instance block is lowered as a standalone function

        set methodNameSet[method.index] = true;
    }

    // Fill inherited method slots from their declaring supertraits. Their
    // declaring-trait identity selects the already lowered implementation.
    for method, i in traitInfo.methods {
    for method, i in vec::view⟨resolver::TraitMethod⟩(&traitInfo.methods) {
        if not methodNameSet[i] {
            let inheritedInst = resolver::findInstance(
                self.resolver, method.owner, instEntry.concreteType
            ) else throw LowerError::MissingMetadata;
            set methodNames[i] = instanceMethodName(

        set values[i] = il::DataValue {
            item: il::DataItem::Fn(methodNames[i]),
            count: 1,
        };
    }
    self.data.append(il::Data {
    vec::append⟨il::Data⟩(&mut self.data, il::Data {
        name: vName,
        size: traitInfo.methods.len as u32 * resolver::PTR_SIZE,
        alignment: resolver::PTR_SIZE,
        readOnly: true,
        isZeroInit: false,

    }
    let mut b = dataBuilder(self.allocator);
    try lowerConstDataInto(self, value, data.ty, layout.size, qualName, &mut b);
    let result = dataBuilderFinish(&b);

    self.data.append(il::Data {
    vec::append⟨il::Data⟩(&mut self.data, il::Data {
        name: qualName,
        size: layout.size,
        alignment: layout.alignment,
        readOnly,
        isZeroInit: not readOnly and result.zeroInit,
        values: result.values,
    }, self.allocator);
}

/// Emit the in-memory representation of a slice header: `{ ptr, len, cap }`.
/// Emit a 16-byte slice header containing a pointer, length, and padding.
fn dataSliceHeader(b: *mut DataValueBuilder, dataSym: *[u8], len: u32) {
    dataBuilderPush(b, il::DataValue {
        item: il::DataItem::Sym(dataSym),
        count: 1
    });

            val: len as i64
        },
        count: 1
    });
    dataBuilderPush(b, il::DataValue {
        item: il::DataItem::Val {
            typ: il::Type::W32,
            val: len as i64
        },
        count: 1
        item: il::DataItem::Undef,
        count: 4,
    });
}

/// Lower a compile-time `&[...]` expression to a concrete slice header.
fn lowerConstAddressSliceInto(

            set dataName = try pushDeclData(self, layout.size, layout.alignment, readOnly, backing.values, dataPrefix);
        }
    } else {
        set dataName = try pushDeclData(self, layout.size, layout.alignment, readOnly, backing.values, dataPrefix);
    }
    dataSliceHeader(b, dataName, arrInfo.length);
    let length = resolver::concreteArrayLength(arrInfo.length)
        else throw LowerError::MissingMetadata;
    dataSliceHeader(b, dataName, length);
}

/// Lower a constant expression payload into a builder without slot padding.
fn lowerConstDataPayloadInto(
    self: *mut Lowerer,

    dataPrefix: *[u8],
    b: *mut DataValueBuilder
) throws (LowerError) {
    let case resolver::Type::Array(arrInfo) = ty
        else throw LowerError::ExpectedArray;
    let length = arrInfo.length;
    let length = resolver::concreteArrayLength(arrInfo.length)
        else throw LowerError::MissingMetadata;
    let elemTy = *arrInfo.item;
    let elemLayout = resolver::getTypeLayout(elemTy);

    if let case ast::NodeValue::Undef = repeat.item.value {
        dataBuilderPush(b, il::DataValue {

}

/// Find an existing string data entry with matching content.
// TODO: Optimize with hash table or remove?
fn findStringData(self: *Lowerer, s: *[u8]) -> ?*[u8] {
    for d in self.data {
    for d in vec::view⟨il::Data⟩(&self.data) {
        if d.values.len == 1 {
            if let case il::DataItem::Str(existing) = d.values[0].item {
                if mem::eq(existing, s) {
                    return d.name;
                }

    readOnly: bool,
    values: *[il::DataValue],
    dataPrefix: *[u8]
) -> *[u8] throws (LowerError) {
    let name = try nextDeclDataName(self, dataPrefix, self.data.len, "literal");
    self.data.append(il::Data {
    vec::append⟨il::Data⟩(&mut self.data, il::Data {
        name,
        size,
        alignment,
        readOnly,
        isZeroInit: not readOnly and dataValuesAreZeroInit(values),

}

/// Find an existing read-only slice data entry with matching values.
// TODO: Optimize with hash table or remove?
fn findSliceData(self: *Lowerer, values: *[il::DataValue], alignment: u32) -> ?*[u8] {
    for d in self.data {
    for d in vec::view⟨il::Data⟩(&self.data) {
        if d.alignment == alignment and d.readOnly and dataValuesEq(d.values, values) {
            return d.name;
        }
    }
    return nil;

    if readOnly {
        if let found = findConstData(self.low, values, alignment) {
            set dataName = found;
        } else {
            set dataName = try nextDataName(self);
            self.low.data.append(il::Data {
            vec::append⟨il::Data⟩(&mut self.low.data, il::Data {
                name: dataName,
                size,
                alignment,
                readOnly,
                isZeroInit: false,
                values,
            }, self.low.allocator);
        }
    } else {
        set dataName = try nextDataName(self);
        self.low.data.append(il::Data {
        vec::append⟨il::Data⟩(&mut self.low.data, il::Data {
            name: dataName,
            size,
            alignment,
            readOnly,
            isZeroInit: dataValuesAreZeroInit(values),

    // Get data address.
    let ptrReg = nextReg(self);
    emit(self, il::Instr::Copy { dst: ptrReg, val: il::Val::DataSym(dataName) });

    return try buildSliceValue(
        self, elemTy, mutable, il::Val::Reg(ptrReg), il::Val::Imm(length as i64), il::Val::Imm(length as i64)
        self, elemTy, mutable, il::Val::Reg(ptrReg), il::Val::Imm(length as i64)
    );
}

/// Generate a unique data name for inline literals, eg. `fnName$literal$N`.
fn nextDataName(self: *mut FnLowerer) -> *[u8] throws (LowerError) {

/// Remove the last block parameter and its associated variable.
/// Used when detecting a trivial phi that can be eliminated.
fn removeLastBlockParam(self: *mut FnLowerer, block: BlockId) {
    let blk = getBlockMut(self, block);
    if blk.params.len > 0 {
        // TODO: Use `pop`?
        set blk.params = @sliceOf(blk.params.ptr, blk.params.len - 1, blk.params.cap);
        set blk.params.len -= 1;
    }
    if blk.paramVars.len > 0 {
        // TODO: Use `pop`?
        set blk.paramVars = @sliceOf(blk.paramVars.ptr, blk.paramVars.len - 1, blk.paramVars.cap);
        set blk.paramVars.len -= 1;
    }
}

/// Rewrite cached SSA values for a variable across all blocks, and also
/// rewrite any terminator arguments that reference the provisional register.

        if blk.vars[*v] == from {
            set blk.vars[*v] = to;
        }
        if blk.instrs.len > 0 {
            let ix = blk.instrs.len - 1;
            match &mut blk.instrs[ix] {
            match &mut blk.instrs.data[ix] {
                case il::Instr::Jmp { args, .. } =>
                    rewriteValInSlice(*args, from, to),
                case il::Instr::Br { thenArgs, elseArgs, .. } => {
                    rewriteValInSlice(*thenArgs, from, to);
                    rewriteValInSlice(*elseArgs, from, to);

    let vars = try! alloc::allocSlice(self.low.fnArena, @sizeOf(?il::Val), @alignOf(?il::Val), varCount) as *mut [?il::Val];

    for i in 0..varCount {
        set vars[i] = nil;
    }
    self.blockData.append(BlockData {
    vec::append⟨BlockData⟩(&mut self.blockData, BlockData {
        label,
        params: &mut [],
        paramVars: &mut [],
        instrs: &mut [],
        locs: &mut [],
        preds: &mut [],
        params: vec::Vec⟨il::Param⟩ { data: &mut [], len: 0 },
        paramVars: vec::Vec⟨u32⟩ { data: &mut [], len: 0 },
        instrs: vec::Vec⟨il::Instr⟩ { data: &mut [], len: 0 },
        locs: vec::Vec⟨il::SrcLoc⟩ { data: &mut [], len: 0 },
        preds: vec::Vec⟨u32⟩ { data: &mut [], len: 0 },
        vars,
        sealState: Sealed::No { incompleteVars: &mut [] },
        sealState: Sealed::No {
            incompleteVars: vec::Vec⟨u32⟩ { data: &mut [], len: 0 },
        },
        loopDepth: self.loopDepth,
    }, self.allocator);

    return id;
}

    labelBase: *[u8],
    param: il::Param
) -> BlockId throws (LowerError) {
    let block = try createBlock(self, labelBase);
    let blk = getBlockMut(self, block);
    blk.params.append(param, self.allocator);
    vec::append⟨il::Param⟩(&mut blk.params, param, self.allocator);

    return block;
}

/// Switch to building a different block.

        return; // Already sealed.
    };
    set blk.sealState = Sealed::Yes;

    // Complete all incomplete block parameters.
    for varId in incompleteVars {
    for varId in vec::view⟨u32⟩(&incompleteVars) {
        try resolveBlockArgs(self, block, Var(varId));
    }
}

/// Seal a block and switch to it.

    switchToBlock(self, block);
}

/// Get block data by block id.
fn getBlock(self: *FnLowerer, block: BlockId) -> *BlockData {
    return &self.blockData[*block];
    return &self.blockData.data[*block];
}

/// Get mutable block data by block id.
fn getBlockMut(self: *mut FnLowerer, block: BlockId) -> *mut BlockData {
    return &mut self.blockData[*block];
    return &mut self.blockData.data[*block];
}

/// Get the current block being built.
fn currentBlock(self: *FnLowerer) -> BlockId {
    let block = self.currentBlock else {

            else => {},
        }
    }
    // Record source location alongside instruction when enabled.
    if self.low.options.debug {
        block.locs.append(self.srcLoc, self.allocator);
        vec::append⟨il::SrcLoc⟩(&mut block.locs, self.srcLoc, self.allocator);
    }
    block.instrs.append(instr, self.allocator);
    vec::append⟨il::Instr⟩(&mut block.instrs, instr, self.allocator);
}

/// Emit an unconditional jump to `target`.
fn emitJmp(self: *mut FnLowerer, target: BlockId) throws (LowerError) {
    emit(self, il::Instr::Jmp { target: *target, args: &mut [] });

    let condReg = emitValToReg(self, condVal);

    try emitBr(self, condReg, thenBlock, elseBlock);
}

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

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


    let lenReg = nextReg(self);
    emitLoadW32At(self, lenReg, sliceReg, SLICE_LEN_OFFSET);
    return il::Val::Reg(lenReg);
}

/// Load the capacity from a slice value.
fn loadSliceCap(self: *mut FnLowerer, sliceReg: il::Reg) -> il::Val {
    let capReg = nextReg(self);
    emitLoadW32At(self, capReg, sliceReg, SLICE_CAP_OFFSET);
    return il::Val::Reg(capReg);
}

/// Emit a load instruction for a scalar value at `src` plus `offset`.
/// For reading values that may be aggregates, use `emitRead` instead.
fn emitLoad(self: *mut FnLowerer, src: il::Reg, offset: i32, typ: resolver::Type) -> il::Val {
    let dst = nextReg(self);
    let ilTyp = ilType(self.low, typ);

fn blockHasTerminator(self: *FnLowerer) -> bool {
    let blk = getBlock(self, currentBlock(self));
    if blk.instrs.len == 0 {
        return false;
    }
    match blk.instrs[blk.instrs.len - 1] {
    match blk.instrs.data[blk.instrs.len - 1] {
        case il::Instr::Ret { .. },
             il::Instr::Jmp { .. },
             il::Instr::Br { .. },
             il::Instr::Switch { .. },
             il::Instr::Unreachable =>

/// Add a predecessor edge from `pred` to `target`.
/// Must be called before the target block is sealed. Duplicates are ignored.
fn addPredecessor(self: *mut FnLowerer, target: BlockId, pred: BlockId) {
    let blk = getBlockMut(self, target);
    assert blk.sealState <> Sealed::Yes, "addPredecessor: adding predecessor to sealed block";
    let preds = &mut blk.preds;
    for i in 0..preds.len {
        if preds[i] == *pred { // Avoid duplicate predecessor entries.
    for i in 0..blk.preds.len {
        if blk.preds.data[i] == *pred { // Avoid duplicate predecessor entries.
            return;
        }
    }
    preds.append(*pred, self.allocator);
    vec::append⟨u32⟩(&mut blk.preds, *pred, self.allocator);
}

/// Finalize all blocks and return the block array.
fn finalizeBlocks(self: *mut FnLowerer) -> *[il::Block] throws (LowerError) {
    let blocks = try! alloc::allocSlice(
        self.low.fnArena, @sizeOf(il::Block), @alignOf(il::Block), self.blockData.len
    ) as *mut [il::Block];

    for i in 0..self.blockData.len {
        let data = &self.blockData[i];
        let data = &mut self.blockData.data[i];

        set blocks[i] = il::Block {
            label: data.label,
            params: &data.params[..],
            instrs: data.instrs,
            locs: &data.locs[..],
            preds: &data.preds[..],
            params: vec::view⟨il::Param⟩(&data.params),
            instrs: vec::viewMut⟨il::Instr⟩(&mut data.instrs),
            locs: vec::view⟨il::SrcLoc⟩(&data.locs),
            preds: vec::view⟨u32⟩(&data.preds),
            loopDepth: data.loopDepth,
        };
    }
    return &blocks[..self.blockData.len];
}

    type: il::Type,
    mutable: bool,
    val: il::Val
) -> Var {
    let id = self.vars.len;
    self.vars.append(VarData { name, type, mutable, addressTaken: false }, self.allocator);
    vec::append⟨VarData⟩(
        &mut self.vars,
        VarData { name, type, mutable, addressTaken: false },
        self.allocator,
    );

    let v = Var(id);
    if self.currentBlock <> nil {
        defVar(self, v, val);
    }

            throw LowerError::InvalidUse;
        }
        // Single predecessor means no merge needed, variable is implicitly
        // available without a block parameter.
        if blk.preds.len == 1 {
            let pred = BlockId(blk.preds[0]);
            let pred = BlockId(blk.preds.data[0]);
            if *pred <> *block {
                let val = try useVarInBlock(self, pred, v);
                set blk.vars[*v] = val; // Cache.
                return val;
            }

/// Searches from most recently declared to first, enabling shadowing.
fn lookupVarByName(self: *FnLowerer, name: *[u8]) -> ?Var {
    let mut id = self.vars.len;
    while id > 0 {
        set id -= 1;
        if let varName = self.vars[id].name {
        if let varName = self.vars.data[id].name {
            // Names are interned strings, so pointer comparison suffices.
            if varName == name {
                return Var(id);
            }
        }

    return self.vars.len;
}

/// Restore lexical variable scope depth.
fn exitVarScope(self: *mut FnLowerer, savedVarsLen: u32) {
    set self.vars = @sliceOf(self.vars.ptr, savedVarsLen, self.vars.cap);
    set self.vars.len = savedVarsLen;
}

/// Get the metadata for a variable.
fn getVar(self: *FnLowerer, v: Var) -> *VarData {
    assert *v < self.vars.len;
    return &self.vars[*v];
    return &self.vars.data[*v];
}

/// Create a block parameter to merge a variable's value from multiple
/// control flow paths.
///

    let type = getVar(self, v).type;

    // Create block parameter and add it to the block.
    let param = il::Param { value: reg, type };
    let blk = getBlockMut(self, block);
    blk.params.append(param, self.allocator);
    blk.paramVars.append(*v, self.allocator); // Associate variable with parameter.
    vec::append⟨il::Param⟩(&mut blk.params, param, self.allocator);
    vec::append⟨u32⟩(&mut blk.paramVars, *v, self.allocator); // Associate variable with parameter.

    // Record that this variable's value in this block is now the parameter register.
    // This must happen before the predecessor loop to handle self-referential loops.
    set blk.vars[*v] = il::Val::Reg(reg);

    match &mut blk.sealState {
        case Sealed::No { incompleteVars } => {
            // Block unsealed: defer until sealing.
            incompleteVars.append(*v, self.allocator);
            vec::append⟨u32⟩(incompleteVars, *v, self.allocator);
        },
        case Sealed::Yes => {
            // Block sealed: check for trivial phi before committing. If all
            // predecessors provide the same value, we can remove the param we
            // just created and use that value directly.


    // Find the parameter index corresponding to this variable.
    // Each variable that needs merging gets its own block parameter slot.
    let mut paramIdx: u32 = 0;
    for i in 0..blk.paramVars.len {
        if blk.paramVars[i] == *v {
        if blk.paramVars.data[i] == *v {
            set paramIdx = i;
            break;
        }
    }

    // For each predecessor, recursively look up the variable's reaching definition
    // in that block, then patch the predecessor's terminator to pass that value
    // as an argument to this block's parameter.
    for predId in blk.preds {
    for predId in vec::view⟨u32⟩(&blk.preds) {
        let pred = BlockId(predId);
        // This may recursively trigger more block arg resolution if the
        // predecessor also needs to look up the variable from its predecessors.
        let val = try useVarInBlock(self, pred, v);
        assert val <> il::Val::Undef, "createBlockParam: predecessor provides undef value for block parameter";

    // Get the block parameter register.
    let paramReg = blk.vars[*v];
    // Check if all predecessors provide the same value.
    let mut sameVal: ?il::Val = nil;

    for predId in blk.preds {
    for predId in vec::view⟨u32⟩(&blk.preds) {
        let pred = BlockId(predId);
        let val = try useVarInBlock(self, pred, v);

        // Check if this is a self-reference.
        // This happens in cycles where the loop back-edge passes the phi to

    let data = getBlockMut(self, from);
    let ix = data.instrs.len - 1; // The terminator is always the last instruction.

    // TODO: We shouldn't need to use a mutable subscript here, given that the
    // fields are already mutable.
    match &mut data.instrs[ix] {
    match &mut data.instrs.data[ix] {
        case il::Instr::Jmp { args, .. } => {
            set *args = growArgs(self, *args, paramIdx + 1);
            set args[paramIdx] = val;
        }
        case il::Instr::Br { thenTarget, thenArgs, elseTarget, elseArgs, .. } => {

        } else {
            set name = try paramName(&astParams[i].value);
        }
        let v = newVar(self, name, type, false, il::Val::Undef);

        self.params.append(FnParamBinding { var: v, reg }, self.allocator);
        vec::append⟨FnParamBinding⟩(
            &mut self.params,
            FnParamBinding { var: v, reg },
            self.allocator,
        );
    }
    return params;
}

/// Resolve match subject.

    let entry = try createBlock(self, "entry");
    set self.entryBlock = entry;
    switchToBlock(self, entry);

    /// Bind parameter registers to variables in the entry block.
    for def in self.params {
    for def in vec::view⟨FnParamBinding⟩(&self.params) {
        defVar(self, def.var, il::Val::Reg(def.reg));
    }
    /// Lower function body.
    try lowerBlock(self, body);


}

/// Lower a scalar match as a switch instruction.
fn lowerMatchSwitch(self: *mut FnLowerer, prongs: *mut [*ast::Node], subject: *MatchSubject, mergeBlock: *mut ?BlockId) throws (LowerError) {
    let mut blocks: [BlockId; 32] = undefined;
    let mut cases: *mut [il::SwitchCase] = &mut [];
    let mut cases = vec::Vec⟨il::SwitchCase⟩ { data: &mut [], len: 0 };
    let mut defaultIdx: u32 = 0;
    let entry = currentBlock(self);

    for p, i in prongs {
        let case ast::NodeValue::MatchProng(prong) = p.value

                set blocks[i] = try createBlock(self, "case");
                for pat in pats {
                    let cv = resolver::constValueEntry(self.low.resolver, pat)
                        else throw LowerError::MissingConst(pat);

                    cases.append(il::SwitchCase {
                    vec::append⟨il::SwitchCase⟩(&mut cases, il::SwitchCase {
                        value: constToScalar(cv),
                        target: *blocks[i],
                        args: &mut []
                    }, self.allocator);
                }

    }
    emit(self, il::Instr::Switch {
        val: subject.val,
        defaultTarget: *blocks[defaultIdx],
        defaultArgs: &mut [],
        cases: &mut cases[..]
        cases: vec::viewMut⟨il::SwitchCase⟩(&mut cases),
    });

    for p, i in prongs {
        let case ast::NodeValue::MatchProng(prong) = p.value
            else throw LowerError::UnexpectedNodeValue(p);

    if let case resolver::Type::Pointer(_) = *inner {
        return il::Val::Imm(0);
    }
    if let case resolver::Type::Slice(slice) = *inner {
        return try buildSliceValue(
            self, slice.item, slice.mutable, il::Val::Imm(0), il::Val::Imm(0), il::Val::Imm(0)
            self, slice.item, slice.mutable, il::Val::Imm(0), il::Val::Imm(0)
        );
    }
    let valOffset = resolver::getOptionalValOffset(*inner) as i32;
    return try buildTagged(self, resolver::getTypeLayout(optType), 0, nil, *inner, 1, valOffset);
}

        successType, self.fnType.throwList
    );
    return try buildTagged(self, layout, tag, payload, payloadType, resolver::PTR_SIZE as i32, RESULT_VAL_OFFSET);
}

/// Build a slice aggregate from a data pointer, length and capacity.
/// Build a 16-byte slice aggregate from a data pointer and length.
fn buildSliceValue(
    self: *mut FnLowerer,
    elemTy: *resolver::Type,
    mutable: bool,
    ptrVal: il::Val,
    lenVal: il::Val,
    capVal: il::Val
    lenVal: il::Val
) -> il::Val throws (LowerError) {
    let sliceType = resolver::Type::Slice(resolver::SliceType {
        class: types::PointerClass::Unsafe,
        item: elemTy,
        mutable,

        mutable,
    });

    try emitStore(self, dst, SLICE_PTR_OFFSET, ptrTy, ptrVal);
    try emitStore(self, dst, SLICE_LEN_OFFSET, resolver::Type::U32, lenVal);
    try emitStore(self, dst, SLICE_CAP_OFFSET, resolver::Type::U32, capVal);

    return il::Val::Reg(dst);
}

/// Build a trait object fat pointer from a data pointer and a v-table.

    offset: i32
) -> il::Val throws (LowerError) {
    let elemLayout = resolver::getTypeLayout(*arr.item);
    let stride = elemLayout.size as i32;
    let mut result: ?il::Val = nil;
    let length = resolver::concreteArrayLength(arr.length)
        else throw LowerError::MissingMetadata;

    for i in 0..arr.length {
    for i in 0..length {
        let elemOffset = offset + (i as i32) * stride;
        let cmp = try emitEqAtOffset(self, a, b, elemOffset, *arr.item);
        set result = emitLogicalAnd(self, result, cmp);
    }
    if let r = result {

    let typ = try typeOf(self, node);
    let case resolver::Type::Array(arrInfo) = typ else {
        throw LowerError::ExpectedArray;
    };
    let elemTy = *arrInfo.item;
    let length = arrInfo.length;
    let length = resolver::concreteArrayLength(arrInfo.length)
        else throw LowerError::MissingMetadata;
    let elemLayout = resolver::getTypeLayout(elemTy);
    let dst = try emitReserve(self, typ);

    // Evaluate the repeated item once.
    let repeatVal = try lowerExpr(self, repeat.item);

    let itemType = try specializeType(self, *info.itemType);

    // Extract data pointer and container length.
    let mut dataReg = baseReg;
    let mut containerLen: il::Val = undefined;
    if let cap = info.capacity { // Slice from array.
        set containerLen = il::Val::Imm(cap as i64);
    if let descriptor = info.capacity { // Slice from array.
        let specialized = try specializeType(self, *descriptor);
        let capacity = resolver::concreteArrayLength(&specialized)
            else throw LowerError::MissingMetadata;
        set containerLen = il::Val::Imm(capacity as i64);
    } else { // Slice from slice.
        set dataReg = loadSlicePtr(self, baseReg);
        set containerLen = loadSliceLen(self, baseReg);
    }


        throw LowerError::MissingMetadata;
    };
    let r = try resolveSliceRangePtr(self, container, range, info);
    let itemType = try specializeType(self, *info.itemType);
    return try buildSliceValue(
        self, &itemType, info.mutable, il::Val::Reg(r.dataReg), r.count, r.count
        self, &itemType, info.mutable, il::Val::Reg(r.dataReg), r.count
    );
}

/// Lower an address-of (`&x`) expression.
fn lowerAddressOf(self: *mut FnLowerer, node: *ast::Node, addr: ast::AddressOf) -> il::Val throws (LowerError) {

            if isAggregateType(typ) {
                return val;
            }
            // For scalars, if we've already materialized a stack slot for this
            // variable, the SSA value is that slot pointer.
            if self.vars[*v].addressTaken {
            if self.vars.data[*v].addressTaken {
                // Already address-taken; return existing stack pointer.
                return val;
            }
            // Materialize a stack slot using the declaration's resolved
            // layout so `align(N)` on locals is honored.
            let layout = resolver::getLayout(self.low.resolver, addr.target, typ);
            let slot = emitReserveLayout(self, layout);
            try emitStore(self, slot, 0, typ, val);
            let stackVal = il::Val::Reg(slot);

            set self.vars[*v].addressTaken = true;
            set self.vars.data[*v].addressTaken = true;
            defVar(self, v, stackVal);

            return stackVal;
        }
        // Fall back to symbol lookup for constants/statics.

    };
    let arrayTy = try typeOf(self, arrayNode);
    let case resolver::Type::Array(arrayInfo) = arrayTy else {
        throw LowerError::ExpectedArray;
    };
    let length = arrayInfo.length;
    let length = resolver::concreteArrayLength(arrayInfo.length)
        else throw LowerError::MissingMetadata;
    if length == 0 {
        return try buildSliceValue(
            self, slice.item, slice.mutable, il::Val::Imm(0), il::Val::Imm(0), il::Val::Imm(0)
            self, slice.item, slice.mutable, il::Val::Imm(0), il::Val::Imm(0)
        );
    }
    if resolver::isConstExpr(self.low.resolver, arrayNode) {
        let mut b = dataBuilder(self.low.allocator);
        match arrayNode.value {

            slice.item, slice.mutable, length
        );
    }
    let data = try lowerExpr(self, arrayNode);
    let count = il::Val::Imm(length as i64);
    return try buildSliceValue(self, slice.item, slice.mutable, data, count, count);
    return try buildSliceValue(self, slice.item, slice.mutable, data, count);
}

/// Lower the common element pointer computation for subscript operations.
/// Handles both arrays and slices by resolving the container type, extracting
/// the data pointer (for slices), and emitting an [`il::Instr::Elem`] to compute

            set elemType = *arrInfo.item;
            // Runtime safety check: index must be strictly less than array length.
            // Skip when the index is a compile-time constant, since we check
            // that in the resolver.
            if not resolver::isConstExpr(self.low.resolver, index) {
                let arrLen = il::Val::Imm(arrInfo.length as i64);
                let length = resolver::concreteArrayLength(arrInfo.length)
                    else throw LowerError::MissingMetadata;
                let arrLen = il::Val::Imm(length as i64);
                try emitTrapUnlessCmp(self, il::CmpOp::Ult, il::Type::W32, indexVal, arrLen);
            }
        }
        else => throw LowerError::ExpectedSliceOrArray,
    }

                let layout = resolver::getLayout(self.low.resolver, node, typ);
                let slot = emitReserveLayout(self, layout);
                try emitStore(self, slot, 0, typ, varVal);

                let v = newVar(self, name, ilType, l.mutable, il::Val::Reg(slot));
                set self.vars[*v].addressTaken = true;
                set self.vars.data[*v].addressTaken = true;

                return;
            }
        }
    }

            let containerVal = try lowerExpr(self, f.iterable);
            let containerReg = emitValToReg(self, containerVal);

            let mut dataReg = containerReg;
            let mut lengthVal: il::Val = undefined;
            if let len = length {
            if let descriptor = length {
                let specialized = try specializeType(self, *descriptor);
                let len = resolver::concreteArrayLength(&specialized)
                    else throw LowerError::MissingMetadata;
                set lengthVal = il::Val::Imm(len as i64);
            } else {
                set lengthVal = loadSliceLen(self, containerReg);
                set dataReg = loadSlicePtr(self, containerReg);
            }


/// Lower a builtin call expression.
fn lowerBuiltinCall(self: *mut FnLowerer, node: *ast::Node, kind: ast::Builtin, args: *mut [*ast::Node]) -> il::Val throws (LowerError) {
    match kind {
        case ast::Builtin::SliceOf => return try lowerSliceOf(self, node, args),
        case ast::Builtin::Relocate => return try lowerRelocate(self, args),
        case ast::Builtin::SizeOf, ast::Builtin::AlignOf => {
            let constVal = resolver::constValueEntry(self.low.resolver, node) else {
                throw LowerError::MissingConst(node);
            };
            return try constValueToVal(self, constVal, node);
            if let constVal = resolver::constValueEntry(self.low.resolver, node) {
                return try constValueToVal(self, constVal, node);
            }
            if args.len <> 1 {
                throw LowerError::InvalidArgCount;
            }
            let ty = try typeOf(self, args[0]);
            let layout = resolver::getTypeLayout(ty);
            let mut value = layout.size;
            if kind == ast::Builtin::AlignOf {
                set value = layout.alignment;
            }
            return il::Val::Imm(value as i64);
        }
    }
}

/// Lower a `@sliceOf(ptr, len)` or `@sliceOf(ptr, len, cap)` builtin call.
/// Lower a two-argument `@sliceOf(ptr, len)` builtin call.
fn lowerSliceOf(self: *mut FnLowerer, node: *ast::Node, args: *mut [*ast::Node]) -> il::Val throws (LowerError) {
    if args.len <> 2 and args.len <> 3 {
    if args.len <> 2 {
        throw LowerError::InvalidArgCount;
    }
    let sliceTy = try typeOf(self, node);
    let case resolver::Type::Slice(slice) = sliceTy
        else throw LowerError::ExpectedSliceOrArray;
    let ptrVal = try lowerExpr(self, args[0]);
    let lenVal = try lowerExpr(self, args[1]);
    let mut capVal = lenVal;
    if args.len == 3 {
        set capVal = try lowerExpr(self, args[2]);
    }
    if not isLtEq(lenVal, capVal) {
        try emitTrapIfLt(self, il::Type::W32, capVal, lenVal);
    return try buildSliceValue(self, slice.item, slice.mutable, ptrVal, lenVal);
}

/// Lower `@relocate(destination, source)` as an overlap-safe byte move.
fn lowerRelocate(
    self: *mut FnLowerer,
    args: *mut [*ast::Node],
) -> il::Val throws (LowerError) {
    if args.len <> 2 {
        throw LowerError::InvalidArgCount;
    }
    return try buildSliceValue(self, slice.item, slice.mutable, ptrVal, lenVal, capVal);

    let destinationSlice = emitValToReg(self, try lowerExpr(self, args[0]));
    let destination = loadSlicePtr(self, destinationSlice);
    let destinationLen = loadSliceLen(self, destinationSlice);
    let sourceSlice = emitValToReg(self, try lowerExpr(self, args[1]));
    let source = loadSlicePtr(self, sourceSlice);
    let sourceLen = loadSliceLen(self, sourceSlice);

    // The destination must hold every source byte.
    try emitTrapIfLt(self, il::Type::W32, destinationLen, sourceLen);

    let forwardBlock = try createBlock(self, "relocate.forward");
    let backwardBlock = try createBlock(self, "relocate.backward");
    let doneBlock = try createBlock(self, "relocate.done");
    try emitBrCmp(
        self,
        il::CmpOp::Ult,
        il::Type::W64,
        il::Val::Reg(destination),
        il::Val::Reg(source),
        forwardBlock,
        backwardBlock,
    );

    // Moving toward a lower address cannot overwrite unread source bytes.
    try switchToAndSeal(self, forwardBlock);
    try emitByteCopyLoop(
        self,
        destination,
        source,
        sourceLen,
        "relocate.forward",
    );
    try emitJmp(self, doneBlock);

    // Moving toward a higher address must copy from the end for overlap safety.
    try switchToAndSeal(self, backwardBlock);
    let remainingReg = nextReg(self);
    let backwardHeader = try createBlockWithParam(
        self,
        "relocate.backward",
        il::Param { value: remainingReg, type: il::Type::W32 },
    );
    let backwardBody = try createBlock(self, "relocate.backward");
    let backwardDone = try createBlock(self, "relocate.backward");
    try emitJmpWithArg(self, backwardHeader, sourceLen);

    switchToBlock(self, backwardHeader);
    try emitBrCmp(
        self,
        il::CmpOp::Ult,
        il::Type::W32,
        il::Val::Imm(0),
        il::Val::Reg(remainingReg),
        backwardBody,
        backwardDone,
    );

    try switchToAndSeal(self, backwardBody);
    let byteIndex = emitTypedBinOp(
        self,
        il::BinOp::Sub,
        il::Type::W32,
        il::Val::Reg(remainingReg),
        il::Val::Imm(1),
    );
    let sourceByte = emitElem(self, 1, source, byteIndex);
    let byteReg = nextReg(self);
    emit(self, il::Instr::Load {
        typ: il::Type::W8,
        dst: byteReg,
        src: sourceByte,
        offset: 0,
    });
    let destinationByte = emitElem(self, 1, destination, byteIndex);
    emit(self, il::Instr::Store {
        typ: il::Type::W8,
        src: il::Val::Reg(byteReg),
        dst: destinationByte,
        offset: 0,
    });
    try emitJmpWithArg(self, backwardHeader, byteIndex);

    try sealBlock(self, backwardHeader);
    try switchToAndSeal(self, backwardDone);
    try emitJmp(self, doneBlock);

    try switchToAndSeal(self, doneBlock);
    return il::Val::Undef;
}

/// Lower a `try` expression.
fn lowerTry(self: *mut FnLowerer, node: *ast::Node, t: ast::Try) -> il::Val throws (LowerError) {
    let case ast::NodeValue::Call(callExpr) = t.expr.value else {

    let entry = currentBlock(self);

    // First pass: create blocks, resolve error types, and build switch cases.
    let mut blocks: [BlockId; MAX_CATCH_CLAUSES] = undefined;
    let mut errTypes: [?resolver::Type; MAX_CATCH_CLAUSES] = undefined;
    let mut cases: *mut [il::SwitchCase] = &mut [];
    let mut cases = vec::Vec⟨il::SwitchCase⟩ { data: &mut [], len: 0 };
    let mut defaultIdx: ?u32 = nil;

    for clauseNode, i in catches {
        let case ast::NodeValue::CatchClause(clause) = clauseNode.value
            else panic "lowerMultiCatch: expected CatchClause";


        if let typeNode = clause.typeNode {
            let errTy = try typeOf(self, typeNode);
            set errTypes[i] = errTy;

            cases.append(il::SwitchCase {
            vec::append⟨il::SwitchCase⟩(&mut cases, il::SwitchCase {
                value: getOrAssignErrorTag(self.low, errTy) as i64,
                target: *blocks[i],
                args: &mut []
            }, self.allocator);
        } else {

    }
    emit(self, il::Instr::Switch {
        val: il::Val::Reg(tagReg),
        defaultTarget: *defaultTarget,
        defaultArgs: &mut [],
        cases
        cases: vec::viewMut⟨il::SwitchCase⟩(&mut cases),
    });

    // Second pass: emit each catch clause body.
    for clauseNode, i in catches {
        let case ast::NodeValue::CatchClause(clause) = clauseNode.value

    // Now all predecessors of header are known, seal it.
    try sealBlock(self, header);
    try switchToAndSeal(self, done);
}

/// Lower `slice.append(val, allocator)`.
///
/// Emits inline grow-if-needed logic:
///
///     load len, cap from slice header
///     if len < cap: jmp @store
///     else:         jmp @grow
///
///     @grow:
///       newCap = max(cap * 2, 1)
///       call allocator.func(allocator.ctx, newCap * stride, alignment)
///       copy old data to new pointer
///       update slice ptr and cap
///       jmp @store
///
///     @store:
///       store element at ptr + len * stride
///       increment len
///
fn lowerSliceAppend(self: *mut FnLowerer, call: ast::Call, elemType: *resolver::Type) -> il::Val throws (LowerError) {
    let case ast::NodeValue::FieldAccess(access) = call.callee.value
        else throw LowerError::MissingMetadata;

    // Get the address of the slice header.
    let sliceVal = try lowerExpr(self, access.parent);
    let sliceReg = emitValToReg(self, sliceVal);

    // Lower the value to append and the allocator.
    let elemVal = try lowerExpr(self, call.args[0]);
    let allocVal = try lowerExpr(self, call.args[1]);
    let allocReg = emitValToReg(self, allocVal);

    let elemLayout = resolver::getTypeLayout(*elemType);
    let stride = elemLayout.size;
    let alignment = elemLayout.alignment;

    // Load current length and capacity.
    let lenVal = loadSliceLen(self, sliceReg);
    let capVal = loadSliceCap(self, sliceReg);

    // Branch: if length is smaller than capacity, go to @store else @grow.
    let storeBlock = try createBlock(self, "append.store");
    let growBlock = try createBlock(self, "append.grow");
    try emitBrCmp(self, il::CmpOp::Ult, il::Type::W32, lenVal, capVal, storeBlock, growBlock);
    try switchToAndSeal(self, growBlock);

    // -- @grow block ----------------------------------------------------------

    // `newCap = max(cap * 2, 1)`.
    // We are only here when at capacity, so we use `or` with `1` to ensure at least capacity `1`.
    let doubledVal = emitTypedBinOp(self, il::BinOp::Shl, il::Type::W32, capVal, il::Val::Imm(1));
    let newCapVal = emitTypedBinOp(self, il::BinOp::Or, il::Type::W32, doubledVal, il::Val::Imm(1));

    // Call allocator: `a.func(a.ctx, newCap * stride, alignment)`.
    let allocFnReg = nextReg(self);
    emitLoadW64At(self, allocFnReg, allocReg, 0);

    let allocCtxReg = nextReg(self);
    emitLoadW64At(self, allocCtxReg, allocReg, 8);

    let byteSize = emitTypedBinOp(self, il::BinOp::Mul, il::Type::W32, newCapVal, il::Val::Imm(stride as i64));
    let args = try allocVals(self, 3);

    set args[0] = il::Val::Reg(allocCtxReg);
    set args[1] = byteSize;
    set args[2] = il::Val::Imm(alignment as i64);

    let newPtrReg = nextReg(self);
    emit(self, il::Instr::Call {
        retTy: il::Type::W64,
        dst: newPtrReg,
        func: il::Val::Reg(allocFnReg),
        args,
    });

    // Copy old data byte-by-byte.
    let oldPtrReg = loadSlicePtr(self, sliceReg);
    let copyBytes = emitTypedBinOp(self, il::BinOp::Mul, il::Type::W32, lenVal, il::Val::Imm(stride as i64));
    try emitByteCopyLoop(self, newPtrReg, oldPtrReg, copyBytes, "append");

    // Update slice header.
    emitStoreW64At(self, il::Val::Reg(newPtrReg), sliceReg, SLICE_PTR_OFFSET);
    emitStoreW32At(self, newCapVal, sliceReg, SLICE_CAP_OFFSET);

    try emitJmp(self, storeBlock);
    try switchToAndSeal(self, storeBlock);

    // -- @store block ---------------------------------------------------------

    // Store element at `ptr + len * stride`.
    let ptrReg = loadSlicePtr(self, sliceReg);
    let elemDst = emitElem(self, stride, ptrReg, lenVal);
    try emitStore(self, elemDst, 0, *elemType, elemVal);

    // Increment len.
    let newLen = emitTypedBinOp(self, il::BinOp::Add, il::Type::W32, lenVal, il::Val::Imm(1));
    emitStoreW32At(self, newLen, sliceReg, SLICE_LEN_OFFSET);

    return il::Val::Reg(sliceReg);
}

/// Lower `slice.delete(index)`.
///
/// Bounds-check the index, shift elements after it by one stride
/// via a byte-copy loop, and decrement `len`.
fn lowerSliceDelete(self: *mut FnLowerer, call: ast::Call, elemType: *resolver::Type) throws (LowerError) {
    let case ast::NodeValue::FieldAccess(access) = call.callee.value
        else throw LowerError::MissingMetadata;

    let elemLayout = resolver::getTypeLayout(*elemType);
    let stride = elemLayout.size;

    // Get slice header address.
    let sliceVal = try lowerExpr(self, access.parent);
    let sliceReg = emitValToReg(self, sliceVal);

    // Lower the index argument.
    let indexVal = try lowerExpr(self, call.args[0]);

    // Load len and bounds-check: index must be smaller than length.
    let lenVal = loadSliceLen(self, sliceReg);
    try emitTrapUnlessCmp(self, il::CmpOp::Ult, il::Type::W32, indexVal, lenVal);

    // Compute the destination and source for the shift.
    let ptrReg = loadSlicePtr(self, sliceReg);
    let dst = emitElem(self, stride, ptrReg, indexVal);

    // `src = dst + stride`.
    let src = emitPtrOffset(self, dst, stride as i32);

    // Move `(len - index - 1) * stride`.
    let tailLen = emitTypedBinOp(self, il::BinOp::Sub, il::Type::W32, lenVal, indexVal);
    let tailLenMinusOne = emitTypedBinOp(self, il::BinOp::Sub, il::Type::W32, tailLen, il::Val::Imm(1));
    let moveBytes = emitTypedBinOp(self, il::BinOp::Mul, il::Type::W32, tailLenMinusOne, il::Val::Imm(stride as i64));

    // Shift elements left via byte-copy loop.
    // When deleting the last element, the loop is a no-op.
    try emitByteCopyLoop(self, dst, src, moveBytes, "delete");
    // Decrement length.
    let newLen = emitTypedBinOp(self, il::BinOp::Sub, il::Type::W32, lenVal, il::Val::Imm(1));

    emitStoreW32At(self, newLen, sliceReg, SLICE_LEN_OFFSET);
}

/// Lower a call expression, which may be a function call or type constructor.
fn lowerCallOrCtor(self: *mut FnLowerer, node: *ast::Node, call: ast::Call) -> il::Val throws (LowerError) {
    let nodeData = resolver::nodeData(self.low.resolver, node).extra;

    // Check for slice method dispatch.
    if let case resolver::NodeExtra::SliceAppend { elemType } = nodeData {
        let concrete = try specializeType(self, *elemType);
        return try lowerSliceAppend(self, call, &concrete);
    }
    if let case resolver::NodeExtra::SliceDelete { elemType } = nodeData {
        let concrete = try specializeType(self, *elemType);
        try lowerSliceDelete(self, call, &concrete);
        return il::Val::Undef;
    }
    // Check for trait method dispatch.
    if let case resolver::NodeExtra::TraitMethodCall { traitInfo, methodIndex } = nodeData {
        return try lowerTraitMethodCall(self, node, call, traitInfo, methodIndex);
    }
    if let case resolver::NodeExtra::GenericBoundMethodCall {

        typ: il::Type::W64,
        dst: fnPtrReg,
        src: vtableReg,
        offset: slotOffset,
    });
    let methodFnType = traitInfo.methods[methodIndex].fnType;
    let methodFnType = traitInfo.methods.data[methodIndex].fnType;

    // Build args: optional return param slot + data pointer (receiver) + user args.
    let argOffset: u32 = 1 if requiresReturnParam(methodFnType) else 0;
    let args = try allocVals(self, call.args.len + 1 + argOffset);
    set args[argOffset] = il::Val::Reg(dataReg);

    }
    let concreteType = try specializeType(self, resolver::Type::Parameter(param));
    let inst = resolver::findInstance(
        self.low.resolver, traitInfo, concreteType
    ) else throw LowerError::MissingMetadata;
    let method = &traitInfo.methods[methodIndex];
    let method = &traitInfo.methods.data[methodIndex];
    let _ = resolver::findInstance(
        self.low.resolver, method.owner, concreteType
    ) else throw LowerError::MissingMetadata;
    let methodSym = inst.methods[methodIndex];
    let case resolver::SymbolData::Value {

            } else if let generic = try lowerGenericFnValue(self, node) {
                set val = generic;
            // First try local variable lookup, then global symbol lookup.
            } else if let v = lookupLocalVar(self, node) {
                set val = try useVar(self, v);
                if self.vars[*v].addressTaken {
                if self.vars.data[*v].addressTaken {
                    let typ = try typeOf(self, node);
                    let ptr = emitValToReg(self, val);
                    set val = emitRead(self, ptr, 0, typ);
                }
            } else {

                let mut handled = false;
                if let case resolver::Type::Array(array) = parentTy {
                    if let case ast::NodeValue::Ident(name) = access.child.value;
                       mem::eq(name, "len")
                    {
                        set val = il::Val::Imm(array.length as i64);
                        let length = resolver::concreteArrayLength(array.length)
                            else throw LowerError::MissingMetadata;
                        set val = il::Val::Imm(length as i64);
                        set handled = true;
                    }
                }
                if not handled {
                    set val = try lowerFieldAccess(self, access);

lib/std/lang/parser.rad +127 -87

@test export mod tests;

use std::mem;
use std::io;
use std::fmt;
use std::lang::vec;
use std::lang::alloc;
use std::lang::types;
use std::lang::ast;
use std::lang::strings;
use std::lang::scanner;

instantiate vec::append⟨*ast::Node⟩,
            vec::viewMut⟨*ast::Node⟩;

/// Maximum `u32` value.
export constant U32_MAX: u32 = 0xFFFFFFFF;
/// Minimum `i64` value.
export constant I64_MIN: i64 = -0x8000000000000000;
/// Largest magnitude representable by a negative `i64`.

        return node(p, ast::NodeValue::ArrayRepeatLit(
            ast::ArrayRepeatLit { item: firstExpr, count }
        ));
    }
    // Regular array literal: `[a, b, ...]`.
    let mut items = ast::nodeSlice(p.arena, 64).append(firstExpr, p.allocator);
    let mut items = ast::nodeVec(p.arena, 64);
    vec::append⟨*ast::Node⟩(&mut items, firstExpr, p.allocator);

    while consume(p, scanner::TokenKind::Comma) and not check(p, scanner::TokenKind::RBracket) {
        let elem = try parseNormalExpr(p);
        items.append(elem, p.allocator);
        vec::append⟨*ast::Node⟩(&mut items, elem, p.allocator);
    }
    try expect(p, scanner::TokenKind::RBracket, "expected `]` after array elements");

    return node(p, ast::NodeValue::ArrayLit(items));
    return node(p, ast::NodeValue::ArrayLit(vec::viewMut⟨*ast::Node⟩(&mut items)));
}

/// Parse a function call expression.
fn parseCall(p: *mut Parser, callee: *ast::Node) -> *ast::Node
    throws (ParseError)

fn parseGenericArgs(p: *mut Parser) -> *mut [*ast::Node] throws (ParseError) {
    try expect(p, scanner::TokenKind::LAngle, "expected left angle before generic arguments");
    if check(p, scanner::TokenKind::RAngle) {
        throw failParsing(p, "generic argument list cannot be empty");
    }
    let mut args = ast::nodeSlice(p.arena, 4);
    let mut args = ast::nodeVec(p.arena, 4);
    loop {
        args.append(try parseGenericArg(p), p.allocator);
        vec::append⟨*ast::Node⟩(&mut args, try parseGenericArg(p), p.allocator);
        if not consume(p, scanner::TokenKind::Comma) {
            break;
        }
        if check(p, scanner::TokenKind::RAngle) {
            throw failParsing(p, "expected generic argument after `,`");
        }
    }
    try expect(p, scanner::TokenKind::RAngle, "expected right angle after generic arguments");
    return args;
    return vec::viewMut⟨*ast::Node⟩(&mut args);
}

/// Parse generic arguments following a target.
fn parseGenericApply(p: *mut Parser, target: *ast::Node) -> *ast::Node
    throws (ParseError)

{
    let leaf = try parseLeaf(p);
    return try parsePostfix(p, leaf);
}

/// Parse a builtin function call like `@sizeOf(T)` or `@alignOf(T)`.
/// Parse a builtin function call.
fn parseBuiltin(p: *mut Parser) -> *ast::Node
    throws (ParseError)
{
    // Skip the '@' to get the name.
    let ident = p.current.source;

        set kind = ast::Builtin::SizeOf;
    } else if ident == "@alignOf" {
        set kind = ast::Builtin::AlignOf;
    } else if ident == "@sliceOf" {
        set kind = ast::Builtin::SliceOf;
    } else if ident == "@relocate" {
        set kind = ast::Builtin::Relocate;
    } else {
        throw failParsing(p, "unknown builtin");
    }
    try expect(p, scanner::TokenKind::LParen, "expected `(` after builtin name");

    // Parse arguments into a list. Use capacity 4 to handle any valid argument count
    // plus some extra for error recovery.
    let mut args = ast::nodeSlice(p.arena, 4);
    let mut args = ast::nodeVec(p.arena, 4);

    if kind == ast::Builtin::SliceOf {
    if kind == ast::Builtin::SliceOf or kind == ast::Builtin::Relocate {
        // Parse comma-separated expressions until closing paren.
        // Argument count validation is done in semantic analysis.
        while not check(p, scanner::TokenKind::RParen) {
            args.append(try parseExpr(p), p.allocator);
            vec::append⟨*ast::Node⟩(&mut args, try parseExpr(p), p.allocator);
            if not consume(p, scanner::TokenKind::Comma) {
                break;
            }
        }
    } else {
        args.append(try parseType(p), p.allocator);
        vec::append⟨*ast::Node⟩(&mut args, try parseType(p), p.allocator);
    }
    try expect(p, scanner::TokenKind::RParen, "expected `)` after builtin argument");

    return node(p, ast::NodeValue::BuiltinCall { kind, args });
    return node(p, ast::NodeValue::BuiltinCall {
        kind, args: vec::viewMut⟨*ast::Node⟩(&mut args),
    });
}

/// Parse a single expression.
///
/// Parses unary and binary operators using precedence climbing.

    throw failParsing(p, "expected assignment after `set`");
}

/// Parse leading attributes and declaration modifiers.
fn parseAttributes(p: *mut Parser) -> ?ast::Attributes {
    let mut attrs = ast::nodeSlice(p.arena, 4);
    let mut attrs = ast::nodeVec(p.arena, 4);

    if let attr = tryParseAnnotation(p) {
        attrs.append(attr, p.allocator);
        vec::append⟨*ast::Node⟩(&mut attrs, attr, p.allocator);
    }
    if consume(p, scanner::TokenKind::Export) {
        attrs.append(nodeAttribute(p, ast::Attribute::Export), p.allocator);
        vec::append⟨*ast::Node⟩(&mut attrs, nodeAttribute(p, ast::Attribute::Export), p.allocator);
    }
    if consume(p, scanner::TokenKind::Unsafe) {
        attrs.append(nodeAttribute(p, ast::Attribute::Unsafe), p.allocator);
        vec::append⟨*ast::Node⟩(&mut attrs, nodeAttribute(p, ast::Attribute::Unsafe), p.allocator);
    }
    if attrs.len > 0 {
        return ast::Attributes { list: attrs };
        return ast::Attributes { list: vec::viewMut⟨*ast::Node⟩(&mut attrs) };
    }
    return nil;
}

/// Try to parse an annotation like `@default`.

    }
}

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

        if check(p, end) or check(p, scanner::TokenKind::Eof) {
            break;
        }
        if not consume(p, scanner::TokenKind::Semicolon) {

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

    if not consume(p, scanner::TokenKind::LBrace) {
        throw failParsing(p, "expected `{`");
    }
    try parseStmtsUntil(p, scanner::TokenKind::RBrace, &mut blk);
    try parseStmtsUntil(p, scanner::TokenKind::RBrace, &mut statements);
    try expect(p, scanner::TokenKind::RBrace, "expected `}`");

    let blk = ast::Block { statements: vec::viewMut⟨*ast::Node⟩(&mut statements) };
    return node(p, ast::NodeValue::Block(blk));
}

/// Create an empty block with no statements.
fn mkBlock(p: *mut Parser, cap: u32) -> ast::Block {
    return ast::Block { statements: ast::nodeSlice(p.arena, cap) };
/// Create an empty transient statement vector with the requested capacity.
fn mkStatementVec(p: *mut Parser, capacity: u32) -> vec::Vec⟨*ast::Node⟩ {
    return ast::nodeVec(p.arena, capacity);
}

/// Create a block containing a single statement node.
fn mkBlockWith(p: *mut Parser, node: *ast::Node) -> ast::Block {
    let stmts = ast::nodeSlice(p.arena, 1).append(node, p.allocator);
    return ast::Block { statements: stmts };
    let mut statements = ast::nodeVec(p.arena, 1);
    vec::append⟨*ast::Node⟩(&mut statements, node, p.allocator);
    return ast::Block { statements: vec::viewMut⟨*ast::Node⟩(&mut statements) };
}

/// Parse the branch that follows `else` in let-else style constructs.
///
/// Allows either a block, a single statement like `return`,

    try expect(p, scanner::TokenKind::Try, "expected `try`");

    let shouldPanic = consume(p, scanner::TokenKind::Bang);
    let returnsOptional = consume(p, scanner::TokenKind::Question);
    let expr = try parseUnaryExpr(p);
    let mut catches = ast::nodeSlice(p.arena, 4);
    let mut catches = ast::nodeVec(p.arena, 4);

    while consume(p, scanner::TokenKind::Catch) {
        let mut binding: ?*ast::Node = nil;
        let mut typeNode: ?*ast::Node = nil;


        }
        let body = try parseBlock(p);
        let clause = node(p, ast::NodeValue::CatchClause(
            ast::CatchClause { binding, typeNode, body }
        ));
        catches.append(clause, p.allocator);
        vec::append⟨*ast::Node⟩(&mut catches, clause, p.allocator);
    }
    return node(p, ast::NodeValue::Try(
        ast::Try { expr, catches, shouldPanic, returnsOptional }
    ));
    return node(p, ast::NodeValue::Try(ast::Try {
        expr,
        catches: vec::viewMut⟨*ast::Node⟩(&mut catches),
        shouldPanic,
        returnsOptional,
    }));
}

/// Parse an `if` expression, with optional `else` or `else if` clauses.
///
/// The `else if` construct is handled by creating a recursive structure:

    try expect(p, scanner::TokenKind::Match, "expected `match`");

    let subject = try parseCond(p);
    try expect(p, scanner::TokenKind::LBrace, "expected `{` before match prongs");

    let mut prongs = ast::nodeSlice(p.arena, 128);
    let mut prongs = ast::nodeVec(p.arena, 128);
    while not check(p, scanner::TokenKind::RBrace) and
          not check(p, scanner::TokenKind::Eof) // TODO: We shouldn't have to manually check for EOF.
    {
        let prongNode = try parseMatchProng(p);
        prongs.append(prongNode, p.allocator);
        vec::append⟨*ast::Node⟩(&mut prongs, prongNode, p.allocator);
        consume(p, scanner::TokenKind::Comma);
    }
    try expect(p, scanner::TokenKind::RBrace, "expected `}` after match prongs");

    return node(p, ast::NodeValue::Match(
        ast::Match { subject, prongs }
    ));
    return node(p, ast::NodeValue::Match(ast::Match {
        subject, prongs: vec::viewMut⟨*ast::Node⟩(&mut prongs),
    }));
}

/// Parse a single `match` prong.
fn parseMatchProng(p: *mut Parser) -> *ast::Node
    throws (ParseError)
{
    let mut guard: ?*ast::Node = nil;

    // Case prong: `case <pattern>, ... if <guard> => <body>`.
    if consume(p, scanner::TokenKind::Case) {
        let mut patterns = ast::nodeSlice(p.arena, 16);
        let mut patterns = ast::nodeVec(p.arena, 16);
        loop {
            let pattern = try parseMatchPattern(p);
            patterns.append(pattern, p.allocator);
            vec::append⟨*ast::Node⟩(&mut patterns, pattern, p.allocator);

            if not consume(p, scanner::TokenKind::Comma) {
                break;
            }
            // After a comma, check for tokens that start a new prong.

            set guard = try parseCond(p);
        }
        try expect(p, scanner::TokenKind::FatArrow, "expected `=>` after case pattern");
        let body = try parseStmt(p);

        return node(p, ast::NodeValue::MatchProng(
            ast::MatchProng { arm: ast::ProngArm::Case(patterns), guard, body }
        ));
        return node(p, ast::NodeValue::MatchProng(ast::MatchProng {
            arm: ast::ProngArm::Case(vec::viewMut⟨*ast::Node⟩(&mut patterns)),
            guard,
            body,
        }));
    }
    // Else prong: `else if <guard> => <body>`.
    if consume(p, scanner::TokenKind::Else) {
        if consume(p, scanner::TokenKind::If) {
            set guard = try parseCond(p);

) -> *mut [*ast::Node]
    throws (ParseError)
{
    let terminator = scanner::TokenKind::RBrace if mode == RecordFieldMode::Labeled
        else scanner::TokenKind::RParen;
    let mut fields = ast::nodeSlice(p.arena, MAX_RECORD_FIELDS);
    let mut fields = ast::nodeVec(p.arena, MAX_RECORD_FIELDS);
    while not check(p, terminator) {
        let mut recordField: ast::NodeValue = undefined;
        match mode {
            case RecordFieldMode::Labeled => {
                // Allow optional `let` keyword before field name.

                set recordField = ast::NodeValue::RecordField {
                    field: nil, type, value: nil,
                };
            }
        }
        fields.append(node(p, recordField), p.allocator);
        vec::append⟨*ast::Node⟩(&mut fields, node(p, recordField), p.allocator);

        if not consume(p, scanner::TokenKind::Comma) {
            break;
        }
    }
    try expect(p, terminator, "expected closing delimiter after record fields");

    return fields;
    return vec::viewMut⟨*ast::Node⟩(&mut fields);
}

/// Parse an optional generic parameter list.
fn parseGenericParams(p: *mut Parser) -> *mut [*ast::Node] throws (ParseError) {
    let mut params = ast::nodeSlice(p.arena, 4);
    let mut params = ast::nodeVec(p.arena, 4);
    if not consume(p, scanner::TokenKind::LAngle) {
        return params;
        return vec::viewMut⟨*ast::Node⟩(&mut params);
    }
    if check(p, scanner::TokenKind::RAngle) {
        throw failParsing(p, "generic parameter list cannot be empty");
    }
    loop {

            let bounds = try parseDerives(p);
            set param = node(p, ast::NodeValue::GenericParam(
                ast::GenericParam::Type { name, bounds }
            ));
        }
        params.append(param, p.allocator);
        vec::append⟨*ast::Node⟩(&mut params, param, p.allocator);
        if not consume(p, scanner::TokenKind::Comma) {
            break;
        }
        if check(p, scanner::TokenKind::RAngle) {
            throw failParsing(p, "expected generic parameter after `,`");
        }
    }
    try expect(p, scanner::TokenKind::RAngle, "expected right angle after generic parameters");
    return params;
    return vec::viewMut⟨*ast::Node⟩(&mut params);
}

/// Parse an optional derives list (`: Trait + Trait`).
fn parseDerives(p: *mut Parser) -> *mut [*ast::Node] throws (ParseError) {
    let mut derives = ast::nodeSlice(p.arena, 4);
    let mut derives = ast::nodeVec(p.arena, 4);

    if not consume(p, scanner::TokenKind::Colon) {
        return derives;
        return vec::viewMut⟨*ast::Node⟩(&mut derives);
    }
    loop {
        let t = try parseTypePath(p);
        derives.append(t, p.allocator);
        vec::append⟨*ast::Node⟩(&mut derives, t, p.allocator);

        if not consume(p, scanner::TokenKind::Plus) {
            break;
        }
    }
    return derives;
    return vec::viewMut⟨*ast::Node⟩(&mut derives);
}

/// Parse a single record literal field.
/// Can be either labeled, or shorthand.
fn parseRecordLitField(p: *mut Parser) -> *ast::Node

/// Eg. `{ x: 1, y: 2 }`
/// Eg. `{ x: 1, .. }`
fn parseRecordLit(p: *mut Parser, typeName: ?*ast::Node) -> *ast::Node
    throws (ParseError)
{
    let mut fields = ast::nodeSlice(p.arena, MAX_RECORD_FIELDS);
    let mut fields = ast::nodeVec(p.arena, MAX_RECORD_FIELDS);
    let mut ignoreRest = false;
    try expect(p, scanner::TokenKind::LBrace, "expected `{` to begin record literal");

    while not check(p, scanner::TokenKind::RBrace) {
        // Check for `..` to ignore remaining fields.
        if consume(p, scanner::TokenKind::DotDot) {
            set ignoreRest = true;
            break;
        }
        let field = try parseRecordLitField(p);
        fields.append(field, p.allocator);
        vec::append⟨*ast::Node⟩(&mut fields, field, p.allocator);

        if not consume(p, scanner::TokenKind::Comma) {
            break;
        }
    }
    try expect(p, scanner::TokenKind::RBrace, "expected `}` to end record literal");

    return node(p, ast::NodeValue::RecordLit(
        ast::RecordLit { typeName, fields, ignoreRest }
    ));
    return node(p, ast::NodeValue::RecordLit(ast::RecordLit {
        typeName,
        fields: vec::viewMut⟨*ast::Node⟩(&mut fields),
        ignoreRest,
    }));
}

/// Parse a named record declaration.
/// `record Point { x: i32, y: i32 }`, or `record Pair(i32, i32);`
fn parseRecordDecl(p: *mut Parser, attrs: ?ast::Attributes) -> *ast::Node

    let params = try parseGenericParams(p);
    let derives = try parseDerives(p);

    try expect(p, scanner::TokenKind::LBrace, "expected `{` before union body");

    let mut variants = ast::nodeSlice(p.arena, 128);
    let mut variants = ast::nodeVec(p.arena, 128);
    while not check(p, scanner::TokenKind::RBrace) {
        // Allow optional `case` keyword before variant name.
        consume(p, scanner::TokenKind::Case);

        let variantName = try parseIdent(p, "expected variant name");

        let variant = node(p, ast::NodeValue::UnionDeclVariant(
            ast::UnionDeclVariant {
                name: variantName, index: variants.len as u32, value: explicitValue, type: payloadType,
            }
        ));
        variants.append(variant, p.allocator);
        vec::append⟨*ast::Node⟩(&mut variants, variant, p.allocator);

        if not consume(p, scanner::TokenKind::Comma) {
            break;
        }
    }
    try expect(p, scanner::TokenKind::RBrace, "expected `}`");

    return node(p, ast::NodeValue::UnionDecl(
        ast::UnionDecl { name, params, variants, attrs, derives }
    ));
    return node(p, ast::NodeValue::UnionDecl(ast::UnionDecl {
        name,
        params,
        variants: vec::viewMut⟨*ast::Node⟩(&mut variants),
        attrs,
        derives,
    }));
}

/// Parse a function parameter.
fn parseFnParam(p: *mut Parser) -> *ast::Node
    throws (ParseError)

/// Parse an optional `throws` clause and return the collected type list.
fn parseThrowList(p: *mut Parser) -> *mut [*ast::Node]
    throws (ParseError)
{
    if not consume(p, scanner::TokenKind::Throws) {
        return ast::nodeSlice(p.arena, 0);
        return &mut [];
    }
    return try parseList(
        p,
        scanner::TokenKind::LParen,
        scanner::TokenKind::RParen,

/// Parse a function signature following the function name.
fn parseFnTypeSig(p: *mut Parser) -> ast::FnSig
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::LParen, "expected `(` after function name");
    let mut params = ast::nodeSlice(p.arena, 8);
    let mut params = ast::nodeVec(p.arena, 8);

    while not check(p, scanner::TokenKind::RParen) {
        let param = try parseFnParam(p);
        params.append(param, p.allocator);
        vec::append⟨*ast::Node⟩(&mut params, param, p.allocator);

        if not consume(p, scanner::TokenKind::Comma) {
            break;
        }
    }

    if consume(p, scanner::TokenKind::Arrow) {
        set returnType = try parseType(p);
    }
    let throwList = try parseThrowList(p);

    return ast::FnSig { params, returnType, throwList };
    return ast::FnSig {
        params: vec::viewMut⟨*ast::Node⟩(&mut params),
        returnType,
        throwList,
    };
}

/// Parse a function declaration.
fn parseFnDecl(p: *mut Parser, attrs: ?ast::Attributes) -> *ast::Node
    throws (ParseError)


    if consume(p, scanner::TokenKind::Semicolon) {
        if let a = attrs; ast::attributesContains(&a, ast::Attribute::Extern) {
            // Keep existing attributes unchanged.
        } else {
            let mut list = ast::nodeSlice(p.arena, 4);
            let mut list = ast::nodeVec(p.arena, 4);
            if let a = attrs {
                for i in 0..a.list.len {
                    list.append(a.list[i], p.allocator);
                    vec::append⟨*ast::Node⟩(&mut list, a.list[i], p.allocator);
                }
            }
            let attrNode = nodeAttribute(p, ast::Attribute::Extern);
            list.append(attrNode, p.allocator);
            set fnAttrs = ast::Attributes { list };
            vec::append⟨*ast::Node⟩(&mut list, attrNode, p.allocator);
            set fnAttrs = ast::Attributes { list: vec::viewMut⟨*ast::Node⟩(&mut list) };
        }
    } else {
        set body = try parseBlock(p);
    }
    return node(p, ast::NodeValue::FnDecl(

export fn parseModule(p: *mut Parser) -> *mut ast::Node
    throws (ParseError)
{
    advance(p); // Set the parser up with a first token.

    let mut blk = mkBlock(p, 512);
    try parseStmtsUntil(p, scanner::TokenKind::Eof, &mut blk);
    let mut statements = mkStatementVec(p, 512);
    try parseStmtsUntil(p, scanner::TokenKind::Eof, &mut statements);
    consume(p, scanner::TokenKind::Eof);

    let blk = ast::Block { statements: vec::viewMut⟨*ast::Node⟩(&mut statements) };
    return node(p, ast::NodeValue::Block(blk));
}

/// Consume a token of the given kind if present.
export fn consume(p: *mut Parser, kind: scanner::TokenKind) -> bool {

}

/// Parse one or more explicit specialization roots.
fn parseInstantiate(p: *mut Parser) -> *ast::Node throws (ParseError) {
    try expect(p, scanner::TokenKind::Instantiate, "expected `instantiate`");
    let mut applications = ast::nodeSlice(p.arena, 4);
    let mut applications = ast::nodeVec(p.arena, 4);
    loop {
        let target = try parseTypePath(p);
        if not check(p, scanner::TokenKind::LAngle) {
            throw failParsing(p, "`instantiate` requires a generic application");
        }
        applications.append(try parseGenericApply(p, target), p.allocator);
        vec::append⟨*ast::Node⟩(&mut applications, try parseGenericApply(p, target), p.allocator);
        if not consume(p, scanner::TokenKind::Comma) {
            break;
        }
    }
    return node(p, ast::NodeValue::Instantiate(applications));
    return node(p, ast::NodeValue::Instantiate(
        vec::viewMut⟨*ast::Node⟩(&mut applications)
    ));
}

/// Parse a trait declaration.
/// Syntax: `trait Name { fn (*Trait) method(...) -> T; ... }`
fn parseTraitDecl(p: *mut Parser, attrs: ?ast::Attributes) -> *ast::Node

    try expect(p, scanner::TokenKind::Trait, "expected `trait`");
    let name = try parseIdent(p, "expected trait name");
    let supertraits = try parseDerives(p);
    try expect(p, scanner::TokenKind::LBrace, "expected `{` after trait name");

    let mut methods = ast::nodeSlice(p.arena, ast::MAX_TRAIT_METHODS);
    let mut methods = ast::nodeVec(p.arena, ast::MAX_TRAIT_METHODS);
    while not check(p, scanner::TokenKind::RBrace) and
          not check(p, scanner::TokenKind::Eof)
    {
        let method = try parseTraitMethodSig(p);
        methods.append(method, p.allocator);
        vec::append⟨*ast::Node⟩(&mut methods, method, p.allocator);
    }
    try expect(p, scanner::TokenKind::RBrace, "expected `}` after trait methods");

    return node(p, ast::NodeValue::TraitDecl { name, supertraits, methods, attrs });
    return node(p, ast::NodeValue::TraitDecl {
        name,
        supertraits,
        methods: vec::viewMut⟨*ast::Node⟩(&mut methods),
        attrs,
    });
}

/// Parse a trait method signature.
/// Syntax: `fn (*Trait) fnord(<params>) -> ReturnType;`
fn parseTraitMethodSig(p: *mut Parser) -> *ast::Node

    let traitName = try parseTypePath(p);
    try expect(p, scanner::TokenKind::For, "expected `for` after trait name");
    let targetType = try parseType(p);
    try expect(p, scanner::TokenKind::LBrace, "expected `{` after target type");

    let mut methods = ast::nodeSlice(p.arena, ast::MAX_TRAIT_METHODS);
    let mut methods = ast::nodeVec(p.arena, ast::MAX_TRAIT_METHODS);

    while not check(p, scanner::TokenKind::RBrace) and
          not check(p, scanner::TokenKind::Eof)
    {
        let attrs = parseAttributes(p);
        try expect(p, scanner::TokenKind::Fn, "expected `fn`");
        let method = try parseMethodDecl(p, attrs);

        methods.append(method, p.allocator);
        vec::append⟨*ast::Node⟩(&mut methods, method, p.allocator);
    }
    try expect(p, scanner::TokenKind::RBrace, "expected `}` after instance methods");

    return node(p, ast::NodeValue::InstanceDecl { traitName, targetType, methods });
    return node(p, ast::NodeValue::InstanceDecl {
        traitName,
        targetType,
        methods: vec::viewMut⟨*ast::Node⟩(&mut methods),
    });
}

/// Parse a method declaration with a receiver.
/// Syntax: `fn (t: *mut Type) fnord(<params>) -> ReturnType { body }`
///

    open: scanner::TokenKind,
    close: scanner::TokenKind,
    parseItem: fn (*mut Parser) -> *ast::Node throws (ParseError)
) -> *mut [*ast::Node] throws (ParseError) {
    try expect(p, open, listExpectMessage(open));
    let mut items = ast::nodeSlice(p.arena, 8);
    let mut items = ast::nodeVec(p.arena, 8);

    while not check(p, close) {
        let item = try parseItem(p);
        items.append(item, p.allocator);
        vec::append⟨*ast::Node⟩(&mut items, item, p.allocator);

        if not consume(p, scanner::TokenKind::Comma) {
            break;
        }
    }
    try expect(p, close, listExpectMessage(close));

    return items;
    return vec::viewMut⟨*ast::Node⟩(&mut items);
}

lib/std/lang/resolver.rad +394 -359

// 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::vec;
use std::lang::alloc;
use std::lang::types;
use std::lang::ast;
use std::lang::parser;
use std::lang::module;

    name: *[u8],
    /// Module-local identity used by semantic tables.
    moduleId: u16,
    nodeId: u32,
    /// Method signatures, including from supertraits.
    methods: *mut [TraitMethod],
    methods: vec::Vec⟨TraitMethod⟩,
    /// Supertraits that must also be implemented.
    supertraits: *mut [*TraitType],
    supertraits: vec::Vec⟨*TraitType⟩,
    /// Rigid `Self` type used by static signatures.
    selfType: *GenericParamType,
    /// Whether signature resolution has started or completed.
    state: TraitState,
    /// Whether every vtable-exposed method is object-safe.


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

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

    symbol: *mut Symbol,
}

/// Array type payload.
export record ArrayType {
    /// Element type.
    item: *Type,
    length: u32,
    /// Typed constant descriptor for the array length.
    length: *Type,
}

/// Anonymous record whose field layout depends on rigid parameters.
export record GenericRecordType {
    /// Fields in declaration order.

export record SliceRangeInfo {
    /// Element type of the resulting slice.
    itemType: *Type,
    /// Whether the resulting slice is mutable.
    mutable: bool,
    /// Static capacity if container is an array.
    capacity: ?u32,
    /// Typed array length descriptor, or `nil` when slicing a slice.
    capacity: ?*Type,
}

/// Pre-computed metadata for `for` loop iteration.
/// Used by the lowerer to avoid re-analyzing the iterable type.
export union ForLoopInfo {

        valType: *Type,
        range: ast::Range,
        bindingName: ?*[u8],
        indexName: ?*[u8]
    },
    /// Iterating over an array or slice. For arrays, the length field is set.
    /// Iterating over an array or slice.
    Collection {
        /// Element type.
        elemType: *Type,
        length: ?u32,
        /// Typed array length descriptor, or `nil` for a slice.
        length: ?*Type,
        /// Optional element binding name.
        bindingName: ?*[u8],
        /// Optional index binding name.
        indexName: ?*[u8]
    },
}

/// A rigid type parameter belonging to one generic declaration.

    /// Whether the declaration explicitly carries the `Linear` marker.
    declaredLinear: bool,
    /// Whether a generic function body has already been checked.
    bodyResolved: bool,
    /// Symbolic body types consumed by lowering, recorded during body analysis.
    typeUses: *mut [GenericTypeUse],
    typeUses: vec::Vec⟨GenericTypeUse⟩,
    /// Next generic template.
    next: ?*mut GenericTemplate,
}

/// Canonical concrete specialization of a generic record or union.

    Pointer(PointerType),
    /// Pointer-like slice.
    Slice(SliceType),
    /// Eg. `[i32; 32]`.
    Array(ArrayType),
    /// Array type whose length depends on a rigid constant parameter.
    GenericArray {
        item: *Type,
        length: *ast::Node,
    },
    /// Rigid integer constant parameter within a generic declaration.
    ConstParameter(*GenericParamType),
    /// Canonical typed integer generic argument.
    ConstArgument {
        type: *Type,

    GenericDataApply(*GenericDataApplyType),
    /// An erased pointer-like type with a v-table.
    TraitObject(TraitObjectType),
}

/// Return a concrete `u32` array length from its typed descriptor.
export fn concreteArrayLength(length: *Type) -> ?u32 {
    let case Type::ConstArgument { type, value } = *length else return nil;
    if *type <> Type::U32 or value.negative
        or value.magnitude > parser::U32_MAX as u64
    {
        return nil;
    }
    return value.magnitude as u32;
}

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

    GenericSpecializationLimit,
}

/// Diagnostics returned by the analyzer.
export record Diagnostics {
    /// Recorded errors in analysis order.
    errors: *mut [Error],
}

/// Call context.
union CallCtx {

        /// Whether the receiver is the first explicit call argument.
        explicitReceiver: bool,
    },
    /// Standalone method call metadata.
    MethodCall { method: *MethodEntry },
    /// Slice `.append(val, allocator)` method call.
    SliceAppend { elemType: *Type },
    /// Slice `.delete(index)` method call.
    SliceDelete { elemType: *Type },
    /// Concrete specialization selected by an explicit generic function value.
    GenericFnCall(*GenericFnSpecialization),
    /// Symbolic generic call resolved under the caller's specialization.
    GenericFnDependency(*GenericFnDependency),
}

    /// Combined semantic metadata table indexed by node ID.
    nodeData: NodeDataTable,
    /// Linked list of interned types.
    types: ?*TypeNode,
    /// Diagnostics recorded so far.
    errors: *mut [Error],
    errors: vec::Vec⟨Error⟩,
    /// Module graph for the current package.
    moduleGraph: *module::ModuleGraph,
    /// Cache of module scopes indexed by module ID.
    moduleScopes: [?*mut Scope; module::MAX_MODULES],
    /// Trait instance registry.

record TypeNode {
    ty: Type,
    next: ?*TypeNode,
}

instantiate vec::append⟨*Type⟩,
            vec::view⟨*Type⟩;

instantiate vec::append⟨RecordField⟩,
            vec::view⟨RecordField⟩;

instantiate vec::append⟨UnionVariant⟩,
            vec::view⟨UnionVariant⟩;

instantiate vec::append⟨*GenericParamType⟩,
            vec::view⟨*GenericParamType⟩;

instantiate vec::append⟨TraitMethod⟩,
            vec::view⟨TraitMethod⟩;

instantiate vec::append⟨*TraitType⟩,
            vec::view⟨*TraitType⟩;

instantiate vec::append⟨GenericTypeUse⟩,
            vec::view⟨GenericTypeUse⟩;

instantiate vec::push⟨Error⟩,
            vec::viewMut⟨Error⟩;

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

    set self.types = node;

    return &node.ty;
}

/// Allocate the canonical typed descriptor for a concrete array length.
fn allocConcreteArrayLength(self: *mut Resolver, length: u32) -> *Type {
    return allocType(self, Type::ConstArgument {
        type: allocType(self, Type::U32),
        value: ConstInt {
            magnitude: length as u64,
            bits: 32,
            signed: false,
            negative: false,
        },
    });
}

/// Allocate a symbolic array length descriptor for a generic constant expression.
fn allocSymbolicArrayLength(self: *mut Resolver, expression: *ast::Node) -> *Type {
    if let sym = symbolFor(self, expression) {
        if let case SymbolData::ConstParameter(param) = sym.data {
            if let declaredType = param.constType; *declaredType == Type::U32 {
                return allocType(self, Type::ConstParameter(param));
            }
        }
    }
    return allocType(self, Type::GenericConstExpr {
        type: allocType(self, Type::U32),
        expr: expression,
    });
}

/// Return whether a type contains a rigid generic parameter.
export fn containsGenericParameter(ty: Type) -> bool {
    match ty {
        case Type::Pointer(pointer) =>
            return containsGenericParameter(*pointer.target),
        case Type::Slice(slice) =>
            return containsGenericParameter(*slice.item),
        case Type::Parameter(_), Type::ConstParameter(_),
             Type::GenericConstExpr { .. } => return true,
        case Type::Array(array) => return containsGenericParameter(*array.item),
        case Type::GenericArray { .. } => return true,
        case Type::Array(array) =>
            return containsGenericParameter(*array.item)
                or containsGenericParameter(*array.length),
        case Type::Optional(inner) => return containsGenericParameter(*inner),
        // Symbolic anonymous records require materialization even when their
        // own fields happen not to mention a rigid parameter.
        case Type::GenericRecord(_) => return true,
        case Type::GenericDataApply(_) => return true,

                mutable: slice.mutable,
            });
        }
        case Type::Array(array) => {
            let item = try materializeConcreteGenericData(self, *array.item, site);
            let length = try materializeConcreteGenericData(
                self, *array.length, site
            );
            return Type::Array(ArrayType {
                item: allocType(self, item),
                length: array.length,
                length: allocType(self, length),
            });
        }
        case Type::GenericArray { item, length } => {
            let inner = try materializeConcreteGenericData(self, *item, site);
            return Type::GenericArray { item: allocType(self, inner), length };
        }
        case Type::Optional(inner) => {
            let value = try materializeConcreteGenericData(self, *inner, site);
            return Type::Optional(allocType(self, value));
        }
        case Type::GenericDataApply(app) => {
            let a = alloc::arenaAllocator(&mut self.arena);
            let mut args: *mut [*Type] = &mut [];
            let mut args = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
            let mut concrete = true;
            for arg in app.args {
                let value = try materializeConcreteGenericData(self, *arg, site);
                set concrete = concrete and not containsGenericParameter(value);
                args.append(allocType(self, value), a);
                vec::append⟨*Type⟩(&mut args, allocType(self, value), a);
            }
            let argsView = vec::view⟨*Type⟩(&args);
            if concrete {
                let nominal = try specializeGenericData(
                    self, app.site, app.template, &args[..], false
                    self, app.site, app.template, argsView, false
                );
                return Type::Nominal(nominal);
            }
            let application = try! alloc::alloc(
                &mut self.arena,
                @sizeOf(GenericDataApplyType),
                @alignOf(GenericDataApplyType),
            ) as *mut GenericDataApplyType;
            set *application = GenericDataApplyType {
                template: app.template,
                args: &args[..],
                args: argsView,
                site: app.site,
            };
            return Type::GenericDataApply(application);
        }
        case Type::Fn(info) => {
            let a = alloc::arenaAllocator(&mut self.arena);
            let mut params: *mut [*Type] = &mut [];
            let mut throwTypes: *mut [*Type] = &mut [];
            let mut params = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
            let mut throwTypes = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
            for param in info.paramTypes {
                let value = try materializeConcreteGenericData(self, *param, site);
                params.append(allocType(self, value), a);
                vec::append⟨*Type⟩(&mut params, allocType(self, value), a);
            }
            for thrown in info.throwList {
                let value = try materializeConcreteGenericData(self, *thrown, site);
                throwTypes.append(allocType(self, value), a);
                vec::append⟨*Type⟩(&mut throwTypes, allocType(self, value), a);
            }
            let result = try materializeConcreteGenericData(
                self, *info.returnType, site
            );
            return Type::Fn(allocFnType(self, FnType {
                paramTypes: &params[..],
                paramTypes: vec::view⟨*Type⟩(&params),
                returnType: allocType(self, result),
                throwList: &throwTypes[..],
                throwList: vec::view⟨*Type⟩(&throwTypes),
                isUnsafe: info.isUnsafe,
                localCount: info.localCount,
            }));
        }
        case Type::GenericRecord(rec) => {
            let a = alloc::arenaAllocator(&mut self.arena);
            let mut fields: *mut [RecordField] = &mut [];
            let mut fields = vec::Vec⟨RecordField⟩ { data: &mut [], len: 0 };
            let mut symbolic = false;
            for field in rec.fields {
                let fieldType = try materializeConcreteGenericData(
                    self, field.fieldType, site
                );
                set symbolic = symbolic or containsGenericParameter(fieldType);
                fields.append(RecordField {
                vec::append⟨RecordField⟩(&mut fields, RecordField {
                    name: field.name,
                    fieldType,
                    offset: field.offset,
                }, a);
            }

                &mut self.arena,
                @sizeOf(GenericRecordType),
                @alignOf(GenericRecordType),
            ) as *mut GenericRecordType;
            set *updatedRec = GenericRecordType {
                fields: &fields[..],
                fields: vec::view⟨RecordField⟩(&fields),
                labeled: rec.labeled,
            };
            let updated = Type::GenericRecord(updatedRec);
            if symbolic {
                return updated;

                mutable: slice.mutable,
            });
        }
        case Type::Array(array) => {
            let item = copyStructuralTypeToArena(*array.item, arena);
            let length = copyStructuralTypeToArena(*array.length, arena);
            return Type::Array(ArrayType {
                item: allocArenaType(arena, item),
                length: array.length,
                length: allocArenaType(arena, length),
            });
        }
        case Type::Optional(inner) => {
            let stored = copyStructuralTypeToArena(*inner, arena);
            return Type::Optional(allocArenaType(arena, stored));
        }
        case Type::Fn(info) => {
            let a = alloc::arenaAllocator(arena);
            let mut params: *mut [*Type] = &mut [];
            let mut throwList: *mut [*Type] = &mut [];
            let mut params = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
            let mut throwList = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
            for param in info.paramTypes {
                let stored = copyStructuralTypeToArena(*param, arena);
                params.append(allocArenaType(arena, stored), a);
                vec::append⟨*Type⟩(&mut params, allocArenaType(arena, stored), a);
            }
            for thrown in info.throwList {
                let stored = copyStructuralTypeToArena(*thrown, arena);
                throwList.append(allocArenaType(arena, stored), a);
                vec::append⟨*Type⟩(&mut throwList, allocArenaType(arena, stored), a);
            }
            let returnType = copyStructuralTypeToArena(*info.returnType, arena);
            let storedInfo = try! alloc::alloc(
                arena, @sizeOf(FnType), @alignOf(FnType)
            ) as *mut FnType;
            set *storedInfo = FnType {
                paramTypes: &params[..],
                paramTypes: vec::view⟨*Type⟩(&params),
                returnType: allocArenaType(arena, returnType),
                throwList: &throwList[..],
                throwList: vec::view⟨*Type⟩(&throwList),
                isUnsafe: info.isUnsafe,
                localCount: info.localCount,
            };
            return Type::Fn(storedInfo);
        }

                mutable: slice.mutable,
            });
        }
        case Type::Array(array) => {
            let item = try substituteTypeWithContext(context, *array.item, sub);
            let length = try substituteTypeWithContext(
                context, *array.length, sub
            );
            return Type::Array(ArrayType {
                item: allocSubstitutedType(context, item),
                length: array.length,
            });
        }
        case Type::GenericArray { item, length } => {
            let concreteItem = try substituteTypeWithContext(context, *item, sub);
            let mut arrayLength: u32 = 0;
            match *context {
                case TypeSubstitutionContext::Resolution { resolver, .. } => {
                    let value = constValueWithSubstitution(resolver, length, sub)
                        else throw emitError(resolver, length, ErrorKind::ConstExprRequired);
                    if not validateConstIntRange(value, Type::U32) {
                        throw emitError(resolver, length, ErrorKind::NumericLiteralOverflow);
                    }
                    let case ConstValue::Int(int) = value
                        else throw emitError(resolver, length, ErrorKind::ConstExprRequired);
                    set arrayLength = int.magnitude as u32;
                }
                case TypeSubstitutionContext::ReadOnly { resolver, .. } => {
                    let value = constIntWithSubstitution(
                        resolver, length, Type::U32, sub
                    ) else throw ResolveError::Failure;
                    set arrayLength = value.magnitude as u32;
                }
            }
            return Type::Array(ArrayType {
                item: allocSubstitutedType(context, concreteItem),
                length: arrayLength,
                length: allocSubstitutedType(context, length),
            });
        }
        case Type::Optional(inner) => {
            let value = try substituteTypeWithContext(context, *inner, sub);
            return Type::Optional(allocSubstitutedType(context, value));
        }
        case Type::GenericDataApply(app) => {
            let a = alloc::arenaAllocator(substitutionArena(context));
            let mut args: *mut [*Type] = &mut [];
            let mut args = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
            let mut symbolic = false;
            for arg in app.args {
                let replacement = try substituteTypeWithContext(context, *arg, sub);
                set symbolic = symbolic or containsGenericParameter(replacement);
                args.append(allocSubstitutedType(context, replacement), a);
                vec::append⟨*Type⟩(&mut args, allocSubstitutedType(context, replacement), a);
            }
            let argsView = vec::view⟨*Type⟩(&args);
            match *context {
                case TypeSubstitutionContext::Resolution { resolver, .. } => {
                    if symbolic {
                        let application = try! alloc::alloc(
                            &mut resolver.arena,
                            @sizeOf(GenericDataApplyType),
                            @alignOf(GenericDataApplyType),
                        ) as *mut GenericDataApplyType;
                        set *application = GenericDataApplyType {
                            template: app.template,
                            args: &args[..],
                            args: argsView,
                            site: app.site,
                        };
                        return Type::GenericDataApply(application);
                    }
                    let nominal = try specializeGenericData(
                        resolver, app.site, app.template, &args[..], false
                        resolver, app.site, app.template, argsView, false
                    );
                    return Type::Nominal(nominal);
                }
                case TypeSubstitutionContext::ReadOnly { resolver, .. } => {
                    if symbolic {
                        throw ResolveError::Failure;
                    }
                    let specialization = findGenericDataSpecialization(
                        resolver, app.template, &args[..]
                        resolver, app.template, argsView
                    ) else throw ResolveError::Failure;
                    return Type::Nominal(specialization.nominal);
                }
            }
        }

                ..
            } = *context {
                set persistentArena = arena;
            }
            let a = alloc::arenaAllocator(persistentArena);
            let mut fields: *mut [RecordField] = &mut [];
            let mut fields = vec::Vec⟨RecordField⟩ { data: &mut [], len: 0 };
            let mut offset: u32 = 0;
            let mut alignment: u32 = 1;
            for field in rec.fields {
                let fieldType = try substituteTypeWithContext(
                    context, field.fieldType, sub

                        );
                    }
                }
                let fieldLayout = getTypeLayout(fieldType);
                set offset = mem::alignUp(offset, fieldLayout.alignment);
                fields.append(RecordField {
                vec::append⟨RecordField⟩(&mut fields, RecordField {
                    name: field.name,
                    fieldType: storedFieldType,
                    offset: offset as i32,
                }, a);
                set offset += fieldLayout.size;

            }
            let nominal = try! alloc::alloc(
                persistentArena, @sizeOf(NominalType), @alignOf(NominalType)
            ) as *mut NominalType;
            set *nominal = NominalType::Record(RecordType {
                fields: &fields[..],
                fields: vec::view⟨RecordField⟩(&fields),
                labeled: rec.labeled,
                layout: Layout {
                    size: mem::alignUp(offset, alignment),
                    alignment,
                },

            return Type::Nominal(nominal);
        }
        case Type::Fn(info) => {
            let arena = substitutionArena(context);
            let a = alloc::arenaAllocator(arena);
            let mut params: *mut [*Type] = &mut [];
            let mut throwTypes: *mut [*Type] = &mut [];
            let mut params = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
            let mut throwTypes = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
            for param in info.paramTypes {
                let concrete = try substituteTypeWithContext(context, *param, sub);
                params.append(allocSubstitutedType(context, concrete), a);
                vec::append⟨*Type⟩(&mut params, allocSubstitutedType(context, concrete), a);
            }
            for thrown in info.throwList {
                let concrete = try substituteTypeWithContext(context, *thrown, sub);
                throwTypes.append(allocSubstitutedType(context, concrete), a);
                vec::append⟨*Type⟩(&mut throwTypes, allocSubstitutedType(context, concrete), a);
            }
            let result = try substituteTypeWithContext(
                context, *info.returnType, sub
            );
            let fnType = try! alloc::alloc(
                arena, @sizeOf(FnType), @alignOf(FnType)
            ) as *mut FnType;
            set *fnType = FnType {
                paramTypes: &params[..],
                paramTypes: vec::view⟨*Type⟩(&params),
                returnType: allocSubstitutedType(context, result),
                throwList: &throwTypes[..],
                throwList: vec::view⟨*Type⟩(&throwTypes),
                isUnsafe: info.isUnsafe,
                localCount: info.localCount,
            };
            return Type::Fn(fnType);
        }

}

/// Returns an error, if any, associated with the given node.
fn errorForNode(self: *Resolver, node: *ast::Node) -> ?*Error {
    for i in 0..self.errors.len {
        let err = &self.errors[i];
        let err = &self.errors.data[i];
        if err.node == node {
            return err;
        }
    }
    return nil;

        unsafeDepth: 0,
        config,
        arena,
        nodeData: NodeDataTable { entries: storage.nodeData },
        types: nil,
        errors: @sliceOf(storage.errors.ptr, 0, storage.errors.len),
        errors: vec::Vec⟨Error⟩ { data: storage.errors, len: 0 },
        // TODO: Shouldn't be undefined.
        moduleGraph: undefined,
        moduleScopes,
        instances: undefined,
        instancesLen: 0,

        genericDataSpecializations: nil,
        genericRoots: 0,
        genericSpecializationCount: 0,
    };
}
/// Return the diagnostics collected by the resolver.
fn diagnostics(self: *mut Resolver) -> Diagnostics {
    return Diagnostics { errors: vec::viewMut⟨Error⟩(&mut self.errors) };
}

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

}

/// Record an error diagnostic and return an error sentinel suitable for throwing.
fn emitError(self: *mut Resolver, node: ?*ast::Node, kind: ErrorKind) -> ResolveError {
    // If our error list is full, just return an error without recording it.
    if self.errors.len >= self.errors.cap {
    if self.errors.len >= self.errors.data.len {
        return ResolveError::Failure;
    }
    // Don't record more than one error per node.
    if let n = node; errorForNode(self, n) <> nil {
        return ResolveError::Failure;
    }
    let idx = self.errors.len;
    set self.errors = @sliceOf(self.errors.ptr, idx + 1, self.errors.cap);
    set self.errors[idx] = Error { kind, node, moduleId: self.currentMod };
    assert vec::push⟨Error⟩(
        &mut self.errors,
        Error { kind, node, moduleId: self.currentMod },
    ), "emitError: error storage unexpectedly full";

    return ResolveError::Failure;
}

/// Like [`emitError`], but for type mismatches specifically.

fn recordGenericTypeUse(self: *mut Resolver, site: *ast::Node, ty: Type) {
    let current = self.currentGenericTemplate else return;
    if not containsGenericParameter(ty) {
        return;
    }
    current.typeUses.append(
    vec::append⟨GenericTypeUse⟩(
        &mut current.typeUses,
        GenericTypeUse { site, ty },
        alloc::arenaAllocator(&mut self.arena),
    );
}


}

/// Associate slice range metadata with a subscript expression.
fn setSliceRangeInfo(self: *mut Resolver, node: *ast::Node, info: SliceRangeInfo) {
    recordGenericTypeUse(self, node, *info.itemType);
    if let length = info.capacity {
        recordGenericTypeUse(self, node, *length);
    }
    set self.nodeData.entries[node.id].extra = NodeExtra::SliceRange(info);
}

/// Associate union variant metadata with a pattern or constructor node.
fn setVariantInfo(self: *mut Resolver, node: *ast::Node, ordinal: u32, tag: u32) {

fn setForLoopInfo(self: *mut Resolver, node: *ast::Node, info: ForLoopInfo) {
    set self.nodeData.entries[node.id].extra = NodeExtra::ForLoop(info);
    match info {
        case ForLoopInfo::Range { valType, .. } =>
            recordGenericTypeUse(self, node, *valType),
        case ForLoopInfo::Collection { elemType, .. } =>
            recordGenericTypeUse(self, node, *elemType),
        case ForLoopInfo::Collection { elemType, length, .. } => {
            recordGenericTypeUse(self, node, *elemType);
            if let descriptor = length {
                recordGenericTypeUse(self, node, *descriptor);
            }
        }
    }
}

/// Retrieve the constant value associated with a node, if any.
export fn constValueEntry(self: *Resolver, node: *ast::Node) -> ?ConstValue {

        }
    }
    return layout;
}

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

/// Get the layout of an optional type.

    match to {
        case Type::Array(lhs) => {
            let case Type::Array(rhs) = from
                else return nil;

            if lhs.length <> rhs.length {
            if not typesEqual(*lhs.length, *rhs.length) {
                return nil;
            }
            // For array literals, check each element individually for
            // assignability.
            match rval.value {
                case ast::NodeValue::ArrayLit(items) => {
                    if rhs.length == 0 and lhs.length == 0 {
                    if let length = concreteArrayLength(lhs.length); length == 0 {
                        return Coercion::Identity;
                    }
                    // TODO: This won't work, because we should be setting coercions
                    // for every list item, but we don't. It's best to not have an
                    // `isAssignable` function and just have one that records coercions.

            }
            return bEnd == nil;
        }
        case Type::Array(aa) => {
            let case Type::Array(ab) = b else return false;
            return aa.length == ab.length and typesEqual(*aa.item, *ab.item);
            return typesEqual(*aa.length, *ab.length)
                and typesEqual(*aa.item, *ab.item);
        }
        case Type::Optional(oa) => {
            let case Type::Optional(ob) = b else return false;
            return typesEqual(*oa, *ob);
        }

            case 1 => return RecordField {
                name: LEN_FIELD,
                fieldType: Type::U32,
                offset: PTR_SIZE as i32,
            },
            case 2 => return RecordField {
                name: CAP_FIELD,
                fieldType: Type::U32,
                offset: PTR_SIZE as i32 + 4,
            },
            else => return nil,
        }
    }
    if let case Type::Nominal(NominalType::Record(recInfo)) = ty;
        index < recInfo.fields.len

) -> RecordType throws (ResolveError) {
    if fields.len > parser::MAX_RECORD_FIELDS {
        throw emitError(self, node, ErrorKind::Internal);
    }
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut result: *mut [RecordField] = &mut [];
    let mut result = vec::Vec⟨RecordField⟩ { data: &mut [], len: 0 };
    let mut offset: u32 = 0;
    let mut alignment: u32 = 1;
    for fieldNode, i in fields {
        let case ast::NodeValue::RecordField {
            field: nameNode,

        if labeled {
            let requiredName = nameNode
                else panic "buildRecordType: labeled record field missing name";
            set name = try nodeName(self, requiredName);
        }
        result.append(RecordField {
        vec::append⟨RecordField⟩(&mut result, RecordField {
            name,
            fieldType,
            offset: offset as i32,
        }, a);
        set offset += layout.size;
        set alignment = max(alignment, layout.alignment);
    }
    return RecordType {
        fields: &result[..],
        fields: vec::view⟨RecordField⟩(&result),
        labeled,
        layout: Layout {
            size: mem::alignUp(offset, alignment),
            alignment,
        },

    source: AggregateMemberSource,
) -> UnionType throws (ResolveError) {
    assert decl.variants.len <= MAX_UNION_VARIANTS,
        "buildUnionType: maximum union variants exceeded";
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut variants: *mut [UnionVariant] = &mut [];
    let mut variants = vec::Vec⟨UnionVariant⟩ { data: &mut [], len: 0 };
    let mut iota: u32 = 0;
    let mut tagSubstitution: ?*Substitution = nil;
    if let case AggregateMemberSource::Generic {
        substitution, ..
    } = source {

            name,
            variantNode,
            0,
        );
        set symbol.moduleId = owner.moduleId;
        variants.append(UnionVariant { name, valueType, symbol }, a);
        vec::append⟨UnionVariant⟩(
            &mut variants, UnionVariant { name, valueType, symbol }, a
        );
    }
    let info = computeUnionLayout(&variants[..]);
    let variantView = vec::view⟨UnionVariant⟩(&variants);
    let info = computeUnionLayout(variantView);
    return UnionType {
        variants: &variants[..],
        variants: variantView,
        layout: info.layout,
        valOffset: info.valOffset,
        isAllVoid: info.isAllVoid,
        declaredLinear,
    };

            expected: template.params.len,
            actual: app.args.len,
        }));
    }
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut args: *mut [*Type] = &mut [];
    let mut args = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
    for argNode, i in app.args {
        let argType = try resolveGenericArgument(self, argNode, template.params[i]);
        if containsGenericParameter(argType) {
            throw emitError(self, argNode, ErrorKind::GenericConcreteArgumentsRequired);
        }
        args.append(allocType(self, argType), a);
        vec::append⟨*Type⟩(&mut args, allocType(self, argType), a);
    }
    let nominal = try specializeGenericData(
        self, node, templateSym, &args[..], rooted
        self, node, templateSym, vec::view⟨*Type⟩(&args), rooted
    );

    setNodeSymbol(self, node, templateSym);
    setNodeType(self, node, Type::Nominal(nominal));
    return nominal;

            expected: template.params.len,
            actual: app.args.len,
        }));
    }
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut args: *mut [*Type] = &mut [];
    let mut args = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
    let caller = currentGenericTemplateSymbol(self);
    for argNode, i in app.args {
        let argType = try resolveGenericArgument(self, argNode, template.params[i]);
        let symbolic = containsGenericParameter(argType);
        if symbolic and caller == nil {

                        self, argNode, ErrorKind::GenericBoundUnsatisfied(bound.name)
                    );
                }
            }
        }
        args.append(allocType(self, argType), a);
        vec::append⟨*Type⟩(&mut args, allocType(self, argType), a);
    }
    let argsView = vec::view⟨*Type⟩(&args);
    if rooted {
        if caller <> nil {
            throw emitError(self, node, ErrorKind::GenericConcreteArgumentsRequired);
        }
        let specialization = try internGenericFnSpecialization(
            self, templateSym, &args[..], node, 0
            self, templateSym, argsView, node, 0
        );
        setNodeSymbol(self, node, templateSym);
        setNodeType(self, node, Type::Fn(specialization.fnType));
        set self.nodeData.entries[node.id].extra =
            NodeExtra::GenericFnCall(specialization);
        return specialization.fnType;
    }
    if caller == nil {
        if let existing = findGenericFnSpecialization(self, templateSym, &args[..]) {
        if let existing = findGenericFnSpecialization(self, templateSym, argsView) {
            setNodeSymbol(self, node, templateSym);
            setNodeType(self, node, Type::Fn(existing.fnType));
            set self.nodeData.entries[node.id].extra =
                NodeExtra::GenericFnCall(existing);
            return existing.fnType;
        }
    }
    let sub = Substitution { params: template.params, args: &args[..] };
    let sub = Substitution { params: template.params, args: argsView };
    let applied = try substituteType(self, Type::Fn(signature), &sub, node);
    let case Type::Fn(appliedFn) = applied
        else throw emitError(self, node, ErrorKind::Internal);
    recordGenericFnDependency(
        self, node, caller, templateSym, &args[..], appliedFn
        self, node, caller, templateSym, argsView, appliedFn
    );
    return appliedFn;
}

/// Expand explicit roots through symbolic generic calls to a fixed point.

        };
        let mut edge = self.genericFnDependencies;
        while let dependency = edge {
            if dependency.caller == specialization.template {
                let a = alloc::arenaAllocator(&mut self.arena);
                let mut concreteArgs: *mut [*Type] = &mut [];
                let mut concreteArgs = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
                for arg in dependency.args {
                    let concrete = try substituteType(
                        self, *arg, &callerSub, dependency.site
                    );
                    if containsGenericParameter(concrete) {

                            self,
                            dependency.site,
                            ErrorKind::GenericConcreteArgumentsRequired,
                        );
                    }
                    concreteArgs.append(allocType(self, concrete), a);
                    vec::append⟨*Type⟩(
                        &mut concreteArgs, allocType(self, concrete), a
                    );
                }
                let concreteArgsView = vec::view⟨*Type⟩(&concreteArgs);
                let calleeTemplate = genericTemplateFor(self, dependency.callee)
                    else throw emitError(
                        self, dependency.site, ErrorKind::Internal
                    );
                for arg, i in concreteArgs {
                for arg, i in concreteArgsView {
                    for bound in calleeTemplate.params[i].bounds {
                        if findInstance(self, bound, *arg) == nil {
                            throw emitError(
                                self,
                                dependency.site,

                    }
                }
                let concreteCallee = try internGenericFnSpecialization(
                    self,
                    dependency.callee,
                    &concreteArgs[..],
                    concreteArgsView,
                    dependency.site,
                    specialization.depth + 1,
                );
                let resolution = try! alloc::alloc(
                    &mut self.arena,

        );
        let sub = Substitution {
            params: template.params,
            args: specialization.args,
        };
        for typeUse in template.typeUses {
        for typeUse in vec::view⟨GenericTypeUse⟩(&template.typeUses) {
            let concrete = try substituteType(
                self, typeUse.ty, &sub, typeUse.site
            );
            if containsGenericParameter(concrete) {
                throw emitError(

) -> *[*GenericParamType] throws (ResolveError) {
    if nodes.len > MAX_GENERIC_PARAMS {
        throw emitError(self, owner, ErrorKind::GenericParameterLimit);
    }
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut result: *mut [*GenericParamType] = &mut [];
    let mut result = vec::Vec⟨*GenericParamType⟩ { data: &mut [], len: 0 };
    for paramNode, index in nodes {
        let case ast::NodeValue::GenericParam(param) = paramNode.value
            else throw emitError(self, paramNode, ErrorKind::Internal);
        let mut paramName: *[u8] = undefined;
        let mut nameNode: *ast::Node = undefined;
        let mut traitBounds: *mut [*TraitType] = &mut [];
        let mut traitBounds = vec::Vec⟨*TraitType⟩ { data: &mut [], len: 0 };
        let mut constType: ?*Type = nil;
        match param {
            case ast::GenericParam::Const { name, type } => {
                set nameNode = name;
                set paramName = try nodeName(self, name);

                    let boundSym = try resolveNamePath(self, bound);
                    let case SymbolData::Trait(traitInfo) = boundSym.data else {
                        throw emitError(self, bound, ErrorKind::GenericBoundNotTrait);
                    };
                    setNodeSymbol(self, bound, boundSym);
                    traitBounds.append(traitInfo, a);
                    vec::append⟨*TraitType⟩(&mut traitBounds, traitInfo, a);
                }
            }
        }
        let used = try! alloc::alloc(
            &mut self.arena, @sizeOf(bool), @alignOf(bool)

        set *p = GenericParamType {
            owner,
            node: paramNode,
            name: paramName,
            index,
            bounds: &traitBounds[..],
            bounds: vec::view⟨*TraitType⟩(&traitBounds),
            used,
            constType,
        };
        let data = SymbolData::ConstParameter(p) if constType <> nil
            else SymbolData::TypeParameter(p);

            setNodeType(self, paramNode, *ty);
        } else {
            setNodeType(self, nameNode, Type::Parameter(p));
            setNodeType(self, paramNode, Type::Parameter(p));
        }
        result.append(p, a);
        vec::append⟨*GenericParamType⟩(&mut result, p, a);
    }
    return &result[..];
    return vec::view⟨*GenericParamType⟩(&result);
}

/// Retrieve sparse metadata for a generic declaration symbol.
export fn genericTemplateFor(self: *Resolver, symbol: *Symbol) -> ?*GenericTemplate {
    let mut cursor = self.genericTemplates;

        {
            throw emitError(self, node, ErrorKind::GenericFnAttribute);
        }
    }
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut paramTypes: *mut [*Type] = &mut [];
    let mut throwList: *mut [*Type] = &mut [];
    let mut paramTypes = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
    let mut throwList = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
    let mut fnType = FnType {
        paramTypes: &[],
        returnType: allocType(self, Type::Void),
        throwList: &[],
        isUnsafe: ast::hasAttribute(attrMask, ast::Attribute::Unsafe),

            self, paramNode, typeContext
        ) catch e {
            exitFn(self);
            throw e;
        };
        paramTypes.append(allocType(self, paramTy), a);
        vec::append⟨*Type⟩(&mut paramTypes, allocType(self, paramTy), a);
    }

    if decl.sig.throwList.len > MAX_FN_THROWS {
        exitFn(self);
        throw emitError(self, node, ErrorKind::FnThrowOverflow(CountMismatch {

        };
        try ensureStorableType(self, throwNode, throwTy) catch e {
            exitFn(self);
            throw e;
        };
        throwList.append(allocType(self, throwTy), a);
        vec::append⟨*Type⟩(&mut throwList, allocType(self, throwTy), a);
    }
    exitFn(self);
    set fnType.paramTypes = &paramTypes[..];
    set fnType.throwList = &throwList[..];
    set fnType.paramTypes = vec::view⟨*Type⟩(&paramTypes);
    set fnType.throwList = vec::view⟨*Type⟩(&throwList);

    let fnInfo = allocFnType(self, fnType);
    let ty = Type::Fn(fnInfo);
    let sym = try bindValueIdent(self, decl.name, node, ty, false, 0, attrMask)
        else throw emitError(self, node, ErrorKind::ExpectedIdentifier);

            params: genericParams,
            signature: fnInfo,
            members: &[],
            declaredLinear: false,
            bodyResolved: false,
            typeUses: &mut [],
            typeUses: vec::Vec⟨GenericTypeUse⟩ { data: &mut [], len: 0 },
            next: nil,
        });
    }
    return ty;
}

        params: genericParams,
        signature: nil,
        members: &[],
        declaredLinear,
        bodyResolved: true,
        typeUses: &mut [],
        typeUses: vec::Vec⟨GenericTypeUse⟩ { data: &mut [], len: 0 },
        next: nil,
    });
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut memberTypes: *mut [*Type] = &mut [];
    let mut memberTypes = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
    for member in members {
        let memberTy = try resolveGenericDataMember(self, member) catch e {
            exitScope(self);
            throw e;
        };
        memberTypes.append(allocType(self, memberTy), a);
        vec::append⟨*Type⟩(&mut memberTypes, allocType(self, memberTy), a);
    }
    exitScope(self);
    set metadata.members = &memberTypes[..];
    set metadata.members = vec::view⟨*Type⟩(&memberTypes);
}

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

    };
    set *entry = TraitType {
        name,
        moduleId: self.currentMod,
        nodeId: node.id,
        methods: &mut [],
        supertraits: &mut [],
        methods: vec::Vec⟨TraitMethod⟩ { data: &mut [], len: 0 },
        supertraits: vec::Vec⟨*TraitType⟩ { data: &mut [], len: 0 },
        selfType,
        state: TraitState::Queued,
        objectSafe: true,
    };
    return entry;

}

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


                expected: ast::MAX_TRAIT_METHODS,
                actual: traitType.methods.len as u32 + superTrait.methods.len as u32,
            }));
        }
        // Copy inherited methods into this trait's method table.
        for inherited in superTrait.methods {
        for inherited in vec::view⟨TraitMethod⟩(&superTrait.methods) {
            if let _ = findTraitMethod(traitType, inherited.name) {
                throw emitError(self, superNode, ErrorKind::DuplicateBinding(inherited.name));
            }
            traitType.methods.append(TraitMethod {
            vec::append⟨TraitMethod⟩(&mut traitType.methods, TraitMethod {
                name: inherited.name,
                fnType: inherited.fnType,
                mutable: inherited.mutable,
                receiverClass: inherited.receiverClass,
                owner: inherited.owner,
                index: traitType.methods.len as u32,
                index: traitType.methods.len,
            }, a);
        }
        traitType.supertraits.append(superTrait, a);
        vec::append⟨*TraitType⟩(&mut traitType.supertraits, superTrait, a);
        if not superTrait.objectSafe {
            set traitType.objectSafe = false;
        }
    }


        if receiverTargetName <> traitType.name {
            throw emitError(self, receiver, ErrorKind::TraitReceiverMismatch);
        }
        // Resolve parameter types and return type.
        let a = alloc::arenaAllocator(&mut self.arena);
        let mut paramTypes: *mut [*Type] = &mut [];
        let mut throwList: *mut [*Type] = &mut [];
        let mut paramTypes = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
        let mut throwList = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
        let mut retType = allocType(self, Type::Void);

        if sig.params.len > MAX_FN_PARAMS {
            throw emitError(self, methodNode, ErrorKind::FnParamOverflow(CountMismatch {
                expected: MAX_FN_PARAMS,

        }
        for paramNode in sig.params {
            let case ast::NodeValue::FnParam(param) = paramNode.value
                else throw emitError(self, paramNode, ErrorKind::ExpectedIdentifier);
            let paramTy = try resolveTraitSignatureType(self, traitType, param.type);
            paramTypes.append(allocType(self, paramTy), a);
            vec::append⟨*Type⟩(&mut paramTypes, allocType(self, paramTy), a);
        }
        if let ret = sig.returnType {
            set retType = allocType(
                self, try resolveTraitSignatureType(self, traitType, ret)
            );

                actual: sig.throwList.len,
            }));
        }
        for throwNode in sig.throwList {
            let throwTy = try resolveTraitSignatureType(self, traitType, throwNode);
            throwList.append(allocType(self, throwTy), a);
            vec::append⟨*Type⟩(&mut throwList, allocType(self, throwTy), a);
        }
        let fnType = FnType {
            paramTypes: &paramTypes[..],
            paramTypes: vec::view⟨*Type⟩(&paramTypes),
            returnType: retType,
            throwList: &throwList[..],
            throwList: vec::view⟨*Type⟩(&throwList),
            isUnsafe: ast::hasAttribute(attrMask, ast::Attribute::Unsafe),
            localCount: 0,
        };
        if containsGenericParameter(Type::Fn(&fnType)) {
            set traitType.objectSafe = false;
        }
        traitType.methods.append(TraitMethod {
        vec::append⟨TraitMethod⟩(&mut traitType.methods, TraitMethod {
            name: methodName,
            fnType: allocFnType(self, fnType),
            mutable,
            receiverClass,
            owner: traitType,
            index: traitType.methods.len as u32,
            index: traitType.methods.len,
        }, a);

        setNodeType(self, methodNode, Type::Void);
    }
    set traitType.state = TraitState::Complete;

            }
        }

        // Build final function type: receiver plus trait's canonical types.
        let a = alloc::arenaAllocator(&mut self.arena);
        // TODO: Improve this pattern, maybe via something like `(&[]).append(..)`?
        let mut paramTypes: *mut [*Type] = &mut [];
        paramTypes.append(allocType(self, receiverPtrType), a);
        let mut paramTypes = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
        vec::append⟨*Type⟩(
            &mut paramTypes, allocType(self, receiverPtrType), a
        );

        for ty in expectedFn.paramTypes {
            paramTypes.append(ty, a);
            vec::append⟨*Type⟩(&mut paramTypes, ty, a);
        }
        let fnType = FnType {
            paramTypes: &paramTypes[..],
            paramTypes: vec::view⟨*Type⟩(&paramTypes),
            returnType: expectedFn.returnType,
            throwList: expectedFn.throwList,
            isUnsafe: expectedFn.isUnsafe,
            localCount: 0,
        };

        set entry.methods[tm.index] = sym;
        set covered[tm.index] = true;
    }

    // Fill inherited method slots from supertrait instances.
    for superTrait in traitInfo.supertraits {
    for superTrait in vec::view⟨*TraitType⟩(&traitInfo.supertraits) {
        let superInst = findInstance(self, superTrait, concreteType)
            else throw emitError(self, node, ErrorKind::MissingSupertraitInstance(superTrait.name));
        for superMethod, mi in superTrait.methods {
        for superMethod, mi in vec::view⟨TraitMethod⟩(&superTrait.methods) {
            let merged = findTraitMethod(traitInfo, superMethod.name)
                else panic "resolveInstanceDecl: inherited method not found";
            if not covered[merged.index] {
                set entry.methods[merged.index] = superInst.methods[mi];
                set covered[merged.index] = true;
            }
        }
    }

    // Check that all trait methods are implemented.
    for method, i in traitInfo.methods {
    for method, i in vec::view⟨TraitMethod⟩(&traitInfo.methods) {
        if not covered[i] {
            throw emitError(self, node, ErrorKind::MissingTraitMethod(method.name));
        }
    }
    set self.instances[self.instancesLen] = entry;

        throw emitError(self, name, ErrorKind::DuplicateBinding(methodName));
    }

    // Resolve parameter types.
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut paramTypes: *mut [*Type] = &mut [];
    let mut paramTypes = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };

    // Receiver is the first parameter.
    let receiverPtrType = Type::Pointer(PointerType {
        class: receiver.class,
        target: allocType(self, concreteType),
        mutable: receiver.mutable,
    });
    paramTypes.append(allocType(self, receiverPtrType), a);
    vec::append⟨*Type⟩(
        &mut paramTypes, allocType(self, receiverPtrType), a
    );

    for paramNode in sig.params {
        let case ast::NodeValue::FnParam(param) = paramNode.value
            else throw emitError(self, paramNode, ErrorKind::ExpectedIdentifier);
        let paramTy = try resolveValueType(self, param.type);
        paramTypes.append(allocType(self, paramTy), a);
        vec::append⟨*Type⟩(&mut paramTypes, allocType(self, paramTy), a);
    }

    // Resolve return type.
    let mut returnType = Type::Void;
    if let retNode = sig.returnType {
        set returnType = try resolveValueType(self, retNode);
    }

    // Resolve throw list.
    let mut throwTypes: *mut [*Type] = &mut [];
    let mut throwTypes = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
    for throwNode in sig.throwList {
        let throwTy = try resolveValueType(self, throwNode);
        throwTypes.append(allocType(self, throwTy), a);
        vec::append⟨*Type⟩(&mut throwTypes, allocType(self, throwTy), a);
    }

    let retTypePtr = allocType(self, returnType);
    let throwList = &throwTypes[..];
    let throwList = vec::view⟨*Type⟩(&throwTypes);
    let paramTypesView = vec::view⟨*Type⟩(&paramTypes);

    let isUnsafe = ast::hasAttribute(attrMask, ast::Attribute::Unsafe);
    // Full function type (receiver + params) for lowering.
    let fullFnType = FnType {
        paramTypes: &paramTypes[..],
        paramTypes: paramTypesView,
        returnType: retTypePtr,
        throwList,
        isUnsafe,
        localCount: 0,
    };
    let fnTy = Type::Fn(allocFnType(self, fullFnType));

    // Function type excluding receiver, for call arg checking.
    let checkFnType = FnType {
        paramTypes: &paramTypes[1..],
        paramTypes: &paramTypesView[1..],
        returnType: retTypePtr,
        throwList,
        isUnsafe,
        localCount: 0,
    };

                } else => {}
            }
        }
        case Type::Array(arrayInfo) => {
            if let case ast::NodeValue::ArrayLit(items) = pattern.value {
                if items.len as u32 <> arrayInfo.length {
                let length = concreteArrayLength(arrayInfo.length)
                    else throw emitError(self, pattern, ErrorKind::ConstExprRequired);
                if items.len as u32 <> length {
                    throw emitError(self, pattern, ErrorKind::RecordFieldCountMismatch(
                        CountMismatch { expected: arrayInfo.length, actual: items.len as u32 }
                        CountMismatch { expected: length, actual: items.len as u32 }
                    ));
                }
                let elemTy = *arrayInfo.item;
                for item in items {
                    try resolveCasePattern(self, item, elemTy, IdentMode::Bind, matchBy);

    self: *mut Resolver,
    node: *ast::Node,
    kind: ast::Builtin,
    args: *mut [*ast::Node]
) -> Type throws (ResolveError) {
    // Handle `@sliceOf(ptr, len)` and `@sliceOf(ptr, len, cap)`.
    // Handle `@sliceOf(ptr, len)`.
    if kind == ast::Builtin::SliceOf {
        if args.len <> 2 and args.len <> 3 {
        if args.len <> 2 {
            throw emitError(self, node, ErrorKind::BuiltinArgCountMismatch(CountMismatch {
                expected: 2,
                actual: args.len as u32,
            }));
        }
        let ptrType = try visit(self, args[0], Type::Unknown);
        let case Type::Pointer(ptr) = ptrType else {
            throw emitError(self, node, ErrorKind::ExpectedPointer);
        };
        let _ = try checkAssignable(self, args[1], Type::U32);
        if args.len == 3 {
            let _ = try checkAssignable(self, args[2], Type::U32);
        }
        return setNodeType(self, node, Type::Slice(SliceType {
            class: ptr.class,
            item: ptr.target,
            mutable: ptr.mutable,
        }));
    }
    if kind == ast::Builtin::Relocate {
        if args.len <> 2 {
            throw emitError(self, node, ErrorKind::BuiltinArgCountMismatch(CountMismatch {
                expected: 2,
                actual: args.len as u32,
            }));
        }
        let destinationType = try visit(self, args[0], Type::Unknown);
        let case Type::Slice(destination) = destinationType else {
            throw emitError(self, args[0], ErrorKind::ExpectedIndexable);
        };
        if not destination.mutable or not typesEqual(*destination.item, Type::U8) {
            throw emitTypeMismatch(self, args[0], TypeMismatch {
                expected: Type::Slice(SliceType {
                    class: destination.class,
                    item: allocType(self, Type::U8),
                    mutable: true,
                }),
                actual: destinationType,
            });
        }
        let sourceType = try visit(self, args[1], Type::Unknown);
        let case Type::Slice(source) = sourceType else {
            throw emitError(self, args[1], ErrorKind::ExpectedIndexable);
        };
        if not source.mutable or not typesEqual(*source.item, Type::U8) {
            throw emitTypeMismatch(self, args[1], TypeMismatch {
                expected: Type::Slice(SliceType {
                    class: source.class,
                    item: allocType(self, Type::U8),
                    mutable: true,
                }),
                actual: sourceType,
            });
        }
        return setNodeType(self, node, Type::Void);
    }
    if args.len <> 1 {
        throw emitError(self, node, ErrorKind::BuiltinArgCountMismatch(CountMismatch {
            expected: 1,
            actual: args.len as u32,
        }));
    }

    let ty = try resolveValueType(self, args[0]);
    recordGenericTypeUse(self, node, ty);
    if containsGenericParameter(ty) {
        return setNodeType(self, node, Type::U32);
    }
    // Ensure the type body is resolved before computing layout.
    // TODO: Somehow, ensuring the type is resolved should just happen all
    // the time, lazily.
    try ensureTypeResolved(self, ty, args[0]);
    if containsGenericParameter(ty) {
        throw emitError(self, args[0], ErrorKind::GenericLayoutRequired);
    }
    // TODO: This should be stored in `symbol` instead of having to recompute it.
    // That way there's a canonical place to look for code gen.
    let layout = getTypeLayout(ty);

    // Evaluate the built-in.
    let mut value: u32 = undefined;
    match kind {
        case ast::Builtin::SizeOf => {
            set value = layout.size;

            set value = layout.alignment;
        },
        case ast::Builtin::SliceOf => {
            panic "unreachable: @sliceOf handled above";
        }
        case ast::Builtin::Relocate => {
            panic "resolveBuiltinCall: unreachable relocation builtin";
        }
    }
    // Record as constant value for constant folding.
    setNodeConstValue(self, node, ConstValue::Int(ConstInt {
        magnitude: value as u64,
        bits: 32,

                return true;
            }
        }
        return typesEqual(pattern, evidence);
    }
    if let case Type::ConstParameter(param) = pattern {
        let case Type::ConstArgument { .. } = actual else return false;
        for candidate, i in params {
            if candidate == param {
                if let prior = inferred[i] {
                    return typesEqual(*prior, actual);
                }
                set inferred[i] = allocType(self, actual);
                return true;
            }
        }
        return typesEqual(pattern, actual);
    }
    if typesEqual(pattern, actual) {
        return true;
    }
    if not containsGenericParameter(pattern) {
        return true;

                self, *inner, *actualInner, params, inferred
            );
        }
        case Type::Array(array) => {
            let case Type::Array(actualArray) = actual else return false;
            return array.length == actualArray.length and inferGenericArgument(
            return inferGenericArgument(
                self, *array.length, *actualArray.length, params, inferred
            ) and inferGenericArgument(
                self, *array.item, *actualArray.item, params, inferred
            );
        }
        case Type::GenericDataApply(application) => {
            let case Type::Nominal(nominal) = actual else return false;

        &mut inferred[..],
    ) {
        throw emitError(self, callee, ErrorKind::GenericInferenceConflict);
    }
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut args: *mut [*Type] = &mut [];
    let mut args = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
    for _, i in template.params {
        let arg = inferred[i] else {
            throw emitError(
                self, callee, ErrorKind::GenericInferenceIncomplete
            );
        };
        args.append(arg, a);
        vec::append⟨*Type⟩(&mut args, arg, a);
    }
    for arg, i in args {
    let argsView = vec::view⟨*Type⟩(&args);
    for arg, i in argsView {
        if not containsGenericParameter(*arg) {
            for bound in template.params[i].bounds {
                if findInstance(self, bound, *arg) == nil {
                    throw emitError(
                        self,

                    );
                }
            }
        }
    }
    let sub = Substitution { params: template.params, args: &args[..] };
    let sub = Substitution { params: template.params, args: argsView };
    let applied = try substituteType(self, Type::Fn(signature), &sub, callee);
    let case Type::Fn(appliedFn) = applied
        else throw emitError(self, callee, ErrorKind::Internal);
    let caller = currentGenericTemplateSymbol(self);
    if caller == nil {
        if let existing = findGenericFnSpecialization(
            self, templateSym, &args[..]
            self, templateSym, argsView
        ) {
            setNodeSymbol(self, callee, templateSym);
            setNodeType(self, callee, Type::Fn(existing.fnType));
            set self.nodeData.entries[callee.id].extra =
                NodeExtra::GenericFnCall(existing);
            return existing.fnType;
        }
    }
    recordGenericFnDependency(
        self, callee, caller, templateSym, &args[..], appliedFn
        self, callee, caller, templateSym, argsView, appliedFn
    );
    return appliedFn;
}

/// Resolve `Trait::method(receiver, ...)` for a rigid bounded parameter.

        self, Type::Fn(method.fnType), &sub, node
    );
    let case Type::Fn(methodFn) = substituted
        else throw emitError(self, node, ErrorKind::Internal);
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut params: *mut [*Type] = &mut [];
    params.append(allocType(self, receiverTy), a);
    let mut params = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
    vec::append⟨*Type⟩(&mut params, allocType(self, receiverTy), a);
    for methodParam in methodFn.paramTypes {
        params.append(methodParam, a);
        vec::append⟨*Type⟩(&mut params, methodParam, a);
    }
    let fullFn = allocFnType(self, FnType {
        paramTypes: &params[..],
        paramTypes: vec::view⟨*Type⟩(&params),
        returnType: methodFn.returnType,
        throwList: methodFn.throwList,
        isUnsafe: methodFn.isUnsafe,
        localCount: 0,
    });

    call: ast::Call,
    ctx: CallCtx,
    expected: Type,
) -> Type throws (ResolveError)
{
    // Intercept method calls on slices before inferring the callee.
    if let case ast::NodeValue::FieldAccess(access) = call.callee.value {
        let parentTy = try infer(self, access.parent);
        if isUnsafePointerType(parentTy) {
            try requireUnsafe(self, access.parent);
        }

        let subjectTy = autoDeref(parentTy);

        if let case Type::Slice(slice) = subjectTy {
            let methodName = try nodeName(self, access.child);
            if methodName == "append" {
                return try resolveSliceAppend(
                    self, node, access.parent, parentTy, call.args, slice.item, slice.mutable
                );
            }
            if methodName == "delete" {
                return try resolveSliceDelete(
                    self, node, access.parent, call.args, slice.item, slice.mutable
                );
            }
        }
    }
    if let bounded = try resolveQualifiedGenericBoundCall(
        self, node, call, ctx
    ) {
        return bounded;
    }


    // Associate return type to call.
    return setNodeType(self, node, *info.returnType);
}

/// Resolve `slice.append(val, allocator)`.
fn resolveSliceAppend(
    self: *mut Resolver,
    node: *ast::Node,
    parent: *ast::Node,
    parentType: Type,
    args: *mut [*ast::Node],
    elemType: *Type,
    mutable: bool
) -> Type throws (ResolveError) {
    if not mutable {
        throw emitError(self, parent, ErrorKind::ImmutableBinding);
    }
    if args.len <> 2 {
        throw emitError(self, node, ErrorKind::FnArgCountMismatch(CountMismatch {
            expected: 2,
            actual: args.len as u32,
        }));
    }
    // First argument must be assignable to the element type.
    try checkAssignable(self, args[0], *elemType);
    // Second argument: the allocator. We accept any type -- the lowerer
    // reads `.func` and `.ctx` at fixed offsets.
    try visit(self, args[1], Type::Unknown);
    recordGenericTypeUse(self, node, *elemType);
    set self.nodeData.entries[node.id].extra = NodeExtra::SliceAppend { elemType };

    // Return the parent's type so the caller can rebind:
    return setNodeType(self, node, parentType);
}

/// Resolve `slice.delete(index)`.
fn resolveSliceDelete(
    self: *mut Resolver,
    node: *ast::Node,
    parent: *ast::Node,
    args: *mut [*ast::Node],
    elemType: *Type,
    mutable: bool
) -> Type throws (ResolveError) {
    if not mutable {
        throw emitError(self, parent, ErrorKind::ImmutableBinding);
    }
    if args.len <> 1 {
        throw emitError(self, node, ErrorKind::FnArgCountMismatch(CountMismatch {
            expected: 1,
            actual: args.len as u32,
        }));
    }
    try checkAssignable(self, args[0], Type::U32);
    recordGenericTypeUse(self, node, *elemType);
    set self.nodeData.entries[node.id].extra = NodeExtra::SliceDelete { elemType };

    return setNodeType(self, node, Type::Void);
}

/// Analyze an assignment expression.
fn resolveAssign(self: *mut Resolver, node: *ast::Node, assign: ast::Assign) -> Type
    throws (ResolveError)
{
    // Slice assignment: `slice[range] = value`.

            }
            let subjectTy = autoDeref(containerTy);
            try checkSliceRangeIndices(self, range);

            let mut item: *Type = undefined;
            let mut capacity: ?u32 = nil;
            let mut capacity: ?*Type = nil;

            if let case Type::Slice(slice) = subjectTy {
                if not slice.mutable {
                    throw emitError(self, container, ErrorKind::ImmutableBinding);
                }
                set item = slice.item;
            } else {
                match subjectTy {
                    case Type::Array(a) => {
                        try validateArraySliceBounds(self, range, a.length, node);
                        if let length = concreteArrayLength(a.length) {
                            try validateArraySliceBounds(self, range, length, node);
                        }
                        set item = a.item;
                        set capacity = a.length;
                    }
                    else => throw emitError(self, container, ErrorKind::ExpectedIndexable),
                }


    match subjectTy {
        case Type::Array(arrayInfo) => {
            return setNodeType(self, node, *arrayInfo.item);
        }
        case Type::GenericArray { item, .. } => {
            return setNodeType(self, node, *item);
        }
        else => {
            throw emitError(self, container, ErrorKind::ExpectedIndexable);
        }
    }
}

        }
    }
    if expectedTy == Type::Unknown {
        throw emitError(self, node, ErrorKind::CannotInferType);
    };
    let arrayTy = Type::Array(ArrayType { item: allocType(self, expectedTy), length });
    let arrayTy = Type::Array(ArrayType {
        item: allocType(self, expectedTy),
        length: allocConcreteArrayLength(self, length),
    });
    return setNodeType(self, node, arrayTy);
}

/// Analyze an array repeat literal expression.
fn resolveArrayRepeat(self: *mut Resolver, node: *ast::Node, lit: ast::ArrayRepeatLit, hint: Type) -> Type
    throws (ResolveError)
{
    let mut itemHint = hint;
    if let case Type::Array(ary) = hint {
        set itemHint = *ary.item;
    } else if let case Type::GenericArray { item, .. } = hint {
        set itemHint = *item;
    } else if let case Type::Optional(inner) = hint {
        if let case Type::Array(ary) = *inner {
            set itemHint = *ary.item;
        }
    }
    let valueTy = try visit(self, lit.item, itemHint);
    let _ = try checkNumeric(self, lit.count);
    let mut arrayTy: Type = undefined;
    let mut length: *Type = undefined;
    if let value = constValueEntry(self, lit.count) {
        if not validateConstIntRange(value, Type::U32) {
            throw emitError(self, lit.count, ErrorKind::NumericLiteralOverflow);
        }
        let case ConstValue::Int(int) = value
            else throw emitError(self, lit.count, ErrorKind::ConstExprRequired);
        set arrayTy = Type::Array(ArrayType {
            item: allocType(self, valueTy),
            length: int.magnitude as u32,
        });
        set length = allocConcreteArrayLength(self, int.magnitude as u32);
    } else if isConstExpr(self, lit.count) and
              containsGenericConstExpr(self, lit.count)
    {
        set arrayTy = Type::GenericArray {
            item: allocType(self, valueTy),
            length: lit.count,
        };
        set length = allocSymbolicArrayLength(self, lit.count);
    } else {
        throw emitError(self, lit.count, ErrorKind::ConstExprRequired);
    }
    return setNodeType(self, node, arrayTy);
    return setNodeType(self, node, Type::Array(ArrayType {
        item: allocType(self, valueTy),
        length,
    }));
}

/// Resolve union variant access.
fn resolveUnionVariantAccess(
    self: *mut Resolver,

        }
        if mem::eq(fieldName, LEN_FIELD) {
            setRecordFieldIndex(self, fieldNode, 1);
            return setNodeType(self, node, Type::U32);
        }
        if mem::eq(fieldName, CAP_FIELD) {
            setRecordFieldIndex(self, fieldNode, 2);
            return setNodeType(self, node, Type::U32);
        }
        throw emitError(self, node, ErrorKind::SliceFieldUnknown(fieldName));
    }
    if let case Type::TraitObject(traitObject) = subjectTy {
        let fieldName = try nodeName(self, access.child);
        let method = findTraitMethod(traitObject.traitInfo, fieldName)

        case Type::Array(arrayInfo) => {
            let fieldNode = access.child;
            let fieldName = try nodeName(self, fieldNode);

            if mem::eq(fieldName, LEN_FIELD) {
                let lengthConst = constInt(arrayInfo.length as u64, 32, false, false);
                setNodeConstValue(self, node, lengthConst);

                return setNodeType(self, node, Type::U32);
            }
            throw emitError(self, node, ErrorKind::ArrayFieldUnknown(fieldName));
        }

        case Type::GenericArray { .. } => {
            let fieldName = try nodeName(self, access.child);
            if mem::eq(fieldName, LEN_FIELD) {
                if let length = concreteArrayLength(arrayInfo.length) {
                    setNodeConstValue(
                        self, node, constInt(length as u64, 32, false, false)
                    );
                }
                return setNodeType(self, node, Type::U32);
            }

            throw emitError(self, node, ErrorKind::ArrayFieldUnknown(fieldName));
        }
        else => {
            // Check for standalone methods on any nominal type (e.g. unions).
            if let case Type::Nominal(_) = subjectTy {

            let subjectTy = autoDeref(containerTy);

            try checkSliceRangeIndices(self, range);

            let mut item: *Type = undefined;
            let mut capacity: ?u32 = nil;
            let mut capacity: ?*Type = nil;

            if let case Type::Slice(slice) = subjectTy {
                if addr.mutable and not slice.mutable {
                    throw emitError(self, addr.target, ErrorKind::ImmutableBinding);
                }
                set item = slice.item;
            } else {
                match subjectTy {
                    case Type::Array(arrayInfo) => {
                        try validateArraySliceBounds(self, range, arrayInfo.length, node);
                        if let length = concreteArrayLength(arrayInfo.length) {
                            try validateArraySliceBounds(self, range, length, node);
                        }
                        set item = arrayInfo.item;
                        set capacity = arrayInfo.length;
                    }
                    else => {
                        throw emitError(self, container, ErrorKind::ExpectedIndexable);

        }
    }
    // Derive a hint for the target type from the slice hint.
    let mut targetHint: Type = Type::Unknown;
    if let case Type::Slice(slice) = hint {
        set targetHint = Type::Array(ArrayType { item: slice.item, length: 0 });
        set targetHint = Type::Array(ArrayType {
            item: slice.item,
            length: allocConcreteArrayLength(self, 0),
        });
    }
    let targetTy = try visit(self, addr.target, targetHint);

    // Mark local variable symbols as address-taken so the lowerer
    // allocates a stack slot eagerly.

                else => panic "resolveTypeSyntax: invalid integer width",
            }
        }
        case ast::TypeSig::Array { itemType, length } => {
            let item = try resolveTypeSyntax(self, itemType, context);
            let mut lengthType: *Type = undefined;
            match context {
                case TypeSyntaxContext::Concrete => {
                    let concreteLength = try checkSizeInt(self, length);
                    set ty = Type::Array(ArrayType {
                        item: allocType(self, item),
                        length: concreteLength,
                    });
                    set lengthType = allocConcreteArrayLength(self, concreteLength);
                }
                case TypeSyntaxContext::Symbolic => {
                    let _ = try checkNumeric(self, length);
                    if let value = constValueEntry(self, length) {
                        if not validateConstIntRange(value, Type::U32) {

                        let case ConstValue::Int(int) = value else {
                            throw emitError(
                                self, length, ErrorKind::ConstExprRequired
                            );
                        };
                        set ty = Type::Array(ArrayType {
                            item: allocType(self, item),
                            length: int.magnitude as u32,
                        });
                        set lengthType = allocConcreteArrayLength(
                            self, int.magnitude as u32
                        );
                    } else if isConstExpr(self, length) and
                              containsGenericConstExpr(self, length)
                    {
                        set ty = Type::GenericArray {
                            item: allocType(self, item),
                            length,
                        };
                        set lengthType = allocSymbolicArrayLength(self, length);
                    } else {
                        throw emitError(
                            self, length, ErrorKind::ConstExprRequired
                        );
                    }
                }
            }
            set ty = Type::Array(ArrayType {
                item: allocType(self, item),
                length: lengthType,
            });
        }
        case ast::TypeSig::Slice { class, itemType, mutable } => {
            let item = try resolveTypeSyntax(self, itemType, context);
            set ty = Type::Slice(SliceType {
                class,

                                actual: app.args.len,
                            }),
                        );
                    }
                    let a = alloc::arenaAllocator(&mut self.arena);
                    let mut args: *mut [*Type] = &mut [];
                    let mut args = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
                    for argNode, i in app.args {
                        let arg = try resolveGenericArgument(
                            self, argNode, template.params[i]
                        );
                        args.append(allocType(self, arg), a);
                        vec::append⟨*Type⟩(&mut args, allocType(self, arg), a);
                    }
                    let symbolic = try! alloc::alloc(
                        &mut self.arena,
                        @sizeOf(GenericDataApplyType),
                        @alignOf(GenericDataApplyType),
                    ) as *mut GenericDataApplyType;
                    set *symbolic = GenericDataApplyType {
                        template: templateSym,
                        args: &args[..],
                        args: vec::view⟨*Type⟩(&args),
                        site: name,
                    };
                    return setNodeType(
                        self, node, Type::GenericDataApply(symbolic)
                    );

                        self, NominalType::Record(recordType)
                    ));
                }
                case TypeSyntaxContext::Symbolic => {
                    let a = alloc::arenaAllocator(&mut self.arena);
                    let mut result: *mut [RecordField] = &mut [];
                    let mut result = vec::Vec⟨RecordField⟩ {
                        data: &mut [],
                        len: 0,
                    };
                    for field in fields {
                        let case ast::NodeValue::RecordField {
                            field: fieldNameNode,
                            type: typeNode,
                            value,

                        }
                        let mut fieldName: ?*[u8] = nil;
                        if let nameNode = fieldNameNode {
                            set fieldName = try nodeName(self, nameNode);
                        }
                        result.append(RecordField {
                        vec::append⟨RecordField⟩(&mut result, RecordField {
                            name: fieldName,
                            fieldType,
                            offset: -1,
                        }, a);
                    }

                        &mut self.arena,
                        @sizeOf(GenericRecordType),
                        @alignOf(GenericRecordType),
                    ) as *mut GenericRecordType;
                    set *genericRecord = GenericRecordType {
                        fields: &result[..],
                        fields: vec::view⟨RecordField⟩(&result),
                        labeled,
                    };
                    set ty = Type::GenericRecord(genericRecord);
                }
            }

                        actual: signature.throwList.len,
                    }
                ));
            }
            let a = alloc::arenaAllocator(&mut self.arena);
            let mut params: *mut [*Type] = &mut [];
            let mut throwTypes: *mut [*Type] = &mut [];
            let mut params = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
            let mut throwTypes = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
            for param in signature.params {
                let paramType = try resolveContextualValueType(
                    self, param, context
                );
                params.append(allocType(self, paramType), a);
                vec::append⟨*Type⟩(&mut params, allocType(self, paramType), a);
            }
            for throwNode in signature.throwList {
                let throwType = try resolveContextualValueType(
                    self, throwNode, context
                );
                try ensureStorableType(self, throwNode, throwType);
                throwTypes.append(allocType(self, throwType), a);
                vec::append⟨*Type⟩(&mut throwTypes, allocType(self, throwType), a);
            }
            let mut returnType = allocType(self, Type::Void);
            if let returnNode = signature.returnType {
                let resolved = try resolveContextualValueType(
                    self, returnNode, context
                );
                try ensureStorableType(self, returnNode, resolved);
                set returnType = allocType(self, resolved);
            }
            set ty = Type::Fn(allocFnType(self, FnType {
                paramTypes: &params[..],
                paramTypes: vec::view⟨*Type⟩(&params),
                returnType,
                throwList: &throwTypes[..],
                throwList: vec::view⟨*Type⟩(&throwTypes),
                isUnsafe: false,
                localCount: 0,
            }));
        }
        case ast::TypeSig::TraitObject { class, traitName, mutable } => {

export fn resolveExpr(
    self: *mut Resolver, expr: *ast::Node, arena: *mut ast::NodeArena
) -> Diagnostics throws (ResolveError) {
    let a = alloc::arenaAllocator(&mut arena.arena);
    let exprStmt = ast::synthNode(arena, ast::NodeValue::ExprStmt(expr));
    let bodyStmts = ast::nodeSlice(arena, 1).append(exprStmt, a);
    let module = ast::synthFnModule(arena, ANALYZE_EXPR_FN_NAME, bodyStmts);
    let mut bodyStmts = ast::nodeVec(arena, 1);
    vec::append⟨*ast::Node⟩(&mut bodyStmts, exprStmt, a);
    let module = ast::synthFnModule(
        arena,
        ANALYZE_EXPR_FN_NAME,
        vec::viewMut⟨*ast::Node⟩(&mut bodyStmts),
    );

    let case ast::NodeValue::Block(block) = module.modBody.value
        else panic "resolveExpr: expected block for module body";
    enterScope(self, module.modBody);
    try resolveModuleDecls(self, &block) catch {
        return Diagnostics { errors: self.errors };
        return diagnostics(self);
    };
    try resolveModuleDefs(self, &block) catch {
        return Diagnostics { errors: self.errors };
        return diagnostics(self);
    };
    exitScope(self);

    return Diagnostics { errors: self.errors };
    return diagnostics(self);
}

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

    enterScope(self, root);
    try resolveModuleDecls(self, &block) catch {
        return Diagnostics { errors: self.errors };
        return diagnostics(self);
    };
    try resolveModuleDefs(self, &block) catch {
        return Diagnostics { errors: self.errors };
        return diagnostics(self);
    };
    exitScope(self);
    setNodeType(self, root, Type::Void);

    try closeGenericFnSpecializations(self) catch {
        return Diagnostics { errors: self.errors };
        return diagnostics(self);
    };
    try materializeGenericFnTypeUses(self) catch {
        return Diagnostics { errors: self.errors };
        return diagnostics(self);
    };
    try validateGenericDataRoots(self) catch {
        return Diagnostics { errors: self.errors };
        return diagnostics(self);
    };
    return Diagnostics { errors: self.errors };
    return diagnostics(self);
}

/// Analyze the module graph. This pass processes `mod` statements, creating symbols
/// and scopes for them, and also binds type names in each module so that cross-module
/// type references work regardless of declaration order.

        let mut receiverClass = types::PointerClass::Unsafe;
        let mut receiverMutable = false;
        let mut haveReceiver = false;
        match checker.resolver.nodeData.entries[node.id].extra {
            case NodeExtra::TraitMethodCall { traitInfo, methodIndex } => {
                let method = &traitInfo.methods[methodIndex];
                let method = &traitInfo.methods.data[methodIndex];
                set receiverClass = method.receiverClass;
                set receiverMutable = method.mutable;
                set haveReceiver = true;
            }
            case NodeExtra::GenericBoundMethodCall {
                traitInfo, methodIndex, explicitReceiver, ..
            } => {
                if not explicitReceiver {
                    let method = &traitInfo.methods[methodIndex];
                    let method = &traitInfo.methods.data[methodIndex];
                    set receiverClass = method.receiverClass;
                    set receiverMutable = method.mutable;
                    set haveReceiver = true;
                }
            }

        let diags = try resolvePackage(self, pkg.rootEntry, pkg.rootAst);
        if not success(&diags) {
            return diags;
        }
        try closeGenericFnSpecializations(self) catch {
            return Diagnostics { errors: self.errors };
            return diagnostics(self);
        };
        try materializeGenericFnTypeUses(self) catch {
            return Diagnostics { errors: self.errors };
            return diagnostics(self);
        };
    }
    // Data roots are validated after every package and reachable generic body
    // has had a chance to root its concrete specialization dependencies.
    try validateGenericDataRoots(self) catch {
        return Diagnostics { errors: self.errors };
        return diagnostics(self);
    };
    return Diagnostics { errors: self.errors };
    return diagnostics(self);
}

/// Resolve a package.
fn resolvePackage(self: *mut Resolver, rootEntry: *module::ModuleEntry, node: *ast::Node) -> Diagnostics throws (ResolveError) {
    let rootId = rootEntry.id;

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

    // Module graph analysis phase: bind all module name symbols and scopes.
    try resolveModuleGraph(self, &block) catch {
        assert self.errors.len > 0, "resolvePackage: failure should have diagnostics";
        return Diagnostics { errors: self.errors };
        return diagnostics(self);
    };

    // Declaration phase: bind all names and analyze top-level declarations.
    try resolveModuleDecls(self, &block) catch {
        assert self.errors.len > 0, "resolvePackage: failure should have diagnostics";
    };
    if self.errors.len > 0 {
        return Diagnostics { errors: self.errors };
        return diagnostics(self);
    }

    // Definition phase: analyze function bodies and sub-module definitions.
    try resolveModuleDefs(self, &block) catch {
        assert self.errors.len > 0, "resolvePackage: failure should have diagnostics";
    };
    setNodeType(self, node, Type::Void);

    return Diagnostics { errors: self.errors };
    return diagnostics(self);
}

lib/std/lang/resolver/printer.rad +5 -6

        }
        case super::Type::Array(array) => {
            io::print("[");
            printTypeBody(*array.item, brief);
            io::print("; ");
            io::printU32(array.length);
            if let length = super::concreteArrayLength(array.length) {
                io::printU32(length);
            } else {
                printTypeBody(*array.length, brief);
            }
            io::print("]");
        }
        case super::Type::GenericArray { item, .. } => {
            io::print("[");
            printTypeBody(*item, brief);
            io::print("; <const>]");
        }
        case super::Type::Optional(inner) => {
            io::print("?");
            printTypeBody(*inner, brief);
        }
        case super::Type::Fn(fnType) => {

lib/std/lang/resolver/tests.rad +25 -152

use std::lang::types;
use std::lang::parser;
use std::lang::scanner;
use std::lang::module;
use std::lang::strings;
use std::lang::vec;

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

/// AST arena storage used by resolver tests.

fn resolveStatements(
    self: *mut super::Resolver, block: ast::Block, arena: *mut ast::NodeArena
) -> TestResult throws (super::ResolveError) {
    let module = ast::synthFnModule(arena, super::ANALYZE_BLOCK_FN_NAME, block.statements);
    let diagnostics = try super::resolveModuleRoot(self, module.modBody) catch {
        return TestResult { diagnostics: super::Diagnostics { errors: self.errors }, root: module.modBody };
        return TestResult {
            diagnostics: super::Diagnostics {
                errors: vec::viewMut⟨super::Error⟩(&mut self.errors),
            },
            root: module.modBody,
        };
    };
    return TestResult { diagnostics, root: module.fnBody };
}

/// Parse and analyze an expression string for testing.

fn expectArrayType(ty: super::Type, length: u32) -> super::Type
    throws (testing::TestError)
{
    let case super::Type::Array(info) = ty
        else throw testing::TestError::Failed;
    try testing::expect(info.length == length);
    let actualLength = super::concreteArrayLength(info.length)
        else throw testing::TestError::Failed;
    try testing::expect(actualLength == length);

    return *info.item;
}

/// Require a slice type and return its element type.

    let arrStmt = try getBlockStmt(result.root, 1);
    let sym = super::symbolFor(&a, arrStmt)
        else throw testing::TestError::Failed;
    let case super::SymbolData::Constant { type: super::Type::Array(arrType), .. } = sym.data
        else throw testing::TestError::Failed;
    try testing::expect(arrType.length == 3);
    let actualLength = super::concreteArrayLength(arrType.length)
        else throw testing::TestError::Failed;
    try testing::expect(actualLength == 3);
}

/// Test that a record field can use a constant as its array length.
@test fn testRecordFieldWithConstArrayLength() throws (testing::TestError) {
    let mut a = testResolver();

        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Test @sliceOf with 3 arguments (ptr, len, cap) succeeds.
@test fn testResolveSliceOfWithCap() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn f(ptr: *u8, len: u32, cap: u32) -> *[u8] { return @sliceOf(ptr, len, cap); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
    // Mutable pointer produces mutable slice.
    {
        let mut a = testResolver();
        let program = "fn f(ptr: *mut u8, len: u32, cap: u32) -> *mut [u8] { return @sliceOf(ptr, len, cap); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test @sliceOf with 3 arguments but wrong cap type.
@test fn testResolveSliceOfCapWrongType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(ptr: *u8, len: u32, cap: bool) -> *[u8] { return @sliceOf(ptr, len, cap); }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Test .cap field access on slices resolves to u32.
@test fn testResolveSliceCapField() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(s: *[u8]) -> u32 { return s.cap; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test `.append()` on immutable slice produces an error.
@test fn testResolveSliceAppendImmutable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn f(s: *[i32], a: A) { s.append(1, a); }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::ImmutableBinding = err.kind
        else throw testing::TestError::Failed;
}

/// Test `.append()` with wrong argument count produces an error.
@test fn testResolveSliceAppendWrongArgCount() throws (testing::TestError) {
    // Too few arguments.
    {
        let mut a = testResolver();
        let program = "fn f(s: *mut [i32]) { s.append(1); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::FnArgCountMismatch(m) = err.kind
            else throw testing::TestError::Failed;
        try testing::expect(m.expected == 2);
        try testing::expect(m.actual == 1);
    }
    // Too many arguments.
    {
        let mut a = testResolver();
        let program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn f(s: *mut [i32], a: A) { s.append(1, a, 0); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::FnArgCountMismatch(m) = err.kind
            else throw testing::TestError::Failed;
        try testing::expect(m.expected == 2);
        try testing::expect(m.actual == 3);
    }
}

/// Test `.append()` with correct arguments succeeds.
@test fn testResolveSliceAppendCorrect() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn f(s: *mut [i32], a: A) { s.append(1, a); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test `.append()` with wrong element type produces an error.
@test fn testResolveSliceAppendWrongElemType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn f(s: *mut [i32], a: A) { s.append(true, a); }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Test `.delete()` on immutable slice produces an error.
@test fn testResolveSliceDeleteImmutable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(s: *[i32]) { s.delete(0); }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::ImmutableBinding = err.kind
        else throw testing::TestError::Failed;
}

/// Test `.delete()` with wrong argument count produces an error.
@test fn testResolveSliceDeleteWrongArgCount() throws (testing::TestError) {
    // No arguments.
    {
        let mut a = testResolver();
        let program = "fn f(s: *mut [i32]) { s.delete(); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::FnArgCountMismatch(m) = err.kind
            else throw testing::TestError::Failed;
        try testing::expect(m.expected == 1);
        try testing::expect(m.actual == 0);
    }
    // Too many arguments.
    {
        let mut a = testResolver();
        let program = "fn f(s: *mut [i32]) { s.delete(0, 1); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::FnArgCountMismatch(m) = err.kind
            else throw testing::TestError::Failed;
        try testing::expect(m.expected == 1);
        try testing::expect(m.actual == 2);
    }
}

/// Test `.delete()` with correct arguments succeeds.
@test fn testResolveSliceDeleteCorrect() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(s: *mut [i32]) { s.delete(0); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test `.delete()` with wrong argument type produces an error.
@test fn testResolveSliceDeleteWrongArgType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(s: *mut [i32]) { s.delete(true); }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Test `match &opt` produces immutable pointer bindings.
@test fn testResolveMatchRefUnionBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some(i32), None } fn f() { let opt = Opt::Some(42); match &opt { case Opt::Some(x) => { *x; } else => {} } }";
    let result = try resolveProgramStr(&mut a, program);

    let arrStmt = try getBlockStmt(result.root, 3);
    let sym = super::symbolFor(&a, arrStmt)
        else throw testing::TestError::Failed;
    let case super::SymbolData::Constant { type: super::Type::Array(arrType), .. } = sym.data
        else throw testing::TestError::Failed;
    try testing::expect(arrType.length == 5);
    let actualLength = super::concreteArrayLength(arrType.length)
        else throw testing::TestError::Failed;
    try testing::expect(actualLength == 5);
}

/// Test cross-module constant expression: a constant in one module references
/// a constant from another module via scope access.
@test fn testCrossModuleConstExpr() throws (testing::TestError) {

    let arrStmt = try getBlockStmt(result.root, 2);
    let sym = super::symbolFor(&a, arrStmt)
        else throw testing::TestError::Failed;
    let case super::SymbolData::Constant { type: super::Type::Array(arrType), .. } = sym.data
        else throw testing::TestError::Failed;
    try testing::expect(arrType.length == 4);
    let actualLength = super::concreteArrayLength(arrType.length)
        else throw testing::TestError::Failed;
    try testing::expect(actualLength == 4);
}

/// Test unsuffixed integer literals in constant expressions.
@test fn testConstExprUnsuffixedLiterals() throws (testing::TestError) {
    try expectConstFold("constant A: u32 = 4 * 4;", 0, 16);

        else throw testing::TestError::Failed;
    let case super::NominalType::Record(recordType) = *nominal
        else throw testing::TestError::Failed;
    let case super::Type::Array(arrayType) = recordType.fields[0].fieldType
        else throw testing::TestError::Failed;
    assert arrayType.length == 4;
    let actualLength = super::concreteArrayLength(arrayType.length)
        else throw testing::TestError::Failed;
    assert actualLength == 4;
    assert recordType.layout.size == 4;
}

/// Equivalent integer expressions share a canonical specialization.
@test fn testGenericConstParameterCanonical() throws (testing::TestError) {

    let case super::ErrorKind::UnresolvedSymbol(name) = err.kind
        else throw testing::TestError::Failed;
    assert mem::eq(name, "T");
}

/// Layout-dependent builtins reject symbolic generic types.
@test fn testGenericParameterLayoutRejected() throws (testing::TestError) {
/// Layout-dependent builtins accept symbolic generic types.
@test fn testGenericParameterLayoutAccepted() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "record Sized⟨T⟩ { bytes: u32 = @sizeOf(T) }",
    );
    try expectErrorKind(&result, super::ErrorKind::GenericLayoutRequired);
    try expectNoErrors(&result);
}

/// Generic data declarations cannot be used without specialization arguments.
@test fn testGenericArgumentsRequired() throws (testing::TestError) {
    let mut a = testResolver();

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

export fn scanner(sourceLoc: SourceLoc, source: *[u8], pool: *mut strings::Pool) -> Scanner {
    // Intern built-in functions and attributes.
    strings::intern(pool, "@sizeOf");
    strings::intern(pool, "@alignOf");
    strings::intern(pool, "@sliceOf");
    strings::intern(pool, "@relocate");
    strings::intern(pool, "@default");
    strings::intern(pool, "@intrinsic");
    strings::intern(pool, "@test");
    // Intern built-in slice methods.
    strings::intern(pool, "append");
    strings::intern(pool, "delete");

    return Scanner { sourceLoc, source, token: 0, cursor: 0, pool };
}

/// Check if we've reached the end of input.

lib/std/lang/slice.rad added +11 -0

1	+	//! Typed slice construction from raw pointers.
2	+
3	+	/// Construct an immutable slice from a pointer and element count.
4	+	export fn fromRawParts⟨T⟩(ptr: T, len: u32) -> [T] {
5	+	return @sliceOf(ptr, len);
6	+	}
7	+
8	+	/// Construct a mutable slice from a pointer and element count.
9	+	export fn fromRawPartsMut⟨T⟩(ptr: mut T, len: u32) -> mut [T] {
10	+	return @sliceOf(ptr, len);
11	+	}

lib/std/lang/vec.rad added +151 -0

1	+	//! Typed vectors over caller-provided or allocator-grown storage.
2	+
3	+	use std::lang::alloc;
4	+	use std::lang::slice;
5	+
6	+	/// Typed vector metadata with initialized length and storage capacity.
7	+	export record Vec⟨T⟩ {
8	+	/// Typed slice containing the vector's storage.
9	+	data: *mut [T],
10	+	/// Number of initialized elements.
11	+	len: u32,
12	+	}
13	+
14	+	/// Initialize a vector over caller-owned storage.
15	+	export fn init⟨T⟩(vec: mut Vec⟨T⟩, arena: mut [T]) {
16	+	set vec.data = arena;
17	+	set vec.len = 0;
18	+	}
19	+
20	+	/// Return the number of initialized elements.
21	+	export fn len⟨T⟩(vec: *Vec⟨T⟩) -> u32 {
22	+	return vec.len;
23	+	}
24	+
25	+	/// Return the storage capacity in elements.
26	+	export fn capacity⟨T⟩(vec: *Vec⟨T⟩) -> u32 {
27	+	return vec.data.len;
28	+	}
29	+
30	+	/// Return a view containing the initialized elements.
31	+	export fn view⟨T⟩(vec: Vec⟨T⟩) -> [T] {
32	+	return slice::fromRawParts⟨T⟩(vec.data.ptr, vec.len);
33	+	}
34	+
35	+	/// Return a mutable view containing the initialized elements.
36	+	export fn viewMut⟨T⟩(vec: mut Vec⟨T⟩) -> mut [T] {
37	+	return slice::fromRawPartsMut⟨T⟩(vec.data.ptr, vec.len);
38	+	}
39	+
40	+	/// Reset a vector without clearing its storage.
41	+	export fn reset⟨T⟩(vec: *mut Vec⟨T⟩) {
42	+	set vec.len = 0;
43	+	}
44	+
45	+	/// Return a typed pointer to an element, or `nil` when out of bounds.
46	+	export fn get⟨T⟩(vec: Vec⟨T⟩, index: u32) -> ?T {
47	+	if index >= vec.len {
48	+	return nil;
49	+	}
50	+
51	+	return &vec.data[index];
52	+	}
53	+
54	+	/// Append an element, returning `false` when the vector is full.
55	+	export fn push⟨T⟩(vec: *mut Vec⟨T⟩, value: T) -> bool {
56	+	if vec.len >= vec.data.len {
57	+	return false;
58	+	}
59	+
60	+	set vec.data[vec.len] = value;
61	+	set vec.len += 1;
62	+
63	+	return true;
64	+	}
65	+
66	+	/// Move bytes between equally bounded, potentially overlapping storage regions.
67	+	fn relocateBytes(destination: mut [u8], source: mut [u8]) {
68	+	@relocate(destination, source);
69	+	}
70	+
71	+	/// Allocate grown storage and move the initialized bytes into it.
72	+	fn growStorage(
73	+	data: *mut u8,
74	+	initializedBytes: u32,
75	+	capacityBytes: u32,
76	+	alignment: u32,
77	+	allocator: alloc::Allocator,
78	+	) -> *mut u8 {
79	+	if capacityBytes == 0 {
80	+	return data;
81	+	}
82	+	let grown = allocator.func(allocator.ctx, capacityBytes, alignment) as *mut u8;
83	+	if initializedBytes > 0 {
84	+	relocateBytes(
85	+	slice::fromRawPartsMut⟨u8⟩(grown, initializedBytes),
86	+	slice::fromRawPartsMut⟨u8⟩(data, initializedBytes),
87	+	);
88	+	}
89	+	return grown;
90	+	}
91	+
92	+	/// Append an element, growing the vector when it is full.
93	+	export fn append⟨T⟩(vec: *mut Vec⟨T⟩, value: T, allocator: alloc::Allocator) {
94	+	if vec.len == vec.data.len {
95	+	let capacity = (vec.data.len << 1) \| 1;
96	+	let itemSize = @sizeOf(T);
97	+	let data = growStorage(
98	+	vec.data.ptr as mut opaque as mut u8,
99	+	vec.len * itemSize,
100	+	capacity * itemSize,
101	+	@alignOf(T),
102	+	allocator,
103	+	) as mut opaque as mut T;
104	+	set vec.data = slice::fromRawPartsMut⟨T⟩(data, capacity);
105	+	}
106	+
107	+	set vec.data[vec.len] = value;
108	+	set vec.len += 1;
109	+	}
110	+
111	+	/// Replace an initialized element, returning `false` when out of bounds.
112	+	export fn put⟨T⟩(vec: *mut Vec⟨T⟩, index: u32, value: T) -> bool {
113	+	if index >= vec.len {
114	+	return false;
115	+	}
116	+
117	+	set vec.data[index] = value;
118	+	return true;
119	+	}
120	+
121	+	/// Remove and return an initialized element while preserving later element order.
122	+	export fn remove⟨T⟩(vec: *mut Vec⟨T⟩, index: u32) -> T {
123	+	assert index < vec.len;
124	+
125	+	let removed = vec.data[index];
126	+	let tailBytes = (vec.len - index - 1) * @sizeOf(T);
127	+	if tailBytes > 0 {
128	+	relocateBytes(
129	+	slice::fromRawPartsMut⟨u8⟩(
130	+	&mut vec.data[index] as mut opaque as mut u8,
131	+	tailBytes,
132	+	),
133	+	slice::fromRawPartsMut⟨u8⟩(
134	+	&mut vec.data[index + 1] as mut opaque as mut u8,
135	+	tailBytes,
136	+	),
137	+	);
138	+	}
139	+
140	+	set vec.len -= 1;
141	+	return removed;
142	+	}
143	+
144	+	/// Remove and return the last element, or `nil` when empty.
145	+	export fn pop⟨T⟩(vec: *mut Vec⟨T⟩) -> ?T {
146	+	if vec.len == 0 {
147	+	return nil;
148	+	}
149	+	set vec.len -= 1;
150	+	return vec.data[vec.len];
151	+	}

lib/std/slice.rad added +5 -0

1	+	//! Public typed slice API.
2	+	//!
3	+	//! The implementation lives in `std::lang::slice` so language modules can
4	+	//! resolve it before this stable top-level facade.
5	+	export use std::lang::slice::*;

lib/std/tests.rad +146 -5

//! Tests for formatting functions.

use std::lang::alloc;
use std::fmt;
use std::mem;
use std::vec;
use std::slice;
use std::testing;
use std::sys::unix;

/// Mixed-width value used by vector tests.
record Obj {

    wide: u64,
    /// Narrow field.
    narrow: u8,
}

/// Zero-sized value used by vector growth and removal tests.
record ZeroSized {}

// fmt /////////////////////////////////////////////////////////////////////////

@test fn testFormatU32Zero() throws (testing::TestError) {
    let mut buffer: [u8; 11] = [0; 11];
    let result: *[u8] = fmt::formatU32(0, &mut buffer[..]);

    try testing::expect(mem::cmp("abcd", "abc") > 0);
}

// vec /////////////////////////////////////////////////////////////////////////

instantiate vec::Vec⟨i32⟩,
            vec::init⟨i32⟩,
instantiate vec::init⟨i32⟩,
            vec::len⟨i32⟩,
            vec::capacity⟨i32⟩,
            vec::reset⟨i32⟩,
            vec::get⟨i32⟩,
            vec::viewMut⟨i32⟩,
            vec::push⟨i32⟩,
            vec::put⟨i32⟩,
            vec::pop⟨i32⟩;
            vec::pop⟨i32⟩,
            vec::append⟨i32⟩,
            vec::remove⟨i32⟩,
            vec::view⟨i32⟩;

instantiate vec::init⟨u8⟩,
            vec::append⟨u8⟩,
            vec::view⟨u8⟩;

instantiate vec::Vec⟨Obj⟩,
            vec::init⟨Obj⟩,
instantiate vec::init⟨Obj⟩,
            vec::get⟨Obj⟩,
            vec::push⟨Obj⟩,
            vec::put⟨Obj⟩;

instantiate vec::init⟨ZeroSized⟩,
            vec::append⟨ZeroSized⟩,
            vec::remove⟨ZeroSized⟩,
            vec::view⟨ZeroSized⟩;

@test fn testVecInitialState() throws (testing::TestError) {
    let mut arena: [i32; 4] = undefined;
    let mut v: vec::Vec⟨i32⟩ = undefined;
    vec::init⟨i32⟩(&mut v, &mut arena[..]);


        else throw testing::TestError::Failed;
    assert *replaced == 999;
    assert not vec::put⟨i32⟩(&mut v, 3, 1);
}

@test fn testVecMutableViewAliasesStorage() throws (testing::TestError) {
    let mut arena: [i32; 2] = undefined;
    let mut v: vec::Vec⟨i32⟩ = undefined;
    vec::init⟨i32⟩(&mut v, &mut arena[..]);

    assert vec::push⟨i32⟩(&mut v, 10);
    assert vec::push⟨i32⟩(&mut v, 20);

    let mut view = vec::viewMut⟨i32⟩(&mut v);
    assert view.len == 2;
    set view[1] = 999;

    let updated = vec::get⟨i32⟩(&v, 1)
        else throw testing::TestError::Failed;
    assert *updated == 999;
}

@test fn testVecPopReset() throws (testing::TestError) {
    let mut arena: [i32; 2] = undefined;
    let mut v: vec::Vec⟨i32⟩ = undefined;
    vec::init⟨i32⟩(&mut v, &mut arena[..]);


    let pair = vec::get⟨Obj⟩(&v, 0)
        else throw testing::TestError::Failed;
    assert pair.wide == 12;
    assert pair.narrow == 2;
}

/// Storage for allocations made while testing vector growth.
static VEC_GROWTH_STORAGE: [u8; 256] = undefined;

@test fn testVecAppendAndRemove() throws (testing::TestError) {
    let mut arena = alloc::new(&mut VEC_GROWTH_STORAGE[..]);
    let allocator = alloc::arenaAllocator(&mut arena);
    let mut storage: [i32; 2] = undefined;
    let mut values: vec::Vec⟨i32⟩ = undefined;
    vec::init⟨i32⟩(&mut values, &mut storage[..]);

    vec::append⟨i32⟩(&mut values, 10, allocator);
    vec::append⟨i32⟩(&mut values, 20, allocator);
    vec::append⟨i32⟩(&mut values, 30, allocator);
    assert vec::capacity⟨i32⟩(&values) > 2;
    let grown = vec::view⟨i32⟩(&values);
    assert grown.len == 3;
    assert grown[0] == 10;
    assert grown[1] == 20;
    assert grown[2] == 30;

    let capacity = vec::capacity⟨i32⟩(&values);
    let first = vec::remove⟨i32⟩(&mut values, 0);
    assert first == 10;
    vec::append⟨i32⟩(&mut values, 40, allocator);
    let third = vec::remove⟨i32⟩(&mut values, 1);
    assert third == 30;
    let middle = vec::view⟨i32⟩(&values);
    assert middle.len == 2;
    assert middle[0] == 20;
    assert middle[1] == 40;
    assert vec::capacity⟨i32⟩(&values) == capacity;

    let final = vec::remove⟨i32⟩(&mut values, 1);
    assert final == 40;
    let last = vec::view⟨i32⟩(&values);
    assert last.len == 1;
    assert last[0] == 20;
}

@test fn testVecZeroSizedGrowthAndRemove() throws (testing::TestError) {
    let mut arena = alloc::new(&mut VEC_GROWTH_STORAGE[..]);
    let allocator = alloc::arenaAllocator(&mut arena);
    let mut values: vec::Vec⟨ZeroSized⟩ = undefined;
    vec::init⟨ZeroSized⟩(&mut values, &mut []);

    vec::append⟨ZeroSized⟩(&mut values, ZeroSized {}, allocator);
    vec::append⟨ZeroSized⟩(&mut values, ZeroSized {}, allocator);
    vec::append⟨ZeroSized⟩(&mut values, ZeroSized {}, allocator);
    vec::append⟨ZeroSized⟩(&mut values, ZeroSized {}, allocator);
    let initialized = vec::view⟨ZeroSized⟩(&values);
    assert initialized.len == 4;

    let removed: ZeroSized = vec::remove⟨ZeroSized⟩(&mut values, 1);
    assert removed == ZeroSized {};
    let remaining = vec::view⟨ZeroSized⟩(&values);
    assert remaining.len == 3;
}

@test fn testVecAppendFromEmpty() throws (testing::TestError) {
    let mut arena = alloc::new(&mut VEC_GROWTH_STORAGE[..]);
    let allocator = alloc::arenaAllocator(&mut arena);
    let mut values: vec::Vec⟨i32⟩ = undefined;
    vec::init⟨i32⟩(&mut values, &mut []);

    vec::append⟨i32⟩(&mut values, 99, allocator);
    assert vec::capacity⟨i32⟩(&values) > 0;
    let view = vec::view⟨i32⟩(&values);
    assert view.len == 1;
    assert view[0] == 99;
}

@test fn testVecAppendU8() throws (testing::TestError) {
    let mut arena = alloc::new(&mut VEC_GROWTH_STORAGE[..]);
    let allocator = alloc::arenaAllocator(&mut arena);
    let mut storage: [u8; 1] = undefined;
    let mut values: vec::Vec⟨u8⟩ = undefined;
    vec::init⟨u8⟩(&mut values, &mut storage[..]);

    vec::append⟨u8⟩(&mut values, 0xAB, allocator);
    vec::append⟨u8⟩(&mut values, 0xCD, allocator);
    let view = vec::view⟨u8⟩(&values);
    assert view.len == 2;
    assert view[0] == 0xAB;
    assert view[1] == 0xCD;
}

// slice ///////////////////////////////////////////////////////////////////////

instantiate slice::fromRawParts⟨i32⟩,
            slice::fromRawPartsMut⟨i32⟩;

@test fn testSliceFromRawParts() throws (testing::TestError) {
    let mut values: [i32; 4] = [10, 20, 30, 40];
    let view = slice::fromRawParts⟨i32⟩(&values[1], 2);
    assert view.len == 2;
    assert view[0] == 20;
    assert view[1] == 30;

    let mutable = slice::fromRawPartsMut⟨i32⟩(&mut values[0], 3);
    assert mutable.len == 3;
    set mutable[1] = 99;
    assert values[1] == 99;
    assert view[0] == 99;

    let empty = slice::fromRawParts⟨i32⟩(&values[0], 0);
    assert empty.len == 0;
}

lib/std/vec.rad +5 -70

//! Typed vector backed by caller-owned static storage.

/// Typed vector metadata backed by caller-owned storage.
export record Vec⟨T⟩ {
    /// Typed slice containing the vector's storage.
    data: *mut [T],
    /// Number of initialized elements.
    len: u32,
}

/// Initialize a vector over caller-owned storage.
export fn init⟨T⟩(vec: *mut Vec⟨T⟩, arena: *mut [T]) {
    set vec.data = arena;
    set vec.len = 0;
}

/// Return the number of initialized elements.
export fn len⟨T⟩(vec: *Vec⟨T⟩) -> u32 {
    return vec.len;
}

/// Return the storage capacity in elements.
export fn capacity⟨T⟩(vec: *Vec⟨T⟩) -> u32 {
    return vec.data.len;
}

/// Reset a vector without clearing its storage.
export fn reset⟨T⟩(vec: *mut Vec⟨T⟩) {
    set vec.len = 0;
}

/// Return a typed pointer to an element, or `nil` when out of bounds.
export fn get⟨T⟩(vec: *Vec⟨T⟩, index: u32) -> ?*T {
    if index >= vec.len {
        return nil;
    }

    return &vec.data[index];
}

/// Append an element, returning `false` when the vector is full.
export fn push⟨T⟩(vec: *mut Vec⟨T⟩, value: T) -> bool {
    if vec.len >= vec.data.len {
        return false;
    }

    set vec.data[vec.len] = value;
    set vec.len += 1;

    return true;
}

/// Replace an initialized element, returning `false` when out of bounds.
export fn put⟨T⟩(vec: *mut Vec⟨T⟩, index: u32, value: T) -> bool {
    if index >= vec.len {
        return false;
    }

    set vec.data[index] = value;
    return true;
}

/// Remove and return the last element, or `nil` when empty.
export fn pop⟨T⟩(vec: *mut Vec⟨T⟩) -> ?T {
    if vec.len == 0 {
        return nil;
    }
    set vec.len -= 1;
    return vec.data[vec.len];
}
//! Public typed vector API.
//!
//! The implementation lives in `std::lang::vec` so language modules can
//! resolve it before this stable top-level facade.
export use std::lang::vec::*;

seed/radiance.rv64 +0 -0

Binary file changed.

seed/radiance.rv64.git +1 -1

1		-	f102340ee2c496ef3ae997c4a449df1e805d63e30eef07fe7aa562bf2884eab3
	1	+	3225bfc0f4e8414a142c1c31c309d6172bf96408739626c07578605ac8253188

std.lib +3 -0

lib/std.rad
lib/std/char.rad
lib/std/fmt.rad
lib/std/mem.rad
lib/std/slice.rad
lib/std/vec.rad
lib/std/io.rad
lib/std/intrinsics.rad
lib/std/sys.rad
lib/std/collections.rad

lib/std/arch/rv64/asm/scanner.rad
lib/std/arch/rv64/asm/parser.rad
lib/std/arch/rv64/asm/emit.rad
lib/std/lang.rad
lib/std/lang/alloc.rad
lib/std/lang/slice.rad
lib/std/lang/vec.rad
lib/std/lang/types.rad
lib/std/lang/strings.rad
lib/std/lang/sexpr.rad
lib/std/lang/ast.rad
lib/std/lang/ast/printer.rad

test/tests/array.slice.full.ril +0 -1

fn w64 $sliceFull(w64 %0, w64 %1) {
  @entry0
    reserve %2 16 8;
    store w64 %1 %2 0;
    store w32 4 %2 8;
    store w32 4 %2 12;
    blit %0 %2 16;
    ret %0;
}

test/tests/array.slice.openend.ril +0 -1

    add w64 %4 %1 %3;
    sub w32 %5 4 %2;
    reserve %6 16 8;
    store w64 %4 %6 0;
    store w32 %5 %6 8;
    store w32 %5 %6 12;
    blit %0 %6 16;
    ret %0;
}

test/tests/array.slice.openstart.ril +0 -1

    unreachable;
  @guard#pass2
    reserve %3 16 8;
    store w64 %1 %3 0;
    store w32 %2 %3 8;
    store w32 %2 %3 12;
    blit %0 %3 16;
    ret %0;
}

test/tests/builtin.sliceof.invalid.cap.rad deleted +0 -10

//! returns: 133
//! Test @sliceOf runtime validation for len > cap.

@default fn main() -> i32 {
    let mut arr: [i32; 4] = [10, 20, 30, 40];
    let ptr: *i32 = &arr[0];
    let slice: *[i32] = @sliceOf(ptr, 4, 3);

    return slice.len as i32;
}

test/tests/const.array.repeat.string.slice.ril +2 -2

}

data $WORDS align 8 {
    sym $WORDS$literal$0;
    w32 3;
    w32 3;
    undef * 4;
    sym $WORDS$literal$0;
    w32 3;
    w32 3;
    undef * 4;
}

fn w32 $main() {
  @entry0
    copy %0 $WORDS;

test/tests/const.array.strings.slice.ril +3 -3

}

data $WORDS align 8 {
    sym $WORDS$literal$0;
    w32 5;
    w32 5;
    undef * 4;
    sym $WORDS$literal$1;
    w32 6;
    w32 6;
    undef * 4;
    sym $WORDS$literal$0;
    w32 5;
    w32 5;
    undef * 4;
}

fn w32 $totalLen() {
  @entry0
    copy %0 $WORDS;

test/tests/const.record.union.ril +3 -3

}

data $KEYWORDS align 8 {
    sym $KEYWORDS$literal$0;
    w32 2;
    w32 2;
    undef * 4;
    w8 0;
    undef * 7;
    sym $KEYWORDS$literal$1;
    w32 3;
    w32 3;
    undef * 4;
    w8 1;
    undef * 7;
    sym $KEYWORDS$literal$2;
    w32 2;
    w32 2;
    undef * 4;
    w8 2;
    undef * 7;
}

fn w32 $getFirstTag() {

test/tests/const.slice.of.slices.ril +5 -5

}

data $GROUPS$literal$2 align 8 {
    sym $GROUPS$literal$0;
    w32 2;
    w32 2;
    undef * 4;
    sym $GROUPS$literal$1;
    w32 2;
    w32 2;
    undef * 4;
}

data $GROUPS$literal$3 align 1 {
    str "efg";
}

data $GROUPS$literal$4 align 8 {
    sym $GROUPS$literal$3;
    w32 3;
    w32 3;
    undef * 4;
}

data $GROUPS align 8 {
    sym $GROUPS$literal$2;
    w32 2;
    w32 2;
    undef * 4;
    sym $GROUPS$literal$4;
    w32 1;
    w32 1;
    undef * 4;
}

fn w32 $totalLen() {
  @entry0
    copy %0 $GROUPS;

test/tests/const.string.ril +1 -2

}

data $HELLO align 8 {
    sym $HELLO$literal$0;
    w32 5;
    w32 5;
    undef * 4;
}

fn w32 $getLen() {
  @entry0
    copy %0 $HELLO$literal$0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store w32 5 %1 8;
    store w32 5 %1 12;
    load w32 %2 %1 8;
    ret %2;
}

test/tests/const.string.scoped.names.ril +4 -6

}

data $HELLO1 align 8 {
    sym $HELLO1$literal$0;
    w32 5;
    w32 5;
    undef * 4;
}

data $HELLO2 align 8 {
    sym $HELLO1$literal$0;
    w32 5;
    w32 5;
    undef * 4;
}

data $MSGS$literal$3 align 1 {
    str "world";
}

data $MSGS align 8 {
    sym $HELLO1$literal$0;
    w32 5;
    w32 5;
    undef * 4;
    sym $MSGS$literal$3;
    w32 5;
    w32 5;
    undef * 4;
}

fn w32 $totalLen() {
  @entry0
    copy %0 $HELLO1$literal$0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store w32 5 %1 8;
    store w32 5 %1 12;
    load w32 %2 %1 8;
    copy %3 $HELLO1$literal$0;
    reserve %4 16 8;
    store w64 %3 %4 0;
    store w32 5 %4 8;
    store w32 5 %4 12;
    load w32 %5 %4 8;
    add w32 %6 %2 %5;
    copy %7 $MSGS;
    load w32 %8 %7 8;
    add w32 %9 %6 %8;

test/tests/field.aggregate.ril +0 -1

    store w32 3 %0 8;
    reserve %1 24 8;
    reserve %2 16 8;
    store w64 %0 %2 0;
    store w32 3 %2 8;
    store w32 3 %2 12;
    blit %1 %2 16;
    store w32 77 %1 16;
    load w32 %3 %1 8;
    ret %3;
}

test/tests/generic.array.iteration.rad added +42 -0

1	+	//! returns: 0
2	+	//! Generic array iteration specializes symbolic element types and lengths.
3	+
4	+	/// Array storage whose length is derived from a constant argument.
5	+	record Extended⟨T, constant N: u32⟩ {
6	+	/// Elements stored in the derived array type.
7	+	items: [T; N + 1],
8	+	}
9	+
10	+	/// Visit every element and return the last one by index.
11	+	fn lastAfterVisit⟨T, constant N: u32⟩(items: [T; N]) -> T {
12	+	let mut visited: u32 = 0;
13	+	for _ in items {
14	+	set visited += 1;
15	+	}
16	+	assert visited == items.len;
17	+	return items[items.len - 1];
18	+	}
19	+
20	+	fn lastByte⟨constant N: u64⟩(items: [u8; N]) -> u8 {
21	+	assert items.len == 3;
22	+	return items[items.len - 1];
23	+	}
24	+
25	+	instantiate Extended⟨i32, 2⟩;
26	+	instantiate Extended⟨u8, 3⟩;
27	+	instantiate lastAfterVisit⟨i32, 3⟩;
28	+	instantiate lastAfterVisit⟨u8, 4⟩;
29	+	instantiate lastByte⟨3⟩;
30	+
31	+	/// Exercise generic iteration for distinct element types and derived lengths.
32	+	@default fn main() -> i32 {
33	+	let integers = Extended⟨i32, 2⟩ { items: [3, 5, 8] };
34	+	let bytes = Extended⟨u8, 3⟩ { items: [1, 2, 3, 13] };
35	+	let integer = lastAfterVisit⟨i32, 3⟩(integers.items);
36	+	let byte = lastAfterVisit⟨u8, 4⟩(bytes.items);
37	+	let bytes64: [u8; 3] = [1, 2, 3];
38	+	assert bytes64.len == 3;
39	+	let last = lastByte⟨3⟩(bytes64);
40	+	assert last == bytes64[bytes64.len - 1];
41	+	return integer + byte as i32 + last as i32 - 24;
42	+	}

test/tests/generic.function.ril +0 -2

    load w64 %2 %1 0;
    load w32 %3 %1 8;
    reserve %4 16 8;
    store w64 %2 %4 0;
    store w32 %3 %4 8;
    store w32 %3 %4 12;
    blit %0 %4 16;
    ret %0;
}

fn w64 $"test::reslice⟨i32⟩"(w64 %0, w64 %1) {

    load w64 %2 %1 0;
    load w32 %3 %1 8;
    reserve %4 16 8;
    store w64 %2 %4 0;
    store w32 %3 %4 8;
    store w32 %3 %4 12;
    blit %0 %4 16;
    ret %0;
}

fn w64 $"test::some⟨test::Pair⟩"(w64 %0, w64 %1) {

test/tests/literal.slice.bytes.ril +0 -1

  @entry0
    copy %0 $byteSlice$literal$0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store w32 3 %1 8;
    store w32 3 %1 12;
    load w32 %2 %1 8;
    ret %2;
}

test/tests/literal.slice.dedup.ril +0 -2

  @entry0
    copy %0 $dedupSlice$literal$0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store w32 3 %1 8;
    store w32 3 %1 12;
    copy %2 $dedupSlice$literal$0;
    reserve %3 16 8;
    store w64 %2 %3 0;
    store w32 3 %3 8;
    store w32 3 %3 12;
    load w32 %4 %1 8;
    load w32 %5 %3 8;
    add w32 %6 %4 %5;
    ret %6;
}

test/tests/literal.slice.empty.ril +0 -1

fn w32 $emptySlice() {
  @entry0
    reserve %0 16 8;
    store w64 0 %0 0;
    store w32 0 %0 8;
    store w32 0 %0 12;
    load w32 %1 %0 8;
    ret %1;
}

test/tests/literal.slice.multi.ril +0 -2

  @entry0
    copy %0 $multiSlice$literal$0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store w32 2 %1 8;
    store w32 2 %1 12;
    copy %2 $multiSlice$literal$1;
    reserve %3 16 8;
    store w64 %2 %3 0;
    store w32 3 %3 8;
    store w32 3 %3 12;
    load w32 %4 %1 8;
    load w32 %5 %3 8;
    add w32 %6 %4 %5;
    ret %6;
}

test/tests/literal.slice.record.ril +0 -1

  @entry0
    copy %0 $localSliceOfRecords$literal$0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store w32 2 %1 8;
    store w32 2 %1 12;
    load w32 %2 %1 8;
    br.ult w32 0 %2 @guard#pass1 @guard#trap2;
  @guard#pass1
    load w64 %3 %1 0;
    sload w32 %4 %3 0;

test/tests/literal.slice.ril +0 -1

  @entry0
    copy %0 $sliceLiteral$literal$0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store w32 3 %1 8;
    store w32 3 %1 12;
    load w32 %2 %1 8;
    ret %2;
}

test/tests/literal.string.dedup.ril +0 -2

  @entry0
    copy %0 $dedupString$literal$0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store w32 5 %1 8;
    store w32 5 %1 12;
    copy %2 $dedupString$literal$0;
    reserve %3 16 8;
    store w64 %2 %3 0;
    store w32 5 %3 8;
    store w32 5 %3 12;
    load w32 %4 %1 8;
    load w32 %5 %3 8;
    add w32 %6 %4 %5;
    ret %6;
}

test/tests/literal.string.empty.ril +0 -1

  @entry0
    copy %0 $emptyString$literal$0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store w32 0 %1 8;
    store w32 0 %1 12;
    load w32 %2 %1 8;
    ret %2;
}

test/tests/literal.string.fns.ril +0 -2

  @entry0
    copy %0 $first$literal$0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store w32 3 %1 8;
    store w32 3 %1 12;
    load w32 %2 %1 8;
    ret %2;
}

fn w32 $second() {
  @entry0
    copy %0 $second$literal$0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store w32 3 %1 8;
    store w32 3 %1 12;
    load w32 %2 %1 8;
    ret %2;
}

test/tests/literal.string.multi.ril +0 -2

  @entry0
    copy %0 $multiString$literal$0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store w32 5 %1 8;
    store w32 5 %1 12;
    copy %2 $multiString$literal$1;
    reserve %3 16 8;
    store w64 %2 %3 0;
    store w32 5 %3 8;
    store w32 5 %3 12;
    load w32 %4 %1 8;
    load w32 %5 %3 8;
    add w32 %6 %4 %5;
    ret %6;
}

test/tests/literal.string.ril +0 -1

  @entry0
    copy %0 $stringLen$literal$0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store w32 5 %1 8;
    store w32 5 %1 12;
    load w32 %2 %1 8;
    ret %2;
}

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

}

data $ENTRIES align 8 {
    sym $ENTRIES$literal$2;
    w32 2;
    w32 2;
    undef * 4;
    w8 10;
    undef * 7;
    sym $ENTRIES$literal$3;
    w32 2;
    w32 2;
    undef * 4;
    w8 11;
    undef * 7;
}

fn w32 $main() {

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

}

data $ENTRIES align 8 {
    sym $ENTRIES$literal$0;
    w32 1;
    w32 1;
    undef * 4;
    w8 0;
    undef * 7;
    sym $ENTRIES$literal$1;
    w32 1;
    w32 1;
    undef * 4;
    w8 1;
    undef * 7;
}

fn w32 $main() {

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

}

data $ENTRIES align 8 {
    sym $ENTRIES$literal$0;
    w32 2;
    w32 2;
    undef * 4;
    w8 10;
    undef * 7;
    sym $ENTRIES$literal$1;
    w32 2;
    w32 2;
    undef * 4;
    w8 11;
    undef * 7;
}

fn w32 $main() {

test/tests/opt.slice.npo.ril +0 -12

fn w8 $checkNil() {
  @entry0
    reserve %0 16 8;
    store w64 0 %0 0;
    store w32 0 %0 8;
    store w32 0 %0 12;
    load w64 %1 %0 0;
    eq w64 %2 %1 0;
    br.ne w32 %2 0 @assert.ok2 @assert.fail1;
  @assert.fail1
    unreachable;

    store w8 2 %0 1;
    store w8 3 %0 2;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store w32 3 %1 8;
    store w32 3 %1 12;
    reserve %2 16 8;
    blit %2 %1 16;
    load w64 %3 %2 0;
    ne w64 %4 %3 0;
    br.ne w32 %4 0 @assert.ok2 @assert.fail1;

62	60		store w8 20 %0 1;
63	61		store w8 30 %0 2;
64	62		reserve %1 16 8;
65	63		store w64 %0 %1 0;
66	64		store w32 3 %1 8;
67		-	store w32 3 %1 12;
68	65		reserve %2 16 8;
69	66		blit %2 %1 16;
70	67		reserve %3 16 8;
71	68		blit %3 %2 16;
72	69		load w64 %4 %3 0;

    unreachable;
  @merge13
    reserve %13 16 8;
    store w64 0 %13 0;
    store w32 0 %13 8;
    store w32 0 %13 12;
    reserve %14 16 8;
    blit %14 %13 16;
    load w64 %15 %14 0;
    br.ne w32 %15 0 @then14 @else15;
  @then14

129	125		store w8 20 %0 1;
130	126		store w8 30 %0 2;
131	127		reserve %1 16 8;
132	128		store w64 %0 %1 0;
133	129		store w32 3 %1 8;
134		-	store w32 3 %1 12;
135	130		reserve %2 16 8;
136	131		blit %2 %1 16;
137	132		reserve %3 16 8;
138	133		blit %3 %2 16;
139	134		load w64 %4 %3 0;

fn w64 $returnNil(w64 %0) {
  @entry0
    reserve %1 16 8;
    store w64 0 %1 0;
    store w32 0 %1 8;
    store w32 0 %1 12;
    blit %0 %1 16;
    ret %0;
}

fn w64 $returnSome(w64 %0) {

    store w8 42 %1 0;
    store w8 99 %1 1;
    reserve %2 16 8;
    store w64 %1 %2 0;
    store w32 2 %2 8;
    store w32 2 %2 12;
    blit %0 %2 16;
    ret %0;
}

fn w8 $checkReturn() {

    store w8 5 %0 0;
    store w8 6 %0 1;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store w32 2 %1 8;
    store w32 2 %1 12;
    reserve %2 16 8;
    blit %2 %1 16;
    reserve %3 16 8;
    blit %3 %2 16;
    jmp @arm1;

    jmp @merge6;
  @merge6
    reserve %5 16 8;
    store w64 0 %5 0;
    store w32 0 %5 8;
    store w32 0 %5 12;
    reserve %6 16 8;
    blit %6 %5 16;
    jmp @arm7;
  @arm7
    load w64 %7 %6 0;

fn w8 $checkEq() {
  @entry0
    reserve %0 16 8;
    store w64 0 %0 0;
    store w32 0 %0 8;
    store w32 0 %0 12;
    reserve %1 16 8;
    store w64 0 %1 0;
    store w32 0 %1 8;
    store w32 0 %1 12;
    load w64 %2 %0 0;
    load w64 %3 %1 0;
    eq w64 %4 %2 %3;
    load w32 %5 %0 8;
    load w32 %6 %1 8;

285	274		store w8 1 %9 0;
286	275		store w8 2 %9 1;
287	276		reserve %10 16 8;
288	277		store w64 %9 %10 0;
289	278		store w32 2 %10 8;
290		-	store w32 2 %10 12;
291	279		reserve %11 16 8;
292	280		blit %11 %10 16;
293	281		load w64 %12 %11 0;
294	282		load w64 %13 %0 0;
295	283		eq w64 %14 %12 %13;

test/tests/ptr.deref.ril +0 -2

    call w32 %4 $derefArrayIndex(%3);
    copy %5 $main$literal$0;
    reserve %6 16 8;
    store w64 %5 %6 0;
    store w32 3 %6 8;
    store w32 3 %6 12;
    call w32 %7 $derefSliceIndex(%6);
    add w32 %8 %1 %2;
    add w32 %9 %8 %4;
    add w32 %10 %9 %7;
    ret %10;
}


test/tests/reference.array.repeat.ril +0 -1

  @entry0
    copy %1 $repeatedSlice$literal$0;
    reserve %2 16 8;
    store w64 %1 %2 0;
    store w32 3 %2 8;
    store w32 3 %2 12;
    blit %0 %2 16;
    ret %0;
}

test/tests/relocate.bounds.rad added +10 -0

1	+	//! returns: 133
2	+	//! Test that relocation traps when the destination is shorter than the source.
3	+
4	+	@default fn main() -> i32 {
5	+	let mut bytes: [u8; 4] = [1, 2, 3, 4];
6	+	let destination: *mut [u8] = &mut bytes[0..1];
7	+	let source: *mut [u8] = &mut bytes[1..3];
8	+	@relocate(destination, source);
9	+	return 0;
10	+	}

test/tests/relocate.rad added +37 -0

1	+	//! returns: 0
2	+	//! Test overlap-safe relocation between mutable byte slices.
3	+
4	+	@default fn main() -> i32 {
5	+	let mut bytes: [u8; 6] = [1, 2, 3, 4, 5, 6];
6	+
7	+	let rightDestination: *mut [u8] = &mut bytes[1..5];
8	+	let rightSource: *mut [u8] = &mut bytes[0..4];
9	+	@relocate(rightDestination, rightSource);
10	+
11	+	assert bytes[0] == 1;
12	+	assert bytes[1] == 1;
13	+	assert bytes[2] == 2;
14	+	assert bytes[3] == 3;
15	+	assert bytes[4] == 4;
16	+	assert bytes[5] == 6;
17	+
18	+	let leftDestination: *mut [u8] = &mut bytes[0..4];
19	+	let leftSource: *mut [u8] = &mut bytes[1..5];
20	+	@relocate(leftDestination, leftSource);
21	+
22	+	assert bytes[0] == 1;
23	+	assert bytes[1] == 2;
24	+	assert bytes[2] == 3;
25	+	assert bytes[3] == 4;
26	+	assert bytes[4] == 4;
27	+	assert bytes[5] == 6;
28	+
29	+	let emptyDestination: *mut [u8] = &mut bytes[0..0];
30	+	let emptySource: *mut [u8] = &mut bytes[6..6];
31	+	@relocate(emptyDestination, emptySource);
32	+
33	+	assert bytes[0] == 1;
34	+	assert bytes[5] == 6;
35	+
36	+	return 0;
37	+	}

test/tests/slice.append.rad deleted +0 -191

//! returns: 0
//! Test slice .append() method with inline allocator.

/// Simple bump allocator for testing.
record Arena {
    data: *mut [u8],
    offset: u32,
}

fn newArena(data: *mut [u8]) -> Arena {
    return Arena { data, offset: 0 };
}

fn arenaAlloc(arena: *mut Arena, size: u32, al: u32) -> *mut opaque {
    let aligned = (arena.offset + al - 1) / al * al;
    let newOffset = aligned + size;

    assert newOffset <= arena.data.len as u32;

    let base: *mut u8 = &mut arena.data[aligned];
    set arena.offset = newOffset;

    return base as *mut opaque;
}

/// Allocator record matching the compiler's expected layout.
record Allocator {
    func: fn(*mut opaque, u32, u32) -> *mut opaque,
    ctx: *mut opaque,
}

fn arenaAllocFn(ctx: *mut opaque, size: u32, al: u32) -> *mut opaque {
    let arena = ctx as *mut Arena;
    return arenaAlloc(arena, size, al);
}

fn arenaAllocator(arena: *mut Arena) -> Allocator {
    return Allocator {
        func: arenaAllocFn,
        ctx: arena as *mut opaque,
    };
}

static BUF: [u8; 4096] = undefined;

@default fn main() -> i32 {
    let mut arena = newArena(&mut BUF[..]);
    let a = arenaAllocator(&mut arena);

    // Allocate initial capacity of 4.
    let ptr = arenaAlloc(&mut arena, @sizeOf(i32) * 4, @alignOf(i32));
    let mut nums = @sliceOf(ptr as *mut i32, 0, 4);

    // Append within capacity.
    nums.append(10, a);
    nums.append(20, a);
    nums.append(30, a);

    if nums.len <> 3 {
        return 1;
    }
    if nums.cap <> 4 {
        return 2;
    }
    if nums[0] <> 10 {
        return 3;
    }
    if nums[1] <> 20 {
        return 4;
    }
    if nums[2] <> 30 {
        return 5;
    }

    // Append to fill capacity.
    nums.append(40, a);

    if nums.len <> 4 {
        return 6;
    }
    if nums.cap <> 4 {
        return 7;
    }

    // Append past capacity -- triggers growth.
    nums.append(50, a);

    if nums.len <> 5 {
        return 8;
    }
    // Cap should have grown (cap * 2 | 1 = 4 * 2 | 1 = 9).
    if nums.cap <> 9 {
        return 9;
    }
    if nums[4] <> 50 {
        return 10;
    }

    // Verify old elements survived the copy.
    if nums[0] <> 10 {
        return 11;
    }
    if nums[3] <> 40 {
        return 12;
    }

    // Append from empty (cap == 0 triggers growth with cap = 1).
    let mut empty = @sliceOf(ptr as *mut i32, 0, 0);
    empty.append(99, a);

    if empty.len <> 1 {
        return 13;
    }
    if empty.cap <> 1 {
        return 14;
    }
    if empty[0] <> 99 {
        return 15;
    }

    // Sum all elements in nums.
    let mut sum: i32 = 0;
    for n in nums {
        set sum += n;
    }
    if sum <> 150 {
        return 16;
    }

    // Test append with u8 elements (stride = 1).
    let bytePtr = arenaAlloc(&mut arena, 2, 1);
    let mut bytes = @sliceOf(bytePtr as *mut u8, 0, 2);
    bytes.append(0xAB, a);
    bytes.append(0xCD, a);

    if bytes.len <> 2 {
        return 17;
    }
    if bytes[0] <> 0xAB {
        return 18;
    }
    if bytes[1] <> 0xCD {
        return 19;
    }

    // Trigger growth on u8 slice.
    bytes.append(0xEF, a);

    if bytes.len <> 3 {
        return 20;
    }
    if bytes.cap <> 5 {
        return 21;
    }
    if bytes[2] <> 0xEF {
        return 22;
    }
    // Verify old u8 elements survived.
    if bytes[0] <> 0xAB {
        return 23;
    }

    // Test that .append() returns the slice, allowing rebinding.
    let ptr2 = arenaAlloc(&mut arena, @sizeOf(i32) * 2, @alignOf(i32));
    let mut vals = @sliceOf(ptr2 as *mut i32, 0, 2);

    // Append within capacity, rebind via return value.
    set vals = vals.append(42, a);
    assert vals.len == 1;
    assert vals[0] == 42;

    set vals = vals.append(43, a);
    assert vals.len == 2;

    // Append past capacity -- triggers growth and returns updated slice.
    let oldPtr = &vals[0] as *opaque;
    set vals = vals.append(44, a);
    assert vals.len == 3;
    assert vals.cap == 5;

    // After growth, the data pointer should have changed.
    let newPtr = &vals[0] as *opaque;
    assert oldPtr <> newPtr;

    // Verify all elements survived.
    assert vals[0] == 42;
    assert vals[1] == 43;
    assert vals[2] == 44;

    return 0;
}

test/tests/slice.append.ril deleted +0 -789

data mut $BUF align 1 {
    undef * 4096;
}

fn w64 $newArena(w64 %0, w64 %1) {
  @entry0
    reserve %2 24 8;
    blit %2 %1 16;
    store w32 0 %2 16;
    blit %0 %2 24;
    ret %0;
}

fn w64 $arenaAlloc(w64 %0, w32 %1, w32 %2) {
  @entry0
    load w32 %3 %0 16;
    add w32 %4 %3 %2;
    sub w32 %5 %4 1;
    udiv w32 %6 %5 %2;
    mul w32 %7 %6 %2;
    add w32 %8 %7 %1;
    load w32 %9 %0 8;
    br.ult w32 %9 %8 @assert.fail1 @assert.ok2;
  @assert.fail1
    unreachable;
  @assert.ok2
    load w32 %10 %0 8;
    br.ult w32 %7 %10 @guard#pass3 @guard#trap4;
  @guard#pass3
    load w64 %11 %0 0;
    add w64 %12 %11 %7;
    store w32 %8 %0 16;
    ret %12;
  @guard#trap4
    ebreak;
    unreachable;
}

fn w64 $arenaAllocFn(w64 %0, w32 %1, w32 %2) {
  @entry0
    call w64 %3 $arenaAlloc(%0, %1, %2);
    ret %3;
}

fn w64 $arenaAllocator(w64 %0, w64 %1) {
  @entry0
    reserve %2 16 8;
    copy %3 $arenaAllocFn;
    store w64 %3 %2 0;
    store w64 %1 %2 8;
    blit %0 %2 16;
    ret %0;
}

fn w32 $main() {
  @entry0
    copy %0 $BUF;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store w32 4096 %1 8;
    store w32 4096 %1 12;
    reserve %2 24 8;
    call w64 %3 $newArena(%2, %1);
    reserve %4 16 8;
    call w64 %5 $arenaAllocator(%4, %3);
    mul w32 %6 4 4;
    call w64 %7 $arenaAlloc(%3, %6, 4);
    reserve %8 16 8;
    store w64 %7 %8 0;
    store w32 0 %8 8;
    store w32 4 %8 12;
    load w32 %9 %8 8;
    load w32 %10 %8 12;
    br.ult w32 %9 %10 @append.store1 @append.grow2;
  @append.store1
    load w64 %24 %8 0;
    mul w64 %25 %9 4;
    add w64 %26 %24 %25;
    store w32 10 %26 0;
    add w32 %27 %9 1;
    store w32 %27 %8 8;
    load w32 %32 %8 8;
    load w32 %33 %8 12;
    br.ult w32 %32 %33 @append.store6 @append.grow7;
  @append.grow2
    shl w32 %11 %10 1;
    or w32 %12 %11 1;
    load w64 %13 %5 0;
    load w64 %14 %5 8;
    mul w32 %15 %12 4;
    call w64 %16 %13(%14, %15, 4);
    load w64 %17 %8 0;
    mul w32 %18 %9 4;
    jmp @append3(0);
  @append3(w32 %19)
    br.ult w32 %19 %18 @append4 @append5;
  @append4
    add w64 %20 %17 %19;
    load w8 %21 %20 0;
    add w64 %22 %16 %19;
    store w8 %21 %22 0;
    add w32 %23 %19 1;
    jmp @append3(%23);
  @append5
    store w64 %16 %8 0;
    store w32 %12 %8 12;
    jmp @append.store1;
  @append.store6
    load w64 %47 %8 0;
    mul w64 %48 %32 4;
    add w64 %49 %47 %48;
    store w32 20 %49 0;
    add w32 %50 %32 1;
    store w32 %50 %8 8;
    load w32 %55 %8 8;
    load w32 %56 %8 12;
    br.ult w32 %55 %56 @append.store11 @append.grow12;
  @append.grow7
    shl w32 %34 %33 1;
    or w32 %35 %34 1;
    load w64 %36 %5 0;
    load w64 %37 %5 8;
    mul w32 %38 %35 4;
    call w64 %39 %36(%37, %38, 4);
    load w64 %40 %8 0;
    mul w32 %41 %32 4;
    jmp @append8(0);
  @append8(w32 %42)
    br.ult w32 %42 %41 @append9 @append10;
  @append9
    add w64 %43 %40 %42;
    load w8 %44 %43 0;
    add w64 %45 %39 %42;
    store w8 %44 %45 0;
    add w32 %46 %42 1;
    jmp @append8(%46);
  @append10
    store w64 %39 %8 0;
    store w32 %35 %8 12;
    jmp @append.store6;
  @append.store11
    load w64 %70 %8 0;
    mul w64 %71 %55 4;
    add w64 %72 %70 %71;
    store w32 30 %72 0;
    add w32 %73 %55 1;
    store w32 %73 %8 8;
    load w32 %76 %8 8;
    br.ne w32 %76 3 @then16 @merge17;
  @append.grow12
    shl w32 %57 %56 1;
    or w32 %58 %57 1;
    load w64 %59 %5 0;
    load w64 %60 %5 8;
    mul w32 %61 %58 4;
    call w64 %62 %59(%60, %61, 4);
    load w64 %63 %8 0;
    mul w32 %64 %55 4;
    jmp @append13(0);
  @append13(w32 %65)
    br.ult w32 %65 %64 @append14 @append15;
  @append14
    add w64 %66 %63 %65;
    load w8 %67 %66 0;
    add w64 %68 %62 %65;
    store w8 %67 %68 0;
    add w32 %69 %65 1;
    jmp @append13(%69);
  @append15
    store w64 %62 %8 0;
    store w32 %58 %8 12;
    jmp @append.store11;
  @then16
    ret 1;
  @merge17
    load w32 %77 %8 12;
    br.ne w32 %77 4 @then18 @merge19;
  @then18
    ret 2;
  @merge19
    load w32 %78 %8 8;
    br.ult w32 0 %78 @guard#pass22 @guard#trap23;
  @then20
    ret 3;
  @merge21
    load w32 %81 %8 8;
    br.ult w32 1 %81 @guard#pass26 @guard#trap27;
  @guard#pass22
    load w64 %79 %8 0;
    sload w32 %80 %79 0;
    br.ne w32 %80 10 @then20 @merge21;
  @guard#trap23
    ebreak;
    unreachable;
  @then24
    ret 4;
  @merge25
    load w32 %86 %8 8;
    br.ult w32 2 %86 @guard#pass30 @guard#trap31;
  @guard#pass26
    load w64 %82 %8 0;
    mul w64 %83 1 4;
    add w64 %84 %82 %83;
    sload w32 %85 %84 0;
    br.ne w32 %85 20 @then24 @merge25;
  @guard#trap27
    ebreak;
    unreachable;
  @then28
    ret 5;
  @merge29
    load w32 %93 %8 8;
    load w32 %94 %8 12;
    br.ult w32 %93 %94 @append.store32 @append.grow33;
  @guard#pass30
    load w64 %87 %8 0;
    mul w64 %88 2 4;
    add w64 %89 %87 %88;
    sload w32 %90 %89 0;
    br.ne w32 %90 30 @then28 @merge29;
  @guard#trap31
    ebreak;
    unreachable;
  @append.store32
    load w64 %108 %8 0;
    mul w64 %109 %93 4;
    add w64 %110 %108 %109;
    store w32 40 %110 0;
    add w32 %111 %93 1;
    store w32 %111 %8 8;
    load w32 %114 %8 8;
    br.ne w32 %114 4 @then37 @merge38;
  @append.grow33
    shl w32 %95 %94 1;
    or w32 %96 %95 1;
    load w64 %97 %5 0;
    load w64 %98 %5 8;
    mul w32 %99 %96 4;
    call w64 %100 %97(%98, %99, 4);
    load w64 %101 %8 0;
    mul w32 %102 %93 4;
    jmp @append34(0);
  @append34(w32 %103)
    br.ult w32 %103 %102 @append35 @append36;
  @append35
    add w64 %104 %101 %103;
    load w8 %105 %104 0;
    add w64 %106 %100 %103;
    store w8 %105 %106 0;
    add w32 %107 %103 1;
    jmp @append34(%107);
  @append36
    store w64 %100 %8 0;
    store w32 %96 %8 12;
    jmp @append.store32;
  @then37
    ret 6;
  @merge38
    load w32 %115 %8 12;
    br.ne w32 %115 4 @then39 @merge40;
  @then39
    ret 7;
  @merge40
    load w32 %118 %8 8;
    load w32 %119 %8 12;
    br.ult w32 %118 %119 @append.store41 @append.grow42;
  @append.store41
    load w64 %133 %8 0;
    mul w64 %134 %118 4;
    add w64 %135 %133 %134;
    store w32 50 %135 0;
    add w32 %136 %118 1;
    store w32 %136 %8 8;
    load w32 %139 %8 8;
    br.ne w32 %139 5 @then46 @merge47;
  @append.grow42
    shl w32 %120 %119 1;
    or w32 %121 %120 1;
    load w64 %122 %5 0;
    load w64 %123 %5 8;
    mul w32 %124 %121 4;
    call w64 %125 %122(%123, %124, 4);
    load w64 %126 %8 0;
    mul w32 %127 %118 4;
    jmp @append43(0);
  @append43(w32 %128)
    br.ult w32 %128 %127 @append44 @append45;
  @append44
    add w64 %129 %126 %128;
    load w8 %130 %129 0;
    add w64 %131 %125 %128;
    store w8 %130 %131 0;
    add w32 %132 %128 1;
    jmp @append43(%132);
  @append45
    store w64 %125 %8 0;
    store w32 %121 %8 12;
    jmp @append.store41;
  @then46
    ret 8;
  @merge47
    load w32 %140 %8 12;
    br.ne w32 %140 9 @then48 @merge49;
  @then48
    ret 9;
  @merge49
    load w32 %141 %8 8;
    br.ult w32 4 %141 @guard#pass52 @guard#trap53;
  @then50
    ret 10;
  @merge51
    load w32 %146 %8 8;
    br.ult w32 0 %146 @guard#pass56 @guard#trap57;
  @guard#pass52
    load w64 %142 %8 0;
    mul w64 %143 4 4;
    add w64 %144 %142 %143;
    sload w32 %145 %144 0;
    br.ne w32 %145 50 @then50 @merge51;
  @guard#trap53
    ebreak;
    unreachable;
  @then54
    ret 11;
  @merge55
    load w32 %149 %8 8;
    br.ult w32 3 %149 @guard#pass60 @guard#trap61;
  @guard#pass56
    load w64 %147 %8 0;
    sload w32 %148 %147 0;
    br.ne w32 %148 10 @then54 @merge55;
  @guard#trap57
    ebreak;
    unreachable;
  @then58
    ret 12;
  @merge59
    reserve %164 16 8;
    store w64 %7 %164 0;
    store w32 0 %164 8;
    store w32 0 %164 12;
    load w32 %167 %164 8;
    load w32 %168 %164 12;
    br.ult w32 %167 %168 @append.store62 @append.grow63;
  @guard#pass60
    load w64 %150 %8 0;
    mul w64 %151 3 4;
    add w64 %152 %150 %151;
    sload w32 %153 %152 0;
    br.ne w32 %153 40 @then58 @merge59;
  @guard#trap61
    ebreak;
    unreachable;
  @append.store62
    load w64 %182 %164 0;
    mul w64 %183 %167 4;
    add w64 %184 %182 %183;
    store w32 99 %184 0;
    add w32 %185 %167 1;
    store w32 %185 %164 8;
    load w32 %188 %164 8;
    br.ne w32 %188 1 @then67 @merge68;
  @append.grow63
    shl w32 %169 %168 1;
    or w32 %170 %169 1;
    load w64 %171 %5 0;
    load w64 %172 %5 8;
    mul w32 %173 %170 4;
    call w64 %174 %171(%172, %173, 4);
    load w64 %175 %164 0;
    mul w32 %176 %167 4;
    jmp @append64(0);
  @append64(w32 %177)
    br.ult w32 %177 %176 @append65 @append66;
  @append65
    add w64 %178 %175 %177;
    load w8 %179 %178 0;
    add w64 %180 %174 %177;
    store w8 %179 %180 0;
    add w32 %181 %177 1;
    jmp @append64(%181);
  @append66
    store w64 %174 %164 0;
    store w32 %170 %164 12;
    jmp @append.store62;
  @then67
    ret 13;
  @merge68
    load w32 %189 %164 12;
    br.ne w32 %189 1 @then69 @merge70;
  @then69
    ret 14;
  @merge70
    load w32 %190 %164 8;
    br.ult w32 0 %190 @guard#pass73 @guard#trap74;
  @then71
    ret 15;
  @merge72
    load w32 %195 %8 8;
    load w64 %196 %8 0;
    jmp @loop75(0, 0);
  @guard#pass73
    load w64 %191 %164 0;
    sload w32 %192 %191 0;
    br.ne w32 %192 99 @then71 @merge72;
  @guard#trap74
    ebreak;
    unreachable;
  @loop75(w32 %197, w32 %201)
    br.slt w32 %197 %195 @body76 @merge77;
  @body76
    mul w64 %198 %197 4;
    add w64 %199 %196 %198;
    sload w32 %200 %199 0;
    add w32 %202 %201 %200;
    add w32 %203 %197 1;
    jmp @loop75(%203, %202);
  @merge77
    br.ne w32 %201 150 @then78 @merge79;
  @then78
    ret 16;
  @merge79
    call w64 %217 $arenaAlloc(%3, 2, 1);
    reserve %218 16 8;
    store w64 %217 %218 0;
    store w32 0 %218 8;
    store w32 2 %218 12;
    load w32 %222 %218 8;
    load w32 %223 %218 12;
    br.ult w32 %222 %223 @append.store80 @append.grow81;
  @append.store80
    load w64 %237 %218 0;
    add w64 %238 %237 %222;
    store w8 171 %238 0;
    add w32 %239 %222 1;
    store w32 %239 %218 8;
    load w32 %244 %218 8;
    load w32 %245 %218 12;
    br.ult w32 %244 %245 @append.store85 @append.grow86;
  @append.grow81
    shl w32 %224 %223 1;
    or w32 %225 %224 1;
    load w64 %226 %5 0;
    load w64 %227 %5 8;
    mul w32 %228 %225 1;
    call w64 %229 %226(%227, %228, 1);
    load w64 %230 %218 0;
    mul w32 %231 %222 1;
    jmp @append82(0);
  @append82(w32 %232)
    br.ult w32 %232 %231 @append83 @append84;
  @append83
    add w64 %233 %230 %232;
    load w8 %234 %233 0;
    add w64 %235 %229 %232;
    store w8 %234 %235 0;
    add w32 %236 %232 1;
    jmp @append82(%236);
  @append84
    store w64 %229 %218 0;
    store w32 %225 %218 12;
    jmp @append.store80;
  @append.store85
    load w64 %259 %218 0;
    add w64 %260 %259 %244;
    store w8 205 %260 0;
    add w32 %261 %244 1;
    store w32 %261 %218 8;
    load w32 %264 %218 8;
    br.ne w32 %264 2 @then90 @merge91;
  @append.grow86
    shl w32 %246 %245 1;
    or w32 %247 %246 1;
    load w64 %248 %5 0;
    load w64 %249 %5 8;
    mul w32 %250 %247 1;
    call w64 %251 %248(%249, %250, 1);
    load w64 %252 %218 0;
    mul w32 %253 %244 1;
    jmp @append87(0);
  @append87(w32 %254)
    br.ult w32 %254 %253 @append88 @append89;
  @append88
    add w64 %255 %252 %254;
    load w8 %256 %255 0;
    add w64 %257 %251 %254;
    store w8 %256 %257 0;
    add w32 %258 %254 1;
    jmp @append87(%258);
  @append89
    store w64 %251 %218 0;
    store w32 %247 %218 12;
    jmp @append.store85;
  @then90
    ret 17;
  @merge91
    load w32 %265 %218 8;
    br.ult w32 0 %265 @guard#pass94 @guard#trap95;
  @then92
    ret 18;
  @merge93
    load w32 %268 %218 8;
    br.ult w32 1 %268 @guard#pass98 @guard#trap99;
  @guard#pass94
    load w64 %266 %218 0;
    load w8 %267 %266 0;
    br.ne w8 %267 171 @then92 @merge93;
  @guard#trap95
    ebreak;
    unreachable;
  @then96
    ret 19;
  @merge97
    load w32 %274 %218 8;
    load w32 %275 %218 12;
    br.ult w32 %274 %275 @append.store100 @append.grow101;
  @guard#pass98
    load w64 %269 %218 0;
    add w64 %270 %269 1;
    load w8 %271 %270 0;
    br.ne w8 %271 205 @then96 @merge97;
  @guard#trap99
    ebreak;
    unreachable;
  @append.store100
    load w64 %289 %218 0;
    add w64 %290 %289 %274;
    store w8 239 %290 0;
    add w32 %291 %274 1;
    store w32 %291 %218 8;
    load w32 %294 %218 8;
    br.ne w32 %294 3 @then105 @merge106;
  @append.grow101
    shl w32 %276 %275 1;
    or w32 %277 %276 1;
    load w64 %278 %5 0;
    load w64 %279 %5 8;
    mul w32 %280 %277 1;
    call w64 %281 %278(%279, %280, 1);
    load w64 %282 %218 0;
    mul w32 %283 %274 1;
    jmp @append102(0);
  @append102(w32 %284)
    br.ult w32 %284 %283 @append103 @append104;
  @append103
    add w64 %285 %282 %284;
    load w8 %286 %285 0;
    add w64 %287 %281 %284;
    store w8 %286 %287 0;
    add w32 %288 %284 1;
    jmp @append102(%288);
  @append104
    store w64 %281 %218 0;
    store w32 %277 %218 12;
    jmp @append.store100;
  @then105
    ret 20;
  @merge106
    load w32 %295 %218 12;
    br.ne w32 %295 5 @then107 @merge108;
  @then107
    ret 21;
  @merge108
    load w32 %296 %218 8;
    br.ult w32 2 %296 @guard#pass111 @guard#trap112;
  @then109
    ret 22;
  @merge110
    load w32 %300 %218 8;
    br.ult w32 0 %300 @guard#pass115 @guard#trap116;
  @guard#pass111
    load w64 %297 %218 0;
    add w64 %298 %297 2;
    load w8 %299 %298 0;
    br.ne w8 %299 239 @then109 @merge110;
  @guard#trap112
    ebreak;
    unreachable;
  @then113
    ret 23;
  @merge114
    mul w32 %309 4 2;
    call w64 %310 $arenaAlloc(%3, %309, 4);
    reserve %311 16 8;
    store w64 %310 %311 0;
    store w32 0 %311 8;
    store w32 2 %311 12;
    load w32 %314 %311 8;
    load w32 %315 %311 12;
    br.ult w32 %314 %315 @append.store117 @append.grow118;
  @guard#pass115
    load w64 %301 %218 0;
    load w8 %302 %301 0;
    br.ne w8 %302 171 @then113 @merge114;
  @guard#trap116
    ebreak;
    unreachable;
  @append.store117
    load w64 %329 %311 0;
    mul w64 %330 %314 4;
    add w64 %331 %329 %330;
    store w32 42 %331 0;
    add w32 %332 %314 1;
    store w32 %332 %311 8;
    blit %311 %311 16;
    load w32 %335 %311 8;
    br.eq w32 %335 1 @assert.ok123 @assert.fail122;
  @append.grow118
    shl w32 %316 %315 1;
    or w32 %317 %316 1;
    load w64 %318 %5 0;
    load w64 %319 %5 8;
    mul w32 %320 %317 4;
    call w64 %321 %318(%319, %320, 4);
    load w64 %322 %311 0;
    mul w32 %323 %314 4;
    jmp @append119(0);
  @append119(w32 %324)
    br.ult w32 %324 %323 @append120 @append121;
  @append120
    add w64 %325 %322 %324;
    load w8 %326 %325 0;
    add w64 %327 %321 %324;
    store w8 %326 %327 0;
    add w32 %328 %324 1;
    jmp @append119(%328);
  @append121
    store w64 %321 %311 0;
    store w32 %317 %311 12;
    jmp @append.store117;
  @assert.fail122
    unreachable;
  @assert.ok123
    load w32 %336 %311 8;
    br.ult w32 0 %336 @guard#pass126 @guard#trap127;
  @assert.fail124
    unreachable;
  @assert.ok125
    load w32 %341 %311 8;
    load w32 %342 %311 12;
    br.ult w32 %341 %342 @append.store128 @append.grow129;
  @guard#pass126
    load w64 %337 %311 0;
    sload w32 %338 %337 0;
    br.eq w32 %338 42 @assert.ok125 @assert.fail124;
  @guard#trap127
    ebreak;
    unreachable;
  @append.store128
    load w64 %356 %311 0;
    mul w64 %357 %341 4;
    add w64 %358 %356 %357;
    store w32 43 %358 0;
    add w32 %359 %341 1;
    store w32 %359 %311 8;
    blit %311 %311 16;
    load w32 %362 %311 8;
    br.eq w32 %362 2 @assert.ok134 @assert.fail133;
  @append.grow129
    shl w32 %343 %342 1;
    or w32 %344 %343 1;
    load w64 %345 %5 0;
    load w64 %346 %5 8;
    mul w32 %347 %344 4;
    call w64 %348 %345(%346, %347, 4);
    load w64 %349 %311 0;
    mul w32 %350 %341 4;
    jmp @append130(0);
  @append130(w32 %351)
    br.ult w32 %351 %350 @append131 @append132;
  @append131
    add w64 %352 %349 %351;
    load w8 %353 %352 0;
    add w64 %354 %348 %351;
    store w8 %353 %354 0;
    add w32 %355 %351 1;
    jmp @append130(%355);
  @append132
    store w64 %348 %311 0;
    store w32 %344 %311 12;
    jmp @append.store128;
  @assert.fail133
    unreachable;
  @assert.ok134
    load w32 %363 %311 8;
    br.ult w32 0 %363 @guard#pass135 @guard#trap136;
  @guard#pass135
    load w64 %364 %311 0;
    load w32 %367 %311 8;
    load w32 %368 %311 12;
    br.ult w32 %367 %368 @append.store137 @append.grow138;
  @guard#trap136
    ebreak;
    unreachable;
  @append.store137
    load w64 %382 %311 0;
    mul w64 %383 %367 4;
    add w64 %384 %382 %383;
    store w32 44 %384 0;
    add w32 %385 %367 1;
    store w32 %385 %311 8;
    blit %311 %311 16;
    load w32 %388 %311 8;
    br.eq w32 %388 3 @assert.ok143 @assert.fail142;
  @append.grow138
    shl w32 %369 %368 1;
    or w32 %370 %369 1;
    load w64 %371 %5 0;
    load w64 %372 %5 8;
    mul w32 %373 %370 4;
    call w64 %374 %371(%372, %373, 4);
    load w64 %375 %311 0;
    mul w32 %376 %367 4;
    jmp @append139(0);
  @append139(w32 %377)
    br.ult w32 %377 %376 @append140 @append141;
  @append140
    add w64 %378 %375 %377;
    load w8 %379 %378 0;
    add w64 %380 %374 %377;
    store w8 %379 %380 0;
    add w32 %381 %377 1;
    jmp @append139(%381);
  @append141
    store w64 %374 %311 0;
    store w32 %370 %311 12;
    jmp @append.store137;
  @assert.fail142
    unreachable;
  @assert.ok143
    load w32 %389 %311 12;
    br.eq w32 %389 5 @assert.ok145 @assert.fail144;
  @assert.fail144
    unreachable;
  @assert.ok145
    load w32 %390 %311 8;
    br.ult w32 0 %390 @guard#pass146 @guard#trap147;
  @guard#pass146
    load w64 %391 %311 0;
    br.ne w64 %364 %391 @assert.ok149 @assert.fail148;
  @guard#trap147
    ebreak;
    unreachable;
  @assert.fail148
    unreachable;
  @assert.ok149
    load w32 %394 %311 8;
    br.ult w32 0 %394 @guard#pass152 @guard#trap153;
  @assert.fail150
    unreachable;
  @assert.ok151
    load w32 %397 %311 8;
    br.ult w32 1 %397 @guard#pass156 @guard#trap157;
  @guard#pass152
    load w64 %395 %311 0;
    sload w32 %396 %395 0;
    br.eq w32 %396 42 @assert.ok151 @assert.fail150;
  @guard#trap153
    ebreak;
    unreachable;
  @assert.fail154
    unreachable;
  @assert.ok155
    load w32 %402 %311 8;
    br.ult w32 2 %402 @guard#pass160 @guard#trap161;
  @guard#pass156
    load w64 %398 %311 0;
    mul w64 %399 1 4;
    add w64 %400 %398 %399;
    sload w32 %401 %400 0;
    br.eq w32 %401 43 @assert.ok155 @assert.fail154;
  @guard#trap157
    ebreak;
    unreachable;
  @assert.fail158
    unreachable;
  @assert.ok159
    ret 0;
  @guard#pass160
    load w64 %403 %311 0;
    mul w64 %404 2 4;
    add w64 %405 %403 %404;
    sload w32 %406 %405 0;
    br.eq w32 %406 44 @assert.ok159 @assert.fail158;
  @guard#trap161
    ebreak;
    unreachable;
}


test/tests/slice.basic.rad +0 -9

/// Returns the length field from a slice header.
fn sliceLen(s: *[i32]) -> u32 {
    return s.len;
}

/// Returns the capacity field from a slice header.
fn sliceCap(s: *[i32]) -> u32 {
    return s.cap;
}

/// Returns the pointer field from a slice header.
fn slicePtr(s: *[i32]) -> *i32 {
    return s.ptr;
}


/// Builds a slice header from a pointer and length.
fn sliceOf(ptr: *i32, len: u32) -> *[i32] {
    return @sliceOf(ptr, len);
}

/// Builds a slice header from pointer, length, and capacity.
fn sliceOfWithCap(ptr: *i32, len: u32, cap: u32) -> *[i32] {
    return @sliceOf(ptr, len, cap);
}

test/tests/slice.basic.ril +0 -21

  @entry0
    load w32 %1 %0 8;
    ret %1;
}

fn w32 $sliceCap(w64 %0) {
  @entry0
    load w32 %1 %0 12;
    ret %1;
}

fn w64 $slicePtr(w64 %0) {
  @entry0
    load w64 %1 %0 0;
    ret %1;
}

fn w64 $sliceOf(w64 %0, w64 %1, w32 %2) {
  @entry0
    reserve %3 16 8;
    store w64 %1 %3 0;
    store w32 %2 %3 8;
    store w32 %2 %3 12;
    blit %0 %3 16;
    ret %0;
}

fn w64 $sliceOfWithCap(w64 %0, w64 %1, w32 %2, w32 %3) {
  @entry0
    br.ult w32 %3 %2 @guard#trap1 @guard#pass2;
  @guard#trap1
    ebreak;
    unreachable;
  @guard#pass2
    reserve %4 16 8;
    store w64 %1 %4 0;
    store w32 %2 %4 8;
    store w32 %3 %4 12;
    blit %0 %4 16;
    ret %0;
}

test/tests/slice.cap.rad deleted +0 -53

//! returns: 0
//! Test slice capacity field and @sliceOf builtin.

@default fn main() -> i32 {
    // Test that regular slices have cap == len.
    let mut arr: [i32; 4] = [10, 20, 30, 40];
    let s = &mut arr[..];

    if s.cap <> 4 {
        return 1;
    }
    if s.len <> s.cap {
        return 2;
    }

    // Test @sliceOf with explicit capacity.
    let ptr = &mut arr[0];
    let s2 = @sliceOf(ptr, 2, 4);

    if s2.len <> 2 {
        return 3;
    }
    if s2.cap <> 4 {
        return 4;
    }
    if s2[0] <> 10 {
        return 5;
    }
    if s2[1] <> 20 {
        return 6;
    }

    // Test @sliceOf with zero length.
    let s3 = @sliceOf(ptr, 0, 4);

    if s3.len <> 0 {
        return 7;
    }
    if s3.cap <> 4 {
        return 8;
    }

    // Test @sliceOf still works and has cap == len.
    let s4 = @sliceOf(ptr, 3);

    if s4.len <> 3 {
        return 9;
    }
    if s4.cap <> 3 {
        return 10;
    }
    return 0;
}

test/tests/slice.delete.rad deleted +0 -61

//! returns: 0
//! Test slice .delete() method.

@default fn main() -> i32 {
    let mut arr: [i32; 5] = [10, 20, 30, 40, 50];
    let mut s = &mut arr[..];

    // Delete middle element (index 2: value 30).
    s.delete(2);

    if s.len <> 4 {
        return 1;
    }
    if s[0] <> 10 {
        return 2;
    }
    if s[1] <> 20 {
        return 3;
    }
    if s[2] <> 40 {
        return 4;
    }
    if s[3] <> 50 {
        return 5;
    }

    // Delete first element (index 0: value 10).
    s.delete(0);

    if s.len <> 3 {
        return 6;
    }
    if s[0] <> 20 {
        return 7;
    }
    if s[1] <> 40 {
        return 8;
    }
    if s[2] <> 50 {
        return 9;
    }

    // Delete last element (index 2: value 50).
    s.delete(2);

    if s.len <> 2 {
        return 10;
    }
    if s[0] <> 20 {
        return 11;
    }
    if s[1] <> 40 {
        return 12;
    }

    // Cap should be unchanged.
    if s.cap <> 5 {
        return 13;
    }
    return 0;
}

test/tests/slice.delete.ril deleted +0 -231

fn w32 $main() {
  @entry0
    reserve %0 20 4;
    store w32 10 %0 0;
    store w32 20 %0 4;
    store w32 30 %0 8;
    store w32 40 %0 12;
    store w32 50 %0 16;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store w32 5 %1 8;
    store w32 5 %1 12;
    load w32 %2 %1 8;
    br.ult w32 2 %2 @guard#pass1 @guard#trap2;
  @guard#pass1
    load w64 %3 %1 0;
    mul w64 %4 2 4;
    add w64 %5 %3 %4;
    add w64 %6 %5 4;
    sub w32 %7 %2 2;
    sub w32 %8 %7 1;
    mul w32 %9 %8 4;
    jmp @delete3(0);
  @guard#trap2
    ebreak;
    unreachable;
  @delete3(w32 %10)
    br.ult w32 %10 %9 @delete4 @delete5;
  @delete4
    add w64 %11 %6 %10;
    load w8 %12 %11 0;
    add w64 %13 %5 %10;
    store w8 %12 %13 0;
    add w32 %14 %10 1;
    jmp @delete3(%14);
  @delete5
    sub w32 %15 %2 1;
    store w32 %15 %1 8;
    load w32 %17 %1 8;
    br.ne w32 %17 4 @then6 @merge7;
  @then6
    ret 1;
  @merge7
    load w32 %18 %1 8;
    br.ult w32 0 %18 @guard#pass10 @guard#trap11;
  @then8
    ret 2;
  @merge9
    load w32 %21 %1 8;
    br.ult w32 1 %21 @guard#pass14 @guard#trap15;
  @guard#pass10
    load w64 %19 %1 0;
    sload w32 %20 %19 0;
    br.ne w32 %20 10 @then8 @merge9;
  @guard#trap11
    ebreak;
    unreachable;
  @then12
    ret 3;
  @merge13
    load w32 %26 %1 8;
    br.ult w32 2 %26 @guard#pass18 @guard#trap19;
  @guard#pass14
    load w64 %22 %1 0;
    mul w64 %23 1 4;
    add w64 %24 %22 %23;
    sload w32 %25 %24 0;
    br.ne w32 %25 20 @then12 @merge13;
  @guard#trap15
    ebreak;
    unreachable;
  @then16
    ret 4;
  @merge17
    load w32 %31 %1 8;
    br.ult w32 3 %31 @guard#pass22 @guard#trap23;
  @guard#pass18
    load w64 %27 %1 0;
    mul w64 %28 2 4;
    add w64 %29 %27 %28;
    sload w32 %30 %29 0;
    br.ne w32 %30 40 @then16 @merge17;
  @guard#trap19
    ebreak;
    unreachable;
  @then20
    ret 5;
  @merge21
    load w32 %36 %1 8;
    br.ult w32 0 %36 @guard#pass24 @guard#trap25;
  @guard#pass22
    load w64 %32 %1 0;
    mul w64 %33 3 4;
    add w64 %34 %32 %33;
    sload w32 %35 %34 0;
    br.ne w32 %35 50 @then20 @merge21;
  @guard#trap23
    ebreak;
    unreachable;
  @guard#pass24
    load w64 %37 %1 0;
    add w64 %38 %37 4;
    sub w32 %39 %36 0;
    sub w32 %40 %39 1;
    mul w32 %41 %40 4;
    jmp @delete26(0);
  @guard#trap25
    ebreak;
    unreachable;
  @delete26(w32 %42)
    br.ult w32 %42 %41 @delete27 @delete28;
  @delete27
    add w64 %43 %38 %42;
    load w8 %44 %43 0;
    add w64 %45 %37 %42;
    store w8 %44 %45 0;
    add w32 %46 %42 1;
    jmp @delete26(%46);
  @delete28
    sub w32 %47 %36 1;
    store w32 %47 %1 8;
    load w32 %49 %1 8;
    br.ne w32 %49 3 @then29 @merge30;
  @then29
    ret 6;
  @merge30
    load w32 %50 %1 8;
    br.ult w32 0 %50 @guard#pass33 @guard#trap34;
  @then31
    ret 7;
  @merge32
    load w32 %53 %1 8;
    br.ult w32 1 %53 @guard#pass37 @guard#trap38;
  @guard#pass33
    load w64 %51 %1 0;
    sload w32 %52 %51 0;
    br.ne w32 %52 20 @then31 @merge32;
  @guard#trap34
    ebreak;
    unreachable;
  @then35
    ret 8;
  @merge36
    load w32 %58 %1 8;
    br.ult w32 2 %58 @guard#pass41 @guard#trap42;
  @guard#pass37
    load w64 %54 %1 0;
    mul w64 %55 1 4;
    add w64 %56 %54 %55;
    sload w32 %57 %56 0;
    br.ne w32 %57 40 @then35 @merge36;
  @guard#trap38
    ebreak;
    unreachable;
  @then39
    ret 9;
  @merge40
    load w32 %63 %1 8;
    br.ult w32 2 %63 @guard#pass43 @guard#trap44;
  @guard#pass41
    load w64 %59 %1 0;
    mul w64 %60 2 4;
    add w64 %61 %59 %60;
    sload w32 %62 %61 0;
    br.ne w32 %62 50 @then39 @merge40;
  @guard#trap42
    ebreak;
    unreachable;
  @guard#pass43
    load w64 %64 %1 0;
    mul w64 %65 2 4;
    add w64 %66 %64 %65;
    add w64 %67 %66 4;
    sub w32 %68 %63 2;
    sub w32 %69 %68 1;
    mul w32 %70 %69 4;
    jmp @delete45(0);
  @guard#trap44
    ebreak;
    unreachable;
  @delete45(w32 %71)
    br.ult w32 %71 %70 @delete46 @delete47;
  @delete46
    add w64 %72 %67 %71;
    load w8 %73 %72 0;
    add w64 %74 %66 %71;
    store w8 %73 %74 0;
    add w32 %75 %71 1;
    jmp @delete45(%75);
  @delete47
    sub w32 %76 %63 1;
    store w32 %76 %1 8;
    load w32 %78 %1 8;
    br.ne w32 %78 2 @then48 @merge49;
  @then48
    ret 10;
  @merge49
    load w32 %79 %1 8;
    br.ult w32 0 %79 @guard#pass52 @guard#trap53;
  @then50
    ret 11;
  @merge51
    load w32 %82 %1 8;
    br.ult w32 1 %82 @guard#pass56 @guard#trap57;
  @guard#pass52
    load w64 %80 %1 0;
    sload w32 %81 %80 0;
    br.ne w32 %81 20 @then50 @merge51;
  @guard#trap53
    ebreak;
    unreachable;
  @then54
    ret 12;
  @merge55
    load w32 %87 %1 12;
    br.ne w32 %87 5 @then58 @merge59;
  @guard#pass56
    load w64 %83 %1 0;
    mul w64 %84 1 4;
    add w64 %85 %83 %84;
    sload w32 %86 %85 0;
    br.ne w32 %86 40 @then54 @merge55;
  @guard#trap57
    ebreak;
    unreachable;
  @then58
    ret 13;
  @merge59
    ret 0;
}


test/tests/slice.range.ril +0 -5

    add w64 %7 %4 %6;
    sub w32 %8 %3 %2;
    reserve %9 16 8;
    store w64 %7 %9 0;
    store w32 %8 %9 8;
    store w32 %8 %9 12;
    blit %0 %9 16;
    ret %0;
}

fn w64 $sliceRangeOpenEnd(w64 %0, w64 %1, w32 %2) {

    add w64 %6 %3 %5;
    sub w32 %7 %4 %2;
    reserve %8 16 8;
    store w64 %6 %8 0;
    store w32 %7 %8 8;
    store w32 %7 %8 12;
    blit %0 %8 16;
    ret %0;
}

fn w64 $sliceRangeOpenStart(w64 %0, w64 %1, w32 %2) {

    unreachable;
  @guard#pass2
    reserve %5 16 8;
    store w64 %3 %5 0;
    store w32 %2 %5 8;
    store w32 %2 %5 12;
    blit %0 %5 16;
    ret %0;
}

fn w64 $sliceRangeFull(w64 %0, w64 %1) {

    load w64 %2 %1 0;
    load w32 %3 %1 8;
    reserve %4 16 8;
    store w64 %2 %4 0;
    store w32 %3 %4 8;
    store w32 %3 %4 12;
    blit %0 %4 16;
    ret %0;
}

fn w64 $sliceArray(w64 %0, w64 %1) {

    add w64 %3 %1 %2;
    sub w32 %4 3 1;
    reserve %5 16 8;
    store w64 %3 %5 0;
    store w32 %4 %5 8;
    store w32 %4 %5 12;
    blit %0 %5 16;
    ret %0;
}

test/tests/slice.runtime.i32.ril +0 -3

    reserve %2 4 4;
    store w32 %1 %2 0;
    reserve %3 16 8;
    store w64 %2 %3 0;
    store w32 1 %3 8;
    store w32 1 %3 12;
    blit %0 %3 16;
    ret %0;
}

fn w64 $sliceWithVars(w64 %0, w32 %1, w32 %2) {

    store w32 %1 %3 0;
    store w32 %2 %3 4;
    reserve %4 16 8;
    store w64 %3 %4 0;
    store w32 2 %4 8;
    store w32 2 %4 12;
    blit %0 %4 16;
    ret %0;
}

fn w64 $sliceWithMixed(w64 %0, w32 %1) {

    store w32 42 %2 4;
    store w32 %1 %2 8;
    reserve %3 16 8;
    store w64 %2 %3 0;
    store w32 3 %3 8;
    store w32 3 %3 12;
    blit %0 %3 16;
    ret %0;
}

test/tests/slice.runtime.literal.ril +0 -2

    reserve %2 1 1;
    store w8 %1 %2 0;
    reserve %3 16 8;
    store w64 %2 %3 0;
    store w32 1 %3 8;
    store w32 1 %3 12;
    blit %0 %3 16;
    ret %0;
}

fn w64 $sliceWithVars(w64 %0, w8 %1, w8 %2) {

16	15		store w8 %1 %3 0;
17	16		store w8 %2 %3 1;
18	17		reserve %4 16 8;
19	18		store w64 %3 %4 0;
20	19		store w32 2 %4 8;
21		-	store w32 2 %4 12;
22	20		blit %0 %4 16;
23	21		ret %0;
24	22		}

test/tests/trait.supertrait.ril +0 -3

    load w64 %8 %7 8;
    copy %9 $main$literal$0;
    reserve %10 16 8;
    store w64 %9 %10 0;
    store w32 3 %10 8;
    store w32 3 %10 12;
    call w32 %11 %8(%6, %10);
    br.eq w32 %11 3 @assert.ok2 @assert.fail1;
  @assert.fail1
    unreachable;
  @assert.ok2

    load w64 %15 %5 8;
    load w64 %16 %15 0;
    reserve %17 16 8;
    store w64 %13 %17 0;
    store w32 8 %17 8;
    store w32 8 %17 12;
    call w32 %18 %16(%14, %17);
    br.eq w32 %18 5 @assert.ok6 @assert.fail5;
  @assert.fail5
    unreachable;
  @assert.ok6

  @assert.fail13
    unreachable;
  @assert.ok14
    ret 0;
}


test/tests/vec.generic.rad added +43 -0

1	+	//! returns: 0
2	+
3	+	use std::lang::alloc;
4	+	use std::vec;
5	+
6	+	/// Fixed storage for vector growth allocations.
7	+	static VEC_ARENA_STORAGE: [u8; 64] = undefined;
8	+
9	+	/// Initial vector storage whose capacity is deliberately exceeded.
10	+	static VEC_INITIAL_STORAGE: [i32; 2] = undefined;
11	+
12	+	instantiate vec::init⟨i32⟩,
13	+	vec::append⟨i32⟩,
14	+	vec::view⟨i32⟩,
15	+	vec::remove⟨i32⟩;
16	+
17	+	/// Exercise public vector specializations from outside the standard package.
18	+	@default fn main() -> i32 {
19	+	let mut arena = alloc::new(&mut VEC_ARENA_STORAGE[..]);
20	+	let allocator = alloc::arenaAllocator(&mut arena);
21	+	let mut values: vec::Vec⟨i32⟩ = undefined;
22	+	vec::init⟨i32⟩(&mut values, &mut VEC_INITIAL_STORAGE[..]);
23	+
24	+	vec::append⟨i32⟩(&mut values, 10, allocator);
25	+	vec::append⟨i32⟩(&mut values, 20, allocator);
26	+	vec::append⟨i32⟩(&mut values, 30, allocator);
27	+
28	+	let initialized = vec::view⟨i32⟩(&values);
29	+	assert initialized.len == 3;
30	+	assert initialized[0] == 10;
31	+	assert initialized[1] == 20;
32	+	assert initialized[2] == 30;
33	+
34	+	let removed = vec::remove⟨i32⟩(&mut values, 1);
35	+	assert removed == 20;
36	+
37	+	let remaining = vec::view⟨i32⟩(&values);
38	+	assert remaining.len == 2;
39	+	assert remaining[0] == 10;
40	+	assert remaining[1] == 30;
41	+
42	+	return 0;
43	+	}

658	664		}
659	665		set funcPath[desc.modPath.len - 1] = desc.fnName;
660	666		let funcArg = synthScopeAccess(arena, &funcPath[..desc.modPath.len]);
661	667
662	668		let a = alloc::arenaAllocator(&mut arena.arena);
663		-	let args = ast::nodeSlice(arena, 3)
664		-	.append(modArg, a)
665		-	.append(nameArg, a)
666		-	.append(funcArg, a);
667		-
668		-	return ast::synthNode(arena, ast::NodeValue::Call(ast::Call { callee, args }));
	669	+	let mut args = ast::nodeVec(arena, 3);
	670	+	vec::append⟨*ast::Node⟩(&mut args, modArg, a);
	671	+	vec::append⟨*ast::Node⟩(&mut args, nameArg, a);
	672	+	vec::append⟨*ast::Node⟩(&mut args, funcArg, a);
	673	+	let argsView = vec::viewMut⟨*ast::Node⟩(&mut args);
	674	+
	675	+	return ast::synthNode(arena, ast::NodeValue::Call(ast::Call {
	676	+	callee,
	677	+	args: argsView,
	678	+	}));
669	679		}
670	680
671	681		/// Inject a test runner into the entry package's root module.
672	682		///
673	683		/// Scans all parsed modules for `@test fn` declarations, then appends

714	724
715	725		/// Synthesize the test entry point.
716	726		fn synthTestMainFn(arena: mut ast::NodeArena, tests: [TestDesc]) -> *ast::Node {
717	727		// Build array literal: `[testing::test(...), ...]`.
718	728		let a = alloc::arenaAllocator(&mut arena.arena);
719		-	let mut elements = ast::nodeSlice(arena, tests.len as u32);
	729	+	let mut elements = ast::nodeVec(arena, tests.len as u32);
720	730		for i in 0..tests.len {
721		-	elements.append(synthTestCall(arena, &tests[i]), a);
	731	+	vec::append⟨*ast::Node⟩(&mut elements, synthTestCall(arena, &tests[i]), a);
722	732		}
723		-	let arrayLit = ast::synthNode(arena, ast::NodeValue::ArrayLit(elements));
	733	+	let arrayLit = ast::synthNode(
	734	+	arena,
	735	+	ast::NodeValue::ArrayLit(vec::viewMut⟨*ast::Node⟩(&mut elements))
	736	+	);
724	737
725	738		// Build: `&[...]`.
726	739		let testsRef = ast::synthNode(arena, ast::NodeValue::AddressOf(ast::AddressOf {
727	740		target: arrayLit, mutable: false,
728	741		}));
729	742
730	743		// Build: `testing::runAllTests(&[...])`.
731	744		let runFn = synthScopeAccess(arena, &["testing", "runAllTests"]);
732		-	let callArgs = ast::nodeSlice(arena, 1).append(testsRef, a);
	745	+	let mut callArgs = ast::nodeVec(arena, 1);
	746	+	vec::append⟨*ast::Node⟩(&mut callArgs, testsRef, a);
733	747		let callExpr = ast::synthNode(arena, ast::NodeValue::Call(ast::Call {
734		-	callee: runFn, args: callArgs,
	748	+	callee: runFn, args: vec::viewMut⟨*ast::Node⟩(&mut callArgs),
735	749		}));
736	750
737	751		// Build: `return testing::runAllTests(&[...]);`
738	752		let retStmt = ast::synthNode(arena, ast::NodeValue::Return { value: callExpr });
739		-	let bodyStmts = ast::nodeSlice(arena, 1).append(retStmt, a);
740		-	let fnBody = ast::synthNode(arena, ast::NodeValue::Block(ast::Block { statements: bodyStmts }));
	753	+	let mut bodyStmts = ast::nodeVec(arena, 1);
	754	+	vec::append⟨*ast::Node⟩(&mut bodyStmts, retStmt, a);
	755	+	let fnBody = ast::synthNode(arena, ast::NodeValue::Block(ast::Block {
	756	+	statements: vec::viewMut⟨*ast::Node⟩(&mut bodyStmts),
	757	+	}));
741	758
742	759		// Build: `fn #testMain() -> i32`
743	760		let fnName = ast::synthNode(arena, ast::NodeValue::Ident(strings::intern(&mut STRING_POOL, "#testMain")));
744	761		let returnType = ast::synthNode(arena, ast::NodeValue::TypeSig(ast::TypeSig::Integer {
745	762		width: 4, sign: ast::Signedness::Signed,
746	763		}));
747	764		let fnSig = ast::FnSig {
748		-	params: ast::nodeSlice(arena, 0),
	765	+	params: &mut [],
749	766		returnType,
750		-	throwList: ast::nodeSlice(arena, 0),
	767	+	throwList: &mut [],
751	768		};
752	769
753	770		// `@default` attribute.
754	771		let attrNode = ast::synthNode(arena, ast::NodeValue::Attribute(ast::Attribute::Default));
755		-	let attrList = ast::nodeSlice(arena, 1).append(attrNode, a);
756		-	let fnAttrs = ast::Attributes { list: attrList };
	772	+	let mut attrList = ast::nodeVec(arena, 1);
	773	+	vec::append⟨*ast::Node⟩(&mut attrList, attrNode, a);
	774	+	let fnAttrs = ast::Attributes {
	775	+	list: vec::viewMut⟨*ast::Node⟩(&mut attrList),
	776	+	};
757	777
758	778		return ast::synthNode(arena, ast::NodeValue::FnDecl(ast::FnDecl {
759		-	name: fnName, params: ast::nodeSlice(arena, 0), sig: fnSig, body: fnBody, attrs: fnAttrs,
	779	+	name: fnName,
	780	+	params: &mut [],
	781	+	sig: fnSig,
	782	+	body: fnBody,
	783	+	attrs: fnAttrs,
760	784		}));
761	785		}
762	786
763	787		/// Append a declaration to a block node's statement list.
764	788		fn injectIntoBlock(

767	791		decl: *ast::Node
768	792		) {
769	793		let case ast::NodeValue::Block(block) = blockNode.value else {
770	794		panic "injectIntoBlock: expected Block node";
771	795		};
772		-	let stmts = block.statements.append(decl, alloc::arenaAllocator(&mut arena.arena));
773		-	set blockNode.value = ast::NodeValue::Block(ast::Block { statements: stmts });
	796	+	let a = alloc::arenaAllocator(&mut arena.arena);
	797	+	let mut stmts = ast::nodeVec(arena, block.statements.len as u32 + 1);
	798	+	for stmt in block.statements {
	799	+	vec::append⟨*ast::Node⟩(&mut stmts, stmt, a);
	800	+	}
	801	+	vec::append⟨*ast::Node⟩(&mut stmts, decl, a);
	802	+	set blockNode.value = ast::NodeValue::Block(ast::Block {
	803	+	statements: vec::viewMut⟨*ast::Node⟩(&mut stmts),
	804	+	});
774	805		}
775	806
776	807		/// Write a self-contained RV64 image containing text and data sections.
777	808		fn writeImage(
778	809		code: *[u32],

871	902		}
872	903
873	904		// Resolve all packages.
874	905		// TODO: Fix this error printing dance.
875	906		let diags = try resolver::resolve(&mut res, &ctx.graph, &resolverPkgs[..resolverPackageCount]) catch {
876		-	let diags = resolver::Diagnostics { errors: res.errors };
	907	+	let diags = resolver::Diagnostics {
	908	+	errors: vec::viewMut⟨resolver::Error⟩(&mut res.errors),
	909	+	};
877	910		resolver::printer::printDiagnostics(&diags, &res);
878	911		throw Error::Other;
879	912		};
880	913		if not resolver::success(&diags) {
881	914		resolver::printer::printDiagnostics(&diags, &res);

1026	1059		else => {}
1027	1060		}
1028	1061		if let path = codegenOptions.logPath {
1029	1062		pkgLog(entryPkg, &["generating code", "(", path, ")", ".."]);
1030	1063		}
1031		-	return rv64::finishProgram(&mut generator, &low.data[..], storage, asmData, &mut RO_DATA_BUF[..], &mut RW_DATA_BUF[..]);
	1064	+	return rv64::finishProgram(
	1065	+	&mut generator,
	1066	+	vec::view⟨il::Data⟩(&low.data),
	1067	+	storage,
	1068	+	asmData,
	1069	+	&mut RO_DATA_BUF[..],
	1070	+	&mut RW_DATA_BUF[..],
	1071	+	);
1032	1072		}
1033	1073
1034	1074		/// Lower, optionally dump, and optionally generate binary output.
1035	1075		fn compile(
1036	1076		ctx: *mut CompileContext,

90	90
91	91		# A `.rad` executable test can have a same-basename `.ras` module.
92	92		$(patsubst %.ras,%.rv64,$(BIN_TEST_RAD_ASM_SRC)): %.rv64: %.ras
93	93		$(patsubst %.start.ras,%.rv64,$(BIN_TEST_RAD_START_SRC)): %.rv64: %.start.ras
94	94
	95	+	# Cross-package generic tests compile with the standard library.
	96	+	$(BIN_TEST_DIR)/vec.generic.rv64: $(BIN_TEST_DIR)/vec.generic.rad $(STD_LIB) $(RAD_BIN)
	97	+	@echo "radiance $(BIN_TEST_DIR)/vec.generic.rad => $@"
	98	+	@$(RADIANCE) $(STD) -pkg test -mod $< -entry test -o $@
	99	+
95	100		# Compile each executable test to a binary.
96	101		$(BIN_TEST_DIR)/%.rv64: $(BIN_TEST_DIR)/%.rad $(RAD_BIN)
97	102		@echo "radiance $< => $@"
98	103		@$(RADIANCE) -pkg test -mod $< $(patsubst %,-mod %,$(wildcard $(@:.rv64=)/*.rad)) $(patsubst %,-start %,$(wildcard $(@:.rv64=.start.ras))) $(patsubst %,-mod %,$(wildcard $(@:.rv64=.ras))) -o $@
99	104

104	109		clean-bin-test:
105	110		@rm -f $(BIN_RUNNER) \
106	111		$(BIN_RUNNER:.rv64=.rv64.debug) \
107	112		$(BIN_RUNNER:.rv64=.rv64.s) \
108	113		$(BIN_RUNNER:.rv64=.rv64.o) \
109		-	$(BIN_TEST_EXE_BIN) \
	114	+	$(wildcard $(BIN_TEST_DIR)/*.rv64) \
110	115		$(wildcard $(BIN_TEST_DIR)/*.rv64.debug) \
111	116		$(wildcard $(BIN_TEST_DIR)/*.rv64.s)
112	117
113	118		seed:
114	119		seed/update

1	1		//! Radiance compiler front-end.
2	2		use std::mem;
3	3		use std::fmt;
	4	+	use std::vec;
4	5		use std::io;
5	6		use std::lang::alloc;
6	7		use std::lang::ast;
7	8		use std::lang::parser;
8	9		use std::lang::scanner;

20	21		use std::lang::gen::types;
21	22		use std::sys;
22	23		use std::sys::unix;
23	24		use std::collections::dict;
24	25
	26	+	instantiate vec::append⟨*ast::Node⟩,
	27	+	vec::viewMut⟨*ast::Node⟩,
	28	+	vec::viewMut⟨resolver::Error⟩,
	29	+	vec::view⟨il::Data⟩;
	30	+
25	31		/// Maximum number of modules we can load per package.
26	32		constant MAX_LOADED_MODULES: u32 = 64;
27	33		/// Maximum number of packages we can compile.
28	34		constant MAX_PACKAGES: u32 = 4;
29	35		/// Total module entries across all packages.

1	1		//! The Radiance Standard Library.
2	2
	3	+	export mod lang;
	4	+	export mod slice;
	5	+	export mod vec;
3	6		export mod io;
4	7		export mod collections;
5	8		export mod char;
6		-	export mod lang;
7	9		export mod sys;
8	10		export mod arch;
9	11		export mod fmt;
10	12		export mod mem;
11		-	export mod vec;
12	13		export mod intrinsics;
13	14
14	15		// Test modules.
15	16		@test export mod testing;
16	17		@test export mod tests;

346	346		let rwDataSize = data::emitSection(
347	347		globalData, &dataSymMap, &generator.e.labels, codeBase, rwDataBuf, false
348	348		);
349	349		return Program {
350	350		code: emit::getCode(&generator.e),
351		-	funcs: generator.e.funcs,
	351	+	funcs: emit::getFuncs(&generator.e),
352	352		roDataSize,
353	353		rwDataSize,
354	354		debugEntries: emit::getDebugEntries(&generator.e),
355	355		};
356	356		}

40	40		use std::lang::strings;
41	41		use std::lang::gen;
42	42		use std::collections::dict;
43	43		use std::arch::rv64::encode;
44	44		use std::arch::rv64;
	45	+	use std::vec;
	46	+
	47	+	instantiate vec::view⟨u32⟩;
	48	+
	49	+	instantiate vec::view⟨u8⟩;
	50	+
	51	+	instantiate vec::view⟨Symbol⟩;
	52	+
	53	+	instantiate vec::view⟨Fixup⟩;
45	54
46	55		/// Assembler scanner module.
47	56		export mod scanner;
48	57		/// Assembler parser module.
49	58		export mod parser;

455	464		export record Assembler {
456	465		/// Allocation arena for temporary assembler state.
457	466		arena: *mut alloc::Arena,
458	467		/// Assembler lexical scanner.
459	468		scan: scanner::Scanner,
460		-	/// Output text buffer.
461		-	text: *mut [u32],
462		-	/// Output data buffer.
463		-	data: *mut [u8],
	469	+	/// Append-backed output text storage.
	470	+	text: vec::Vec⟨u32⟩,
	471	+	/// Append-backed output data storage.
	472	+	data: vec::Vec⟨u8⟩,
464	473		/// Current output section.
465	474		section: Section,
466		-	/// Defined symbols.
467		-	symbols: *mut [Symbol],
	475	+	/// Append-backed defined symbols.
	476	+	symbols: vec::Vec⟨Symbol⟩,
468	477		/// Name-to-symbol index map.
469	478		symbolMap: dict::Dict,
470	479		/// Name-to-integer map.
471	480		constMap: dict::Dict,
472	481		/// Names marked by `.export`.
473	482		exportMap: dict::Dict,
474		-	/// Pending fixups.
475		-	fixups: *mut [Fixup],
476		-	/// Fixups that reference text outside this assembly fragment.
477		-	externalFixups: *mut [Fixup],
	483	+	/// Append-backed pending fixups.
	484	+	fixups: vec::Vec⟨Fixup⟩,
	485	+	/// Append-backed fixups that reference text outside this assembly fragment.
	486	+	externalFixups: vec::Vec⟨Fixup⟩,
478	487		/// Absolute runtime address of data-section offset zero.
479	488		dataBase: u32,
480	489		}
481	490
482	491		/// Assemble source using `dataBase` as the runtime address of the data-section.

500	509		let exportEntries = try! alloc::allocSlice(arena, @sizeOf(dict::Entry), @alignOf(dict::Entry), tableCap);
501	510
502	511		let mut a = Assembler {
503	512		arena,
504	513		scan: scanner::scanner(sourceKind, source, pool),
505		-	text: @sliceOf(textBuf.ptr, 0, textBuf.len),
506		-	data: @sliceOf(dataBuf.ptr, 0, dataBuf.len),
	514	+	text: vec::Vec⟨u32⟩ { data: textBuf, len: 0 },
	515	+	data: vec::Vec⟨u8⟩ { data: dataBuf, len: 0 },
507	516		section: Section::Text,
508		-	symbols: @sliceOf((symbols as mut [Symbol]).ptr, 0, (symbols as mut [Symbol]).len),
	517	+	symbols: vec::Vec⟨Symbol⟩ {
	518	+	data: symbols as *mut [Symbol],
	519	+	len: 0,
	520	+	},
509	521		symbolMap: dict::init(entries as *mut [dict::Entry]),
510	522		constMap: dict::init(constEntries as *mut [dict::Entry]),
511	523		exportMap: dict::init(exportEntries as *mut [dict::Entry]),
512		-	fixups: @sliceOf((fixups as mut [Fixup]).ptr, 0, (fixups as mut [Fixup]).len),
513		-	externalFixups: @sliceOf((externalFixups as mut [Fixup]).ptr, 0, (externalFixups as mut [Fixup]).len),
	524	+	fixups: vec::Vec⟨Fixup⟩ {
	525	+	data: fixups as *mut [Fixup],
	526	+	len: 0,
	527	+	},
	528	+	externalFixups: vec::Vec⟨Fixup⟩ {
	529	+	data: externalFixups as *mut [Fixup],
	530	+	len: 0,
	531	+	},
514	532		dataBase,
515	533		};
516	534		// Parse assembly source and emit instructions.
517	535		try parser::parseProgram(&mut a);
518	536		// Resolve fixups and finalize program.
519	537		try emit::finishProgram(&mut a);
520	538
521	539		return Program {
522		-	text: a.text,
523		-	data: a.data,
524		-	symbols: a.symbols,
525		-	externalFixups: a.externalFixups,
	540	+	text: vec::view⟨u32⟩(&a.text),
	541	+	data: vec::view⟨u8⟩(&a.data),
	542	+	symbols: vec::view⟨Symbol⟩(&a.symbols),
	543	+	externalFixups: vec::view⟨Fixup⟩(&a.externalFixups),
526	544		};
527	545		}
528	546
529	547		/// Return the next power of two at least as large as `value`.
530	548		fn nextPowerOfTwo(value: u32) -> u32 {

36	49		}
37	50		}
38	51
39	52		/// Append one byte to the data section.
40	53		export fn emitByte(a: *mut super::Assembler, byte: u8) throws (super::Error) {
41		-	a.data.append(byte, alloc::arenaAllocator(a.arena));
	54	+	vec::append⟨u8⟩(&mut a.data, byte, alloc::arenaAllocator(a.arena));
42	55		}
43	56
44	57		/// Emit a little-endian integer with `bytes` bytes.
45	58		fn emitDataInt(a: *mut super::Assembler, bits: u64, bytes: u32) throws (super::Error) {
46	59		for i in 0..bytes {

48	61		}
49	62		}
50	63
51	64		/// Patch a little-endian integer with `bytes` bytes.
52	65		fn patchDataInt(a: *mut super::Assembler, offset: u32, bits: u64, bytes: u32) {
	66	+	let data = vec::viewMut⟨u8⟩(&mut a.data);
53	67		for i in 0..bytes {
54		-	set a.data[offset + i] = ((bits >> ((i as u64) * super::BITS_PER_BYTE)) & super::BYTE_MASK) as u8;
	68	+	set data[offset + i] = ((bits >> ((i as u64) * super::BITS_PER_BYTE)) & super::BYTE_MASK) as u8;
55	69		}
56	70		}
57	71
58	72		/// Emit an integer data directive value.
59	73		export fn emitDataValue(a: *mut super::Assembler, value: i64, width: super::DataWidth) throws (super::Error) {

78	92		}
79	93		}
80	94
81	95		/// Record a pending symbol fixup.
82	96		fn recordFixup(a: mut super::Assembler, symbol: [u8], info: super::FixupInfo) {
83		-	a.fixups.append(super::Fixup { symbol, info }, alloc::arenaAllocator(a.arena));
	97	+	vec::append⟨super::Fixup⟩(&mut a.fixups, super::Fixup { symbol, info }, alloc::arenaAllocator(a.arena));
84	98		}
85	99
86	100		/// Record a text fixup that must be resolved after all program text is known.
87	101		fn recordExternalFixup(a: *mut super::Assembler, fixup: super::Fixup) {
88		-	a.externalFixups.append(fixup, alloc::arenaAllocator(a.arena));
	102	+	vec::append⟨super::Fixup⟩(&mut a.externalFixups, fixup, alloc::arenaAllocator(a.arena));
89	103		}
90	104
91	105		/// Record a text-section symbol fixup and reserve its instruction words.
92	106		export fn recordTextFixup(a: mut super::Assembler, symbol: [u8], info: super::FixupInfo, words: u32) throws (super::Error) {
93	107		recordFixup(a, symbol, info);

96	110
97	111		/// Find a previously defined symbol by name.
98	112		fn findSymbol(a: super::Assembler, name: [u8]) -> ?super::Symbol {
99	113		let idx = dict::get(&a.symbolMap, name)
100	114		else return nil;
101		-	return a.symbols[idx as u32];
	115	+	return vec::view⟨super::Symbol⟩(&a.symbols)[idx as u32];
102	116		}
103	117
104	118		/// Return the final address for a data symbol.
105	119		fn dataSymbolAddr(a: *super::Assembler, symbol: super::Symbol) -> i32 throws (super::Error) {
106	120		if symbol.section <> super::Section::Data {

109	123		return symbol.offset + (a.dataBase as i32);
110	124		}
111	125
112	126		/// Resolve final symbol references and patch all delayed output.
113	127		export fn finishProgram(a: *mut super::Assembler) throws (super::Error) {
114		-	for i in 0..a.fixups.len {
115		-	let fixup = a.fixups[i];
	128	+	let fixups = vec::view⟨super::Fixup⟩(&a.fixups);
	129	+	let text = vec::viewMut⟨u32⟩(&mut a.text);
	130	+	for fixup in fixups {
116	131		let symbol = findSymbol(a, fixup.symbol) else {
117	132		match fixup.info {
118	133		case super::FixupInfo::Jal { .. }, super::FixupInfo::Addr { .. } => {
119	134		recordExternalFixup(a, fixup);
120	135		continue;

133	148		if not encode::isBranchImm(rel) {
134	149		throw super::Error::Invalid { offset: 0, message: "branch target out of range" };
135	150		}
136	151		let word = encodeBranch(op, rs1, rs2, rel);
137	152
138		-	set a.text[index] = word;
	153	+	set text[index] = word;
139	154		}
140	155		case super::FixupInfo::Jal { rd, index } => {
141	156		if symbol.section <> super::Section::Text {
142	157		throw super::Error::Invalid { offset: 0, message: "jump target must be in text section" };
143	158		}

145	160		let rel = symbol.offset - srcOffset;
146	161
147	162		if not encode::isJumpImm(rel) {
148	163		throw super::Error::Invalid { offset: 0, message: "jump target out of range" };
149	164		}
150		-	set a.text[index] = encode::jal(rd, rel);
	165	+	set text[index] = encode::jal(rd, rel);
151	166		}
152	167		case super::FixupInfo::Addr { rd, index } => {
153	168		let mut addr = symbol.offset - (index as i32 * rv64::INSTR_SIZE);
154	169		if symbol.section == super::Section::Data {
155	170		set addr = symbol.offset + (a.dataBase as i32);
156	171		}
157	172		let split = emit::splitImm(addr);
158		-	set a.text[index] = encode::lui(rd, split.hi)
	173	+	set text[index] = encode::lui(rd, split.hi)
159	174		if symbol.section == super::Section::Data
160	175		else encode::auipc(rd, split.hi);
161		-	set a.text[index + 1] = encode::addi(rd, rd, split.lo);
	176	+	set text[index + 1] = encode::addi(rd, rd, split.lo);
162	177		}
163	178		case super::FixupInfo::Word { offset } => {
164	179		let addr = try dataSymbolAddr(a, symbol);
165	180		patchDataInt(a, offset, addr as u64, rv64::WORD_SIZE as u32);
166	181		}

556	559		/// Parse a `.export` directive.
557	560		fn parseExportDirective(a: *mut super::Assembler) throws (super::Error) {
558	561		let name = try parseLabelName(a);
559	562		dict::insert(&mut a.exportMap, name, 1);
560	563		if let idx = dict::get(&a.symbolMap, name) {
561		-	set a.symbols[idx as u32].isExported = true;
	564	+	let symbols = vec::viewMut⟨super::Symbol⟩(&mut a.symbols);
	565	+	set symbols[idx as u32].isExported = true;
562	566		}
563	567		}
564	568
565	569		/// Parse a `.space` directive.
566	570		fn parseSpaceDirective(a: *mut super::Assembler) throws (super::Error) {

8	8		use std::lang::gen::data;
9	9		use std::lang::gen::labels;
10	10		use std::lang::gen::types;
11	11		use std::collections::dict;
12	12		use std::mem;
	13	+	use std::vec;
13	14
14	15		use super::encode;
15	16
	17	+	instantiate vec::append⟨PendingBranch⟩,
	18	+	vec::view⟨PendingBranch⟩;
	19	+
	20	+	instantiate vec::append⟨PendingCall⟩,
	21	+	vec::view⟨PendingCall⟩;
	22	+
	23	+	instantiate vec::append⟨PendingJump⟩,
	24	+	vec::view⟨PendingJump⟩;
	25	+
	26	+	instantiate vec::append⟨PendingAddrLoad⟩,
	27	+	vec::view⟨PendingAddrLoad⟩;
	28	+
	29	+	instantiate vec::append⟨types::FuncAddr⟩,
	30	+	vec::view⟨types::FuncAddr⟩;
	31	+
16	32		/// Maximum number of instructions in code buffer.
17	33		constant MAX_INSTRS: u32 = 2097152;
18	34		/// Maximum code length before byte offset overflows signed 32-bits.
19	35		constant MAX_CODE_LEN: u32 = 0x7FFFFFFF / super::INSTR_SIZE as u32;
20	36		/// Maximum positive value encodable by a signed 32-bit address calculation.

103	119		/// Emitted instructions storage.
104	120		code: *mut [u32],
105	121		/// Current number of emitted instructions.
106	122		codeLen: u32,
107	123		/// Local branches needing offset patching.
108		-	pendingBranches: *mut [PendingBranch],
	124	+	pendingBranches: vec::Vec⟨PendingBranch⟩,
109	125		/// Function calls needing offset patching.
110		-	pendingCalls: *mut [PendingCall],
	126	+	pendingCalls: vec::Vec⟨PendingCall⟩,
111	127		/// Assembly jumps needing offset patching.
112		-	pendingJumps: *mut [PendingJump],
	128	+	pendingJumps: vec::Vec⟨PendingJump⟩,
113	129		/// Function address loads needing offset patching.
114		-	pendingAddrLoads: *mut [PendingAddrLoad],
	130	+	pendingAddrLoads: vec::Vec⟨PendingAddrLoad⟩,
115	131		/// Block label tracking.
116	132		labels: labels::Labels,
117	133		/// Function start positions for printing.
118		-	funcs: *mut [types::FuncAddr],
	134	+	funcs: vec::Vec⟨types::FuncAddr⟩,
119	135		/// Debug entries mapping PCs to source locations.
120	136		debugEntries: *mut [types::DebugEntry],
121	137		/// Number of debug entries recorded.
122	138		debugEntriesLen: u32,
123	139		}

200	216		}
201	217		return Emitter {
202	218		allocator: alloc::arenaAllocator(arena),
203	219		code: code as *mut [u32],
204	220		codeLen: 0,
205		-	pendingBranches: @sliceOf((pendingBranches as *mut [PendingBranch]).ptr, 0, MAX_PENDING),
206		-	pendingCalls: @sliceOf((pendingCalls as *mut [PendingCall]).ptr, 0, MAX_PENDING),
207		-	pendingJumps: @sliceOf((pendingJumps as *mut [PendingJump]).ptr, 0, MAX_PENDING),
208		-	pendingAddrLoads: @sliceOf((pendingAddrLoads as *mut [PendingAddrLoad]).ptr, 0, MAX_PENDING),
	221	+	pendingBranches: vec::Vec⟨PendingBranch⟩ {
	222	+	data: pendingBranches as *mut [PendingBranch],
	223	+	len: 0,
	224	+	},
	225	+	pendingCalls: vec::Vec⟨PendingCall⟩ {
	226	+	data: pendingCalls as *mut [PendingCall],
	227	+	len: 0,
	228	+	},
	229	+	pendingJumps: vec::Vec⟨PendingJump⟩ {
	230	+	data: pendingJumps as *mut [PendingJump],
	231	+	len: 0,
	232	+	},
	233	+	pendingAddrLoads: vec::Vec⟨PendingAddrLoad⟩ {
	234	+	data: pendingAddrLoads as *mut [PendingAddrLoad],
	235	+	len: 0,
	236	+	},
209	237		labels: labels::init(blockOffsets as mut [i32], funcEntries as mut [dict::Entry]),
210		-	funcs: @sliceOf((funcs as *mut [types::FuncAddr]).ptr, 0, MAX_FUNCS),
	238	+	funcs: vec::Vec⟨types::FuncAddr⟩ {
	239	+	data: funcs as *mut [types::FuncAddr],
	240	+	len: 0,
	241	+	},
211	242		debugEntries,
212	243		debugEntriesLen: 0,
213	244		};
214	245		}
215	246

256	287		recordFuncAt(e, name, e.codeLen);
257	288		}
258	289
259	290		/// Record a function's start position at `index` for printing.
260	291		export fn recordFuncAt(e: mut Emitter, name: [u8], index: u32) {
261		-	e.funcs.append(types::FuncAddr { name, index }, e.allocator);
	292	+	vec::append⟨types::FuncAddr⟩(&mut e.funcs, types::FuncAddr { name, index }, e.allocator);
262	293		}
263	294
264	295		/// Record a local branch needing later patching.
265	296		/// Unconditional jumps use a single slot (J-type, +-1MB range).
266	297		/// Conditional branches use two slots (B-type has only +-4KB range,
267	298		/// so large functions may need the inverted-branch + JAL fallback).
268	299		export fn recordBranch(e: *mut Emitter, targetBlock: u32, kind: BranchKind) {
269		-	e.pendingBranches.append(PendingBranch {
	300	+	vec::append⟨PendingBranch⟩(&mut e.pendingBranches, PendingBranch {
270	301		index: e.codeLen,
271	302		target: targetBlock,
272	303		kind: kind,
273	304		}, e.allocator);
274	305

282	313
283	314		/// Record a function call needing later patching.
284	315		/// Emits placeholder instructions that will be patched later.
285	316		/// Uses two slots to support long-distance calls.
286	317		export fn recordCall(e: mut Emitter, target: [u8]) {
287		-	e.pendingCalls.append(PendingCall {
	318	+	vec::append⟨PendingCall⟩(&mut e.pendingCalls, PendingCall {
288	319		index: e.codeLen,
289	320		target,
290	321		}, e.allocator);
291	322
292	323		emit(e, encode::nop()); // Placeholder for AUIPC.
293	324		emit(e, encode::nop()); // Placeholder for JALR.
294	325		}
295	326
296	327		/// Record a jump emitted by assembly that needs whole-program patching.
297	328		export fn recordJumpAt(e: mut Emitter, target: [u8], rd: gen::Reg, index: u32) {
298		-	e.pendingJumps.append(PendingJump {
	329	+	vec::append⟨PendingJump⟩(&mut e.pendingJumps, PendingJump {
299	330		index,
300	331		target,
301	332		rd,
302	333		}, e.allocator);
303	334		}

312	343		emit(e, encode::nop()); // Placeholder for ADDI.
313	344		}
314	345
315	346		/// Record a function address load already reserved by assembly.
316	347		export fn recordAddrLoadAt(e: mut Emitter, target: [u8], rd: gen::Reg, index: u32) {
317		-	e.pendingAddrLoads.append(PendingAddrLoad {
	348	+	vec::append⟨PendingAddrLoad⟩(&mut e.pendingAddrLoads, PendingAddrLoad {
318	349		index,
319	350		target,
320	351		rd: rd,
321	352		isData: false,
322	353		}, e.allocator);
323	354		}
324	355
325	356		/// Record a data address load needing later patching.
326	357		/// Uses an absolute 32-bit load sequence matching the current data memory map.
327	358		export fn recordDataAddrLoad(e: mut Emitter, target: [u8], rd: gen::Reg) {
328		-	e.pendingAddrLoads.append(PendingAddrLoad {
	359	+	vec::append⟨PendingAddrLoad⟩(&mut e.pendingAddrLoads, PendingAddrLoad {
329	360		index: e.codeLen,
330	361		target,
331	362		rd: rd,
332	363		isData: true,
333	364		}, e.allocator);

341	372		/// Called after each function.
342	373		///
343	374		/// Uses two-instruction sequences: short branches use `branch` and `nop`,
344	375		/// long branches use inverted branch and `jal` or `auipc` and `jalr`.
345	376		export fn patchLocalBranches(e: *mut Emitter) {
346		-	for i in 0..e.pendingBranches.len {
347		-	let p = e.pendingBranches[i];
	377	+	let pendingBranches = vec::view⟨PendingBranch⟩(&e.pendingBranches);
	378	+	for p in pendingBranches {
348	379		let offset = labels::branchToBlock(&e.labels, p.index, p.target, super::INSTR_SIZE);
349	380		match p.kind {
350	381		case BranchKind::Cond { op, rs1, rs2 } => {
351	382		if encode::isBranchImm(offset) {
352	383		patch(e, p.index, encodeCondBranch(op, rs1, rs2, offset));

372	403		assert encode::isJumpImm(offset), "patchLocalBranches: jump offset too large";
373	404		patch(e, p.index, encode::jal(super::ZERO, offset));
374	405		},
375	406		}
376	407		}
377		-	set e.pendingBranches = @sliceOf(e.pendingBranches.ptr, 0, e.pendingBranches.cap);
	408	+	set e.pendingBranches.len = 0;
378	409		}
379	410
380	411		/// Encode a conditional branch instruction.
381	412		fn encodeCondBranch(op: il::CmpOp, rs1: gen::Reg, rs2: gen::Reg, offset: i32) -> u32 {
382	413		match op {

398	429		}
399	430
400	431		/// Patch all pending function calls.
401	432		/// Called after all functions have been generated.
402	433		export fn patchCalls(e: *mut Emitter) {
403		-	for i in 0..e.pendingCalls.len {
404		-	let p = e.pendingCalls[i];
	434	+	let pendingCalls = vec::view⟨PendingCall⟩(&e.pendingCalls);
	435	+	for p in pendingCalls {
405	436		let offset = branchOffsetToFunc(e, p.index, p.target);
406	437		let s = splitImm(offset);
407	438
408	439		// `AUIPC scratch, hi(offset)`.
409	440		patch(e, p.index, encode::auipc(super::SCRATCH1, s.hi));

412	443		}
413	444		}
414	445
415	446		/// Patch all pending assembly jumps.
416	447		export fn patchJumps(e: *mut Emitter) {
417		-	for i in 0..e.pendingJumps.len {
418		-	let p = e.pendingJumps[i];
	448	+	let pendingJumps = vec::view⟨PendingJump⟩(&e.pendingJumps);
	449	+	for p in pendingJumps {
419	450		let offset = branchOffsetToFunc(e, p.index, p.target);
420	451
421	452		assert encode::isJumpImm(offset), "patchJumps: jump offset too large";
422	453		patch(e, p.index, encode::jal(p.rd, offset));
423	454		}
424	455		}
425	456
426	457		/// Patch all pending function and data address loads.
427	458		/// Called after all functions have been generated and data layout is known.
428	459		export fn patchAddrLoads(e: mut Emitter, dataSymMap: data::DataSymMap) {
429		-	for i in 0..e.pendingAddrLoads.len {
430		-	let p = e.pendingAddrLoads[i];
	460	+	let pendingAddrLoads = vec::view⟨PendingAddrLoad⟩(&e.pendingAddrLoads);
	461	+	for p in pendingAddrLoads {
431	462		if p.isData {
432	463		let addr = data::lookupAddr(dataSymMap, p.target) else {
433	464		panic "patchAddrLoads: data symbol not found";
434	465		};
435	466		assert addr <= MAX_I32_ADDR, "patchAddrLoads: data address too large";

703	734
704	735		//////////////////
705	736		// Code Access //
706	737		//////////////////
707	738
	739	+	/// Get function start positions as an initialized slice.
	740	+	export fn getFuncs(e: Emitter) -> [types::FuncAddr] {
	741	+	return vec::view⟨types::FuncAddr⟩(&e.funcs);
	742	+	}
	743	+
708	744		/// Get emitted code as a slice.
709	745		export fn getCode(e: Emitter) -> [u32] {
710	746		return &e.code[..e.codeLen];
711	747		}
712	748

21	21		@test fn testAddAssemblyExportsOnlyGlobalTextSymbols() throws (testing::TestError) {
22	22		let mut arena = alloc::new(&mut ASSEMBLY_ARENA_STORAGE[..]);
23	23		let symbols = try alloc::allocSlice(&mut arena, @sizeOf(asm::Symbol), @alignOf(asm::Symbol), 2) catch {
24	24		throw testing::TestError::Failed;
25	25		};
26		-	let mut symbolSlice = @sliceOf((symbols as *mut [asm::Symbol]).ptr, 2, 2);
	26	+	let mut symbolSlice = @sliceOf((symbols as *mut [asm::Symbol]).ptr, 2);
27	27		set symbolSlice[0] = asm::Symbol {
28	28		name: "local",
29	29		section: asm::Section::Text,
30	30		offset: 0,
31	31		isExported: false,

1	1		//! Radiance language implementation.
2	2		export mod alloc;
	3	+	export mod slice;
	4	+	export mod vec;
3	5		export mod sexpr;
4	6		export mod types;
5	7		export mod strings;
6	8		export mod scanner;
7	9		export mod ast;