radiance · commit

compiler/radiance.rad +19 -19

/// Main arena size (96 MB) - lives throughout compilation.
/// Used for: resolver data, types, symbols, global IL data, and codegen output.
constant MAIN_ARENA_SIZE: u32 = 100663296;

/// AST storage arena.
static TEMP_ARENA: [u8; TEMP_ARENA_SIZE] = undefined;
static TEMP_ARENA: [u8; TEMP_ARENA_SIZE] = [0; TEMP_ARENA_SIZE];
/// Scratch storage reclaimed after each generated function.
static FN_ARENA: [u8; FN_ARENA_SIZE] = undefined;
static FN_ARENA: [u8; FN_ARENA_SIZE] = [0; FN_ARENA_SIZE];
/// Main storage arena - persists throughout compilation.
static MAIN_ARENA: [u8; MAIN_ARENA_SIZE] = undefined;
static MAIN_ARENA: [u8; MAIN_ARENA_SIZE] = [0; MAIN_ARENA_SIZE];

/// Module source code.
static MODULE_SOURCES: [u8; MAX_SOURCES_SIZE] = undefined;
static MODULE_SOURCES: [u8; MAX_SOURCES_SIZE] = [0; MAX_SOURCES_SIZE];
/// Module entries for all packages.
static MODULE_ENTRIES: [module::ModuleEntry; MAX_TOTAL_MODULES] = undefined;
unsafe static MODULE_ENTRIES: [module::ModuleEntry; MAX_TOTAL_MODULES] = undefined;
/// String pool.
static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
unsafe static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };

/// Package scope.
static RESOLVER_PKG_SCOPE: resolver::Scope = undefined;
unsafe static RESOLVER_PKG_SCOPE: resolver::Scope = undefined;
/// Errors emitted by resolver.
static RESOLVER_ERRORS: [resolver::Error; resolver::MAX_ERRORS] = undefined;
unsafe static RESOLVER_ERRORS: [resolver::Error; resolver::MAX_ERRORS] = undefined;

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

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

/// Maximum rodata size (4MB).

/// Maximum rwdata size (4MB).
constant MAX_RW_DATA_SIZE: u32 = 4194304;
/// Maximum path length.
constant MAX_PATH_LEN: u32 = 256;
/// Read-only data buffer.
static RO_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = undefined;
static RO_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = [0; MAX_RO_DATA_SIZE];
/// Read-write data buffer.
static RW_DATA_BUF: [u8; MAX_RW_DATA_SIZE] = undefined;
static RW_DATA_BUF: [u8; MAX_RW_DATA_SIZE] = [0; MAX_RW_DATA_SIZE];
/// Assembly module source buffer.
static ASM_SOURCE_BUF: [u8; MAX_SOURCES_SIZE] = undefined;
static ASM_SOURCE_BUF: [u8; MAX_SOURCES_SIZE] = [0; MAX_SOURCES_SIZE];
/// Temporary assembly text buffer.
static ASM_TEXT_BUF: [u32; 262144] = undefined;
static ASM_TEXT_BUF: [u32; 262144] = [0; 262144];
/// Temporary assembly data buffer.
static ASM_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = undefined;
static ASM_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = [0; MAX_RO_DATA_SIZE];
/// Accumulated assembly read-only data.
static ASM_RO_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = undefined;
static ASM_RO_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = [0; MAX_RO_DATA_SIZE];

/// Assembly source file extension.
constant ASM_SOURCE_EXT: *[u8] = ".ras";
/// Symbol name exported for startup code to call the semantic entry function.
export constant DEFAULT_ENTRY_SYMBOL: *[u8] = "::default";

/// Create an empty source input set for one package.
fn packageInput(name: *[u8]) -> PackageInput {
    return PackageInput {
        name,
        startupPath: nil,
        radPaths: undefined,
        radPaths: [""; MAX_LOADED_MODULES],
        radPathCount: 0,
        asmPaths: undefined,
        asmPaths: [""; MAX_ASM_MODULES],
        asmPathCount: 0,
    };
}

/// Register, load, and parse `path` within `pkg`.

fn writeDataWithExt(
    data: *[u8],
    basePath: *[u8],
    ext: *[u8]
) throws (Error) {
    let mut path: [u8; MAX_PATH_LEN] = undefined;
    let mut path: [u8; MAX_PATH_LEN] = [0; MAX_PATH_LEN];
    let mut pos: u32 = 0;

    set pos += try! mem::copy(&mut path[pos..], basePath);
    set pos += try! mem::copy(&mut path[pos..], ext);
    set path[pos] = 0; // Null-terminate for syscall.

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

use std::mem;
use std::testing;
use std::lang::strings;

/// String pool used by assembler scanner tests.
static TEST_STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
unsafe static TEST_STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };

/// Create a scanner for test input.
fn testScanner(source: *[u8]) -> super::Scanner {
    return super::scanner(super::SourceKind::String, source, &mut TEST_STRING_POOL);
    unsafe {
        return super::scanner(super::SourceKind::String, source, &mut TEST_STRING_POOL);
    }
}

/// Scanner recognizes assembler-specific sigils and scoped names.
@test fn testScanRegisterDirectiveAndLabelTokens() throws (testing::TestError) {
    let mut s = testScanner(

lib/std/arch/rv64/asm/tests.rad +6 -6

use std::arch::rv64::encode;
use std::arch::rv64::printer;

use super::scanner;

static ASM_ARENA_STORAGE: [u8; 65536] = undefined;
static ASM_TEXT_STORAGE: [u32; 256] = undefined;
static ASM_DATA_STORAGE: [u8; 1024] = undefined;
static ASM_STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
static PRINT_ARENA_STORAGE: [u8; 1024] = undefined;
static PRINT_BUFFER: [u8; 128] = undefined;
static ASM_ARENA_STORAGE: [u8; 65536] = [0; 65536];
static ASM_TEXT_STORAGE: [u32; 256] = [0; 256];
static ASM_DATA_STORAGE: [u8; 1024] = [0; 1024];
unsafe static ASM_STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
static PRINT_ARENA_STORAGE: [u8; 1024] = [0; 1024];
static PRINT_BUFFER: [u8; 128] = [0; 128];

unsafe fn assembleSource(source: *[u8]) -> super::Program throws (testing::TestError) {
    let mut arena = alloc::new(&mut ASM_ARENA_STORAGE[..]);
    return try super::assemble(
        scanner::SourceKind::String,

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


/// Compute frame layout from local size and used callee-saved registers.
export fn computeFrame(localSize: i32, usedCalleeSaved: u32, epilogueBlock: u32, isLeaf: bool, isDynamic: bool) -> Frame {
    let mut frame = Frame {
        totalSize: 0,
        savedRegs: undefined,
        savedRegs: [SavedReg { reg: super::ZERO, offset: 0 }; super::NUM_SAVED_REGISTERS],
        savedRegsLen: 0,
        epilogueBlock,
        isLeaf,
        isDynamic,
    };

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

use std::collections::dict;

use super::encode;
use super::asm;

static ASSEMBLY_ARENA_STORAGE: [u8; 16777216] = undefined;
static ASSEMBLY_TEXT_STORAGE: [u32; 2] = undefined;
static ASSEMBLY_ARENA_STORAGE: [u8; 16777216] = [0; 16777216];
static ASSEMBLY_TEXT_STORAGE: [u32; 2] = [0; 2];

/// Helper to check encoding equals expected value.
fn expectEncoding(actual: u32, expected: u32) throws (testing::TestError) {
    try testing::expect(actual == expected);
}

lib/std/lang/alloc/tests.rad +8 -8


use std::testing;

/// Test basic allocation.
@test fn testAllocBasic() throws (testing::TestError) {
    static STORAGE: [u8; 64] = undefined;
    static STORAGE: [u8; 64] = [0; 64];
    let mut arena = super::new(&mut STORAGE[..]);

    let ptr = try! super::alloc(&mut arena, 4, 4);
    try testing::expect(super::used(&arena) == 4);
    try testing::expect(super::remaining(&arena) == 60);
}

/// Test that allocations are properly aligned.
@test fn testAllocAlignment() throws (testing::TestError) {
    static STORAGE: [u8; 64] = undefined;
    static STORAGE: [u8; 64] = [0; 64];
    let mut arena = super::new(&mut STORAGE[..]);

    // Allocate 1 byte with 1-byte alignment.
    let p1 = try! super::alloc(&mut arena, 1, 1);
    try testing::expect(super::used(&arena) == 1);

    try testing::expect(super::used(&arena) == 8); // 1 + 3 padding + 4
}

/// Test multiple allocations.
@test fn testAllocMultiple() throws (testing::TestError) {
    static STORAGE: [u8; 128] = undefined;
    static STORAGE: [u8; 128] = [0; 128];
    let mut arena = super::new(&mut STORAGE[..]);

    let p1 = try! super::alloc(&mut arena, 8, 4);
    let p2 = try! super::alloc(&mut arena, 16, 4);
    let p3 = try! super::alloc(&mut arena, 4, 4);

    try testing::expect(super::used(&arena) == 28); // 8 + 16 + 4
}

/// Test that arena throws when exhausted.
@test fn testAllocExhausted() throws (testing::TestError) {
    static STORAGE: [u8; 16] = undefined;
    static STORAGE: [u8; 16] = [0; 16];
    let mut arena = super::new(&mut STORAGE[..]);

    // This should succeed.
    let p1 = try! super::alloc(&mut arena, 8, 4);


    try testing::expect(failed);
}

/// Test that reset allows reuse of memory.
@test fn testAllocReset() throws (testing::TestError) {
    static STORAGE: [u8; 32] = undefined;
    static STORAGE: [u8; 32] = [0; 32];
    let mut arena = super::new(&mut STORAGE[..]);

    let p1 = try! super::alloc(&mut arena, 16, 4);
    try testing::expect(super::used(&arena) == 16);


    let p2 = try! super::alloc(&mut arena, 32, 4);
}

/// Test alignment when offset is already aligned.
@test fn testAllocAlreadyAligned() throws (testing::TestError) {
    static STORAGE: [u8; 64] = undefined;
    static STORAGE: [u8; 64] = [0; 64];
    let mut arena = super::new(&mut STORAGE[..]);

    // Allocate 4 bytes - offset becomes 4, already aligned for next 4-byte alloc.
    let p1 = try! super::alloc(&mut arena, 4, 4);
    try testing::expect(super::used(&arena) == 4);

    try testing::expect(super::used(&arena) == 8);
}

/// Test allocation that would overflow with alignment padding.
@test fn testAllocOverflowWithPadding() throws (testing::TestError) {
    static STORAGE: [u8; 16] = undefined;
    static STORAGE: [u8; 16] = [0; 16];
    let mut arena = super::new(&mut STORAGE[..]);

    // Allocate 1 byte, offset is now 1.
    let p1 = try! super::alloc(&mut arena, 1, 1);


    try testing::expect(failed);
}

/// Test the Allocator interface backed by an arena.
@test unsafe fn testAllocator() throws (testing::TestError) {
    static STORAGE: [u8; 256] = undefined;
    static STORAGE: [u8; 256] = [0; 256];
    let mut arena = super::new(&mut STORAGE[..]);
    let a = super::arenaAllocator(&mut arena);

    // Allocate through the Allocator indirection.
    let p1 = a.func(a.ctx, 16, 4);

lib/std/lang/lower.rad +4 -6

    }
}

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

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

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

    let pathSuffix = mem::stripPrefix(baseDir, filePath) else {
        throw ModuleError::InvalidPath;
    };

    // Parse the stripped path into components.
    let mut parts: [*[u8]; MAX_MODULE_PATH_DEPTH] = undefined;
    let mut parts: [*[u8]; MAX_MODULE_PATH_DEPTH] = [""; MAX_MODULE_PATH_DEPTH];
    let partsLen = parsePath(pathSuffix, &mut parts[..]) else {
        throw ModuleError::InvalidPath;
    };
    if partsLen == 0 {
        throw ModuleError::InvalidPath;

        packageId,
        parent: nil,
        filePath,
        dirLen: 0,
        name: strings::intern(graph.pool, name),
        path: undefined,
        path: [""; MAX_MODULE_PATH_DEPTH],
        pathDepth: 0,
        state: ModuleState::Vacant,
        children: undefined,
        children: [0; MAX_MODULES],
        childrenLen: 0,
        ast: nil,
        source: nil,
    };
    set m.dirLen = dirLength(m.filePath);

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

use std::testing;
use std::lang::ast;
use std::lang::strings;

/// Test arena backing storage.
static TEST_ARENA: [u8; 4096] = undefined;
static TEST_ARENA: [u8; 4096] = [0; 4096];
/// Interned string pool.
static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
unsafe static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };

fn expectSliceEq(actual: *[u8], expected: *[u8])
    throws (testing::TestError)
{
    if not mem::eq(actual, expected) {

    try testing::expect(result == nil);
}

@test fn testParsePathSingleComponent() throws (testing::TestError) {
    let path = "std.rad";
    let mut components: [*[u8]; 8] = undefined;
    let mut components: [*[u8]; 8] = [""; 8];
    let count = super::parsePath(path, &mut components[..]) else {
        throw testing::TestError::Failed;
    };
    try testing::expect(count == 1);
    try expectSliceEq(components[0], "std");
}

@test fn testParsePathMultipleComponents() throws (testing::TestError) {
    let path = "std/lang/parser.rad";
    let mut components: [*[u8]; 8] = undefined;
    let mut components: [*[u8]; 8] = [""; 8];
    let count = super::parsePath(path, &mut components[..]) else {
        throw testing::TestError::Failed;
    };
    try testing::expect(count == 3);
    try expectSliceEq(components[0], "std");

    try expectSliceEq(components[2], "parser");
}

@test fn testParsePathWithoutExtension() throws (testing::TestError) {
    let path = "std/lang/parser";
    let mut components: [*[u8]; 8] = undefined;
    let mut components: [*[u8]; 8] = [""; 8];
    let result = super::parsePath(path, &mut components[..]);
    try testing::expect(result == nil);
}

@test unsafe fn testRegisterFromPathHierarchy() throws (testing::TestError) {

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

use std::lang::strings;

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

/// Assert that a node is an identifier with the given name.
fn expectIdent(node: *ast::Node, name: *[u8])
    throws (testing::TestError)
{

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

                return setNodeType(self, node, hint);
            }
            return setNodeType(self, node, Type::Nil);
        },
        case ast::NodeValue::Undef => {
            try requireUnsafe(self, node);
            return setNodeType(self, node, Type::Undefined);
        },
        case ast::NodeValue::Bool(value) => {
            setNodeConstValue(self, node, ConstValue::Bool(value));
            return setNodeType(self, node, Type::Bool);

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


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

/// AST arena storage used by resolver tests.
static AST_ARENA: [u8; 2097152] = undefined;
static AST_ARENA: [u8; 2097152] = [0; 2097152];

/// Resolver arena storage used by resolver tests.
static ARENA_STORAGE: [u8; 2097152] = undefined;
static ARENA_STORAGE: [u8; 2097152] = [0; 2097152];

/// Node metadata storage used by resolver tests.
static NODE_DATA_STORAGE: [super::NodeData; 256] = undefined;
unsafe static NODE_DATA_STORAGE: [super::NodeData; 256] = undefined;

/// Diagnostic storage used by resolver tests.
static ERROR_STORAGE: [super::Error; 16] = undefined;
unsafe static ERROR_STORAGE: [super::Error; 16] = undefined;

/// Package scope used by resolver tests.
static PKG_SCOPE: super::Scope = undefined;
unsafe static PKG_SCOPE: super::Scope = undefined;

/// Module entries used by resolver tests.
static MODULE_ENTRIES: [module::ModuleEntry; 8] = undefined;
unsafe static MODULE_ENTRIES: [module::ModuleEntry; 8] = undefined;

/// Module graph used by resolver tests.
static MODULE_GRAPH: module::ModuleGraph = undefined;
unsafe static MODULE_GRAPH: module::ModuleGraph = undefined;

/// Module AST arena storage used by resolver tests.
static MODULE_ARENA_STORAGE: [u8; 4096] = undefined;
static MODULE_ARENA_STORAGE: [u8; 4096] = [0; 4096];

/// Module AST arena used by resolver tests.
static MODULE_ARENA: ast::NodeArena = undefined;
unsafe static MODULE_ARENA: ast::NodeArena = undefined;

/// Interned string pool used by resolver tests.
static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
unsafe static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };

/// String literals used in tests.
constant LITERALS: [*[u8]; 15] = [
    "Ok", "Error", "R", "S",
    "f", "Status", "Pending",

    diagnostics: super::Diagnostics,
    root: *ast::Node,
}

/// Create isolated storage for tests to avoid conflicts with global resolver storage.
fn testStorage() -> super::ResolverStorage {
unsafe fn testStorage() -> super::ResolverStorage {
    return super::ResolverStorage {
        arena: alloc::new(&mut ARENA_STORAGE[..]),
        nodeData: &mut NODE_DATA_STORAGE[..],
        pkgScope: &mut PKG_SCOPE,
        errors: &mut ERROR_STORAGE[..],

}

@test unsafe fn testUndefinedCoercions() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let count: i32 = undefined;");
        let result = try resolveBlockStr(&mut a, "unsafe { let count: i32 = undefined; }");
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "let mut value: i32 = 0; set value = undefined;";
        let program = "unsafe { let mut value: i32 = 0; set value = undefined; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "fn f(x: i32) {} fn g() { f(undefined); }";
        let program = "fn f(x: i32) {} unsafe fn g() { f(undefined); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "fn fetch() -> i32 { return undefined; }";
        let program = "unsafe fn fetch() -> i32 { return undefined; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}


        let result = try resolveProgramStr(&mut a, "fn f(x: opaque) {}");
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::OpaqueTypeNotAllowed);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f() { let x: opaque = undefined; }");
        let result = try resolveProgramStr(&mut a, "unsafe fn f() { let x: opaque = undefined; }");
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::OpaqueTypeNotAllowed);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "record R { x: opaque }");

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

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

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


        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "static x: i32 = 0; let p = &x; p as u32;");
        try expectNoErrors(&result);
    } { // Function pointer to numeric.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let f: fn() = undefined; f as u32;");
        let result = try resolveProgramStr(&mut a, "fn run(f: fn()) { f as u32; }");
        try expectNoErrors(&result);
    } { // *u8 to *i32 (u8 to i32 is valid).
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "unsafe fn run() { let p: *u8 = undefined; p as *i32; }");
        try expectNoErrors(&result);

        try expectNoErrors(&result);
    }

    { // *[i32] to *[opaque].
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let s: *[i32] = undefined; s as *[opaque];");
        let result = try resolveProgramStr(&mut a, "fn run(s: *[i32]) { s as *[opaque]; }");
        try expectNoErrors(&result);
    } { // *[opaque] to *[i32].
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "unsafe fn run() { let s: *[opaque] = undefined; s as *[i32]; }");
        try expectNoErrors(&result);

        try expectNoErrors(&result);
    }

    { // Identity cast: *mut [i32] to *mut [i32].
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let s: *mut [i32] = undefined; s as *mut [i32];");
        let result = try resolveProgramStr(&mut a, "fn run(s: *mut [i32]) { s as *mut [i32]; }");
        try expectNoErrors(&result);
    } { // Identity cast: *i32 to *i32.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let p: *i32 = undefined; p as *i32;");
        let result = try resolveProgramStr(&mut a, "fn run(p: *i32) { p as *i32; }");
        try expectNoErrors(&result);
    } { // Identity cast: i32 to i32.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: i32 = 0; x as i32;");
        try expectNoErrors(&result);


/// Tests for invalid `as` casts that should be rejected.
@test unsafe fn testResolveAsCastsInvalid() throws (testing::TestError) {
    { // Pointer to slice is invalid.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let p: *i32 = undefined; p as *[i32];");
        let result = try resolveProgramStr(&mut a, "fn run(p: *i32) { p as *[i32]; }");
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
    } { // Slice to pointer is invalid.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let s: *[i32] = undefined; s as *i32;");
        let result = try resolveProgramStr(&mut a, "fn run(s: *[i32]) { s as *i32; }");
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
    } { // *T to *i32 is invalid.
        let mut a = testResolver();

        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
    } { // Slice to numeric is invalid.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let s: *[i32] = undefined; s as u32;");
        let result = try resolveProgramStr(&mut a, "fn run(s: *[i32]) { s as u32; }");
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
    } { // *record to *u8 is invalid.
        let mut a = testResolver();

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

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

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


    let mut b = testResolver();
    let next = try resolveProgramStr(&mut b, "constant BYTES: *[u8] = \"x\"; unsafe static VALUE: u32 = 7; static DATA: *[u64] = BYTES as *[u64];");
    try expectErrorKind(&next, super::ErrorKind::UnsafeOperation);
}

/// Uninitialized values require an explicit unsafe context in every value position.
@test unsafe fn testUndefinedRequiresUnsafe() throws (testing::TestError) {
    let programs = &[
        "fn run() -> u8 { let pointers: [*u8; 1] = undefined; return *pointers[0]; }",
        "fn run() { let n: u32 = undefined; }",
        "fn run() -> *u8 { return undefined; }",
        "fn take(p: *u8) {} fn run() { take(undefined); }",
        "fn run(p: *u8) { let mut q = p; set q = undefined; }",
        "fn run() { let pointers: [*u8; 1] = [undefined]; }",
        "fn run() { let pointers: [*u8; 2] = [undefined; 2]; }",
        "record R: Copy { p: *u8 } fn run() { let r = R { p: undefined }; }",
        "union U: Copy { Value { p: *u8 } } fn run() { let u = U::Value { p: undefined }; }",
        "static P: *u8 = undefined;",
        "constant P: *u8 = undefined;",
        "static DATA: [u8; 4] = undefined;",
        "record R: Copy { p: *u8 } static VALUE: R = R { p: undefined };",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    }
    try expectAnalyzeOk("unsafe fn run() { let p: *u8 = undefined; }");
    try expectAnalyzeOk("fn run() -> u32 { unsafe { let mut n: u32 = undefined; set n = 7; return n; } }");
    try expectAnalyzeOk("unsafe static P: *u8 = undefined;");
    try expectAnalyzeOk("record R: Copy { p: *u8 } unsafe static VALUE: R = R { p: undefined };");
    try expectAnalyzeOk("fn run() { let data: [u8; 4] = [0; 4]; let pointer: ?*u8 = nil; }");
    try expectAnalyzeOk("static DATA: [u8; 4] = [0; 4];");
}

/// Unsafe initialization does not grant permission to subsequent safe expressions.
@test unsafe fn testUndefinedContextRestored() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn run() { unsafe { let p: *u8 = undefined; } let q: *u8 = undefined; }");
    try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    let mut b = testResolver();
    let next = try resolveProgramStr(&mut b, "unsafe static P: *u8 = undefined; static Q: *u8 = undefined;");
    try expectErrorKind(&next, super::ErrorKind::UnsafeOperation);
}

/// Unsafe declarations may compose unsafe operations and calls.
@test unsafe fn testUnsafePointerOperationsAllowed() throws (testing::TestError) {
    let program = "record Marker: Once {} unsafe fn load(pointer: *unsafe u32) -> u32 { return *pointer; } unsafe fn run(pointer: *unsafe u32) -> u32 { let next = pointer + 1; let same = pointer == next; return load(pointer); }";
    try expectAnalyzeOk(program);
}

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

use std::lang::strings;
use std::mem;
use std::testing;

/// String pool for testing.
static TEST_STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
unsafe static TEST_STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };

/// Create a scanner backed by the test string pool.
fn testScanner(source: *[u8]) -> super::Scanner {
    return super::scanner(super::SourceLoc::File("test.r"), source, &mut TEST_STRING_POOL);
    unsafe {
        return super::scanner(super::SourceLoc::File("test.r"), source, &mut TEST_STRING_POOL);
    }
}

@test fn testScanTokens() throws (testing::TestError) {
    let mut s = testScanner(
        "'x' < fnord fnord: 0 => >> mod and nil"

        try testing::expect(false);
    }
}

@test fn testScanEmptyInput() throws (testing::TestError) {
    let mut s = super::Scanner {
        sourceLoc: super::SourceLoc::File("test.r"),
        source: "",
        token: 0,
        cursor: 0,
        pool: &mut TEST_STRING_POOL,
    };
    let mut s = testScanner("");
    let tok: super::Token = super::next(&mut s);

    try testing::expect(tok.kind == super::TokenKind::Eof);
    try testing::expect(tok.source.len == 0);
    try testing::expect(tok.offset == 0);

lib/std/tests.rad +1 -1

    try testing::expect(threw);
}

@test fn testWriteFileParts() throws (testing::TestError) {
    let path = "/tmp/radiance-std-write-file-parts.test";
    let mut buffer: [u8; 16] = undefined;
    let mut buffer: [u8; 16] = [0; 16];

    if not unix::writeFileParts(path, &["hello", " ", "world"]) {
        throw testing::TestError::Failed;
    }
    let data = unix::readFile(path, &mut buffer[..]) else {

test/runner.rad +11 -11

constant SOURCE_EXT: *[u8] = ".rad";
/// IL snapshot file extension for binary tests.
constant SNAPSHOT_EXT: *[u8] = ".ril";

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

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

/// Maximum number of data bytes in a `.ras` test binary.
constant ASM_DATA_CAPACITY: u32 = 1024;

// Static storage for large buffers to avoid stack overflow.
// Tests run serially so sharing these is safe.
static SOURCE_BUF: [u8; SOURCE_BUF_SIZE] = undefined;
static EXPECTED_BUF: [u8; EXPECTED_BUF_SIZE] = undefined;
static OUTPUT_BUF: [u8; OUTPUT_BUF_SIZE] = undefined;
static AST_ARENA_STORAGE: [u8; ARENA_SIZE] = undefined;
static IL_ARENA_STORAGE: [u8; ARENA_SIZE] = undefined;
static RESOLVER_ARENA_STORAGE: [u8; ARENA_SIZE] = undefined;
static NODE_DATA_STORAGE: [resolver::NodeData; MAX_NODE_DATA] = undefined;
static ERROR_STORAGE: [resolver::Error; MAX_ERRORS] = undefined;
static ASM_TEXT_STORAGE: [u32; ASM_TEXT_CAPACITY] = undefined;
static ASM_DATA_STORAGE: [u8; ASM_DATA_CAPACITY] = undefined;
unsafe static SOURCE_BUF: [u8; SOURCE_BUF_SIZE] = undefined;
unsafe static EXPECTED_BUF: [u8; EXPECTED_BUF_SIZE] = undefined;
unsafe static OUTPUT_BUF: [u8; OUTPUT_BUF_SIZE] = undefined;
unsafe static AST_ARENA_STORAGE: [u8; ARENA_SIZE] = undefined;
unsafe static IL_ARENA_STORAGE: [u8; ARENA_SIZE] = undefined;
unsafe static RESOLVER_ARENA_STORAGE: [u8; ARENA_SIZE] = undefined;
unsafe static NODE_DATA_STORAGE: [resolver::NodeData; MAX_NODE_DATA] = undefined;
unsafe static ERROR_STORAGE: [resolver::Error; MAX_ERRORS] = undefined;
unsafe static ASM_TEXT_STORAGE: [u32; ASM_TEXT_CAPACITY] = undefined;
unsafe static ASM_DATA_STORAGE: [u8; ASM_DATA_CAPACITY] = undefined;

/// Strip a `//` comment from a line, preserving `//` inside quoted strings.
/// Returns the content before the comment, trimmed of trailing whitespace.
fn stripLine(line: *[u8]) -> *[u8] {
    let mut end = line.len;

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


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

static DATA: [i32; TOTAL] = undefined;
unsafe static DATA: [i32; TOTAL] = undefined;

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    // Verify the array has the expected length.
    if DATA.len <> 12 { return 1; }
    return 0;
}

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

constant SHIFTED: u64 = 4 as u64;

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

// Cast of unsuffixed literal arithmetic.
constant E: u32 = (3 + 4) as u32;
// Nested casts of literal arithmetic.
constant F: u32 = ((3 + 4) as u64) as u32;

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

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

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

constant E: u32 = 2 * 3 + 4;
// Unary negation with literal.
constant F: i32 = -5;
constant G: i32 = F * 2;

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

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    assert A == 16;
    assert BUF.len == 16;
    assert C == 20;
    assert BUF2.len == 20;
    assert D == 10;

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

    q: 0x1234560C,
    r: 0x1234560D,
    s: 0x1234560E,
    t: 0x1234560F,
};
static ANALYZER: Analyzer = undefined;
unsafe static ANALYZER: Analyzer = undefined;

fn fillEntry(out: *mut Entry) {
    set *out = DEFAULT_ENTRY;
}


        return nil;
    }
    return mkEntry();
}

fn init(entries: *mut [Entry]) {
unsafe fn init(entries: *mut [Entry]) {
    set ANALYZER = Analyzer {
        pad0: 0xDEADAAA0,
        pad1: 0xDEADAAA1,
        entries,
        len: 0,
    };
}

fn add() {
unsafe fn add() {
    let idx = ANALYZER.len;
    let entry = mkOptEntry(true) else {
        return;
    };
    set ANALYZER.entries[idx] = entry;
    set ANALYZER.len = idx + 1;
}

fn checkHeader(expected: *[Entry]) -> i32 {
unsafe fn checkHeader(expected: *[Entry]) -> i32 {
    unsafe {
        if ANALYZER.entries.ptr <> expected.ptr or ANALYZER.entries.len <> expected.len {
            // Slice header got clobbered instead of the backing storage.
            return 1;
        }

        return 3;
    }
    return 0;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let target = &mut STORAGE[..];
    init(target);
    add();
    return checkHeader(target);
}

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

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

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

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    set holder.ptr = &mut target;
    set *holder.ptr = 42;

    return target;
}

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

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

static global: Outer = undefined;
unsafe static global: Outer = undefined;

fn readInner(i: Inner) -> i32 {
    return i.value;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    set global = Outer { padding: 0, inner: Inner { value: 42 } };

    assert readInner(global.inner) == 42;
    return 0;
}

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

        }
    }
    return nil;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut fields: [Field; 4] = undefined;
    set fields[0] = Field { name: nil, value: 10 };
    set fields[1] = Field { name: "foo", value: 20 };
    set fields[2] = Field { name: nil, value: 30 };
    set fields[3] = Field { name: "bar", value: 40 };

test/tests/frame.large.rad +4 -4

//! returns: 0
//! Test large stack frames and addressing near top of frame.
fn bigFrame1() -> i32 {
unsafe fn bigFrame1() -> i32 {
    let pad: [u8; 2024] = undefined;
    let n: i32 = 491823;

    return n + 1;
}

fn bigFrame2() -> i32 {
unsafe fn bigFrame2() -> i32 {
    let pad: [u8; 2028] = undefined;
    let arr: [i32; 4] = [1, 2, 3, 4];

    return arr[0] + arr[1] + arr[3];
}

fn bigFrame3() -> i32 {
unsafe fn bigFrame3() -> i32 {
    let mut ary: [u8; 4096] = undefined;
    set ary[4091] = 192;

    return ary[4091] as i32;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    assert bigFrame1() == 491824;
    assert bigFrame2() == 7;
    assert bigFrame3() == 192;
    return 0;
}

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

}

/// Store at offset 2200 (> MAX_IMM) into a record field.
/// Generates `store w32 <imm> %0 2200` in IL, which triggers the
/// SCRATCH1 aliasing bug when adjustOffset clobbers the value.
fn storeLargeOffset() -> i32 {
unsafe fn storeLargeOffset() -> i32 {
    let mut b: Big = undefined;
    set b.tag = 42;
    assert b.tag == 42;
    set b.tag = 99;
    assert b.tag == 99;
    return 0;
}

/// Copy a >2047 byte struct (triggers blit offset overflow).
fn copyBig() -> i32 {
unsafe fn copyBig() -> i32 {
    let mut src: Big = undefined;
    set src.a[0] = 10;
    set src.a[1000] = 20;
    set src.a[2199] = 30;
    set src.tag = 77;

    assert dst.tag == 77;
    return 0;
}

/// Mutate a copy to ensure the blit produced an independent copy.
fn copyIndependence() -> i32 {
unsafe fn copyIndependence() -> i32 {
    let mut a: Big = undefined;
    set a.a[0] = 1;
    set a.a[2199] = 2;
    set a.tag = 100;


    assert b.a[2199] == 2;
    assert b.tag == 200;
    return 0;
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let r1 = storeLargeOffset();
    if r1 <> 0 {
        return 10 + r1;
    }


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

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

static outer: Outer = undefined;
unsafe static outer: Outer = undefined;

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    set outer.inner.value = 42;

    let ptr: *Inner = &outer.inner;

    assert (*ptr).value == 42;

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

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

static container: Container = undefined;
unsafe static container: Container = undefined;

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let sourceOpt: ?i32 = 42;

    set container.opt = sourceOpt;

    if let val = container.opt {

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

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

static container: Container = undefined;
unsafe static container: Container = undefined;

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    set container.opt = 42;

    if let val = container.opt {
        assert val == 42;
        return 0;

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

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

static outer: Outer = undefined;
static source: Inner = undefined;
unsafe static outer: Outer = undefined;
unsafe static source: Inner = undefined;

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    set source.value = 42;

    set outer.inner = source;

    assert outer.inner.value == 42;

test/tests/memzero.union.bug.rad +1 -1

    guard1: u16,
    val: Payload,
    guard2: u32,
}

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut f: Frame = Frame { guard1: 0xDEAD, val: undefined, guard2: 0xDEADBEEF };

    set f.val = Payload::Small(7);
    set f.val = Payload::Big([1, 2, 3]);


test/tests/pointer.slice.store.rad +3 -3


record PtrBox: Copy {
    ptr: *mut *mut [Entry],
}

static STORAGE: [Entry; 2] = undefined;
static TABLE: Table = undefined;
static HOLDER: PtrBox = undefined;
unsafe static STORAGE: [Entry; 2] = undefined;
unsafe static TABLE: Table = undefined;
unsafe static HOLDER: PtrBox = undefined;

/// Exercise slice storage and inspect its pointer fields.
@default unsafe fn main() -> i32 {
    set TABLE.entries = &mut STORAGE[..];
    set TABLE.len     = 0;

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

69	69		assert a[2].x == 561;
70	70		assert a[3].x == 12;
71	71		return 0;
72	72		}
73	73
74		-	fn func4(s: S) -> i32 {
	74	+	unsafe fn func4(s: S) -> i32 {
75	75		let mut a: [S; 2] = undefined;
76	76		set a[0] = s;
77	77
78	78		assert a[0].x == 561;
79	79		assert a[0].y == 938;
80	80		assert a[0].z == 102;
81	81		return 0;
82	82		}
83	83
84		-	fn func5(s: S) -> i32 {
	84	+	unsafe fn func5(s: S) -> i32 {
85	85		let mut a: [S; 2] = undefined;
86	86		let t: S = makeS(s.x, s.y, s.z);
87	87		set a[0] = t;
88	88
89	89		assert a[0].x == 561;
90	90		assert a[0].y == 938;
91	91		assert a[0].z == 102;
92	92		return 0;
93	93		}
94	94
95		-	@default fn main() -> i32 {
	95	+	@default unsafe fn main() -> i32 {
96	96		let s: S = S { x: 561, y: 938, z: 102 };
97	97
98	98		let r1: i32 = func1(s);
99	99		if r1 <> 0 {
100	100		return 10 + r1;

test/tests/slice.append.rad +1 -1

        func: arenaAllocFn,
        ctx: arena as *mut opaque,
    };
}

static BUF: [u8; 4096] = undefined;
unsafe static BUF: [u8; 4096] = undefined;

@default unsafe fn main() -> i32 {
    static arena: Arena = undefined;
    set arena = newArena(&mut BUF[..]);
    let a = arenaAllocator(&mut arena);

test/tests/static.slice.index.assign.rad +2 -2

record Container: Copy {
    pad: i32,
    items: [Inner; 3],
}

static container: Container = undefined;
unsafe static container: Container = undefined;

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    set container.items[0].value = 10;
    set container.items[1].value = 20;
    set container.items[2].value = 30;

    let slice: *mut [Inner] = &mut container.items[..];

test/tests/static.slice.offset.rad +2 -2

static SCRATCH: [Entry; 1] = [Entry { a: 0, b: 0 }];
static STORAGE: [Entry; 2] = [
    Entry { a: 0, b: 0 },
    Entry { a: 0, b: 0 },
];
static TBL: Table = undefined;
unsafe static TBL: Table = undefined;

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    set TBL.scratch = &mut SCRATCH[..];
    set TBL.entries = &mut STORAGE[..];
    set TBL.len     = 0;

    set TBL.entries[TBL.len] = Entry { a: 7, b: 9 };

test/tests/static.zero.bss.rad +2 -2

    /// Field that forces padding after `tag`.
    value: u32,
}

/// Partially initialized aggregate where all concrete bytes are zero.
static POOL: Pool = Pool { table: undefined, count: 0 };
unsafe static POOL: Pool = Pool { table: undefined, count: 0 };

/// Repeated scalar zeros.
static FLAGS: [bool; 4] = [false; 4];

/// Explicit zero fields with undefined padding.
static PADDED: Padded = Padded { tag: 0, value: 0 };

@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    assert POOL.count == 0;
    assert FLAGS[0] == false;
    assert FLAGS[3] == false;
    assert PADDED.tag == 0;
    assert PADDED.value == 0;

test/tests/undefined.aggregate.rad +1 -1

/// Test lowering of undefined for aggregate types.
record Point: Copy { x: i32, y: i32 }

fn test() -> i32 {
unsafe fn test() -> i32 {
    let p: Point = undefined;
    return p.x;
}

test/tests/undefined.primitive.rad +1 -1

/// Test lowering of undefined for primitive types.
fn test() -> i32 {
unsafe fn test() -> i32 {
    let x: i32 = undefined;
    return x;
}

test/tests/undefined.rad +1 -1

//! returns: 0
//! Test undefined values for arrays and assignment.
@default fn main() -> i32 {
@default unsafe fn main() -> i32 {
    let mut ary: [u16; 32] = undefined;
    let x: u32 = 8;
    let y: u32 = 9;

    set ary[0] = 1;

test/tests/undefined.record.field.rad +3 -3

    len: i32,
}

/// Construct a record with one field `undefined` (named-field syntax).
/// The IL must not contain a `blit` or `store` for `x`.
fn partialInit() -> i32 {
unsafe fn partialInit() -> i32 {
    let s = Small { x: undefined, y: 42 };
    return s.y;
}

/// Construct a record with an array field `undefined` (named-field syntax).
/// The IL must not contain a `blit` for `data`.
fn arrayFieldUndef() -> i32 {
unsafe fn arrayFieldUndef() -> i32 {
    let w = WithArray { data: undefined, len: 3 };
    return w.len;
}

/// Both fields defined - normal case for comparison.

    B,
}

/// Union variant with record payload containing an `undefined` field.
/// This exercises `lowerRecordCtor` (positional constructor path).
fn unionPayloadUndef() -> i32 {
unsafe fn unionPayloadUndef() -> i32 {
    let t = Tagged::A { data: undefined, tag: 99 };
    match t {
        case Tagged::A { tag, .. } => return tag,
        else => return -1,
    }

test/tests/undefined.unsafe.rad added +33 -0

1	+	//! returns: 0
2	+
3	+	/// Permanent storage for the initialized pointers.
4	+	static DATA: [u8; 2] = [7, 9];
5	+
6	+	/// Initialize each array element before reading a pointer.
7	+	fn read() -> u8 {
8	+	unsafe {
9	+	let mut pointers: [*u8; 2] = undefined;
10	+	set pointers[0] = &DATA[0];
11	+	set pointers[1] = &DATA[1];
12	+	return pointers[0] + pointers[1];
13	+	}
14	+	}
15	+
16	+	/// Initialize a scalar before returning its value.
17	+	unsafe fn scalar() -> u8 {
18	+	let mut value: u8 = undefined;
19	+	set value = 4;
20	+	return value;
21	+	}
22	+
23	+	/// Check unsafe initialization and safe empty values.
24	+	@default fn main() -> i32 {
25	+	let bytes: [u8; 2] = [0; 2];
26	+	let pointer: ?*u8 = nil;
27	+	if bytes[0] <> 0 or pointer <> nil { return 1; }
28	+	if read() <> 16 { return 2; }
29	+	unsafe {
30	+	if scalar() <> 4 { return 3; }
31	+	}
32	+	return 0;
33	+	}

230	230		/// Create an empty source input set for one package.
231	231		fn packageInput(name: *[u8]) -> PackageInput {
232	232		return PackageInput {
233	233		name,
234	234		startupPath: nil,
235		-	radPaths: undefined,
	235	+	radPaths: [""; MAX_LOADED_MODULES],
236	236		radPathCount: 0,
237		-	asmPaths: undefined,
	237	+	asmPaths: [""; MAX_ASM_MODULES],
238	238		asmPathCount: 0,
239	239		};
240	240		}
241	241
242	242		/// Register, load, and parse `path` within `pkg`.

799	799		fn writeDataWithExt(
800	800		data: *[u8],
801	801		basePath: *[u8],
802	802		ext: *[u8]
803	803		) throws (Error) {
804		-	let mut path: [u8; MAX_PATH_LEN] = undefined;
	804	+	let mut path: [u8; MAX_PATH_LEN] = [0; MAX_PATH_LEN];
805	805		let mut pos: u32 = 0;
806	806
807	807		set pos += try! mem::copy(&mut path[pos..], basePath);
808	808		set pos += try! mem::copy(&mut path[pos..], ext);
809	809		set path[pos] = 0; // Null-terminate for syscall.

143	143
144	144		/// Compute frame layout from local size and used callee-saved registers.
145	145		export fn computeFrame(localSize: i32, usedCalleeSaved: u32, epilogueBlock: u32, isLeaf: bool, isDynamic: bool) -> Frame {
146	146		let mut frame = Frame {
147	147		totalSize: 0,
148		-	savedRegs: undefined,
	148	+	savedRegs: [SavedReg { reg: super::ZERO, offset: 0 }; super::NUM_SAVED_REGISTERS],
149	149		savedRegsLen: 0,
150	150		epilogueBlock,
151	151		isLeaf,
152	152		isDynamic,
153	153		};

104	104		try testing::expect(failed);
105	105		}
106	106
107	107		/// Test the Allocator interface backed by an arena.
108	108		@test unsafe fn testAllocator() throws (testing::TestError) {
109		-	static STORAGE: [u8; 256] = undefined;
	109	+	static STORAGE: [u8; 256] = [0; 256];
110	110		let mut arena = super::new(&mut STORAGE[..]);
111	111		let a = super::arenaAllocator(&mut arena);
112	112
113	113		// Allocate through the Allocator indirection.
114	114		let p1 = a.func(a.ctx, 16, 4);

845	845		}
846	846		}
847	847
848	848		/// Finalize lowering and return the unified IL program.
849	849		export fn finalize(low: &Lowerer) -> il::Program {
850		-	let mut fns: mut [il::Fn] = undefined;
851	850		match low.output {
852	851		case FnOutput::Accumulate(accumulated) => {
853		-	set fns = accumulated;
	852	+	return il::Program {
	853	+	data: &low.data[..],
	854	+	fns: &accumulated[..],
	855	+	};
854	856		}
855	857		case FnOutput::Stream(_) => {
856	858		panic "finalize: cannot finalize streaming lowerer";
857	859		}
858	860		}
859		-	return il::Program {
860		-	data: &low.data[..],
861		-	fns: &fns[..],
862		-	};
863	861		}
864	862
865	863		/////////////////////////////////
866	864		// Qualified Name Construction //
867	865		/////////////////////////////////

44	44		/// Main arena size (96 MB) - lives throughout compilation.
45	45		/// Used for: resolver data, types, symbols, global IL data, and codegen output.
46	46		constant MAIN_ARENA_SIZE: u32 = 100663296;
47	47
48	48		/// AST storage arena.
49		-	static TEMP_ARENA: [u8; TEMP_ARENA_SIZE] = undefined;
	49	+	static TEMP_ARENA: [u8; TEMP_ARENA_SIZE] = [0; TEMP_ARENA_SIZE];
50	50		/// Scratch storage reclaimed after each generated function.
51		-	static FN_ARENA: [u8; FN_ARENA_SIZE] = undefined;
	51	+	static FN_ARENA: [u8; FN_ARENA_SIZE] = [0; FN_ARENA_SIZE];
52	52		/// Main storage arena - persists throughout compilation.
53		-	static MAIN_ARENA: [u8; MAIN_ARENA_SIZE] = undefined;
	53	+	static MAIN_ARENA: [u8; MAIN_ARENA_SIZE] = [0; MAIN_ARENA_SIZE];
54	54
55	55		/// Module source code.
56		-	static MODULE_SOURCES: [u8; MAX_SOURCES_SIZE] = undefined;
	56	+	static MODULE_SOURCES: [u8; MAX_SOURCES_SIZE] = [0; MAX_SOURCES_SIZE];
57	57		/// Module entries for all packages.
58		-	static MODULE_ENTRIES: [module::ModuleEntry; MAX_TOTAL_MODULES] = undefined;
	58	+	unsafe static MODULE_ENTRIES: [module::ModuleEntry; MAX_TOTAL_MODULES] = undefined;
59	59		/// String pool.
60		-	static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
	60	+	unsafe static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
61	61
62	62		/// Package scope.
63		-	static RESOLVER_PKG_SCOPE: resolver::Scope = undefined;
	63	+	unsafe static RESOLVER_PKG_SCOPE: resolver::Scope = undefined;
64	64		/// Errors emitted by resolver.
65		-	static RESOLVER_ERRORS: [resolver::Error; resolver::MAX_ERRORS] = undefined;
	65	+	unsafe static RESOLVER_ERRORS: [resolver::Error; resolver::MAX_ERRORS] = undefined;
66	66
67	67		/// Code generation storage.
68		-	static CODEGEN_DATA_SYMS: [data::DataSym; data::MAX_DATA_SYMS] = undefined;
	68	+	unsafe static CODEGEN_DATA_SYMS: [data::DataSym; data::MAX_DATA_SYMS] = undefined;
69	69		/// Hash table entries for data symbol lookup.
70		-	static CODEGEN_DATA_SYM_ENTRIES: [dict::Entry; data::DATA_SYM_TABLE_SIZE] = undefined;
	70	+	unsafe static CODEGEN_DATA_SYM_ENTRIES: [dict::Entry; data::DATA_SYM_TABLE_SIZE] = undefined;
71	71
72	72		/// Debug info file extension.
73	73		constant DEBUG_EXT: *[u8] = ".debug";
74	74
75	75		/// Maximum rodata size (4MB).

77	77		/// Maximum rwdata size (4MB).
78	78		constant MAX_RW_DATA_SIZE: u32 = 4194304;
79	79		/// Maximum path length.
80	80		constant MAX_PATH_LEN: u32 = 256;
81	81		/// Read-only data buffer.
82		-	static RO_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = undefined;
	82	+	static RO_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = [0; MAX_RO_DATA_SIZE];
83	83		/// Read-write data buffer.
84		-	static RW_DATA_BUF: [u8; MAX_RW_DATA_SIZE] = undefined;
	84	+	static RW_DATA_BUF: [u8; MAX_RW_DATA_SIZE] = [0; MAX_RW_DATA_SIZE];
85	85		/// Assembly module source buffer.
86		-	static ASM_SOURCE_BUF: [u8; MAX_SOURCES_SIZE] = undefined;
	86	+	static ASM_SOURCE_BUF: [u8; MAX_SOURCES_SIZE] = [0; MAX_SOURCES_SIZE];
87	87		/// Temporary assembly text buffer.
88		-	static ASM_TEXT_BUF: [u32; 262144] = undefined;
	88	+	static ASM_TEXT_BUF: [u32; 262144] = [0; 262144];
89	89		/// Temporary assembly data buffer.
90		-	static ASM_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = undefined;
	90	+	static ASM_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = [0; MAX_RO_DATA_SIZE];
91	91		/// Accumulated assembly read-only data.
92		-	static ASM_RO_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = undefined;
	92	+	static ASM_RO_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = [0; MAX_RO_DATA_SIZE];
93	93
94	94		/// Assembly source file extension.
95	95		constant ASM_SOURCE_EXT: *[u8] = ".ras";
96	96		/// Symbol name exported for startup code to call the semantic entry function.
97	97		export constant DEFAULT_ENTRY_SYMBOL: *[u8] = "::default";

1	1		use std::mem;
2	2		use std::testing;
3	3		use std::lang::strings;
4	4
5	5		/// String pool used by assembler scanner tests.
6		-	static TEST_STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
	6	+	unsafe static TEST_STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
7	7
8	8		/// Create a scanner for test input.
9	9		fn testScanner(source: *[u8]) -> super::Scanner {
10		-	return super::scanner(super::SourceKind::String, source, &mut TEST_STRING_POOL);
	10	+	unsafe {
	11	+	return super::scanner(super::SourceKind::String, source, &mut TEST_STRING_POOL);
	12	+	}
11	13		}
12	14
13	15		/// Scanner recognizes assembler-specific sigils and scoped names.
14	16		@test fn testScanRegisterDirectiveAndLabelTokens() throws (testing::TestError) {
15	17		let mut s = testScanner(

9	9		use std::arch::rv64::encode;
10	10		use std::arch::rv64::printer;
11	11
12	12		use super::scanner;
13	13
14		-	static ASM_ARENA_STORAGE: [u8; 65536] = undefined;
15		-	static ASM_TEXT_STORAGE: [u32; 256] = undefined;
16		-	static ASM_DATA_STORAGE: [u8; 1024] = undefined;
17		-	static ASM_STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
18		-	static PRINT_ARENA_STORAGE: [u8; 1024] = undefined;
19		-	static PRINT_BUFFER: [u8; 128] = undefined;
	14	+	static ASM_ARENA_STORAGE: [u8; 65536] = [0; 65536];
	15	+	static ASM_TEXT_STORAGE: [u32; 256] = [0; 256];
	16	+	static ASM_DATA_STORAGE: [u8; 1024] = [0; 1024];
	17	+	unsafe static ASM_STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
	18	+	static PRINT_ARENA_STORAGE: [u8; 1024] = [0; 1024];
	19	+	static PRINT_BUFFER: [u8; 128] = [0; 128];
20	20
21	21		unsafe fn assembleSource(source: *[u8]) -> super::Program throws (testing::TestError) {
22	22		let mut arena = alloc::new(&mut ASM_ARENA_STORAGE[..]);
23	23		return try super::assemble(
24	24		scanner::SourceKind::String,

8	8		use std::collections::dict;
9	9
10	10		use super::encode;
11	11		use super::asm;
12	12
13		-	static ASSEMBLY_ARENA_STORAGE: [u8; 16777216] = undefined;
14		-	static ASSEMBLY_TEXT_STORAGE: [u32; 2] = undefined;
	13	+	static ASSEMBLY_ARENA_STORAGE: [u8; 16777216] = [0; 16777216];
	14	+	static ASSEMBLY_TEXT_STORAGE: [u32; 2] = [0; 2];
15	15
16	16		/// Helper to check encoding equals expected value.
17	17		fn expectEncoding(actual: u32, expected: u32) throws (testing::TestError) {
18	18		try testing::expect(actual == expected);
19	19		}

2	2
3	3		use std::testing;
4	4
5	5		/// Test basic allocation.
6	6		@test fn testAllocBasic() throws (testing::TestError) {
7		-	static STORAGE: [u8; 64] = undefined;
	7	+	static STORAGE: [u8; 64] = [0; 64];
8	8		let mut arena = super::new(&mut STORAGE[..]);
9	9
10	10		let ptr = try! super::alloc(&mut arena, 4, 4);
11	11		try testing::expect(super::used(&arena) == 4);
12	12		try testing::expect(super::remaining(&arena) == 60);
13	13		}
14	14
15	15		/// Test that allocations are properly aligned.
16	16		@test fn testAllocAlignment() throws (testing::TestError) {
17		-	static STORAGE: [u8; 64] = undefined;
	17	+	static STORAGE: [u8; 64] = [0; 64];
18	18		let mut arena = super::new(&mut STORAGE[..]);
19	19
20	20		// Allocate 1 byte with 1-byte alignment.
21	21		let p1 = try! super::alloc(&mut arena, 1, 1);
22	22		try testing::expect(super::used(&arena) == 1);

26	26		try testing::expect(super::used(&arena) == 8); // 1 + 3 padding + 4
27	27		}
28	28
29	29		/// Test multiple allocations.
30	30		@test fn testAllocMultiple() throws (testing::TestError) {
31		-	static STORAGE: [u8; 128] = undefined;
	31	+	static STORAGE: [u8; 128] = [0; 128];
32	32		let mut arena = super::new(&mut STORAGE[..]);
33	33
34	34		let p1 = try! super::alloc(&mut arena, 8, 4);
35	35		let p2 = try! super::alloc(&mut arena, 16, 4);
36	36		let p3 = try! super::alloc(&mut arena, 4, 4);

38	38		try testing::expect(super::used(&arena) == 28); // 8 + 16 + 4
39	39		}
40	40
41	41		/// Test that arena throws when exhausted.
42	42		@test fn testAllocExhausted() throws (testing::TestError) {
43		-	static STORAGE: [u8; 16] = undefined;
	43	+	static STORAGE: [u8; 16] = [0; 16];
44	44		let mut arena = super::new(&mut STORAGE[..]);
45	45
46	46		// This should succeed.
47	47		let p1 = try! super::alloc(&mut arena, 8, 4);
48	48

57	57		try testing::expect(failed);
58	58		}
59	59
60	60		/// Test that reset allows reuse of memory.
61	61		@test fn testAllocReset() throws (testing::TestError) {
62		-	static STORAGE: [u8; 32] = undefined;
	62	+	static STORAGE: [u8; 32] = [0; 32];
63	63		let mut arena = super::new(&mut STORAGE[..]);
64	64
65	65		let p1 = try! super::alloc(&mut arena, 16, 4);
66	66		try testing::expect(super::used(&arena) == 16);
67	67

73	73		let p2 = try! super::alloc(&mut arena, 32, 4);
74	74		}
75	75
76	76		/// Test alignment when offset is already aligned.
77	77		@test fn testAllocAlreadyAligned() throws (testing::TestError) {
78		-	static STORAGE: [u8; 64] = undefined;
	78	+	static STORAGE: [u8; 64] = [0; 64];
79	79		let mut arena = super::new(&mut STORAGE[..]);
80	80
81	81		// Allocate 4 bytes - offset becomes 4, already aligned for next 4-byte alloc.
82	82		let p1 = try! super::alloc(&mut arena, 4, 4);
83	83		try testing::expect(super::used(&arena) == 4);

87	87		try testing::expect(super::used(&arena) == 8);
88	88		}
89	89
90	90		/// Test allocation that would overflow with alignment padding.
91	91		@test fn testAllocOverflowWithPadding() throws (testing::TestError) {
92		-	static STORAGE: [u8; 16] = undefined;
	92	+	static STORAGE: [u8; 16] = [0; 16];
93	93		let mut arena = super::new(&mut STORAGE[..]);
94	94
95	95		// Allocate 1 byte, offset is now 1.
96	96		let p1 = try! super::alloc(&mut arena, 1, 1);
97	97

285	285		let pathSuffix = mem::stripPrefix(baseDir, filePath) else {
286	286		throw ModuleError::InvalidPath;
287	287		};
288	288
289	289		// Parse the stripped path into components.
290		-	let mut parts: [*[u8]; MAX_MODULE_PATH_DEPTH] = undefined;
	290	+	let mut parts: [*[u8]; MAX_MODULE_PATH_DEPTH] = [""; MAX_MODULE_PATH_DEPTH];
291	291		let partsLen = parsePath(pathSuffix, &mut parts[..]) else {
292	292		throw ModuleError::InvalidPath;
293	293		};
294	294		if partsLen == 0 {
295	295		throw ModuleError::InvalidPath;

331	331		packageId,
332	332		parent: nil,
333	333		filePath,
334	334		dirLen: 0,
335	335		name: strings::intern(graph.pool, name),
336		-	path: undefined,
	336	+	path: [""; MAX_MODULE_PATH_DEPTH],
337	337		pathDepth: 0,
338	338		state: ModuleState::Vacant,
339		-	children: undefined,
	339	+	children: [0; MAX_MODULES],
340	340		childrenLen: 0,
341	341		ast: nil,
342	342		source: nil,
343	343		};
344	344		set m.dirLen = dirLength(m.filePath);

4	4		use std::testing;
5	5		use std::lang::ast;
6	6		use std::lang::strings;
7	7
8	8		/// Test arena backing storage.
9		-	static TEST_ARENA: [u8; 4096] = undefined;
	9	+	static TEST_ARENA: [u8; 4096] = [0; 4096];
10	10		/// Interned string pool.
11		-	static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
	11	+	unsafe static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
12	12
13	13		fn expectSliceEq(actual: [u8], expected: [u8])
14	14		throws (testing::TestError)
15	15		{
16	16		if not mem::eq(actual, expected) {

114	114		try testing::expect(result == nil);
115	115		}
116	116
117	117		@test fn testParsePathSingleComponent() throws (testing::TestError) {
118	118		let path = "std.rad";
119		-	let mut components: [*[u8]; 8] = undefined;
	119	+	let mut components: [*[u8]; 8] = [""; 8];
120	120		let count = super::parsePath(path, &mut components[..]) else {
121	121		throw testing::TestError::Failed;
122	122		};
123	123		try testing::expect(count == 1);
124	124		try expectSliceEq(components[0], "std");
125	125		}
126	126
127	127		@test fn testParsePathMultipleComponents() throws (testing::TestError) {
128	128		let path = "std/lang/parser.rad";
129		-	let mut components: [*[u8]; 8] = undefined;
	129	+	let mut components: [*[u8]; 8] = [""; 8];
130	130		let count = super::parsePath(path, &mut components[..]) else {
131	131		throw testing::TestError::Failed;
132	132		};
133	133		try testing::expect(count == 3);
134	134		try expectSliceEq(components[0], "std");

136	136		try expectSliceEq(components[2], "parser");
137	137		}
138	138
139	139		@test fn testParsePathWithoutExtension() throws (testing::TestError) {
140	140		let path = "std/lang/parser";
141		-	let mut components: [*[u8]; 8] = undefined;
	141	+	let mut components: [*[u8]; 8] = [""; 8];
142	142		let result = super::parsePath(path, &mut components[..]);
143	143		try testing::expect(result == nil);
144	144		}
145	145
146	146		@test unsafe fn testRegisterFromPathHierarchy() throws (testing::TestError) {

12	12		use std::lang::strings;
13	13
14	14		/// Unified arena size.
15	15		constant ARENA_SIZE: u32 = 2097152;
16	16		/// Unified arena storage for all AST allocations.
17		-	static ARENA_STORAGE: [u8; ARENA_SIZE] = undefined;
	17	+	static ARENA_STORAGE: [u8; ARENA_SIZE] = [0; ARENA_SIZE];
18	18		/// String pool.
19		-	static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
	19	+	unsafe static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
20	20
21	21		/// Assert that a node is an identifier with the given name.
22	22		fn expectIdent(node: ast::Node, name: [u8])
23	23		throws (testing::TestError)
24	24		{

2955	2955		return setNodeType(self, node, hint);
2956	2956		}
2957	2957		return setNodeType(self, node, Type::Nil);
2958	2958		},
2959	2959		case ast::NodeValue::Undef => {
	2960	+	try requireUnsafe(self, node);
2960	2961		return setNodeType(self, node, Type::Undefined);
2961	2962		},
2962	2963		case ast::NodeValue::Bool(value) => {
2963	2964		setNodeConstValue(self, node, ConstValue::Bool(value));
2964	2965		return setNodeType(self, node, Type::Bool);

12	12
13	13		/// Synthetic file path used for resolver tests.
14	14		constant MODULE_PATH: *[u8] = "/dev/test.rad";
15	15
16	16		/// AST arena storage used by resolver tests.
17		-	static AST_ARENA: [u8; 2097152] = undefined;
	17	+	static AST_ARENA: [u8; 2097152] = [0; 2097152];
18	18
19	19		/// Resolver arena storage used by resolver tests.
20		-	static ARENA_STORAGE: [u8; 2097152] = undefined;
	20	+	static ARENA_STORAGE: [u8; 2097152] = [0; 2097152];
21	21
22	22		/// Node metadata storage used by resolver tests.
23		-	static NODE_DATA_STORAGE: [super::NodeData; 256] = undefined;
	23	+	unsafe static NODE_DATA_STORAGE: [super::NodeData; 256] = undefined;
24	24
25	25		/// Diagnostic storage used by resolver tests.
26		-	static ERROR_STORAGE: [super::Error; 16] = undefined;
	26	+	unsafe static ERROR_STORAGE: [super::Error; 16] = undefined;
27	27
28	28		/// Package scope used by resolver tests.
29		-	static PKG_SCOPE: super::Scope = undefined;
	29	+	unsafe static PKG_SCOPE: super::Scope = undefined;
30	30
31	31		/// Module entries used by resolver tests.
32		-	static MODULE_ENTRIES: [module::ModuleEntry; 8] = undefined;
	32	+	unsafe static MODULE_ENTRIES: [module::ModuleEntry; 8] = undefined;
33	33
34	34		/// Module graph used by resolver tests.
35		-	static MODULE_GRAPH: module::ModuleGraph = undefined;
	35	+	unsafe static MODULE_GRAPH: module::ModuleGraph = undefined;
36	36
37	37		/// Module AST arena storage used by resolver tests.
38		-	static MODULE_ARENA_STORAGE: [u8; 4096] = undefined;
	38	+	static MODULE_ARENA_STORAGE: [u8; 4096] = [0; 4096];
39	39
40	40		/// Module AST arena used by resolver tests.
41		-	static MODULE_ARENA: ast::NodeArena = undefined;
	41	+	unsafe static MODULE_ARENA: ast::NodeArena = undefined;
42	42
43	43		/// Interned string pool used by resolver tests.
44		-	static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
	44	+	unsafe static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
45	45
46	46		/// String literals used in tests.
47	47		constant LITERALS: [*[u8]; 15] = [
48	48		"Ok", "Error", "R", "S",
49	49		"f", "Status", "Pending",

57	57		diagnostics: super::Diagnostics,
58	58		root: *ast::Node,
59	59		}
60	60
61	61		/// Create isolated storage for tests to avoid conflicts with global resolver storage.
62		-	fn testStorage() -> super::ResolverStorage {
	62	+	unsafe fn testStorage() -> super::ResolverStorage {
63	63		return super::ResolverStorage {
64	64		arena: alloc::new(&mut ARENA_STORAGE[..]),
65	65		nodeData: &mut NODE_DATA_STORAGE[..],
66	66		pkgScope: &mut PKG_SCOPE,
67	67		errors: &mut ERROR_STORAGE[..],

2154	2154		}
2155	2155
2156	2156		@test unsafe fn testUndefinedCoercions() throws (testing::TestError) {
2157	2157		{
2158	2158		let mut a = testResolver();
2159		-	let result = try resolveBlockStr(&mut a, "let count: i32 = undefined;");
	2159	+	let result = try resolveBlockStr(&mut a, "unsafe { let count: i32 = undefined; }");
2160	2160		try expectNoErrors(&result);
2161	2161		} {
2162	2162		let mut a = testResolver();
2163		-	let program = "let mut value: i32 = 0; set value = undefined;";
	2163	+	let program = "unsafe { let mut value: i32 = 0; set value = undefined; }";
2164	2164		let result = try resolveProgramStr(&mut a, program);
2165	2165		try expectNoErrors(&result);
2166	2166		} {
2167	2167		let mut a = testResolver();
2168		-	let program = "fn f(x: i32) {} fn g() { f(undefined); }";
	2168	+	let program = "fn f(x: i32) {} unsafe fn g() { f(undefined); }";
2169	2169		let result = try resolveProgramStr(&mut a, program);
2170	2170		try expectNoErrors(&result);
2171	2171		} {
2172	2172		let mut a = testResolver();
2173		-	let program = "fn fetch() -> i32 { return undefined; }";
	2173	+	let program = "unsafe fn fetch() -> i32 { return undefined; }";
2174	2174		let result = try resolveProgramStr(&mut a, program);
2175	2175		try expectNoErrors(&result);
2176	2176		}
2177	2177		}
2178	2178

3672	3672		let result = try resolveProgramStr(&mut a, "fn f(x: opaque) {}");
3673	3673		let err = try expectError(&result);
3674	3674		try expectErrorKind(&result, super::ErrorKind::OpaqueTypeNotAllowed);
3675	3675		} {
3676	3676		let mut a = testResolver();
3677		-	let result = try resolveProgramStr(&mut a, "fn f() { let x: opaque = undefined; }");
	3677	+	let result = try resolveProgramStr(&mut a, "unsafe fn f() { let x: opaque = undefined; }");
3678	3678		let err = try expectError(&result);
3679	3679		try expectErrorKind(&result, super::ErrorKind::OpaqueTypeNotAllowed);
3680	3680		} {
3681	3681		let mut a = testResolver();
3682	3682		let result = try resolveProgramStr(&mut a, "record R { x: opaque }");

3832	3832		let mut a = testResolver();
3833	3833		let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
3834	3834
3835	3835		let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
3836	3836		let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export constant SIZE: u32 = 8;", &mut arena);
3837		-	let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; static BUFFER: [u8; consts::SIZE] = undefined;", &mut arena);
	3837	+	let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; static BUFFER: [u8; consts::SIZE] = [0; consts::SIZE];", &mut arena);
3838	3838
3839	3839		let result = try resolveModuleTree(&mut a, rootId);
3840	3840		try expectNoErrors(&result);
3841	3841		}
3842	3842

4500	4500		let mut a = testResolver();
4501	4501		let result = try resolveBlockStr(&mut a, "static x: i32 = 0; let p = &x; p as u32;");
4502	4502		try expectNoErrors(&result);
4503	4503		} { // Function pointer to numeric.
4504	4504		let mut a = testResolver();
4505		-	let result = try resolveBlockStr(&mut a, "let f: fn() = undefined; f as u32;");
	4505	+	let result = try resolveProgramStr(&mut a, "fn run(f: fn()) { f as u32; }");
4506	4506		try expectNoErrors(&result);
4507	4507		} { // u8 to i32 (u8 to i32 is valid).
4508	4508		let mut a = testResolver();
4509	4509		let result = try resolveProgramStr(&mut a, "unsafe fn run() { let p: u8 = undefined; p as i32; }");
4510	4510		try expectNoErrors(&result);

4514	4514		try expectNoErrors(&result);
4515	4515		}
4516	4516
4517	4517		{ // [i32] to [opaque].
4518	4518		let mut a = testResolver();
4519		-	let result = try resolveBlockStr(&mut a, "let s: [i32] = undefined; s as [opaque];");
	4519	+	let result = try resolveProgramStr(&mut a, "fn run(s: [i32]) { s as [opaque]; }");
4520	4520		try expectNoErrors(&result);
4521	4521		} { // [opaque] to [i32].
4522	4522		let mut a = testResolver();
4523	4523		let result = try resolveProgramStr(&mut a, "unsafe fn run() { let s: [opaque] = undefined; s as [i32]; }");
4524	4524		try expectNoErrors(&result);

4544	4544		try expectNoErrors(&result);
4545	4545		}
4546	4546
4547	4547		{ // Identity cast: mut [i32] to mut [i32].
4548	4548		let mut a = testResolver();
4549		-	let result = try resolveBlockStr(&mut a, "let s: mut [i32] = undefined; s as mut [i32];");
	4549	+	let result = try resolveProgramStr(&mut a, "fn run(s: mut [i32]) { s as mut [i32]; }");
4550	4550		try expectNoErrors(&result);
4551	4551		} { // Identity cast: i32 to i32.
4552	4552		let mut a = testResolver();
4553		-	let result = try resolveBlockStr(&mut a, "let p: i32 = undefined; p as i32;");
	4553	+	let result = try resolveProgramStr(&mut a, "fn run(p: i32) { p as i32; }");
4554	4554		try expectNoErrors(&result);
4555	4555		} { // Identity cast: i32 to i32.
4556	4556		let mut a = testResolver();
4557	4557		let result = try resolveBlockStr(&mut a, "let x: i32 = 0; x as i32;");
4558	4558		try expectNoErrors(&result);

4561	4561
4562	4562		/// Tests for invalid `as` casts that should be rejected.
4563	4563		@test unsafe fn testResolveAsCastsInvalid() throws (testing::TestError) {
4564	4564		{ // Pointer to slice is invalid.
4565	4565		let mut a = testResolver();
4566		-	let result = try resolveBlockStr(&mut a, "let p: i32 = undefined; p as [i32];");
	4566	+	let result = try resolveProgramStr(&mut a, "fn run(p: i32) { p as [i32]; }");
4567	4567		let err = try expectError(&result);
4568	4568		let case super::ErrorKind::InvalidAsCast(_) = err.kind
4569	4569		else throw testing::TestError::Failed;
4570	4570		} { // Slice to pointer is invalid.
4571	4571		let mut a = testResolver();
4572		-	let result = try resolveBlockStr(&mut a, "let s: [i32] = undefined; s as i32;");
	4572	+	let result = try resolveProgramStr(&mut a, "fn run(s: [i32]) { s as i32; }");
4573	4573		let err = try expectError(&result);
4574	4574		let case super::ErrorKind::InvalidAsCast(_) = err.kind
4575	4575		else throw testing::TestError::Failed;
4576	4576		} { // T to i32 is invalid.
4577	4577		let mut a = testResolver();

4585	4585		let err = try expectError(&result);
4586	4586		let case super::ErrorKind::InvalidAsCast(_) = err.kind
4587	4587		else throw testing::TestError::Failed;
4588	4588		} { // Slice to numeric is invalid.
4589	4589		let mut a = testResolver();
4590		-	let result = try resolveBlockStr(&mut a, "let s: *[i32] = undefined; s as u32;");
	4590	+	let result = try resolveProgramStr(&mut a, "fn run(s: *[i32]) { s as u32; }");
4591	4591		let err = try expectError(&result);
4592	4592		let case super::ErrorKind::InvalidAsCast(_) = err.kind
4593	4593		else throw testing::TestError::Failed;
4594	4594		} { // record to u8 is invalid.
4595	4595		let mut a = testResolver();

5099	5099		let mut a = testResolver();
5100	5100		let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
5101	5101
5102	5102		let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
5103	5103		let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export constant WIDTH: u32 = 8; export constant HEIGHT: u32 = 4;", &mut arena);
5104		-	let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; constant TOTAL: u32 = consts::WIDTH * consts::HEIGHT; static BUF: [u8; TOTAL] = undefined;", &mut arena);
	5104	+	let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; constant TOTAL: u32 = consts::WIDTH * consts::HEIGHT; static BUF: [u8; TOTAL] = [0; TOTAL];", &mut arena);
5105	5105
5106	5106		let result = try resolveModuleTree(&mut a, rootId);
5107	5107		try expectNoErrors(&result);
5108	5108		}
5109	5109

5680	5680		let mut b = testResolver();
5681	5681		let next = try resolveProgramStr(&mut b, "constant BYTES: [u8] = \"x\"; unsafe static VALUE: u32 = 7; static DATA: [u64] = BYTES as *[u64];");
5682	5682		try expectErrorKind(&next, super::ErrorKind::UnsafeOperation);
5683	5683		}
5684	5684
	5685	+	/// Uninitialized values require an explicit unsafe context in every value position.
	5686	+	@test unsafe fn testUndefinedRequiresUnsafe() throws (testing::TestError) {
	5687	+	let programs = &[
	5688	+	"fn run() -> u8 { let pointers: [u8; 1] = undefined; return pointers[0]; }",
	5689	+	"fn run() { let n: u32 = undefined; }",
	5690	+	"fn run() -> *u8 { return undefined; }",
	5691	+	"fn take(p: *u8) {} fn run() { take(undefined); }",
	5692	+	"fn run(p: *u8) { let mut q = p; set q = undefined; }",
	5693	+	"fn run() { let pointers: [*u8; 1] = [undefined]; }",
	5694	+	"fn run() { let pointers: [*u8; 2] = [undefined; 2]; }",
	5695	+	"record R: Copy { p: *u8 } fn run() { let r = R { p: undefined }; }",
	5696	+	"union U: Copy { Value { p: *u8 } } fn run() { let u = U::Value { p: undefined }; }",
	5697	+	"static P: *u8 = undefined;",
	5698	+	"constant P: *u8 = undefined;",
	5699	+	"static DATA: [u8; 4] = undefined;",
	5700	+	"record R: Copy { p: *u8 } static VALUE: R = R { p: undefined };",
	5701	+	];
	5702	+	for program in programs {
	5703	+	let mut a = testResolver();
	5704	+	let result = try resolveProgramStr(&mut a, program);
	5705	+	try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
	5706	+	}
	5707	+	try expectAnalyzeOk("unsafe fn run() { let p: *u8 = undefined; }");
	5708	+	try expectAnalyzeOk("fn run() -> u32 { unsafe { let mut n: u32 = undefined; set n = 7; return n; } }");
	5709	+	try expectAnalyzeOk("unsafe static P: *u8 = undefined;");
	5710	+	try expectAnalyzeOk("record R: Copy { p: *u8 } unsafe static VALUE: R = R { p: undefined };");
	5711	+	try expectAnalyzeOk("fn run() { let data: [u8; 4] = [0; 4]; let pointer: ?*u8 = nil; }");
	5712	+	try expectAnalyzeOk("static DATA: [u8; 4] = [0; 4];");
	5713	+	}
	5714	+
	5715	+	/// Unsafe initialization does not grant permission to subsequent safe expressions.
	5716	+	@test unsafe fn testUndefinedContextRestored() throws (testing::TestError) {
	5717	+	let mut a = testResolver();
	5718	+	let result = try resolveProgramStr(&mut a, "fn run() { unsafe { let p: u8 = undefined; } let q: u8 = undefined; }");
	5719	+	try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
	5720	+	let mut b = testResolver();
	5721	+	let next = try resolveProgramStr(&mut b, "unsafe static P: u8 = undefined; static Q: u8 = undefined;");
	5722	+	try expectErrorKind(&next, super::ErrorKind::UnsafeOperation);
	5723	+	}
	5724	+
5685	5725		/// Unsafe declarations may compose unsafe operations and calls.
5686	5726		@test unsafe fn testUnsafePointerOperationsAllowed() throws (testing::TestError) {
5687	5727		let program = "record Marker: Once {} unsafe fn load(pointer: unsafe u32) -> u32 { return pointer; } unsafe fn run(pointer: *unsafe u32) -> u32 { let next = pointer + 1; let same = pointer == next; return load(pointer); }";
5688	5728		try expectAnalyzeOk(program);
5689	5729		}