radiance · Radiance self-hosting compiler

compiler/ lib/ examples/ std/ arch/ char/ collections/ lang/ alloc/ ast/ gen/ il/ module/ parser/ resolver/ printer.rad 21.1 KiB tests.rad 307.7 KiB scanner/ alloc.rad 5.3 KiB ast.rad 23.6 KiB gen.rad 513 B il.rad 15.5 KiB lower.rad 277.2 KiB module.rad 13.5 KiB package.rad 1.3 KiB parser.rad 79.6 KiB resolver.rad 332.7 KiB scanner.rad 17.6 KiB sexpr.rad 6.4 KiB strings.rad 2.2 KiB types.rad 286 B sys/ arch.rad 68 B char.rad 855 B collections.rad 39 B fmt.rad 8.3 KiB intrinsics.rad 467 B io.rad 1.7 KiB lang.rad 276 B mem.rad 2.3 KiB sys.rad 179 B testing.rad 2.4 KiB tests.rad 15.7 KiB vec.rad 3.2 KiB std.rad 281 B scripts/ seed/ sublime/ test/ vim/ .gitignore 336 B .gitsigners 112 B CONTRIBUTING 2.1 KiB LICENSE 1.1 KiB Makefile 4.1 KiB README 2.5 KiB STYLE 2.6 KiB std.lib 1.2 KiB std.lib.test 347 B
lib/std/lang/resolver/tests.rad 307.7 KiB raw
//! Resolver tests.

use std::mem;
use std::testing;
use std::lang::alloc;
use std::lang::ast;
use std::lang::types;
use std::lang::parser;
use std::lang::scanner;
use std::lang::module;
use std::lang::strings;

/// 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] = [0; 2097152];

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

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

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

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

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

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

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

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

/// Interned string pool used by resolver tests.
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",
    "Some", "None", "First",
    "Second", "Opt", "x",
    "value", "idx"
];

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

/// Create isolated storage for tests to avoid conflicts with global resolver storage.
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[..],
    };
}

/// Construct a resolver backed by test storage and a synthetic module graph.
unsafe fn testResolver() -> super::Resolver {
    // TODO: This should be initialized only once.
    for i in 0..LITERALS.len {
        strings::intern(&mut STRING_POOL, LITERALS[i]);
    }
    // TODO: Use local static for this.
    // Reset the module graph for each test.
    set MODULE_ARENA = ast::nodeArena(&mut MODULE_ARENA_STORAGE[..]);
    set MODULE_GRAPH = module::moduleGraph(&mut MODULE_ENTRIES[..], &mut MODULE_ARENA);
    let config = super::Config { buildTest: true };
    let res = super::resolver(testStorage(), config);

    return res;
}

/// Resolve a block of statements by wrapping them in a synthetic function.
unsafe 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(self), root: module.modBody };
    };
    return TestResult { diagnostics, root: module.fnBody };
}

/// Parse and analyze an expression string for testing.
unsafe fn resolveExprStr(self: &mut super::Resolver, stmt: *[u8]) -> TestResult throws (testing::TestError) {
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let mut p = parser::mkParser(scanner::SourceLoc::String, stmt, &mut arena, &mut STRING_POOL);
    parser::advance(&mut p);

    let expr = try parser::parseExpr(&mut p) catch {
        panic "resolveExprStr: parsing failed";
    };
    let diagnostics = try super::resolveExpr(self, expr, &mut arena) catch {
        throw testing::TestError::Failed;
    };
    return TestResult { diagnostics, root: expr };
}

/// Parse and analyze a module string for testing.
/// Use this for code with `fn`, `record`, `union`, etc. at the top level.
unsafe fn resolveProgramStr(self: &mut super::Resolver, stmt: *[u8]) -> TestResult throws (testing::TestError) {
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let stmt: *ast::Node = try parser::parse(scanner::SourceLoc::String, stmt, &mut arena, &mut STRING_POOL) catch {
        panic "resolveProgramStr: parsing failed";
    };
    let diagnostics = try super::resolveModuleRoot(self, stmt) catch {
        throw testing::TestError::Failed;
    };
    return TestResult { diagnostics, root: stmt };
}

/// Parse and analyze a block of statements (eg. inside a function body) for testing.
/// Use this for code with `let` bindings and expressions, not module-level declarations.
unsafe fn resolveBlockStr(self: &mut super::Resolver, stmt: *[u8]) -> TestResult throws (testing::TestError) {
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let parsed = try parser::parse(scanner::SourceLoc::String, stmt, &mut arena, &mut STRING_POOL) catch {
        panic "resolveBlockStr: parsing failed";
    };
    let case ast::NodeValue::Block(block) = parsed.value
        else panic "resolveBlockStr: expected block root";

    let analysis = try resolveStatements(self, block, &mut arena) catch {
        throw testing::TestError::Failed;
    };
    return TestResult {
        diagnostics: analysis.diagnostics,
        root: analysis.root,
    };
}

/// Resolve a module with the full resolution process.
unsafe fn resolveModuleTree(
    res: &mut super::Resolver,
    rootId: u16
) -> TestResult throws (testing::TestError) {
    let root = module::get(&MODULE_GRAPH, rootId)
        else throw testing::TestError::Failed;
    let rootAst = root.ast
        else throw testing::TestError::Failed;
    let packages = [super::Pkg {
        rootEntry: root,
        rootAst,
    }];
    let diagnostics = try super::resolve(res, &MODULE_GRAPH, &packages[..]) catch {
        throw testing::TestError::Failed;
    };
    return TestResult { diagnostics, root: rootAst };
}

/// Register a module in the graph and attach a parsed AST to it.
/// If parentId is nil, registers as a root module.
unsafe fn registerModule(
    graph: &mut module::ModuleGraph,
    parentId: ?u16,
    name: *[u8],
    code: *[u8],
    arena: &mut ast::NodeArena
) -> u16 throws (testing::TestError) {
    let filePath = "<test>";
    let mut modId: u16 = undefined;
    if let parent = parentId {
        set modId = try module::registerChild(graph, &mut STRING_POOL, parent, name, filePath) catch {
            throw testing::TestError::Failed;
        };
    } else {
        set modId = try module::registerRootWithName(graph, &mut STRING_POOL, 0, name, filePath) catch {
            throw testing::TestError::Failed;
        };
    }
    let root = try parser::parse(scanner::SourceLoc::String, code, arena, &mut STRING_POOL) catch {
        panic "registerModule: parsing failed";
    };
    try module::setAst(graph, modId, root) catch {
        panic "registerModule: module not found";
    };
    return modId;
}

/// Ensure an expression statement produces the expected type and return the expression node.
fn expectExprStmtType(self: &super::Resolver, node: *ast::Node, expected: super::Type) -> *ast::Node
    throws (testing::TestError)
{
    let case ast::NodeValue::ExprStmt(expr) = node.value
        else throw testing::TestError::Failed;
    try expectType(self, expr, expected);

    return expr;
}

/// Assert that the test result contains no diagnostic errors.
fn expectNoErrors(r: &TestResult) throws (testing::TestError) {
    try testing::expect(super::success(&r.diagnostics));
}

/// Extract the first error from a test result, failing if none exists.
fn expectError(result: &TestResult) -> super::Error throws (testing::TestError) {
    let err = super::errorAt(&result.diagnostics.errors[..], 0)
        else throw testing::TestError::Failed;
    return err;
}

/// Check if two error kinds match.
fn errorKindMatches(actual: &super::ErrorKind, expected: super::ErrorKind) -> bool {
    if let case super::ErrorKind::DuplicateBinding(expectedName) = expected {
        if let case super::ErrorKind::DuplicateBinding(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::UnresolvedSymbol(expectedName) = expected {
        if let case super::ErrorKind::UnresolvedSymbol(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::RecordFieldMissing(expectedName) = expected {
        if let case super::ErrorKind::RecordFieldMissing(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::RecordFieldUnknown(expectedName) = expected {
        if let case super::ErrorKind::RecordFieldUnknown(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::ArrayFieldUnknown(expectedName) = expected {
        if let case super::ErrorKind::ArrayFieldUnknown(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::SliceFieldUnknown(expectedName) = expected {
        if let case super::ErrorKind::SliceFieldUnknown(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::UnionVariantPayloadMissing(expectedName) = expected {
        if let case super::ErrorKind::UnionVariantPayloadMissing(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::UnionVariantPayloadUnexpected(expectedName) = expected {
        if let case super::ErrorKind::UnionVariantPayloadUnexpected(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::UnionMatchNonExhaustive(expectedName) = expected {
        if let case super::ErrorKind::UnionMatchNonExhaustive(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::MissingTraitMethod(expectedName) = expected {
        if let case super::ErrorKind::MissingTraitMethod(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::MissingSupertraitInstance(expectedName) = expected {
        if let case super::ErrorKind::MissingSupertraitInstance(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::AffineUseAfterMove(expectedName) = expected {
        if let case super::ErrorKind::AffineUseAfterMove(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::LinearUseAfterConsume(expectedName) = expected {
        if let case super::ErrorKind::LinearUseAfterConsume(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::LinearNotConsumed(expectedName) = expected {
        if let case super::ErrorKind::LinearNotConsumed(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::LinearBranchMismatch(expectedName) = expected {
        if let case super::ErrorKind::LinearBranchMismatch(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::BorrowConflict(expectedName) = expected {
        if let case super::ErrorKind::BorrowConflict(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    return *actual == expected;
}

/// Extract the first error and ensure it has the expected kind.
fn expectErrorKind(result: &TestResult, kind: super::ErrorKind) -> super::Error
    throws (testing::TestError)
{
    let err = try expectError(result);
    try testing::expect(errorKindMatches(&err.kind, kind));
    return err;
}

/// Ensure an expression resolves to the expected type annotation.
fn expectType(self: &super::Resolver, expr: *ast::Node, expected: super::Type)
    throws (testing::TestError)
{
    let actual = super::typeFor(self, expr)
        else throw testing::TestError::Failed;

    if actual <> expected {
        throw testing::TestError::Failed;
    }
}

/// Verify that an error represents a specific type mismatch.
fn expectTypeMismatch(err: super::Error, expected: super::Type, actual: super::Type)
    throws (testing::TestError)
{
    let case super::ErrorKind::TypeMismatch(mismatch) = err.kind
        else throw testing::TestError::Failed;
    try testing::expect(mismatch.expected == expected);
    try testing::expect(mismatch.actual == actual);
}

/// Resolve a program and require successful analysis.
unsafe fn expectAnalyzeOk(program: *[u8]) throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Require an inferred integer type mismatch.
unsafe fn expectIntMismatch(program: *[u8], expected: super::Type)
    throws (testing::TestError)
{
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, expected, super::Type::Int);
}

/// Retrieve the nth statement from a block node.
fn getBlockStmt(block: *ast::Node, index: u32) -> *ast::Node
    throws (testing::TestError)
{
    let case ast::NodeValue::Block(body) = block.value
        else throw testing::TestError::Failed;

    if index >= body.statements.len {
        throw testing::TestError::Failed;
    }
    return body.statements[index];
}

/// Retrieve a function body block by function name from the program scope.
unsafe fn getFnBody(a: &super::Resolver, root: *ast::Node, name: *[u8]) -> ast::Block
    throws (testing::TestError)
{
    let scope = super::scopeFor(a, root)
        else throw testing::TestError::Failed;
    let sym = super::findSymbolInScope(scope, name)
        else throw testing::TestError::Failed;
    // Verify it's a value symbol by pattern matching.
    let case super::SymbolData::Value { .. } = sym.data
        else throw testing::TestError::Failed;

    let case ast::NodeValue::FnDecl(fnDecl) = sym.node.value
        else throw testing::TestError::Failed;

    let body = fnDecl.body
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Block(blk) = body.value
        else throw testing::TestError::Failed;

    return blk;
}

/// Get the payload type of a union variant, if it has one.
/// For single-field unlabeled variants like `Variant(i32)`, unwraps to return the inner type.
unsafe fn getUnionVariantPayload(nominalTy: *unsafe super::NominalType, variantName: *[u8]) -> super::Type {
    let case super::NominalType::Union(unionType) = *nominalTy
        else panic "getUnionVariantPayload: not a union";
    for i in 0..unionType.variants.len {
        if mem::eq(unionType.variants[i].name, variantName) {
            let payloadType = unionType.variants[i].valueType;
            // Unwrap single-field unlabeled records to get the inner type.
            if let case super::Type::Nominal(super::NominalType::Record(recInfo)) = payloadType {
                if not recInfo.labeled and recInfo.fields.len == 1 {
                    return recInfo.fields[0].fieldType;
                }
            }
            return payloadType;
        }
    }
    panic "getUnionVariantPayload: variant not found";
}

/// Get a nominal type by name, in the scope of the given block node.
unsafe fn getTypeInScopeOf(a: &super::Resolver, blk: *ast::Node, name: *[u8]) -> *unsafe super::NominalType
    throws (testing::TestError)
{
    let scope = super::scopeFor(a, blk)
        else throw testing::TestError::Failed;
    let sym = super::findSymbolInScope(scope, name)
        else throw testing::TestError::Failed;
    let case super::SymbolData::Type(ty) = sym.data
        else throw testing::TestError::Failed;
    return ty;
}

/// Return the resolved type of a syntax node.
fn typeOf(a: &super::Resolver, node: *ast::Node) -> super::Type
    throws (testing::TestError)
{
    let ty = super::typeFor(a, node)
        else throw testing::TestError::Failed;
    return ty;
}

/// Require an array type and return its element type.
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);

    return *info.item;
}

/// Require a slice type and return its element type.
fn expectSliceType(ty: super::Type, mutable: bool) -> super::Type
    throws (testing::TestError)
{
    let case super::Type::Slice { item, mutable: sliceMut, .. } = ty
        else throw testing::TestError::Failed;
    try testing::expect(sliceMut == mutable);

    return *item;
}

/// Require a pointer type and return its target type.
fn expectPointerType(ty: super::Type, mutable: bool) -> super::Type
    throws (testing::TestError)
{
    let case super::Type::Pointer { target, mutable: ptrMut, .. } = ty
        else throw testing::TestError::Failed;
    try testing::expect(ptrMut == mutable);

    return *target;
}

/// Verify that a node has a constant integer value with the expected magnitude.
fn expectConstInt(a: &super::Resolver, node: *ast::Node, expected: u32)
    throws (testing::TestError)
{
    let constVal = super::constValueEntry(a, node)
        else throw testing::TestError::Failed;

    let case super::ConstValue::Int(int) = constVal
        else throw testing::TestError::Failed;

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

/// Resolve an expression that should evaluate to a constant, and verify it equals the expected value.
unsafe fn resolveAndExpectConstExpr(expr: *[u8], expected: u32)
    throws (testing::TestError)
{
    let mut a = testResolver();
    let result = try resolveExprStr(&mut a, expr);
    try expectNoErrors(&result);
    try expectType(&a, result.root, super::Type::U32);
    try expectConstInt(&a, result.root, expected);
}

/// Resolve a statement that should evaluate to a constant, and verify it equals the expected value.
unsafe fn resolveAndExpectConstStmt(expr: *[u8], expected: u32)
    throws (testing::TestError)
{
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, expr);
    try expectNoErrors(&result);
    let stmt = try getBlockStmt(result.root, 1);
    let expr = try expectExprStmtType(&a, stmt, super::Type::U32);
    try expectConstInt(&a, expr, expected);
}

// Tests ///////////////////////////////////////////////////////////////////////

@test unsafe fn testResolveLit() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveExprStr(&mut a, "true");

    try expectNoErrors(&result);
    try expectType(&a, result.root, super::Type::Bool);
}

@test unsafe fn testResolveStringLiteralType() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveExprStr(&mut a, "\"hello\"");

    try expectNoErrors(&result);
    let ty = try typeOf(&a, result.root);
    let elemTy = try expectSliceType(ty, false);
    try testing::expect(elemTy == super::Type::U8);
}

@test unsafe fn testResolveAsNumeric() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "1 as u32");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::U32);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u32 = 913; x as u8;");
        try expectNoErrors(&result);

        let x = try getBlockStmt(result.root, 1);
        try expectExprStmtType(&a, x, super::Type::U8);
    }
}

@test unsafe fn testResolveAsInvalid() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "true as u32");

    try expectErrorKind(
        &result,
        super::ErrorKind::InvalidAsCast(super::InvalidAsCast {
            from: super::Type::Bool,
            to: super::Type::U32,
        })
    );
}

@test unsafe fn testResolveAsUnionToInt() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Color { Red } Color::Red as u32;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let red = try getBlockStmt(result.root, 1);
    try expectExprStmtType(&a, red, super::Type::U32);
}

@test unsafe fn testResolveBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveBlockStr(&mut a, "let x: bool = true; x;");
    let stmt = try parser::tests::getBlockLastStmt(result.root);

    try expectNoErrors(&result);
    try expectType(&a, stmt, super::Type::Void);
    try expectExprStmtType(&a, stmt, super::Type::Bool);

    let case ast::NodeValue::ExprStmt(x) = stmt.value
        else throw testing::TestError::Failed;

    let sym = super::symbolFor(&a, x)
        else throw testing::TestError::Failed;
    let case super::SymbolData::Value { type: valType, .. } = sym.data
        else throw testing::TestError::Failed;
    try testing::expect(valType == super::Type::Bool);
}

@test unsafe fn testResolveBindingInvalid() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveBlockStr(&mut a, "let x: i32 = true;");
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::I32, super::Type::Bool);
}

@test unsafe fn testResolveDuplicateBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveBlockStr(&mut a, "let x: bool = true; let x: u8 = 1;");
    let stmt = try parser::tests::getBlockLastStmt(result.root);
    try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("x"));
}

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

    let constNode = try getBlockStmt(result.root, 0);
    let sym = super::symbolFor(&a, constNode)
        else throw testing::TestError::Failed;
    let case super::SymbolData::Constant { type: constType, .. } = sym.data
        else throw testing::TestError::Failed;
    try testing::expect(constType == super::Type::I32);
}

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

    let errNode = err.node
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Call(_) = errNode.value
        else throw testing::TestError::Failed;
}

@test unsafe fn testResolveStaticLiteralValue() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "static COUNTER: i32 = 0;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let staticNode = try getBlockStmt(result.root, 0);
    let sym = super::symbolFor(&a, staticNode)
        else throw testing::TestError::Failed;
    let case super::SymbolData::Value { type: valType, .. } = sym.data
        else throw testing::TestError::Failed;
    try testing::expect(valType == super::Type::I32);
}

@test unsafe fn testResolveStaticRequiresConstantExpr() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn seed() -> i32 { return 1; } static COUNTER: i32 = seed();";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectErrorKind(&result, super::ErrorKind::ConstExprRequired);

    let errNode = err.node
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Call(_) = errNode.value
        else throw testing::TestError::Failed;
}

@test unsafe fn testSymbolStoresFnAttributes() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "@default export fn f() { return; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let scope = super::scopeFor(&a, result.root)
        else throw testing::TestError::Failed;
    let sym = super::findSymbolInScope(scope, "f")
        else throw testing::TestError::Failed;

    try testing::expect(ast::hasAttribute(sym.attrs, ast::Attribute::Export));
    try testing::expect(ast::hasAttribute(sym.attrs, ast::Attribute::Default));
    try testing::expectNot(ast::hasAttribute(sym.attrs, ast::Attribute::Extern));
}

@test unsafe fn testSymbolStoresRecordAttributes() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "export record S { value: i32 }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let scope = super::scopeFor(&a, result.root)
        else throw testing::TestError::Failed;
    let sym = super::findSymbolInScope(scope, "S")
        else throw testing::TestError::Failed;

    try testing::expect(ast::hasAttribute(sym.attrs, ast::Attribute::Export));
    try testing::expectNot(ast::hasAttribute(sym.attrs, ast::Attribute::Default));
}

@test unsafe fn testDefaultAttributeRejectedOnRecord() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "@default record T { value: i32 }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::DefaultAttrOnlyOnFn);
}

@test unsafe fn testDefaultAttributeRejectedOnUnion() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "@default union Result { Ok, Err }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::DefaultAttrOnlyOnFn);
}

@test unsafe fn testResolveArrayLiteralTyped() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 2] = [1, 2];");
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 0);
    let case ast::NodeValue::Let(decl) = stmt.value
        else throw testing::TestError::Failed;
    let arrayTy = try typeOf(&a, decl.value);
    let elemTy = try expectArrayType(arrayTy, 2);
    try testing::expect(elemTy == super::Type::I32);
}

@test unsafe fn testResolveArrayLiteralElementMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [bool; 2] = [true, 1];");
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
}

@test unsafe fn testResolveArrayLiteralCannotInfer() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs = [1, 2];");
    try expectErrorKind(&result, super::ErrorKind::CannotInferType);
}

@test unsafe fn testResolveArrayLiteralOverflow() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [u8; 2] = [1, 256];");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

@test unsafe fn testResolveArrayLiteralTooFewElements() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 2] = [1];");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

@test unsafe fn testResolveArrayLiteralTooManyElements() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 2] = [1, 2, 3];");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

@test unsafe fn testResolveArrayLiteralEmptyWithAnnotation() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 0] = [];");
    try expectNoErrors(&result);
}

@test unsafe fn testResolveNestedArrayLiteralTyped() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let grid: [[i32; 2]; 2] = [[1, 2], [3, 4]];");
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 0);
    let case ast::NodeValue::Let(decl) = stmt.value
        else throw testing::TestError::Failed;
    let gridTy = try typeOf(&a, decl.value);
    let rowTy = try expectArrayType(gridTy, 2);
    let elemTy = try expectArrayType(rowTy, 2);
    try testing::expect(elemTy == super::Type::I32);
}

@test unsafe fn testResolveArrayLiteralWithOptionalElems() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [?i32; 2] = [1, 2];");
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 0);
    let case ast::NodeValue::Let(decl) = stmt.value
        else throw testing::TestError::Failed;
    let arrayTy = try typeOf(&a, decl.value);
    let elemTy = try expectArrayType(arrayTy, 2);
    let case super::Type::Optional(inner) = elemTy
        else throw testing::TestError::Failed;
    try testing::expect(*inner == super::Type::I32);
}

@test unsafe fn testResolveArrayLiteralOptionalMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [?bool; 2] = [1, 2];");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

@test unsafe fn testResolveArrayRepeatBasic() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 3] = [42; 3];");
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 0);
    let case ast::NodeValue::Let(decl) = stmt.value
        else throw testing::TestError::Failed;
    let arrayTy = try typeOf(&a, decl.value);
    let elemTy = try expectArrayType(arrayTy, 3);
    try testing::expect(elemTy == super::Type::I32);
}

@test unsafe fn testResolveArrayRepeatWithExpression() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 5] = [3 + 2; 5];");
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 0);
    let case ast::NodeValue::Let(decl) = stmt.value
        else throw testing::TestError::Failed;
    let arrayTy = try typeOf(&a, decl.value);
    let elemTy = try expectArrayType(arrayTy, 5);
    try testing::expect(elemTy == super::Type::I32);
}

@test unsafe fn testResolveArrayRepeatLiteralArithmetic() throws (testing::TestError) {
    let mut a = testResolver();
    // `3 * 1` folds to a compile-time constant, so the repeat count is valid.
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 3] = [42; 3 * 1];");
    try expectNoErrors(&result);
}

@test unsafe fn testResolveArrayRepeatNonConstCount() throws (testing::TestError) {
    let mut a = testResolver();
    // A function call is not a constant expression.
    let result = try resolveProgramStr(&mut a, "fn f() -> u32 { return 3; } let xs: [i32; 3] = [42; f()];");
    try expectErrorKind(&result, super::ErrorKind::ConstExprRequired);
}

@test unsafe fn testResolveArrayRepeatCountMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 4] = [1; 3];");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

@test unsafe fn testResolveArrayIndex() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [i32; 3] = [1, 2, 3]; xs[1];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 1);
    try expectExprStmtType(&a, stmt, super::Type::I32);
}

@test unsafe fn testResolveSliceIndex() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "static xs: [i32; 4] = [1, 2, 3, 4]; let slice = &xs[1..]; slice[1];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let sliceStmt = try getBlockStmt(result.root, 1);
    let case ast::NodeValue::Let(sliceDecl) = sliceStmt.value
        else throw testing::TestError::Failed;
    let sliceTy = try typeOf(&a, sliceDecl.value);
    let elemTy = try expectSliceType(sliceTy, false);
    try testing::expect(elemTy == super::Type::I32);

    let indexStmt = try getBlockStmt(result.root, 2);
    try expectExprStmtType(&a, indexStmt, super::Type::I32);
}

@test unsafe fn testResolveSliceFields() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "static xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[1..]; slice.len; unsafe { slice.ptr; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let lenStmt = try getBlockStmt(result.root, 2);
    let case ast::NodeValue::ExprStmt(lenExpr) = lenStmt.value
        else throw testing::TestError::Failed;
    let lenTy = try typeOf(&a, lenExpr);
    try testing::expect(lenTy == super::Type::U32);

    let ptrStmt = try getBlockStmt(result.root, 3);
    let case ast::NodeValue::Block(ptrBlock) = ptrStmt.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::ExprStmt(ptrExpr) = ptrBlock.statements[0].value
        else throw testing::TestError::Failed;
    let ptrTy = try typeOf(&a, ptrExpr);
    let targetTy = try expectPointerType(ptrTy, false);
    try testing::expect(targetTy == super::Type::I32);
}

@test unsafe fn testResolveSliceLiteralImmutable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let slice: *[i32] = &[1, 2, 3];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Empty array literal infers element type from slice annotation.
@test unsafe fn testResolveSliceLiteralEmpty() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let slice: *[i32] = &[];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Nested array literal should infer inner element type from slice annotation.
@test unsafe fn testResolveSliceLiteralNestedArray() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let slice: *[[i32; 2]] = &[[1, 2], [3, 4]];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test unsafe fn testResolveSliceFromArray() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "static xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[..];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "static xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[0..3];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "static xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[..3];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "static xs: [u8; 2] = [1, 2]; let slice = &xs[1..1];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveSliceLiteralMutableRequiresMut() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let slice: *mut [i32] = &[1, 2, 3];";
    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 unsafe fn testResolveSliceLiteralMutable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let slice: *mut [i32] = &mut [1, 2, 3];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test unsafe fn testResolvePointerMutableAssignmentRequiresMut() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let x: i32 = 0; let ptr: *mut i32 = &x;";
    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 unsafe fn testResolvePointerMutableToImmutableAssignment() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "static x: i32 = 0; let mptr: *mut i32 = &mut x; let ptr: *i32 = mptr;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test unsafe fn testResolveAddressOfRequiresMutableBinding() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let x: i32 = 0; let ptr = &mut x;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    } {
        let mut a = testResolver();
        let program = "let mut x: i32 = 0; &mut x;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveAddressOfSliceRequiresMutableBinding() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let xs: [i32; 3] = [1, 2, 3]; let slice = &mut xs[..];";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    } {
        let mut a = testResolver();
        let program = "let mut xs: [i32; 3] = [1, 2, 3]; &mut xs[..];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveSliceCannotAssignToArray() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: *[u8] = &[1, 2]; let ys: [u8; 2] = xs;";
    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 unsafe fn testResolveSliceSyntaxRequiresAddressOf() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [u8; 2] = [1, 2]; xs[..];";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::SliceRequiresAddress);
}

@test unsafe fn testResolveSliceResliceRequiresAddressOf() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(s: *[u8]) -> *[u8] { return s[..]; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::SliceRequiresAddress);
}

@test unsafe fn testResolveSliceRangeOutOfBounds() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let xs: [u8; 2] = [1, 2]; let slice = &xs[..3];";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::SliceRangeOutOfBounds);
    } {
        let mut a = testResolver();
        let program = "let xs: [u8; 2] = [1, 2]; let slice = &xs[3..];";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::SliceRangeOutOfBounds);
    } {
        let mut a = testResolver();
        let program = "let xs: [u8; 4] = [1, 2, 3, 4]; let slice = &xs[3..2];";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::SliceRangeOutOfBounds);
    }
}

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

    let constStmt = try getBlockStmt(result.root, 1);
    let case ast::NodeValue::ConstDecl(decl) = constStmt.value
        else throw testing::TestError::Failed;
    let valueConst = super::constValueEntry(&a, decl.value)
        else throw testing::TestError::Failed;
    let case super::ConstValue::Int(lenVal) = valueConst
        else throw testing::TestError::Failed;
    try testing::expect(lenVal.magnitude == 3);
    try testing::expect(not lenVal.negative);
}

@test unsafe fn testResolveIndexNonIndexable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let flag: bool = true; flag[0];";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ExpectedIndexable);
}

@test unsafe fn testResolveSliceFieldUnknown() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [i32; 2] = [1, 2]; (&xs[0..]).unknown;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::SliceFieldUnknown("unknown"));
}

@test unsafe fn testResolveArrayFieldUnknown() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [i32; 2] = [1, 2]; xs.field;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ArrayFieldUnknown("field"));
}

@test unsafe fn testResolveIfConditionRequiresBool() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "if 42 {}");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "if true {}");
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveIfLetScopeBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let opt: ?i32 = 42; if let x = opt { x }");
    try expectNoErrors(&result);

    // Get the if-let statement and verify `x` has type `i32`.
    let ifLetStmt = try parser::tests::getBlockLastStmt(result.root);
    let case ast::NodeValue::IfLet(ifLet) = ifLetStmt.value
        else throw testing::TestError::Failed;

    let thenStmt = try parser::tests::getBlockLastStmt(ifLet.thenBranch);
    let case ast::NodeValue::ExprStmt(xExpr) = thenStmt.value
        else throw testing::TestError::Failed;

    try expectType(&a, xExpr, super::Type::I32);

    let scope = super::scopeFor(&a, ifLetStmt)
        else throw testing::TestError::Failed;
    let xSym = super::findSymbolInScope(scope, "x")
        else throw testing::TestError::Failed;
    let case super::SymbolData::Value { type: valType, .. } = xSym.data
        else throw testing::TestError::Failed;

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

@test unsafe fn testResolveIfLetScopeBindingError() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let opt: ?i32 = 42; if let x = opt { x } else { x }");
    let err = try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("x"));

    // Verify the error comes from the else branch (offset 48).
    let errNode = err.node
        else throw testing::TestError::Failed;
    try testing::expect(errNode.span.offset == 48);
}

/// Tests that `if let` with a condition expression binds the variable in scope.
@test unsafe fn testResolveIfLetConditionBindsVariable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; if let x = opt; x == 1 { x }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test unsafe fn testResolveWhileConditionRequiresBool() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "while 1 {}");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "while true {}");
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveWhileLetBindingScope() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let mut opt: ?i32 = 42; while let x = opt; x > 0 { x; opt; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);

        let whileStmt = try parser::tests::getBlockLastStmt(result.root);
        let case ast::NodeValue::WhileLet(loopNode) = whileStmt.value
            else throw testing::TestError::Failed;

        let bodyStmt = try parser::tests::getBlockFirstStmt(loopNode.body);
        try expectExprStmtType(&a, bodyStmt, super::Type::I32);

        let scope = super::scopeFor(&a, whileStmt)
            else throw testing::TestError::Failed;
        let xSym = super::findSymbolInScope(scope, "x")
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: valType, .. } = xSym.data
            else throw testing::TestError::Failed;
        try testing::expect(valType == super::Type::I32);
    } {
        let mut a = testResolver();
        let program = "let opt: ?i32 = nil; while let x = opt; true { break } else { x }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("x"));
    }
}

@test unsafe fn testResolveForArrayBindsElementType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [i32; 2] = [1, 2]; for x in xs { x; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let forStmt = try parser::tests::getBlockLastStmt(result.root);
    let case ast::NodeValue::For(loopNode) = forStmt.value
        else throw testing::TestError::Failed;

    let scope = super::scopeFor(&a, forStmt)
        else throw testing::TestError::Failed;
    let sym = super::findSymbolInScope(scope, "x")
        else throw testing::TestError::Failed;
    let case super::SymbolData::Value { type: valType, .. } = sym.data
        else throw testing::TestError::Failed;
    try testing::expect(valType == super::Type::I32);

    let bindingTy = super::typeFor(&a, loopNode.binding)
        else throw testing::TestError::Failed;
    try testing::expect(bindingTy == super::Type::I32);
}

@test unsafe fn testResolveForIndexedLoopBindsIndex() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [bool; 3] = [true; 3]; for value, idx in xs { value; idx; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let forStmt = try parser::tests::getBlockLastStmt(result.root);
    let case ast::NodeValue::For(loopNode) = forStmt.value
        else throw testing::TestError::Failed;

    let scope = super::scopeFor(&a, forStmt)
        else throw testing::TestError::Failed;
    let valueSym = super::findSymbolInScope(scope, "value")
        else throw testing::TestError::Failed;
    let case super::SymbolData::Value { type: valueValType, .. } = valueSym.data
        else throw testing::TestError::Failed;
    try testing::expect(valueValType == super::Type::Bool);
    let indexSym = super::findSymbolInScope(scope, "idx")
        else throw testing::TestError::Failed;
    let case super::SymbolData::Value { type: indexValType, .. } = indexSym.data
        else throw testing::TestError::Failed;
    try testing::expect(indexValType == super::Type::U32);

    let indexNode = loopNode.index
        else throw testing::TestError::Failed;
    let indexTy = super::typeFor(&a, indexNode)
        else throw testing::TestError::Failed;
    try testing::expect(indexTy == super::Type::U32);
}

@test unsafe fn testResolveForSliceIterable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [i32; 3] = [1, 2, 3]; for x in &xs[..] { x; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let forStmt = try parser::tests::getBlockLastStmt(result.root);
    let case ast::NodeValue::For(loopNode) = forStmt.value
        else throw testing::TestError::Failed;

    let bindingTy = super::typeFor(&a, loopNode.binding)
        else throw testing::TestError::Failed;
    try testing::expect(bindingTy == super::Type::I32);
}

@test unsafe fn testResolveForRequiresIterable() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "for x in true { x; }");
    try expectErrorKind(&result, super::ErrorKind::ExpectedIterable);
}

@test unsafe fn testResolveForRangeBoundsMustNumeric() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveBlockStr(&mut a, "for i in 0..true { i; }");
    try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
}

@test unsafe fn testResolveMatchPatternTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let val: i32 = 0; match val { case true => {} }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::I32, super::Type::Bool);
}

@test unsafe fn testResolveMatchUnionVariantTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union First { A }  union Second { B } fn run(val: First) { match val { case Second::B => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);

    let firstTy = try getTypeInScopeOf(&a, result.root, "First");
    let secondTy = try getTypeInScopeOf(&a, result.root, "Second");
    try expectTypeMismatch(err, super::Type::Nominal(firstTy), super::Type::Nominal(secondTy));
}

@test unsafe fn testResolveMatchUnionPayloadMissing() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some(i32) } fn run(val: Opt) { match val { case Opt::Some => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnionVariantPayloadMissing("Some"));
}

@test unsafe fn testResolveMatchUnionVoidVariantExplicitDiscriminant() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some = 5 } fn run(val: Opt) { match val { case Opt::Some => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test unsafe fn testResolveMatchUnionPayloadUnexpected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { None } fn run(val: Opt) { match val { case Opt::None(x) => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnionVariantPayloadUnexpected("None"));
}

@test unsafe fn testResolveMatchUnionUnknownVariant() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some, None } fn run(value: Opt) { match value { case Opt::Unknown => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("Unknown"));
}

@test unsafe fn testResolveMatchUnionNonExhaustive() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "union Opt { Some, None } fn run(value: Opt) { match value { case Opt::Some => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnionMatchNonExhaustive("None"));
    } {
        let mut a = testResolver();
        let program = "union Opt { Some, None } fn run(value: Opt) { match value { else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveMatchUnionNonExhaustiveExplicitDiscriminants() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union U { A = 3, B = 9 } fn run(value: U) { match value { case U::A => {}, case U::B => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test unsafe fn testResolveMatchUnionBindingScope() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some(i32), None } fn f(value: Opt) { match value { case Opt::Some(x) if x > 0 => { x; } else => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let fnBlock = try getFnBody(&a, result.root, "f");
    try testing::expect(fnBlock.statements.len > 0);

    let matchNode = fnBlock.statements[0];
    let case ast::NodeValue::Match(sw) = matchNode.value
        else throw testing::TestError::Failed;
    let caseNode = sw.prongs[0];

    let scope = super::scopeFor(&a, caseNode)
        else throw testing::TestError::Failed;
    let payloadSym = super::findSymbolInScope(scope, "x")
        else throw testing::TestError::Failed;
    let case super::SymbolData::Value { type: payloadValType, .. } = payloadSym.data
        else throw testing::TestError::Failed;
    try testing::expect(payloadValType == super::Type::I32);
}

@test unsafe fn testResolveMatchUnionPatternNonUnionType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some, None } fn f(value: Opt) { match value { case true => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let optionTy = try getTypeInScopeOf(&a, result.root, "Opt");
    try expectTypeMismatch(err, super::Type::Nominal(optionTy), super::Type::Bool);
}

@test unsafe fn testResolveMatchGuardForms() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn first(value: i32) { match value { case _ if true => {}, else => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that a binding prong binds the subject to the identifier.
@test unsafe fn testResolveMatchBindingProng() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(value: i32) -> i32 { match value { x => return x } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that a binding prong with guard can use the bound variable.
@test unsafe fn testResolveMatchBindingProngGuard() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(value: i32) -> i32 { match value { x if x > 0 => return x, _ => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that a binding prong covers all union variants for exhaustiveness.
@test unsafe fn testResolveMatchBindingProngExhaustive() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union U { A, B, C } fn f(u: U) -> i32 { match u { x => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that `case x =>` fails if `x` is not in scope, since bare identifiers
/// in case patterns are values to compare against, not bindings.
@test unsafe fn testResolveMatchCaseUndefinedIdent() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(n: i32) -> i32 { match n { case x => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("x"));
}

/// Test matching on optionals: exhaustiveness and type unwrapping.
@test unsafe fn testResolveMatchOptional() throws (testing::TestError) {
    {
        // Exhaustive: binding + nil case.
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) { match opt { v => {}, case nil => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        // Missing nil case.
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) { match opt { v => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::OptionalMatchMissingNil);
    } {
        // Missing value case.
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) { match opt { case nil => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::OptionalMatchMissingValue);
    } {
        // Else covers both cases.
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) { match opt { else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        // Binding unwraps the inner type.
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) -> i32 { match opt { v => return v + 1, case nil => return 0 } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that match on non-union types requires exhaustiveness.
@test unsafe fn testResolveMatchGenericExhaustive() throws (testing::TestError) {
    {
        // Match on i32 without catch-all should error.
        let mut a = testResolver();
        let program = "fn f(x: i32) { match x { case 1 => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::MatchNonExhaustive);
    } {
        // Match on i32 with else is fine.
        let mut a = testResolver();
        let program = "fn f(x: i32) { match x { case 1 => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        // Match on i32 with binding catch-all is fine.
        let mut a = testResolver();
        let program = "fn f(x: i32) { match x { y => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        // Match on i32 with wildcard catch-all is fine.
        let mut a = testResolver();
        let program = "fn f(x: i32) { match x { case _ => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that match on bool requires both true and false cases.
@test unsafe fn testResolveMatchBoolExhaustive() throws (testing::TestError) {
    {
        // Match on bool with both cases is fine.
        let mut a = testResolver();
        let program = "fn f(x: bool) { match x { case true => {}, case false => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        // Match on bool missing true should error.
        let mut a = testResolver();
        let program = "fn f(x: bool) { match x { case false => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BoolMatchMissing(true));
    } {
        // Match on bool missing false should error.
        let mut a = testResolver();
        let program = "fn f(x: bool) { match x { case true => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BoolMatchMissing(false));
    } {
        // Match on bool with else is fine.
        let mut a = testResolver();
        let program = "fn f(x: bool) { match x { else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        // Match on bool with binding catch-all is fine.
        let mut a = testResolver();
        let program = "fn f(x: bool) { match x { b => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveBreakRequiresLoop() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "break;");
        try expectErrorKind(&result, super::ErrorKind::InvalidLoopControl);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "loop { break }");
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveContinueRequiresLoop() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "continue;");
        try expectErrorKind(&result, super::ErrorKind::InvalidLoopControl);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "while true { continue }");
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveFnTypeVoidNoParams() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn f() {} f();");
    try expectNoErrors(&result);

    let blockNode = result.root;
    let case ast::NodeValue::Block(block) = blockNode.value
        else throw testing::TestError::Failed;
    let fnNode = try getBlockStmt(blockNode, 0);
    let callStmt = try getBlockStmt(blockNode, 1);

    { // Verify the function symbol captures an empty parameter list and void return.
        let sym = super::symbolFor(&a, fnNode)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = sym.data
            else throw testing::TestError::Failed;
        try testing::expect(fnTy.paramTypes.len == 0);
        try testing::expect(*fnTy.returnType == super::Type::Void);
    }
    { // Checking that the type of the call matches the function return type.
        let callExpr = try expectExprStmtType(&a, callStmt, super::Type::Void);

        let fnSym = super::symbolFor(&a, fnNode)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = fnSym.data
            else throw testing::TestError::Failed;
        try expectType(&a, callExpr, *fnTy.returnType);
    }
}

@test unsafe fn testResolveFnTypeReturnsValue() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f() -> i32 { return 1; } f();";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let blockNode = result.root;
    let case ast::NodeValue::Block(block) = blockNode.value
        else throw testing::TestError::Failed;
    let fnNode = try getBlockStmt(blockNode, 0);
    let callStmt = try getBlockStmt(blockNode, 1);

    { // Function returns i32 with no parameters.
        let sym = super::symbolFor(&a, fnNode)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = sym.data
            else throw testing::TestError::Failed;
        try testing::expect(fnTy.paramTypes.len == 0);
        try testing::expect(*fnTy.returnType == super::Type::I32);
    }
    { // Call expression should inherit the function's return type.
        let callExpr = try expectExprStmtType(&a, callStmt, super::Type::I32);

        let fnSym = super::symbolFor(&a, fnNode)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = fnSym.data
            else throw testing::TestError::Failed;
        try expectType(&a, callExpr, *fnTy.returnType);
    }
}

@test unsafe fn testResolveFnTypeSingleParam() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(x: i8) {} let x: i8 = 1; f(x);";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let blockNode = result.root;
    let case ast::NodeValue::Block(block) = blockNode.value
        else throw testing::TestError::Failed;
    let fnNode = try getBlockStmt(blockNode, 0);
    let callStmt = try getBlockStmt(blockNode, 2);

    { // Single parameter propagates nominal type onto the symbol and parameter node.
        let sym = super::symbolFor(&a, fnNode)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = sym.data
            else throw testing::TestError::Failed;
        try testing::expect(fnTy.paramTypes.len == 1);
        try testing::expect(*fnTy.paramTypes[0] == super::Type::I8);
        try testing::expect(*fnTy.returnType == super::Type::Void);

        let case ast::NodeValue::FnDecl(fnDecl) = fnNode.value
            else throw testing::TestError::Failed;
        try testing::expect(fnDecl.sig.params.len == 1);

        let paramNode = fnDecl.sig.params[0];
        try expectType(&a, paramNode, super::Type::I8);
    }
    { // Call should resolve to void, matching the function's return type.
        let callExpr = try expectExprStmtType(&a, callStmt, super::Type::Void);
        let fnSym = super::symbolFor(&a, fnNode)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = fnSym.data
            else throw testing::TestError::Failed;
        try expectType(&a, callExpr, *fnTy.returnType);
    }
}

@test unsafe fn testResolveFnTypeMultipleParams() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(x: i8, y: i32) {} let x: i8 = 1; let y: i32 = 2; f(x, y);";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let blockNode = result.root;
    let case ast::NodeValue::Block(block) = blockNode.value
        else throw testing::TestError::Failed;
    let fnNode = try getBlockStmt(blockNode, 0);
    let callStmt = try getBlockStmt(blockNode, 3);

    { // Ensure multi-parameter signatures record both argument types.
        let sym = super::symbolFor(&a, fnNode)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = sym.data
            else throw testing::TestError::Failed;
        try testing::expect(fnTy.paramTypes.len == 2);
        try testing::expect(*fnTy.paramTypes[0] == super::Type::I8);
        try testing::expect(*fnTy.paramTypes[1] == super::Type::I32);
        try testing::expect(*fnTy.returnType == super::Type::Void);

        let case ast::NodeValue::FnDecl(fnDecl) = fnNode.value
            else throw testing::TestError::Failed;
        try testing::expect(fnDecl.sig.params.len == 2);

        let firstParam = fnDecl.sig.params[0];
        let secondParam = fnDecl.sig.params[1];
        try expectType(&a, firstParam, super::Type::I8);
        try expectType(&a, secondParam, super::Type::I32);
    }
    { // Call expression should again mirror the function return type.
        let callExpr = try expectExprStmtType(&a, callStmt, super::Type::Void);
        let fnSym = super::symbolFor(&a, fnNode)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = fnSym.data
            else throw testing::TestError::Failed;
        try expectType(&a, callExpr, *fnTy.returnType);
    }
}

@test unsafe fn testResolveFnRecursiveCall() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn flip(b: bool) -> bool { if b { return false; } return flip(false); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let blockNode = result.root;
    let case ast::NodeValue::Block(block) = blockNode.value
        else throw testing::TestError::Failed;
    let fnNode = try getBlockStmt(blockNode, 0);

    { // Function symbol should be visible for recursive calls within its own body.
        let sym = super::symbolFor(&a, fnNode)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: super::Type::Fn(fnTy), .. } = sym.data
            else throw testing::TestError::Failed;
        try testing::expect(fnTy.paramTypes.len == 1);
        try testing::expect(*fnTy.paramTypes[0] == super::Type::Bool);
        try testing::expect(*fnTy.returnType == super::Type::Bool);
    }
}

@test unsafe fn testResolveFnCallMissingArgument() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(x: i8) {} f();";
    let result = try resolveProgramStr(&mut a, program);
    // Expect an error when a required parameter is omitted.
    try expectErrorKind(&result, super::ErrorKind::FnArgCountMismatch(super::CountMismatch {
        expected: 1,
        actual: 0,
    }));
}

@test unsafe fn testResolveFnCallExtraArgument() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f() {} f(1);";
    let result = try resolveProgramStr(&mut a, program);
    // Passing more arguments than declared should fail.
    try expectErrorKind(&result, super::ErrorKind::FnArgCountMismatch(super::CountMismatch {
        expected: 0,
        actual: 1,
    }));
}

@test unsafe fn testResolveFnCallArgumentTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(x: i8) {} f(true);";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    // The argument type (bool) should not match the parameter type (i8).
    try expectTypeMismatch(err, super::Type::I8, super::Type::Bool);
}

@test unsafe fn testResolveFnReturnTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f() -> i32 { return true; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::I32, super::Type::Bool);
}

@test unsafe fn testResolveFnReturnVoid() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f() { return; }");
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn g() -> i32 { return; }");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::I32, super::Type::Void);
    }
}

@test unsafe fn testResolveFnMissingReturn() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f() -> i32 {}");
        try expectErrorKind(&result, super::ErrorKind::FnMissingReturn);
    } {
        let mut a = testResolver();
        let program = "fn g(flag: bool) -> i32 { if flag { return 1; } 2; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::FnMissingReturn);
    }
}

/// Never-returning functions require divergence on every path.
@test unsafe fn testResolveNeverReturn() throws (testing::TestError) {
    for program in &[
        "fn stop() -> ! { panic; } fn f() -> i32 { stop(); }",
        "fn stop() -> ! { panic; } fn f() -> ! { return stop(); }",
        "fn f(callback: fn() -> !) -> ! { callback(); }",
        "fn stop() -> ! { panic; } fn f() -> ! { let _ = stop(); }",
        "fn stop() -> ! { panic; } fn f() -> i32 { let value: i32 = stop(); }",
        "union Token: Once { Held(u32) } fn stop() -> ! { panic; } fn f(token: Token) -> ! { stop(); }",
        "union Token: Once { Held(u32) } fn stop() -> ! { panic; } fn f(token: Token) -> ! { return stop(); }",
        "union Token: Once { Held(u32) } fn stop() -> ! throws (i32) { throw 1; } fn f(token: Token) -> ! { try! stop(); }",
        "fn f() -> ! { while true {} }",
        "fn f(flag: bool) -> ! { if flag { panic; } else { while true {} } }",
        "fn f() -> ! throws (i32) { throw 1; } fn g() -> ! throws (i32) { try f(); }",
        "fn f() -> ! throws (i32) { throw 1; } fn g() -> i32 { try f() catch { return 2; }; }",
    ] {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// A never-returning signature rejects any normal completion path.
@test unsafe fn testResolveNeverFallthrough() throws (testing::TestError) {
    for program in &[
        "fn f() -> ! {}",
        "fn f(flag: bool) -> ! { if flag { panic; } }",
        "fn f() -> ! { while true { break; } }",
        "fn f() -> ! throws (i32) { throw 1; } fn g() -> ! { try f() catch {}; }",
        "fn f() -> ! throws (i32) { throw 1; } fn g() -> ! { try f() catch e as i32 {}; }",
    ] {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::FnMissingReturn);
    }
}

/// No value, including undefined, can construct a never return value.
@test unsafe fn testResolveNeverValue() throws (testing::TestError) {
    for program in &[
        "fn f() -> ! { return; }",
        "fn f() -> ! { return 1; }",
        "unsafe fn f() -> ! { return undefined; }",
        "fn ordinary() {} fn f() { let callback: fn() -> ! = ordinary; }",
    ] {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        let error = try expectError(&result);
    }
}

/// Caught errors preserve the caller's exact-use ownership obligations.
@test unsafe fn testResolveNeverCaughtOwnership() throws (testing::TestError) {
    for program in &[
        "union Token: Once { Held(u32) } fn fail() -> ! throws (i32) { throw 1; } fn f(token: Token) { try fail() catch {}; }",
        "union Token: Once { Held(u32) } fn fail() -> ! throws (i32) { throw 1; } fn f(token: Token) { let absent = try? fail(); }",
    ] {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        let error = try expectError(&result);
        let case super::ErrorKind::LinearNotConsumed(_) = error.kind
            else throw testing::TestError::Failed;
    }
}

@test unsafe fn testResolveFnAllPathsReturn() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn h(flag: bool) -> i32 { if flag { return 1; } else { return 2; } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that match statements with returns in all branches don't require a
/// return at the end of the function.
@test unsafe fn testResolveFnMatchAllPathsReturn() throws (testing::TestError) {
    {
        // Union match with all variants returning.
        let mut a = testResolver();
        let program = "union E { A, B } fn f(e: E) -> i32 { match e { case E::A => return 1, case E::B => return 2 } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        // Match with default case where all branches return.
        let mut a = testResolver();
        let program = "fn f(x: i32) -> i32 { match x { case 1 => return 1, else => return 0, } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        // Match where not all branches return should error.
        let mut a = testResolver();
        let program = "union E { A, B } fn f(e: E) -> i32 { match e { case E::A => return 1, case E::B => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::FnMissingReturn);
    }
}

@test unsafe fn testResolveAssign() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let mut x: i32 = 0; set x = 1;");
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let x: i32 = 0; set x = 1;");
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let mut x: bool = false; set x = 1;");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "set x = 1;");
        try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("x"));
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let mut x: ?i32 = 0; set x = 1;");
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let mut x: ?i32 = 0; set x = nil;");
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveAssignSubscript() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let mut xs: [u8; 2] = [0, 1]; set xs[0] = 9;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
    {
        let mut a = testResolver();
        let program = "static xs: [u8; 2] = [0, 1]; let slice: *mut [u8] = &mut xs[..]; set slice[0] = 1;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
    {
        let mut a = testResolver();
        let program = "static xs: [u8; 2] = [0, 1]; let mut slice: *[u8] = &xs[..]; set slice[0] = 1;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
    {
        let mut a = testResolver();
        let program = "let xs: [u8; 2] = [0, 1]; set xs[0] = 9;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
    {
        let mut a = testResolver();
        let program = "static xs: [u8; 2] = [0, 1]; let slice: *[u8] = &xs[..]; set slice[0] = 1;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
}

@test unsafe fn testResolveAssignIntegerLits() throws (testing::TestError) {
    try expectAnalyzeOk("let x: i8 = 127;");
    try expectAnalyzeOk("let x: i8 = 0x7F;");
    try expectAnalyzeOk("let x: i8 = -128;");
    try expectAnalyzeOk("let x: u8 = 255;");
    try expectAnalyzeOk("let x: u8 = 0b11111111;");
    try expectAnalyzeOk("let x: i16 = 0x7FFF;");
    try expectAnalyzeOk("let x: i16 = -32768;");
    try expectAnalyzeOk("let x: u16 = 0xFFFF;");
    try expectAnalyzeOk("let x: i32 = 2147483647;");
    try expectAnalyzeOk("let x: i32 = -2147483648;");
    try expectAnalyzeOk("let x: u32 = 0xFFFFFFFF;");
    try expectAnalyzeOk("let x: i64 = 9223372036854775807;");
    try expectAnalyzeOk("let x: i64 = -9223372036854775808;");

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

    try expectIntMismatch("let x: i8 = 128;", super::Type::I8);
    try expectIntMismatch("let x: i8 = -129;", super::Type::I8);
    try expectIntMismatch("let x: i8 = 0x80;", super::Type::I8);
    try expectIntMismatch("let x: i8 = 0b10000000;", super::Type::I8);
    try expectIntMismatch("let x: u8 = 256;", super::Type::U8);
    try expectIntMismatch("let x: u8 = -1;", super::Type::U8);
    try expectIntMismatch("let x: u8 = 0b100000000;", super::Type::U8);
    try expectIntMismatch("let x: i16 = 32768;", super::Type::I16);
    try expectIntMismatch("let x: i16 = -32769;", super::Type::I16);
    try expectIntMismatch("let x: u16 = 65536;", super::Type::U16);
    try expectIntMismatch("let x: u16 = -1;", super::Type::U16);
    try expectIntMismatch("let x: i32 = 2147483648;", super::Type::I32);
    try expectIntMismatch("let x: i32 = -2147483649;", super::Type::I32);
    try expectIntMismatch("let x: i32 = 0xFFFFFFFF;", super::Type::I32);
    try expectIntMismatch("let x: u32 = -1;", super::Type::U32);
    try expectIntMismatch("let x: u32 = 0x100000000;", super::Type::U32);
    try expectIntMismatch("let x: i64 = 9223372036854775808;", super::Type::I64);
    try expectIntMismatch("let x: i64 = -9223372036854775809;", super::Type::I64);
    try expectIntMismatch("constant LIMIT: u8 = 512;", super::Type::U8);
    try expectIntMismatch("constant LIMIT: u8 = -5;", super::Type::U8);
}

@test unsafe fn testNilCoercions() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let opt: ?i32 = nil;");
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "fn g(opt: ?i32) {} fn f() { g(nil); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "fn make(flag: bool) -> ?i32 { if flag { return 1; } return nil; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testOptionalComparedWithNil() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = nil; opt == nil; nil == opt; opt == 1; 1 == opt; opt == opt; nil == nil;";
    let result = try resolveBlockStr(&mut a, program);
    try expectNoErrors(&result);

    for i in 1..7 {
        let stmt = try getBlockStmt(result.root, i);
        try expectExprStmtType(&a, stmt, super::Type::Bool);
    }
}

@test unsafe fn testResolveRecordLiteralAllFieldsSet() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } let p = Pt { x: 1, y: 2 };";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test unsafe fn testResolveRecordLiteralMissingField() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } let p = Pt { x: 1 };";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::RecordFieldMissing("y"));
}

@test unsafe fn testResolveRecordLiteralFieldTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } let p = Pt { x: true, y: 2 };";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::I32, super::Type::Bool);

    let errNode = err.node
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Bool(_) = errNode.value
        else throw testing::TestError::Failed;
}

@test unsafe fn testResolveRecordLiteralExtraField() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } let p = Pt { x: 1, z: 3, y: 2 };";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::RecordFieldCountMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Test that anonymous record literals with labels can be passed to functions expecting named records.
@test unsafe fn testResolveAnonRecordLabeledToNamedRecord() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) -> i32 { return p.x; } foo({ x: 1, y: 2 });";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that anonymous record with wrong field name causes out of order error.
@test unsafe fn testResolveAnonRecordWrongFieldName() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) {} foo({ x: 1, z: 2 });";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::RecordFieldOutOfOrder { field: _, prev: _ } = err.kind
        else throw testing::TestError::Failed;
}

/// Test that anonymous record with wrong field type causes type mismatch.
@test unsafe fn testResolveAnonRecordWrongFieldType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) {} foo({ x: true, y: 2 });";
    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 that anonymous record with missing field causes a missing field error.
@test unsafe fn testResolveAnonRecordMissingField() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) {} foo({ x: 1 });";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::RecordFieldMissing("y"));
}

/// Test that anonymous record with extra field causes a count mismatch error.
@test unsafe fn testResolveAnonRecordExtraField() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) {} foo({ x: 1, y: 2, z: 3 });";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::RecordFieldCountMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Test that anonymous record fields can be coerced (e.g., i32 to optional).
@test unsafe fn testResolveAnonRecordFieldCoercion() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Opt { x: ?i32 } fn foo(p: Opt) {} foo({ x: 42 });";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

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

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

/// Test that unlabeled record declarations are analyzed correctly.
@test unsafe fn testResolveUnlabeledRecordDecl() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record R(i32, bool);";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    // Verify the type symbol was created with labeled=false.
    let nominalTy = try getTypeInScopeOf(&a, result.root, "R");
    let case super::NominalType::Record(recordType) = *nominalTy
        else throw testing::TestError::Failed;
    try testing::expect(not recordType.labeled);
    try testing::expect(recordType.fields.len == 2);
    try testing::expect(recordType.fields[0].name == nil);
    try testing::expect(recordType.fields[1].name == nil);
}

@test unsafe fn testResolveLabeledRecordDecl() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record R { x: i32, y: i32 }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let nominalTy = try getTypeInScopeOf(&a, result.root, "R");
    let case super::NominalType::Record(recordType) = *nominalTy
        else throw testing::TestError::Failed;
    try testing::expect(recordType.labeled);
    try testing::expect(recordType.fields.len == 2);
    try testing::expect(recordType.fields[0].name <> nil);
    try testing::expect(recordType.fields[1].name <> nil);
}

@test unsafe fn testResolveRecordFieldAccessValid() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: u8 } let p = Pt { x: 1, y: 2 }; p.y;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let fieldStmt = try getBlockStmt(result.root, 2);
    try expectExprStmtType(&a, fieldStmt, super::Type::U8);
}

@test unsafe fn testResolveRecordFieldAccessUnknownField() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32 } let p = Pt { x: 1 }; p.y;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::RecordFieldUnknown("y"));
}

@test unsafe fn testResolveRecordFieldAccessOnFunctionReturn() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } fn make() -> Pt { return Pt { x: 5, y: 10 }; } make().x;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 2);
    try expectExprStmtType(&a, stmt, super::Type::I32);
}

@test unsafe fn testResolveRecordFieldAccessChained() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record C { value: i32 } record B { c: C } record A { b: B } let a = A { b: B { c: C { value: 100 } } }; a.b.c.value;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 4);
    try expectExprStmtType(&a, stmt, super::Type::I32);
}

@test unsafe fn testResolveRecordFieldAccessOnInteger() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let x: i32 = 42; x.field;";
    let result = try resolveBlockStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ExpectedRecord);
}

@test unsafe fn testResolveRecordFieldAccessOnArray() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let arr: [i32; 3] = [1, 2, 3]; arr.field;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ArrayFieldUnknown("field"));
}

@test unsafe fn testResolveRecordFieldAccessOnBool() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let b: bool = true; b.field;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ExpectedRecord);
}

@test unsafe fn testResolveRecordFieldAccessOnOptional() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32 } let opt: ?Pt = Pt { x: 5 }; opt.x;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ExpectedRecord);
}

/// Records may reference themselves through pointers without causing resolution errors.
@test unsafe fn testResolveRecordSelfReferentialPointer() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record A { next: *A }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Mutually recursive records should resolve without infinite loops.
@test unsafe fn testResolveRecordMutuallyRecursive() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record A { b: *B } record B { a: *A }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Unions may reference themselves through pointers without causing resolution errors.
@test unsafe fn testResolveUnionSelfReferentialPointerAllowed() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union List { Cons(*List), Nil }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Mutually recursive unions should resolve without infinite loops.
@test unsafe fn testResolveUnionMutuallyRecursive() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union A { HasB(*B), None } union B { HasA(*A), None }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Unions with record payloads containing slice references to self should resolve.
/// This matches the pattern in sexpr.rad: `List { tail: *[Expr] }`.
@test unsafe fn testResolveUnionRecordPayloadWithSliceSelfRef() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Expr { Null, List { head: *[u8], tail: *[Expr] } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test unsafe fn testUndefinedCoercions() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "unsafe { let count: i32 = undefined; }");
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        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) {} unsafe fn g() { f(undefined); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "unsafe fn fetch() -> i32 { return undefined; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveBlockVoid() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "{ 42; }");
    try expectNoErrors(&result);

    let block = try getBlockStmt(result.root, 0);
    try expectType(&a, block, super::Type::Void);
}

@test unsafe fn testResolveBlockNever() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "{ panic; }");
    try expectNoErrors(&result);

    let block = try getBlockStmt(result.root, 0);
    try expectType(&a, block, super::Type::Never);
}

@test unsafe fn testResolveIfAllBranchesNever() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "if true { panic; } else { panic; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 0);
    try expectType(&a, stmt, super::Type::Never);
}

@test unsafe fn testResolveIfMixedBranchesNotNever() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "if true { panic; } else {}";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 0);
    try expectType(&a, stmt, super::Type::Void);
}

@test unsafe fn testResolveLetElse() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; let value = opt else panic; value;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let blockNode = result.root;
    let case ast::NodeValue::Block(block) = blockNode.value
        else throw testing::TestError::Failed;
    let letElseNode = try getBlockStmt(blockNode, 1);
    let valueStmt = try getBlockStmt(blockNode, 2);

    { // Ensure the bound identifier receives the inner optional type.
        let valueExpr = try expectExprStmtType(&a, valueStmt, super::Type::I32);

        let sym = super::symbolFor(&a, valueExpr)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: valType, .. } = sym.data
            else throw testing::TestError::Failed;
        try testing::expect(valType == super::Type::I32);
    }
    // The let-else statement itself should be typed as void.
    try expectType(&a, letElseNode, super::Type::Void);
}

@test unsafe fn testResolveLetElseDefaultValue() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = nil; let value = opt else 42; value;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test unsafe fn testResolveLetElseRequiresDivergentElse() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = nil; let value = opt else {}; value;";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::I32, super::Type::Void);
}

@test unsafe fn testResolveLetElseRequiresOptional() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let x: i32 = 42; let value = x else panic;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ExpectedOptional);
}

/// Test that `if let mut` produces a mutable binding.
@test unsafe fn testResolveIfLetMut() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; if let mut v = opt { set v = v + 1; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that `if let` (without mut) rejects assignment.
@test unsafe fn testResolveIfLetImmutable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; if let v = opt { set v = 1; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

/// Test that `let mut ... else` produces a mutable binding.
@test unsafe fn testResolveLetMutElse() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; let mut v = opt else panic; set v = v + 1;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that `let ... else` (without mut) rejects assignment.
@test unsafe fn testResolveLetElseImmutable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; let v = opt else panic; set v = 1;";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

@test unsafe fn testResolveLetCaseElse() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let case _ = 1 else panic;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "let case _ = true else false;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveLetCaseElseRequiresDivergentElse() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let case _ = 1 else {};";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::Int, super::Type::Void);
}

@test unsafe fn testResolveTryValidPropagation() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn fallible() throws (i32) {} fn caller() throws (i32) { try fallible() }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test unsafe fn testResolveTryRequiresThrowsClause() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn fallible() throws (i32) {} fn caller() { try fallible() }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TryRequiresThrows);
}

@test unsafe fn testResolveTryIncompatibleError() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn fallible() throws (i32) {} fn caller() throws (i8) { try fallible() }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TryIncompatibleError);
}

@test unsafe fn testResolveTryNonThrowing() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn safe() {} fn caller() throws (i32) { try safe() }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TryNonThrowing);
}

@test unsafe fn testResolveTryCatchBlockMatchesResult() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Error { Fail } fn fallible() -> u32 throws (Error) { throw Error::Fail; return 0; } fn caller() -> u32 { return try fallible() catch { return 42; }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test unsafe fn testResolveTryCatchBlockDiverges() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Error { Fail } fn fallible() -> u32 throws (Error) { throw Error::Fail; return 0; } fn caller() -> u32 { return try fallible() catch { return 7; }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test unsafe fn testResolveTryCatchBlockMustDiverge() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Error { Fail } fn fallible() -> u32 throws (Error) { throw Error::Fail; return 0; } fn caller() -> u32 { return try fallible() catch { 7; }; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::U32, super::Type::Void);
}

@test unsafe fn testResolveCallMissingTry() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn fallible() throws (i32) {} fn caller() { fallible() }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::MissingTry);
}

/// Test that `try?` converts errors to optionals without requiring caller to throw.
@test unsafe fn testResolveTryOptionalConvertsToOptional() throws (testing::TestError) {
    // `try?` should wrap the return type in optional and not require caller to throw.
    {
        let mut a = testResolver();
        let program = "record S {} fn fallible() -> *S throws (i32) { panic; } fn caller() -> ?*S { return try? fallible(); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
    // `try?` works in non-throwing function.
    {
        let mut a = testResolver();
        let program = "fn fallible() -> i32 throws (i32) { panic; } fn caller() -> ?i32 { return try? fallible(); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
    // `try?` can be used in if-let patterns.
    {
        let mut a = testResolver();
        let program = "fn fallible() -> i32 throws (i32) { panic; } fn caller() -> i32 { if let x = try? fallible() { return x; } return 0; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveThrowValid() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn fail() throws (i32) { throw 1; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test unsafe fn testResolveThrowRequiresThrowsClause() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn fail() { throw 1; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ThrowRequiresThrows);
}

@test unsafe fn testResolveThrowIncompatibleError() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn fail() throws (i32) { throw true; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ThrowIncompatibleError);
}

// Binary operation tests //////////////////////////////////////////////////////

@test unsafe fn testResolveBinaryOpArithmetic() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "4 + 4");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "10 - 3");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "5 * 6");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "20 / 4");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "17 % 5");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: i32 = 4; let y: i32 = 5; x + y;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::I32);
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "1 + (2 * 3) - 4");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let n: i32 = 5; n * 2;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::I32);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let n: i32 = 5; 2 * n;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::I32);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let n: i32 = 5; n - 1;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::I32);
    }
}

@test unsafe fn testResolveBinaryOpComparison() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "5 == 5");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "5 <> 10");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "5 < 10");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "10 > 5");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "5 <= 5");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "10 >= 5");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "true == false");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "5 + 3 > 10 - 4");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let n: i32 = 5; n == 1;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::Bool);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let n: i32 = 5; 1 == n;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::Bool);
    }
}

@test unsafe fn testResolveBinaryOpLogical() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: bool = true; let y: bool = false; x and y;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::Bool);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: bool = true; let y: bool = false; x or y;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::Bool);
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "true and false");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
    }
}

@test unsafe fn testResolveBinaryOpArithmeticTypeMismatch() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "4 + true");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: i32 = 4; let y: bool = false; x + y;");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "10 - false");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "5 * true");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "20 / false");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "17 % true");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "1 + (true * 3)");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
    }
}

@test unsafe fn testResolveBinaryOpLogicalTypeMismatch() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "42 and true");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "true or 5");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "1 and 2");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
    }
}

@test unsafe fn testResolveBinaryOpComparisonTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "true < false");
    try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
}

// Unary operation tests ///////////////////////////////////////////////////////

@test unsafe fn testResolveUnaryOpNot() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "not true");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: bool = true; not x;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::Bool);
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "not (true and false)");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "not 42");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: i32 = 5; not x;");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::Bool, super::Type::I32);
    }
}

@test unsafe fn testResolveUnaryOpNeg() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "-42");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: i32 = 10; -x;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::I32);
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "-(5 + 3)");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: i8 = 5; -x;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::I8);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "-true");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: bool = false; -x;");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
    }
}

@test unsafe fn testResolveUnaryOpBitNot() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "~42");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u32 = 255; ~x;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::U32);
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "~(0xFF)");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: i8 = 5; ~x;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::I8);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "~true");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: bool = false; ~x;");
        try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
    }
}

@test unsafe fn testResolveUnaryOpNested() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "not not true");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "--42");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "~~0xFF");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "-(~42)");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Int);
    }
}

// test fn testNormalPointerArithmetic() throws (testing::TestError) {
//     mut a = testResolver();
//     let result = try resolveProgramStr(&mut a, "fn test() { let ptr: *i32 = undefined; let x = ptr + 1; }");
//     try expectNoErrors(&result);
// }

// Dereference tests //////////////////////////////////////////////////////////

@test unsafe fn testResolveDeref() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "static x: i32 = 42; let ptr: *i32 = &x; *ptr;");
        try expectNoErrors(&result);
        let stmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, stmt, super::Type::I32);
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "*42");
        try expectErrorKind(&result, super::ErrorKind::ExpectedPointer);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: i32 = 5; *x;");
        try expectErrorKind(&result, super::ErrorKind::ExpectedPointer);
    }
}

@test unsafe fn testResolveAssignDeref() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "static x: i32 = 0; let ptr: *mut i32 = &mut x; set *ptr = 42;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "static x: i32 = 0; let ptr: *i32 = &x; set *ptr = 42;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    } {
        let mut a = testResolver();
        let program = "static x: i32 = 0; let mut ptr: *i32 = &x; set *ptr = 42;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    } {
        let mut a = testResolver();
        let program = "static x: u8 = 0; let mut ptr: *mut u8 = &mut x; set *ptr = 255;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

// Type inference tests ///////////////////////////////////////////////////////

@test unsafe fn testResolveBasicTypeInference() throws (testing::TestError) {
    {
        // Boolean literals are unambiguous.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let x = true; x;");
        try expectNoErrors(&result);

        let xStmt = try parser::tests::getBlockLastStmt(result.root);
        try expectExprStmtType(&a, xStmt, super::Type::Bool);
    } {
        // Integer literals are ambiguous.
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let x = 34;");
        try expectErrorKind(&result, super::ErrorKind::CannotInferType);
    }
}

// Union tests /////////////////////////////////////////////////////////////////

@test unsafe fn testResolveUnionVariantWithoutPayload() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Status { Ok, Error } Status::Ok;";
    let result = try resolveProgramStr(&mut a, program);

    let ty = try getTypeInScopeOf(&a, result.root, "Status");
    let case super::NominalType::Union(unionType) = *ty
        else throw testing::TestError::Failed;
    try testing::expect(unionType.variants.len == 2);
    try testing::expect(mem::eq(unionType.variants[0].name, "Ok"));
    try testing::expect(mem::eq(unionType.variants[1].name, "Error"));
    if getUnionVariantPayload(ty, "Ok") <> super::Type::Void {
        throw testing::TestError::Failed;
    }
    let stmt = try getBlockStmt(result.root, 1);
    try expectExprStmtType(&a, stmt, super::Type::Nominal(ty));
    try expectNoErrors(&result);
}

@test unsafe fn testResolveUnionVariantWithPayload() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union R { Ok(i32), Err(bool) } R::Ok(42);";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let ty = try getTypeInScopeOf(&a, result.root, "R");

    let okPayload = getUnionVariantPayload(ty, "Ok");
    try testing::expect(okPayload == super::Type::I32);

    let errPayload = getUnionVariantPayload(ty, "Err");
    try testing::expect(errPayload == super::Type::Bool);

    let stmt = try getBlockStmt(result.root, 1);
    try expectExprStmtType(&a, stmt, super::Type::Nominal(ty));

    // TODO: Test payload type.
}

@test unsafe fn testResolveUnionVariantWithoutPayloadExplicitDiscriminant() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union R { Ok = 7, Err = 11 } R::Ok;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let ty = try getTypeInScopeOf(&a, result.root, "R");
    let stmt = try getBlockStmt(result.root, 1);
    try expectExprStmtType(&a, stmt, super::Type::Nominal(ty));
}

@test unsafe fn testResolveUnionVariantPayloadTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union R { Ok(i32), Error(bool) } R::Ok(true);";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::I32, super::Type::Bool);

    let ty = try getTypeInScopeOf(&a, result.root, "R");
    let payload = getUnionVariantPayload(ty, "Ok");
    try testing::expect(payload == super::Type::I32);

    let errNode = err.node
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Bool(_) = errNode.value
        else throw testing::TestError::Failed;
}

@test unsafe fn testResolveUnionVariantUnexpectedPayload() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Status { Ok, Error } Status::Ok(42);";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);

    let case super::ErrorKind::UnionVariantPayloadUnexpected(_) = err.kind
        else throw testing::TestError::Failed;
    let node = err.node
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Call(_) = node.value
        else throw testing::TestError::Failed;
}

@test unsafe fn testResolveUnionVariantUnknown() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Status { Ok, Error } Status::Unknown;";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("Unknown"));
}

@test unsafe fn testResolveScopeAccessUndefinedType() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "Unknown::X;");
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("Unknown"));
}

@test unsafe fn testResolveUnionVariantVoidPayload() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union R { Success(i32), Pending } R::Pending;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let ty = try getTypeInScopeOf(&a, result.root, "R");
    let payload = getUnionVariantPayload(ty, "Pending");
    try testing::expect(payload == super::Type::Void);

    let stmt = try getBlockStmt(result.root, 1);
    try expectExprStmtType(&a, stmt, super::Type::Nominal(ty));
}

@test unsafe fn testResolveUnionVariantRecordPayload() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record P { x: i32, y: i32 } union S { Point(P), Num(u32) } S::Point(P { x: 10, y: 20 });";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let ty = try getTypeInScopeOf(&a, result.root, "S");
    let stmt = try getBlockStmt(result.root, 2);
    try expectExprStmtType(&a, stmt, super::Type::Nominal(ty));
}

@test unsafe fn testResolveBuiltinSizeOf() throws (testing::TestError) {
    try resolveAndExpectConstExpr("@sizeOf(u8)", 1);
    try resolveAndExpectConstExpr("@sizeOf(u16)", 2);
    try resolveAndExpectConstExpr("@sizeOf(u32)", 4);
    try resolveAndExpectConstExpr("@sizeOf(i32)", 4);
    try resolveAndExpectConstExpr("@sizeOf(bool)", 1);
    try resolveAndExpectConstExpr("@sizeOf(*u32)", 8);
    try resolveAndExpectConstExpr("@sizeOf([u8; 10])", 10);
    try resolveAndExpectConstExpr("@sizeOf(*[u32])", 16);
    try resolveAndExpectConstExpr("@sizeOf(?u8)", 2);
    try resolveAndExpectConstExpr("@sizeOf(?u16)", 4);
    try resolveAndExpectConstExpr("@sizeOf(?u32)", 8);
    try resolveAndExpectConstExpr("@sizeOf(*opaque)", 8);
    try resolveAndExpectConstStmt("record T { x: u8 } @sizeOf(T);", 1);
    try resolveAndExpectConstStmt("record T { x: i32 } @sizeOf(T);", 4);
    try resolveAndExpectConstStmt("record T { x: i32, y: i8 } @sizeOf(T);", 8);
    try resolveAndExpectConstStmt("record T { x: i8, y: i32 } @sizeOf(T);", 8);
    try resolveAndExpectConstStmt("record T { x: i8, y: i32 } @sizeOf(T);", 8);
    try resolveAndExpectConstStmt("record T { x: u32, y: u8, z: u8 }; @sizeOf(T);", 8);
    try resolveAndExpectConstStmt("record T { x: u8, y: u32, z: u8 }; @sizeOf(T);", 12);
    try resolveAndExpectConstStmt("union T { A, B, C }; @sizeOf(T);", 1);
    try resolveAndExpectConstStmt("union T { A, B(u32), C }; @sizeOf(T);", 8);
    try resolveAndExpectConstStmt("union T { A, B(u16), C }; @sizeOf(T);", 4);
    try resolveAndExpectConstStmt("union T { A(u32), B(u16), C(u16) }; @sizeOf(T);", 8);
    try resolveAndExpectConstStmt("union T { A(u32), B(u16), C([u8; 16]) }; @sizeOf(T);", 20);
}

@test unsafe fn testResolveBuiltinAlignOf() throws (testing::TestError) {
    try resolveAndExpectConstExpr("@alignOf(u8)", 1);
    try resolveAndExpectConstExpr("@alignOf(u16)", 2);
    try resolveAndExpectConstExpr("@alignOf(u32)", 4);
    try resolveAndExpectConstExpr("@alignOf(i32)", 4);
    try resolveAndExpectConstExpr("@alignOf(bool)", 1);
    try resolveAndExpectConstExpr("@alignOf(*u8)", 8);
    try resolveAndExpectConstExpr("@alignOf(*u16)", 8);
    try resolveAndExpectConstExpr("@alignOf(*u32)", 8);
    try resolveAndExpectConstExpr("@alignOf(*opaque)", 8);
    try resolveAndExpectConstExpr("@alignOf([u8; 8])", 1);
    try resolveAndExpectConstExpr("@alignOf([u16; 8])", 2);
    try resolveAndExpectConstExpr("@alignOf([u32; 8])", 4);
    try resolveAndExpectConstExpr("@alignOf(*[u32])", 8);
    try resolveAndExpectConstExpr("@alignOf(?u8)", 1);
    try resolveAndExpectConstExpr("@alignOf(?u16)", 2);
    try resolveAndExpectConstExpr("@alignOf(?u32)", 4);
    try resolveAndExpectConstStmt("record T { x: u8, y: u16 }; @alignOf(T);", 2);
    try resolveAndExpectConstStmt("record T { x: u8, y: u32, z: u8 }; @alignOf(T);", 4);
    try resolveAndExpectConstStmt("record T { x: u32, y: u8, z: u8 }; @alignOf(T);", 4);
    try resolveAndExpectConstStmt("union T { A, B, C }; @alignOf(T);", 1);
    try resolveAndExpectConstStmt("union T { A, B(u32), C }; @alignOf(T);", 4);
}

@test unsafe fn testResolveBuiltinSizeOfRecord() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record T { x: u8, y: u32 } @sizeOf(T);";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 1);
    let expr = try expectExprStmtType(&a, stmt, super::Type::U32);
    try expectConstInt(&a, expr, 8);
}

@test unsafe fn testResolveBuiltinSizeOfUnion() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Result { Ok(u32), Err(u8) } @sizeOf(Result);";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, 1);
    let expr = try expectExprStmtType(&a, stmt, super::Type::U32);
    try expectConstInt(&a, expr, 8);
}

@test unsafe fn testResolveAlignAnnotation() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u8 align(8) = 0;");
        try expectNoErrors(&result);

        let stmt = try getBlockStmt(result.root, 0);
        let sym = super::symbolFor(&a, stmt)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: valType, .. } = sym.data
            else throw testing::TestError::Failed;
        let layout = super::getLayout(&a, sym.node, valType);
        try testing::expect(layout.alignment == 8);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let x: u32 align(3) = 0;");
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAlignmentValue(val) = err.kind
            else throw testing::TestError::Failed;
        try testing::expect(val == 3);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let x: u32 align(7) = 0;");
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAlignmentValue(val) = err.kind
            else throw testing::TestError::Failed;
        try testing::expect(val == 7);
    }
}

@test unsafe fn testResolveVoidAssignmentError() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn voidFn() {} let _ = voidFn();";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::CannotAssignVoid);
    } {
        let mut a = testResolver();
        let program = "fn voidFn() {} let x = voidFn();";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::CannotAssignVoid);
    }
}

//
// Module Declaration Tests
//

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

    let rootId = try registerModule(graph, nil, "root", "mod child;", &mut arena);
    let childId = try registerModule(graph, rootId, "child", "{}", &mut arena);
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

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

    // Register root and util modules.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod util; export fn helper() {}", &mut arena);
    let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "util", "fn main() { helper(); }", &mut arena);

    // Resolve should fail: the parent module is not in scope.
    let result = try resolveModuleTree(&mut a, rootId);
    let err = try expectError(&result);
    let case super::ErrorKind::UnresolvedSymbol(name) = err.kind
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(name, "helper"));
}

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

    // Register root and util modules.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod util; fn main() { util::helper(); }", &mut arena);
    let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "util", "export fn helper() {}", &mut arena);

    // Resolve should succeed: parent can access child.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

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

    // Register root with two sibling modules.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod paul; export mod patrick;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "paul", "fn main() { patrick::helper(); }", &mut arena);
    let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "patrick", "export fn helper() -> i32 { return 42; }", &mut arena);

    // Resolve should fail: siblings can't access each other directly.
    let result = try resolveModuleTree(&mut a, rootId);
    let err = try expectError(&result);
    let case super::ErrorKind::UnresolvedSymbol(name) = err.kind
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(name, "patrick"));
}

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

    // Register root with two sibling modules.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod paul; export mod patrick;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "paul", "use root::patrick; fn main() -> i32 { return patrick::helper(); }", &mut arena);
    let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "patrick", "export fn helper() -> i32 { return 42; }", &mut arena);

    // Resolve should succeed: siblings can access each other via root.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

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

    // Register root with two sibling modules that call each other.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod left; export mod right;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "left", "use root::right; export fn leftHelper() -> i32 { return right::rightHelper(); }", &mut arena);
    let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "right", "use root::left; export fn rightHelper() -> i32 { return left::leftHelper(); }", &mut arena);

    // Resolve should succeed: cyclic use is allowed.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

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

    // Register root with types module containing a record.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod types; mod app;", &mut arena);
    let typesId = try registerModule(&mut MODULE_GRAPH, rootId, "types", "export record Point { x: i32, y: i32 }", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::types; fn main() -> i32 { let p = types::Point { x: 1, y: 2 }; return p.x; }", &mut arena);

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

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

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

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

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

    // Register deeply nested modules: `root::app::services::auth`.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod main; export fn helper() -> i32 { return 42; }", &mut arena);
    let mainId = try registerModule(&mut MODULE_GRAPH, rootId, "main", "fn run() -> i32 { return root::helper(); }", &mut arena);

    // Resolve should fail: the `root` module must be imported.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("root"));
}

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

    // Register deeply nested modules: `root::app::services::auth`.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod app; mod main;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "export mod services;", &mut arena);
    let servicesId = try registerModule(&mut MODULE_GRAPH, appId, "services", "export mod auth;", &mut arena);
    let authId = try registerModule(&mut MODULE_GRAPH, servicesId, "auth", "export fn login() -> i32 { return 1; }", &mut arena);
    let mainId = try registerModule(&mut MODULE_GRAPH, rootId, "main", "use root::app::services::auth; fn run() -> i32 { return auth::login(); }", &mut arena);
    let otherId = try registerModule(&mut MODULE_GRAPH, rootId, "other", "use root; fn run() -> i32 { return root::app::services::auth::login(); }", &mut arena);

    // Resolve should succeed: use imports the module symbol.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

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

    // Register root with app trying to use a non-existent module.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod app;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::unknown;", &mut arena);

    // Resolve should fail: module doesn't exist.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("unknown"));
}

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

    // Register root with util module containing a private function.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod util; mod app;", &mut arena);
    let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "util", "fn private() -> i32 { return 42; }", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::util; fn main() -> i32 { return util::private(); }", &mut arena);

    // Resolve should fail: function is not public.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("private"));
}

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

    // Register root with public and private child modules.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod main; mod private;", &mut arena);
    let privateId = try registerModule(&mut MODULE_GRAPH, rootId, "private", "{}", &mut arena);
    let publicId = try registerModule(&mut MODULE_GRAPH, rootId, "main", "use root::private;", &mut arena);

    // Resolve should fail: module is not public.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("private"));
}

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

    // Register root with public and private child modules.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod main; export mod public;", &mut arena);
    let privateId = try registerModule(&mut MODULE_GRAPH, rootId, "public", "{}", &mut arena);
    let publicId = try registerModule(&mut MODULE_GRAPH, rootId, "main", "use root::public;", &mut arena);

    // Resolve should succeed: module is public.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

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

    // Register root with types module containing a private record.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod types; mod app;", &mut arena);
    let typesId = try registerModule(&mut MODULE_GRAPH, rootId, "types", "record Priv { x: i32 }", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::types; fn main() -> types::Priv { return types::Priv { x: 1 }; }", &mut arena);

    // Resolve should fail: record is not public.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("Priv"));
}

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

    // Register root with types module containing a public record.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod types; mod app;", &mut arena);
    let typesId = try registerModule(&mut MODULE_GRAPH, rootId, "types", "export record Pub { x: i32 }", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::types; fn main() -> types::Pub { return types::Pub { x: 1 }; }", &mut arena);

    // Resolve should succeed: record is public.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

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

    // Register root with statics module containing a private static.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod statics; mod app;", &mut arena);
    let staticsId = try registerModule(&mut MODULE_GRAPH, rootId, "statics", "static PRIVATE: i32 = 42;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::statics; fn main() -> i32 { return statics::PRIVATE; }", &mut arena);

    // Resolve should fail: static is not public.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("PRIVATE"));
}

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

    // Register root with statics module containing a public static.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod statics; mod app;", &mut arena);
    let staticsId = try registerModule(&mut MODULE_GRAPH, rootId, "statics", "export static PUBLIC: i32 = 42;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::statics; fn main() -> i32 { return statics::PUBLIC; }", &mut arena);

    // Resolve should succeed: static is public.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

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

        // Test function access.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod child; export fn parentFn() -> i32 { return 42; }", &mut arena);
        let childId = try registerModule(&mut MODULE_GRAPH, rootId, "child", "fn main() -> i32 { return super::parentFn(); }", &mut arena);
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

        // Test type access.
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod child; export record Point { x: i32, y: i32 }", &mut arena);
        let childId = try registerModule(&mut MODULE_GRAPH, rootId, "child", "fn make() -> super::Point { return super::Point { x: 1, y: 2 }; }", &mut arena);
        let result = try resolveModuleTree(&mut a, rootId);
        try expectNoErrors(&result);
    }
}

/// Test nested super access to union variants (e.g. `super::E::A`).
@test unsafe fn testResolveSuperUnionVariant() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod c; export union E { A, B }", &mut arena);
    let childId = try registerModule(&mut MODULE_GRAPH, rootId, "c",
        "fn f(x: super::E) { match x { case super::E::A => {}, case super::E::B => {} } }",
        &mut arena);
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

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

    // Register root with a function, and a child module that uses super to access it.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod joe; export mod kate;", &mut arena);
    let kateId = try registerModule(&mut MODULE_GRAPH, rootId, "kate", "export fn run() {}", &mut arena);
    let joeId = try registerModule(&mut MODULE_GRAPH, rootId, "joe", "use super::kate; fn main() { kate::run(); }", &mut arena);

    // Resolve should succeed - super allows accessing parent module.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

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

    // Register root that declares a module that doesn't exist.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod unknown;", &mut arena);

    // Resolve should fail: module doesn't exist.
    let result = try resolveModuleTree(&mut a, rootId);
    let err = try expectError(&result);
    let case super::ErrorKind::UnresolvedSymbol(name) = err.kind
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(name, "unknown"));
}

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

    // Register root that declares a module twice.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod child; mod child;", &mut arena);
    let childId = try registerModule(&mut MODULE_GRAPH, rootId, "child", "{}", &mut arena);

    // Resolve should fail: can't declare the same module twice.
    let result = try resolveModuleTree(&mut a, rootId);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("child"));
}

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

    // Register root that declares and imports the same module.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod child; use child;", &mut arena);
    let childId = try registerModule(&mut MODULE_GRAPH, rootId, "child", "{}", &mut arena);

    // Resolve should fail: Both `mod` and `use` are trying to create the same binding.
    let result = try resolveModuleTree(&mut a, rootId);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("child"));
}

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

    // Register a module that imports the same module twice.
    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "mod child", &mut arena);
    let childId = try registerModule(&mut MODULE_GRAPH, rootId, "child", "use root; use root;", &mut arena);

    // Resolve should fail.
    let result = try resolveModuleTree(&mut a, rootId);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("root"));
}

/// Test that opaque pointers are allowed in record fields.
@test unsafe fn testOpaquePointerInRecordField() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "record T { x: *opaque }");
    try expectNoErrors(&result);
}

/// You cannot use `@sizeOf` or `@alignOf` on opaque type.
@test unsafe fn testOpaqueTypeNoSizeOfAlignOf() throws (testing::TestError) {
    let mut a = testResolver();

    let result1 = try resolveExprStr(&mut a, "@sizeOf(opaque)");
    let err1 = try expectError(&result1);
    try expectErrorKind(&result1, super::ErrorKind::OpaqueTypeNotAllowed);

    let result2 = try resolveExprStr(&mut a, "@alignOf(opaque)");
    let err2 = try expectError(&result2);
    try expectErrorKind(&result2, super::ErrorKind::OpaqueTypeNotAllowed);
}

/// Test that immutable slice/pointer parameters cannot be borrowed mutably.
@test unsafe fn testMutableBorrowFromImmutablePointer() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(p: *i32) { let x = &mut *p; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

/// Test that immutable slice parameters cannot be borrowed mutably.
@test unsafe fn testMutableBorrowFromImmutableSlice() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(s: *[i32]) { let x: *mut i32 = &mut s[0]; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

/// Test that mutable pointer parameters can be borrowed mutably.
@test unsafe fn testMutableBorrowFromMutablePointer() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(p: *mut i32) { let x: *mut i32 = &mut *p; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that mutable slice parameters can be borrowed mutably.
@test unsafe fn testMutableBorrowFromMutableSlice() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(s: *mut [i32]) { let x: *mut i32 = &mut s[0]; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test borrowing mutably from a field access on a call returning `*mut`.
@test unsafe fn testMutableBorrowFromCallReturningMutablePointer() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Box { x: i32 } fn idBox(b: *mut Box) -> *mut Box { return b; } fn f() { static b: Box = Box { x: 1 }; let px: *mut i32 = &mut idBox(&mut b).x; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that calls returning immutable pointers cannot be mutably borrowed.
@test unsafe fn testMutableBorrowFromCallReturningImmutablePointer() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Box { x: i32 } fn idBox(b: *Box) -> *Box { return b; } fn f() { constant b: Box = Box { x: 1 }; let px: *mut i32 = &mut idBox(&b).x; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

/// Test borrowing mutably from a public static through scope access.
@test unsafe fn testMutableBorrowFromScopeAccessStatic() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod statics; mod app;", &mut arena);
    let staticsId = try registerModule(&mut MODULE_GRAPH, rootId, "statics", "export static COUNTER: i32 = 0;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::statics; fn main() { let p: *mut i32 = &mut statics::COUNTER; set *p = 7; }", &mut arena);

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

/// Test that constants through scope access cannot be mutably borrowed.
@test unsafe fn testMutableBorrowFromScopeAccessConstant() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export constant LIMIT: i32 = 7;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; fn main() { let p: *mut i32 = &mut consts::LIMIT; set *p = 9; }", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

/// Test that mutable bindings of immutable pointers cannot borrow mutably through the pointer.
@test unsafe fn testMutableBorrowFromMutableBindingOfPointer() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f() { static x: i32 = 1; let p: *i32 = &x; let y = &mut *p; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

/// Test that mutable pointer to immutable slice cannot be assigned through index.
/// This tests the case where we have `*mut *[T]`; the outer pointer is mutable but
/// the inner slice is immutable, so we shouldn't be able to mutate the elements.
@test unsafe fn testAssignThroughMutablePointerToImmutableSlice() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(slice: *[i32]) { let p: *mut *[i32] = &mut slice; set p[0] = 1; }";
    let result = try resolveProgramStr(&mut a, program);

    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

/// Test that mutable slice parameters can be assigned through index.
@test unsafe fn testAssignThroughMutableSliceParam() throws (testing::TestError) {
    {
        // Mutable slice param: direct assignment should work
        let mut a = testResolver();
        let program = "fn f(slice: *mut [i32]) { set slice[0] = 1; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        // Immutable slice param: direct assignment should fail
        let mut a = testResolver();
        let program = "fn f(slice: *[i32]) { set slice[0] = 1; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
}

/// Test range end type coercion with assignable types.
@test unsafe fn testRangeEndTypeCoercion() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn f(end: u32) { for i in 0..end {} }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "fn f(start: u32) { for i in start..9 {} }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Mixed-width range bounds require an explicit cast.
@test unsafe fn testRangeEndTypeSubType() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn f(start: i8, end: u32) { for i in start..end {} }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::I8, super::Type::U32);
    } {
        let mut a = testResolver();
        let program = "fn f(start: i8, end: u32) { for i in (start as u32)..end {} }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that try-catch expressions in statement context accept mismatched types.
@test unsafe fn testTryCatchInStatementContextTypeMismatchOk() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f() { try g() catch {}; } fn g() -> bool throws (i32) { panic; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that try-catch blocks in value context require divergence or void.
@test unsafe fn testTryCatchInValueContextTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f() -> bool { return try g() catch {}; } fn g() -> bool throws (i32) { panic; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectTypeMismatch(err, super::Type::Bool, super::Type::Void);
}

/// Test that try-catch blocks in value context work when they diverge.
@test unsafe fn testTryCatchInValueContextDiverges() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f() -> bool { return try g() catch { return false; }; } fn g() -> bool throws (i32) { panic; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that `try?` lifts result type to optional.
@test unsafe fn testTryOptionalLiftsToOptional() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S {} fn f() -> ?*S { return try? g(); } fn g() -> *S throws (i32) { panic; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that record fields can be assigned if the record binding is mutable.
@test unsafe fn testMutableAssignToMutableRecordBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S { x: i32 } fn f() { let mut s = S { x: 1 }; set s.x = 2; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that record fields cannot be assigned if the record binding is immutable.
@test unsafe fn testMutableAssignToImmutableRecordBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S { x: i32 } fn f() { let s = S { x: 1 }; set s.x = 2; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

/// Test that record fields can be assigned through a mutable pointer.
@test unsafe fn testMutableAssignToMutablePointerToRecord() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S { x: i32 } fn f(p: *mut S) { set p.x = 2; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that record fields cannot be assigned through an immutable pointer.
@test unsafe fn testMutableAssignToImmutablePointerToRecord() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S { x: i32 } fn f(p: *S) { set p.x = 2; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

// Opaque pointer tests.

/// You can assign any pointer (*T) to an opaque pointer (*opaque) without a cast.
@test unsafe fn testOpaquePointerAutoCoercion() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "unsafe fn f(x: *i32) { let mut ptr: *i32 = x; let o: *opaque = ptr; set ptr = o as *i32; }");
    try expectNoErrors(&result);
}

/// You cannot assign an opaque pointer to a non-opaque pointer without a cast.
@test unsafe fn testOpaquePointerNoReverseCoercion() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let ptr: *i32 = o; }");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(mismatch) = err.kind
        else throw testing::TestError::Failed;
    let case super::Type::Pointer { target: expectedTarget, .. } = mismatch.expected
        else throw testing::TestError::Failed;
    let case super::Type::Pointer { target: actualTarget, .. } = mismatch.actual
        else throw testing::TestError::Failed;

    try testing::expect(*expectedTarget == super::Type::I32);
    try testing::expect(*actualTarget == super::Type::Opaque);
}

/// You cannot have a value of type `opaque` (function parameter).
@test unsafe fn testOpaqueValue() throws (testing::TestError) {
    {
        let mut a = testResolver();
        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, "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 err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::OpaqueTypeNotAllowed);
    }
}

/// You cannot dereference an opaque pointer, you have to cast it first.
@test unsafe fn testOpaquePointerNoDereference() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let x = *o; }");
    let err = try expectError(&result);
    try expectErrorKind(&result, super::ErrorKind::OpaqueTypeDeref);
}

/// Test that you can dereference after casting.
@test unsafe fn testOpaquePointerDereferenceAfterCast() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "unsafe fn f() { let o: *opaque = undefined; let x = *(o as *i32); }");
    try expectNoErrors(&result);
}

/// You cannot do pointer arithmetic with an opaque pointer.
@test unsafe fn testOpaquePointerNoArithmetic() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let x = o + 1; }");
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::OpaquePointerArithmetic);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let x = 1 + o; }");
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::OpaquePointerArithmetic);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let x = o - 1; }");
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::OpaquePointerArithmetic);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let x = 1 - o; }");
        let err = try expectError(&result);
        try expectErrorKind(&result, super::ErrorKind::OpaquePointerArithmetic);
    }
}

// Wildcard import/reexport tests.

/// Test transitive re-export.
@test unsafe fn testWildcardReexportTransitive() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

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

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

/// Test that wildcard import can access public symbols.
@test unsafe fn testWildcardImportPublicOnly() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod b; mod a;", &mut arena);
    let bId = try registerModule(&mut MODULE_GRAPH, rootId, "b", "export record Value { number: i32 } export fn public() -> i32 { return 1; } fn private() -> i32 { return 2; }", &mut arena);
    let aId = try registerModule(&mut MODULE_GRAPH, rootId, "a", "use root::b::*; fn id(value: Value) -> Value { return value; } fn main() -> i32 { return public() + id(Value { number: 2 }).number; }", &mut arena);

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

/// Test that wildcard import cannot access private symbols.
@test unsafe fn testWildcardImportSkipsPrivate() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod b; mod a;", &mut arena);
    let bId = try registerModule(&mut MODULE_GRAPH, rootId, "b", "export fn public() -> i32 { return 1; } fn private() -> i32 { return 2; }", &mut arena);
    let aId = try registerModule(&mut MODULE_GRAPH, rootId, "a", "use root::b::*; fn main() -> i32 { return private(); }", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("private"));
}

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

    // Verify the array constant has the correct type with length 3.
    let arrStmt = try getBlockStmt(result.root, 1);
    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);
}

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

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

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

/// Test that record field types can reference imported types.
///
/// This tests that `use` statements are processed before record body resolution,
/// allowing record fields to use types from imported modules.
@test unsafe fn testRecordFieldUsesImportedType() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod types; mod scanner;", &mut arena);
    let typesId = try registerModule(&mut MODULE_GRAPH, rootId, "types", "export record Pool { count: u32 }", &mut arena);
    let scannerId = try registerModule(&mut MODULE_GRAPH, rootId, "scanner", "use root::types; record Scanner { pool: *types::Pool }", &mut arena);

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

/// Test that imported constants can be used in array size expressions.
///
/// This tests that constant values are propagated through scope access expressions,
/// enabling compile-time evaluation of array sizes using imported constants.
@test unsafe fn testImportedConstantInArraySize() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export constant SIZE: u32 = 8;", &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);
}

/// Test that `if let case` binds payload variables in the then branch.
///
/// When using `if let case Union::Variant(x) = expr { ... }`, the variable `x` should
/// be bound to the payload value within the then branch scope.
@test unsafe fn testResolveIfCaseBindsPayload() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some(i32), None } fn f(value: Opt) -> i32 { if let case Opt::Some(x) = value { return x; } return 0; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that `if let case` payload binding is scoped to the then branch.
///
/// The payload variable should not be accessible outside the then branch.
@test unsafe fn testResolveIfCasePayloadScopeError() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some(i32), None } fn f(value: Opt) -> i32 { if let case Opt::Some(x) = value {} return x; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::UnresolvedSymbol(name) = err.kind
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(name, "x"));
}

/// Test that `let case` binds payload variables in the current scope.
///
/// When using `let case Union::Variant(x) = expr else { ... }`, the variable `x`
/// should be bound in the scope after the statement.
@test unsafe fn testResolveLetCaseElseBindsPayload() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some(i32), None } fn f(value: Opt) -> i32 { let case Opt::Some(x) = value else panic; return x; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that function pointers with identical signatures are assignable.
///
/// Two function types with the same parameters, return type, and throw list
/// should be considered structurally equal, even if they are separate allocations.
@test unsafe fn testFnPointerAssignability() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn apply(f: fn(i32) -> i32, x: i32) -> i32 { return f(x); } fn double(n: i32) -> i32 { return n * 2; } apply(double, 5);";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that function pointers with different parameter types are not assignable.
@test unsafe fn testFnPointerParamMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn apply(f: fn(i32) -> i32, x: i32) -> i32 { return f(x); } fn other(n: i8) -> i32 { return n as i32; } apply(other, 5);";
    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 that function pointers with different return types are not assignable.
@test unsafe fn testFnPointerReturnMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn apply(f: fn(i32) -> i32, x: i32) -> i32 { return f(x); } fn other(n: i32) -> i8 { return n as i8; } apply(other, 5);";
    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 that named records use nominal typing, not structural.
///
/// Two different named record types with identical fields should NOT be
/// assignable to each other, because they are distinct nominal types.
@test unsafe fn testNamedRecordNominalTyping() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Point { x: i32, y: i32 } record Vec2 { x: i32, y: i32 } fn take(p: Point) -> i32 { return p.x; } let v = Vec2 { x: 1, y: 2 }; take(v);";
    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 that union variants with labeled record payloads can be constructed.
@test unsafe fn testUnionVariantAnonRecordPayload() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Event { Click { x: i32, y: i32 }, Key { code: u32 } } let e = Event::Click { x: 10, y: 20 };";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that unlabeled record literals with positional fields work correctly.
///
/// When a record is declared with positional fields (e.g., `record R(i32, bool)`),
/// the literal must use constructor call syntax with positional arguments.
@test unsafe fn testResolveUnlabeledRecordLitValid() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record R(i32, bool); let r: R = R(1, true);";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that using brace syntax for an unlabeled record causes an error.
@test unsafe fn testResolveUnlabeledRecordLitStyleMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record R(i32); let r = R { x: 1 };";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::RecordFieldStyleMismatch);
}

/// Test that providing too many fields for an unlabeled record causes count mismatch.
@test unsafe fn testResolveUnlabeledRecordLitTooManyFields() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record R(i32, bool); let r = R(1, true, 3);";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::RecordFieldCountMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Test that match pattern with wrong number of bindings causes count mismatch.
@test unsafe fn testResolveMatchPatternWrongBindingCount() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Event { Click { x: i32, y: i32 } } fn f(e: Event) { match e { case Event::Click(a) => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::RecordFieldCountMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Test that shorthand field syntax works in record literals.
/// `Point { x, y }` should be equivalent to `Point { x: x, y: y }`.
@test unsafe fn testResolveRecordLiteralShorthand() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Point { x: i32, y: i32 } fn f() { let x: i32 = 1; let y: i32 = 2; let p = Point { x, y }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test shorthand field syntax with mixed explicit and shorthand fields.
@test unsafe fn testResolveRecordLiteralMixedShorthand() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Point { x: i32, y: i32 } fn f() { let x: i32 = 5; let p = Point { x, y: 10 }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test record-style union variant patterns with shorthand syntax.
@test unsafe fn testResolveMatchRecordPatternShorthand() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Shape { Rect { width: i32, height: i32 } } fn f(s: Shape) -> i32 { match s { case Shape::Rect { width, height } => return width + height } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test record pattern with mixed shorthand and explicit labels.
@test unsafe fn testResolveMatchRecordPatternMixed() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Shape { Rect { width: i32, height: i32 } } fn f(s: Shape) -> i32 { match s { case Shape::Rect { width, height: h } => return width + h } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test record pattern with fields in reverse order.
@test unsafe fn testResolveMatchRecordPatternReversed() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Shape { Rect { width: i32, height: i32 } } fn f(s: Shape) -> i32 { match s { case Shape::Rect { height: h, width: w } => return w + h } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test record pattern with shorthand syntax in reverse order.
/// Pattern `{ height, width }` binds all fields using shorthand, but not in definition order.
@test unsafe fn testResolveMatchRecordPatternShorthandReversed() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Shape { Rect { width: i32, height: i32 } } fn f(s: Shape) -> i32 { match s { case Shape::Rect { height, width } => return width + height } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test record pattern with `..` ignoring fields.
@test unsafe fn testResolveMatchRecordPatternIgnoreRest() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "union G { Point { x: i32, y: i32, z: i32 } } fn f(g: G) -> i32 { match g { case G::Point { x, .. } => return x } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "union G { Point { x: i32, y: i32, z: i32 } } fn f(g: G) -> i32 { match g { case G::Point { x: val, .. } => return val } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "union G { Point { x: i32, y: i32, z: i32 } } fn f(g: G) -> i32 { match g { case G::Point { z, .. } => return z } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "union G { Point { x: i32, y: i32, z: i32 } } fn f(g: G) -> i32 { match g { case G::Point { z, x, .. } => return x + z } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "union G { Point { x: i32, y: i32, z: i32 } } fn f(g: G) -> bool { match g { case G::Point { .. } => return true } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test standalone record pattern matching with unlabeled patterns.
@test unsafe fn testResolveMatchStandaloneRecordUnlabeledPattern() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S(i32); fn f(s: S) -> i32 { match s { case S(x) => return x, else => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test standalone record pattern matching with labeled patterns.
/// Pattern syntax: `T { x }` matches a named record and binds x to the field.
@test unsafe fn testResolveMatchStandaloneRecordLabeledPattern() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record T { x: i32 } fn f(t: T) -> i32 { match t { case T { x } => return x, else => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test standalone record pattern with multiple fields.
/// Pattern syntax: `R(a, b)` matches an unlabeled record with multiple fields.
@test unsafe fn testResolveMatchStandaloneRecordMultipleFields() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record R(bool, u8); fn f(r: R) -> u8 { match r { case R(_, x) => return x, else => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test standalone record pattern with wrong field count.
/// Pattern `S(x, y)` should fail for a single-field record.
@test unsafe fn testResolveMatchStandaloneRecordWrongFieldCount() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S(i32); fn f(s: S) -> i32 { match s { case S(x, y) => return x + y, else => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::RecordFieldCountMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Test array pattern matching with element bindings.
/// Pattern syntax: `[x, y]` matches an array and binds elements.
@test unsafe fn testResolveMatchArrayPattern() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(arr: [i32; 2]) -> i32 { match arr { case [x, y] => return x + y } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test array pattern with placeholder elements.
/// Pattern syntax: `[_, y]` ignores first element.
@test unsafe fn testResolveMatchArrayPatternPlaceholder() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(arr: [i32; 2]) -> i32 { match arr { case [_, y] => return y } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test identifier pattern that binds the whole value.
/// Pattern syntax: `x` matches any value and binds it.
@test unsafe fn testResolveMatchIdentPattern() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(val: i32) -> i32 { match val { x => return x } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test numeric literal pattern matching.
@test unsafe fn testResolveMatchNumericLiteralPattern() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(val: i32) -> i32 { match val { case 42 => return 1, else => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test string literal pattern matching.
@test unsafe fn testResolveMatchStringLiteralPattern() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(val: *[u8]) -> i32 { match val { case \"hello\" => return 1, else => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test boolean literal pattern matching.
@test unsafe fn testResolveMatchBoolLiteralPattern() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(val: bool) -> i32 { match val { case true => return 1, case false => return 0 } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

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

/// Test @sliceOf with wrong argument count produces an error.
@test unsafe fn testResolveSliceOfWrongArgCount() throws (testing::TestError) {
    // No arguments.
    {
        let mut a = testResolver();
        let program = "fn f() -> *[u8] { return @sliceOf(); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::BuiltinArgCountMismatch(mismatch) = err.kind
            else throw testing::TestError::Failed;
        try testing::expect(mismatch.expected == 2);
        try testing::expect(mismatch.actual == 0);
    }
    // Too few arguments.
    {
        let mut a = testResolver();
        let program = "fn f(ptr: *u8) -> *[u8] { return @sliceOf(ptr); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::BuiltinArgCountMismatch(mismatch) = err.kind
            else throw testing::TestError::Failed;
        try testing::expect(mismatch.expected == 2);
        try testing::expect(mismatch.actual == 1);
    }
    // Too many arguments.
    {
        let mut a = testResolver();
        let program = "fn f(ptr: *u8, len: u32, cap: u32, extra: u32) -> *[u8] { return @sliceOf(ptr, len, cap, extra); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::BuiltinArgCountMismatch(mismatch) = err.kind
            else throw testing::TestError::Failed;
        try testing::expect(mismatch.expected == 2);
        try testing::expect(mismatch.actual == 4);
    }
}

/// Test @sliceOf with wrong argument types produces errors.
@test unsafe fn testResolveSliceOfWrongArgTypes() throws (testing::TestError) {
    // Non-pointer first argument.
    {
        let mut a = testResolver();
        let program = "fn f(val: u32, len: u32) -> *[u8] { return @sliceOf(val, len); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::ExpectedPointer = err.kind
            else throw testing::TestError::Failed;
    }
    // Array instead of pointer.
    {
        let mut a = testResolver();
        let program = "fn f(arr: [u8; 4], len: u32) -> *[u8] { return @sliceOf(arr, len); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::ExpectedPointer = err.kind
            else throw testing::TestError::Failed;
    }
    // Non-numeric second argument.
    {
        let mut a = testResolver();
        let program = "fn f(ptr: *u8, len: bool) -> *[u8] { return @sliceOf(ptr, len); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
    // Pointer second argument.
    {
        let mut a = testResolver();
        let program = "fn f(ptr: *u8, len: *u32) -> *[u8] { return @sliceOf(ptr, len); }";
        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 @sliceOf with 3 arguments (ptr, len, cap) succeeds.
@test unsafe fn testResolveSliceOfWithCap() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "unsafe 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 = "unsafe 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 unsafe 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 unsafe 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 unsafe 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 unsafe 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 unsafe 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 unsafe 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 unsafe 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 unsafe 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 unsafe 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 unsafe 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 unsafe 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);
    try expectNoErrors(&result);

    let fnBlock = try getFnBody(&a, result.root, "f");
    let matchNode = fnBlock.statements[1];
    let case ast::NodeValue::Match(sw) = matchNode.value
        else throw testing::TestError::Failed;
    let caseNode = sw.prongs[0];

    let scope = super::scopeFor(&a, caseNode)
        else throw testing::TestError::Failed;
    let payloadSym = super::findSymbolInScope(scope, "x")
        else throw testing::TestError::Failed;
    let case super::SymbolData::Value { type: payloadValType, .. } = payloadSym.data
        else throw testing::TestError::Failed;
    let case super::Type::Pointer { class: types::PointerClass::Ref, target, mutable } = payloadValType
        else throw testing::TestError::Failed;
    try testing::expect(not mutable);
    try testing::expect(*target == super::Type::I32);
}

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

    let fnBlock = try getFnBody(&a, result.root, "f");
    let matchNode = fnBlock.statements[1];
    let case ast::NodeValue::Match(sw) = matchNode.value
        else throw testing::TestError::Failed;
    let caseNode = sw.prongs[0];

    let scope = super::scopeFor(&a, caseNode)
        else throw testing::TestError::Failed;
    let payloadSym = super::findSymbolInScope(scope, "x")
        else throw testing::TestError::Failed;
    let case super::SymbolData::Value { type: payloadValType, .. } = payloadSym.data
        else throw testing::TestError::Failed;
    let case super::Type::Pointer { class: types::PointerClass::Ref, target, mutable } = payloadValType
        else throw testing::TestError::Failed;
    try testing::expect(mutable);
    try testing::expect(*target == super::Type::I32);
}

/// Non-constant integer widening must use an explicit cast.
@test unsafe fn testResolveIntegerWideningRequiresCast() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = x;");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::U32, super::Type::U8);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u16 = x;");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::U16, super::Type::U8);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u16 = 1; let y: u32 = x;");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::U32, super::Type::U16);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: i8 = 1; let y: i32 = x;");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::I32, super::Type::I8);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = x as u32;");
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: i8 = 1; let y: i32 = x as i32;");
        try expectNoErrors(&result);
    }
}

/// Mixed-width integer binary ops require an explicit cast.
@test unsafe fn testResolveIntegerWideningBinOpRequiresCast() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = 2; let z: u32 = x | y;");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::U8, super::Type::U32);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = 0xFF; let z: u32 = x & y;");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::U8, super::Type::U32);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = 2; let z: u32 = x + y;");
        let err = try expectError(&result);
        try expectTypeMismatch(err, super::Type::U8, super::Type::U32);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u8 = x << 2;");
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = 2; let z: u32 = (x as u32) | y;");
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = 2; let z: u32 = (x as u32) + y;");
        try expectNoErrors(&result);
    }
}

/// A mutable slice pointer should be assignable to an immutable slice pointer.
@test unsafe fn testResolveMutSliceAssignableToImmutSlice() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveBlockStr(&mut a, "static arr: [i32; 3] = [1, 2, 3]; let p: *mut [i32] = &mut arr[..]; let q: *[i32] = p;");
    try expectNoErrors(&result);
}

/// Comprehensive tests for `as` cast expressions.
@test unsafe fn testResolveAsCasts() throws (testing::TestError) {
    { // Pointer to numeric.
        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 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);
    } { // **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);
    }

    { // *[i32] to *[opaque].
        let mut a = testResolver();
        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);
    }

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

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

    { // Identity cast: *mut [i32] to *mut [i32].
        let mut a = testResolver();
        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 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 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 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 result = try resolveProgramStr(&mut a, "record R { x: i32 } fn f(p: *R) { p 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 result = try resolveProgramStr(&mut a, "record R { x: i32 } fn f(s: *[R]) { s as *[i32]; }");
        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 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 result = try resolveProgramStr(&mut a, "record R { x: i32 } fn f(p: *R) { p as *u8; }");
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Test that catch binding is available in catch block scope.
@test unsafe fn testResolveTryCatchBinding() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "union Error { Fail } fn fallible() -> u32 throws (Error) { throw Error::Fail; } fn caller() -> u32 { return try fallible() catch err { return 0; }; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "union Error { A, B } fn fallible() -> u32 throws (Error) { throw Error::A; } fn caller() -> u32 { return try fallible() catch e { if e == Error::A { return 1; } else { return 2; } }; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "union Error { Fail } fn fallible() -> u32 throws (Error) { throw Error::Fail; } fn caller() -> u32 { return try fallible() catch err { if err == Error::Fail { return 1; } return 0; }; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "union Error { Fail(u32) } fn fallible() -> u32 throws (Error) { throw Error::Fail(42); } fn caller() -> u32 { return try fallible() catch err { match err { case Error::Fail(x) => return x, } }; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that duplicate union variant patterns are detected.
@test unsafe fn testResolveMatchDuplicateUnionPattern() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "union U { A, B } fn f(u: U) { match u { case U::A => {}, case U::A => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::DuplicateMatchPattern);
    } {
        // No duplicate: distinct variants are fine.
        let mut a = testResolver();
        let program = "union U { A, B } fn f(u: U) { match u { case U::A => {}, case U::B => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that duplicate bool patterns are detected.
@test unsafe fn testResolveMatchDuplicateBoolPattern() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn f(x: bool) { match x { case true => {}, case true => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::DuplicateMatchPattern);
    } {
        let mut a = testResolver();
        let program = "fn f(x: bool) { match x { case false => {}, case false => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::DuplicateMatchPattern);
    }
}

/// Test that duplicate nil patterns in optional match are detected.
@test unsafe fn testResolveMatchDuplicateOptionalPattern() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) { match opt { v => {}, case nil => {}, case nil => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::DuplicateMatchPattern);
    } {
        // Duplicate value binding.
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) { match opt { v => {}, w => {}, case nil => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::DuplicateMatchPattern);
    }
}

/// Test that guarded match arms are not considered duplicates.
@test unsafe fn testResolveMatchGuardedNotDuplicate() throws (testing::TestError) {
    {
        // Guarded union variant followed by same variant is fine.
        let mut a = testResolver();
        let program = "union U { A, B } fn f(u: U) { match u { case U::A if true => {}, case U::A => {}, case U::B => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        // Guarded bool pattern followed by same bool is fine.
        let mut a = testResolver();
        let program = "fn f(x: bool) { match x { case true if true => {}, case true => {}, case false => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        // Guarded nil pattern followed by nil is fine.
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) { match opt { case nil if true => {}, case nil => {}, v => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        // Guarded value binding followed by another binding is fine.
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) { match opt { v if true => {}, w => {}, case nil => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that unreachable else is detected when all union variants are covered.
@test unsafe fn testResolveMatchUnreachableElseUnion() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "union U { A, B } fn f(u: U) { match u { case U::A => {}, case U::B => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnreachableElse);
    } {
        // Partial coverage with else is fine.
        let mut a = testResolver();
        let program = "union U { A, B } fn f(u: U) { match u { case U::A => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that unreachable else is detected when both bool cases are covered.
@test unsafe fn testResolveMatchUnreachableElseBool() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn f(x: bool) { match x { case true => {}, case false => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnreachableElse);
    } {
        // Only one case with else is fine.
        let mut a = testResolver();
        let program = "fn f(x: bool) { match x { case true => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

/// Test that unreachable else is detected when both optional cases are covered.
@test unsafe fn testResolveMatchUnreachableElseOptional() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) { match opt { v => {}, case nil => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnreachableElse);
    } {
        // Only value binding with else is fine.
        let mut a = testResolver();
        let program = "fn f(opt: ?i32) { match opt { v => {}, else => {} } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

// --- Multi-error typed catch tests ---

@test unsafe fn testTypedCatchExhaustive() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrA { return 0; } catch e as ErrB { return 1; }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test unsafe fn testTypedCatchNonExhaustive() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrA { return 0; }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TryCatchNonExhaustive);
}

@test unsafe fn testTypedCatchDuplicate() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrA { return 0; } catch e as ErrA { return 1; }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TryCatchDuplicateType);
}

@test unsafe fn testTypedCatchWithCatchAll() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrA { return 0; } catch { return 1; }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

@test unsafe fn testTypedCatchWrongType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union ErrA { A } union ErrB { B } union ErrC { C } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrC { return 0; } catch e as ErrA { return 1; }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TryIncompatibleError);
}

@test unsafe fn testInferredCatchMultiError() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e { return 0; }; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TryCatchMultiError);
}

@test unsafe fn testResolveInstanceMissingMethod() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "trait S { fn (*S) f() -> i32; } record R { x: i32 } instance S for R {}";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::MissingTraitMethod("f"));
}

@test unsafe fn testResolveInstanceUnknownMethod() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "trait S { fn (*S) f() -> i32; } record R { x: i32 } instance S for R { fn (self: *R) x() -> i32 { return 0; } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("x"));
}

@test unsafe fn testResolveTraitDuplicateMethodRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "trait Adder { fn (*mut Adder) add(n: i32) -> i32; fn (*mut Adder) add(n: i32) -> i32; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("add"));
}

@test unsafe fn testResolveInstanceReceiverTypeMustMatchTarget() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Counter { value: i32 } record Wrong { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Wrong) add(n: i32) -> i32 { return n; } }";
    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 unsafe fn testResolveTraitMethodThrowsRequireTry() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Error { Fail } record Counter { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32 throws (Error); } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 throws (Error) { throw Error::Fail; return n; } } fn caller(a: *mut opaque Adder) -> i32 { return a.add(1); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::MissingTry);
}

/// Trait declares immutable receiver (*Trait) but instance uses mutable (*mut Type).
/// The instance method could mutate through what was originally an immutable pointer.
@test unsafe fn testResolveInstanceMutReceiverOnImmutableTrait() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Counter { value: i32 } trait Reader { fn (*Reader) read() -> i32; } instance Reader for Counter { fn (c: *mut Counter) read() -> i32 { set c.value = c.value + 1; return c.value; } }";
    let result = try resolveProgramStr(&mut a, program);
    // Should reject: instance declares *mut receiver but trait only requires immutable.
    try expectErrorKind(&result, super::ErrorKind::ReceiverMutabilityMismatch);
}

/// Instance method declares different parameter types than the trait.
/// The resolver should reject the mismatch rather than silently using the trait's types.
@test unsafe fn testResolveInstanceParamTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Acc { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Acc { fn (a: *mut Acc) add(n: u8) -> i32 { set a.value = a.value + n as i32; return a.value; } }";
    let result = try resolveProgramStr(&mut a, program);
    // Should reject: instance param type u8 doesn't match trait param type i32.
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Duplicate instance declarations for the same (trait, type) pair should be rejected.
@test unsafe fn testResolveInstanceDuplicateRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Counter { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { set c.value = c.value + n; return c.value; } } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { set c.value = c.value + n + 100; return c.value; } }";
    let result = try resolveProgramStr(&mut a, program);
    // Should reject: duplicate instance for (Adder, Counter).
    try expectErrorKind(&result, super::ErrorKind::DuplicateInstance);
}

/// Trait method receiver must point to the declaring trait type.
@test unsafe fn testResolveTraitReceiverMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Other { x: i32 } trait Foo { fn (*mut Other) bar() -> i32; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TraitReceiverMismatch);
}

/// Using a trait name as a value expression should be rejected.
@test unsafe fn testResolveTraitNameAsValueRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "trait Foo { fn (*Foo) bar() -> i32; } fn test() -> i32 { let x = Foo; return 0; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnexpectedTraitName);
}

/// Cross-module trait: coerce to trait object and dispatch from a different module.
@test unsafe fn testResolveTraitCrossModuleCoercion() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod defs; mod app;", &mut arena);
    let defsId = try registerModule(&mut MODULE_GRAPH, rootId, "defs", "export record Counter { value: i32 } export trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { set c.value = c.value + n; return c.value; } }", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::defs; fn test() -> i32 { static c: defs::Counter = defs::Counter { value: 10 }; let a: *mut opaque defs::Adder = &mut c; return a.add(5); }", &mut arena);

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

/// Instance in a different module from trait and type.
@test unsafe fn testResolveInstanceCrossModule() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod defs; export mod impls; mod app;", &mut arena);
    let defsId = try registerModule(&mut MODULE_GRAPH, rootId, "defs", "export record Counter { value: i32 } export trait Adder { fn (*mut Adder) add(n: i32) -> i32; }", &mut arena);
    let implsId = try registerModule(&mut MODULE_GRAPH, rootId, "impls", "use root::defs; instance defs::Adder for defs::Counter { fn (c: *mut defs::Counter) add(n: i32) -> i32 { set c.value = c.value + n; return c.value; } }", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::defs; fn test() -> i32 { static c: defs::Counter = defs::Counter { value: 10 }; let a: *mut opaque defs::Adder = &mut c; return a.add(5); }", &mut arena);

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

/// Calling a mutable-receiver trait method on an immutable trait object
/// must be rejected.
@test unsafe fn testResolveTraitMutMethodOnImmutableObject() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Counter { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { set c.value = c.value + n; return c.value; } } fn caller(a: *opaque Adder) -> i32 { return a.add(1); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
}

/// Immutable methods on an immutable trait object should be accepted.
@test unsafe fn testResolveTraitImmutableMethodOnImmutableObject() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Counter { value: i32 } trait Reader { fn (*Reader) get() -> i32; } instance Reader for Counter { fn (c: *Counter) get() -> i32 { return c.value; } } fn caller(r: *opaque Reader) -> i32 { return r.get(); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Both mutable and immutable methods on a mutable trait object should work.
@test unsafe fn testResolveTraitMixedMethodsOnMutableObject() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Counter { value: i32 } trait Ops { fn (&mut Ops) inc(); fn (&Ops) get() -> i32; } instance Ops for Counter { fn (c: &mut Counter) inc() { set c.value = c.value + 1; } fn (c: &Counter) get() -> i32 { return c.value; } } fn caller(o: *mut opaque Ops) -> i32 { o.inc(); return o.get(); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Instance method body type must match the trait return type.
/// The trait declares `-> i32` but the body returns `bool`.
@test unsafe fn testResolveInstanceReturnTypeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record R { x: i32 } trait T { fn (*T) get() -> i32; } instance T for R { fn (r: *R) get() -> bool { return 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;
}

/// Diamond supertrait inheritance: traits B and C both extend A.
/// Declaring them independently should work fine.
@test unsafe fn testResolveTraitDiamondSupertrait() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "trait A { fn (*A) f() -> i32; } trait B: A { fn (*B) g() -> i32; } trait C: A { fn (*C) h() -> i32; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Diamond supertrait with a combined trait that would cause duplicate
/// method names should be detected.
@test unsafe fn testResolveTraitDiamondDuplicateMethod() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "trait A { fn (*A) f() -> i32; } trait B: A { fn (*B) g() -> i32; } trait C: A { fn (*C) h() -> i32; } trait D: B + C { fn (*D) i() -> i32; }";
    let result = try resolveProgramStr(&mut a, program);
    // B inherits `f` from A, C inherits `f` from A. D: B + C sees duplicate `f`.
    try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("f"));
}

/// Supertrait instance must exist when declaring a combined trait instance.
@test unsafe fn testResolveInstanceMissingSupertraitInstance() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "trait Base { fn (*Base) f() -> i32; } trait Child: Base { fn (*Child) g() -> i32; } record R { x: i32 } instance Child for R { fn (r: *R) g() -> i32 { return r.x; } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::MissingSupertraitInstance("Base"));
}

/// Instance method omits return type when the trait declares `-> i32`.
/// This is rejected -- the return type must be stated explicitly.
@test unsafe fn testResolveInstanceReturnTypeOmitted() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record R { x: i32 } trait T { fn (*T) get() -> i32; } instance T for R { fn (r: *R) get() { } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Instance method declares throws but the trait method does not throw.
@test unsafe fn testResolveInstanceThrowsMismatchExtra() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union E { Fail } record R { x: i32 } trait T { fn (*T) get() -> i32; } instance T for R { fn (r: *R) get() -> i32 throws (E) { return r.x; } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::FnThrowCountMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Instance method declares a different throws type than the trait.
@test unsafe fn testResolveInstanceThrowsMismatchWrongType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union E1 { Fail } union E2 { Oops } record R { x: i32 } trait T { fn (*T) get() -> i32 throws (E1); } instance T for R { fn (r: *R) get() -> i32 throws (E2) { return r.x; } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Instance method omits throws clause when trait declares throws.
/// This is rejected -- the throws clause must match exactly.
@test unsafe fn testResolveInstanceThrowsOmitted() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union E { Fail } record R { x: i32 } trait T { fn (*T) get() -> i32 throws (E); } instance T for R { fn (r: *R) get() -> i32 { throw E::Fail; return r.x; } }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::FnThrowCountMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Instance method correctly matches the trait's throws clause.
@test unsafe fn testResolveInstanceThrowsMatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union E { Fail } record R { x: i32 } trait T { fn (*T) get() -> i32 throws (E); } instance T for R { fn (r: *R) get() -> i32 throws (E) { throw E::Fail; return r.x; } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

// Constant expression folding tests //////////////////////////////////////////

/// Resolve a program and verify that the constant at the given statement index
/// has the expected integer magnitude.
unsafe fn expectConstFold(program: *[u8], stmtIdx: u32, expected: u64)
    throws (testing::TestError)
{
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, stmtIdx);
    let sym = super::symbolFor(&a, stmt)
        else throw testing::TestError::Failed;
    let case super::SymbolData::Constant { value, .. } = sym.data
        else throw testing::TestError::Failed;
    let val = value else throw testing::TestError::Failed;
    let case super::ConstValue::Int(intVal) = val
        else throw testing::TestError::Failed;
    try testing::expect(intVal.magnitude == expected);
}

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

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

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

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

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

    let arrStmt = try getBlockStmt(result.root, 3);
    let sym = super::symbolFor(&a, arrStmt)
        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);
}

/// Test cross-module constant expression: a constant in one module references
/// a constant from another module via scope access.
@test unsafe fn testCrossModuleConstExpr() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

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

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

/// Test cross-module constant expression used as array size.
@test unsafe fn testCrossModuleConstExprArraySize() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod consts; mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "export 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] = [0; TOTAL];", &mut arena);

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

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

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

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

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

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

    let arrStmt = try getBlockStmt(result.root, 2);
    let sym = super::symbolFor(&a, arrStmt)
        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);
}

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

/// References cannot escape through return types.
@test unsafe fn testRefReturnRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Once {} fn bad(value: &u32) -> &u32 { return value; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
}

/// Case-pattern fallbacks must terminate instead of synthesizing bindings.
@test unsafe fn testCaseLetElseFallbackMustTerminate() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Value { Item(u32) } fn run(value: Value) { let case Value::Item(item) = value else value; item; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::LinearLetElseMustTerminate);
}

/// Case bindings are unavailable on the pattern-failure path.
@test unsafe fn testCaseLetElseFallbackCannotUseBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Value { Item(u32) } fn run(value: Value) { let case Value::Item(item) = value else item; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("item"));
}

/// Unsafe pointer dereference requires an unsafe declaration.
@test unsafe fn testUnsafePointerOperationRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Once {} fn load(pointer: *unsafe u32) -> u32 { return *pointer; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
}

/// Unsafe pointers remain freely copyable inside an unsafe declaration.
@test unsafe fn testUnsafePointerOperationAllowed() throws (testing::TestError) {
    let program = "record Marker: Once {} unsafe fn load(pointer: *unsafe u32) -> u32 { return *pointer; }";
    try expectAnalyzeOk(program);
}

/// Safe code cannot call a function that accepts unsafe operations.
@test unsafe fn testUnsafeFunctionCallRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Once {} unsafe fn load(pointer: *unsafe u32) -> u32 { return *pointer; } fn run(pointer: *unsafe u32) -> u32 { return load(pointer); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnsafeCall);
}

/// Unsafe function values retain their call-site safety requirement.
@test unsafe fn testUnsafeFunctionAliasCallRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "unsafe fn dangerous() -> u32 { return 42; } fn run() -> u32 { let alias = dangerous; return alias(); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnsafeCall);
}

/// References cannot be embedded in aggregate fields.
@test unsafe fn testRefFieldRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Once {} record Bad { value: &u32 }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
}

/// Trait methods may use reference receivers.
@test unsafe fn testTraitRefReceiver() throws (testing::TestError) {
    let program = "record Marker: Once {} record Value { number: i32 } trait Read { fn (&Read) get() -> i32; } instance Read for Value { fn (value: &Value) get() -> i32 { return value.number; } } fn inspect(object: &opaque Read) -> i32 { return object.get(); } fn call(value: &Value) -> i32 { return inspect(value); }";
    try expectAnalyzeOk(program);
}

/// Trait implementations must preserve the receiver pointer class.
@test unsafe fn testTraitReceiverClassMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Value { number: i32 } trait Read { fn (&Read) get() -> i32; } instance Read for Value { fn (value: *Value) get() -> i32 { return value.number; } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TraitReceiverMismatch);
}

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

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

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

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

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

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

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

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

/// Stack storage cannot produce a safe stored pointer or slice.
@test unsafe fn testStackPointerRejected() throws (testing::TestError) {
    let programs = &[
        "fn run() { let value: u32 = 0; let pointer: *u32 = &value; }",
        "fn run() -> *u32 { let value: u32 = 0; return &value; }",
        "fn run(value: u32) -> *u32 { return &value; }",
        "record Cell { value: u32 } fn run() { let cell = Cell { value: 1 }; let pointer: *u32 = &cell.value; }",
        "fn run() { let values = [1, 2]; let pointer: *i32 = &values[0]; }",
        "fn run() { let values = [1, 2]; let slice: *[i32] = &values[..]; }",
        "fn run(value: i32) { let slice: *[i32] = &[value]; }",
        "fn run(value: &u32) -> *u32 { return value; }",
        "fn run(value: &u32) -> *u32 { return &*value; }",
        "fn run(values: &[u32]) -> *[u32] { return values; }",
        "fn run(values: &[u32]) -> *[u32] { return &values[..]; }",
        "fn run(values: &[u32]) -> *u32 { return values.ptr; }",
        "fn run() -> *i32 { return &[1, 2][0]; }",
        "fn run() -> *[i32] { return &[1, 2][..]; }",
        "fn run(value: *u32) -> **u32 { return &value; }",
        "fn run(values: *[u32]) -> *u32 { return &values.len; }",
        "unsafe fn run(value: *unsafe u32) -> *u32 { return &*value; }",
        "fn run() { let value: u32 = 7; let pointer: *unsafe u32 = &value; }",
        "record Cell { value: u32 } fn run(value: &Cell) -> *u32 { return &value.value; }",
        "record Cell { value: *u32 } fn run(value: &u32) -> Cell { return Cell { value }; }",
        "fn run(value: &u32) -> *[u32] { return @sliceOf(value, 1); }",
    ];
    for program in programs {
        let mut resolver = testResolver();
        let result = try resolveProgramStr(&mut resolver, program);
        let _ = try expectError(&result);
    }
}

/// Stack values can be borrowed for a call.
@test unsafe fn testStackBorrowAllowed() throws (testing::TestError) {
    try expectAnalyzeOk("fn read(value: &u32) -> u32 { return *value; } fn run() -> u32 { let value: u32 = 7; return read(&value); }");
    try expectAnalyzeOk("fn write(values: &mut [u32]) { set values[0] = 7; } fn run() { let mut values: [u32; 2] = [1, 2]; write(&mut values[..]); }");
}

/// Raw pointers and slices can be borrowed in an unsafe context.
@test unsafe fn testImplicitRawBorrowAllowed() throws (testing::TestError) {
    let programs = &[
        "fn read(p: &u32) -> u32 { return *p; } unsafe fn run(p: *unsafe u32) -> u32 { return read(p); }",
        "fn write(p: &mut u32) { set *p = 7; } fn run(p: *unsafe mut u32) { unsafe { write(p); write(p); } }",
        "fn read(p: &[u32]) -> u32 { return p[0]; } unsafe fn run(p: *unsafe [u32]) -> u32 { return read(p); }",
        "fn write(p: &mut [u32]) { set p[0] = 7; } unsafe fn run(p: *unsafe mut [u32]) { write(p); write(p); }",
        "fn read(p: &u32) {} unsafe fn run(p: *unsafe mut u32) { read(p); }",
        "trait Read { fn (&Read) get(); } fn read(p: &opaque Read) {} unsafe fn run(p: *unsafe opaque Read) { read(p); }",
    ];
    for program in programs {
        try expectAnalyzeOk(program);
    }
}

/// An implicit borrow of raw storage requires an unsafe context.
@test unsafe fn testImplicitRawBorrowRequiresUnsafe() throws (testing::TestError) {
    let programs = &[
        "fn read(p: &u32) {} fn run(p: *unsafe u32) { read(p); }",
        "fn write(p: &mut u32) {} fn run(p: *unsafe mut u32) { write(p); }",
        "fn read(p: &[u32]) {} fn run(p: *unsafe [u32]) { read(p); }",
        "fn write(p: &mut [u32]) {} fn run(p: *unsafe mut [u32]) { write(p); }",
        "trait Read { fn (&Read) get(); } fn read(p: &opaque Read) {} fn run(p: *unsafe opaque Read) { read(p); }",
        "fn read(p: &u32) {} fn run(p: *unsafe u32) { unsafe { read(p); } read(p); }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    }
}

/// Raw borrows preserve mutability, storage type, and ownership constraints.
@test unsafe fn testImplicitRawBorrowPreservesTypes() throws (testing::TestError) {
    let programs = &[
        "fn write(p: &mut u32) {} unsafe fn run(p: *unsafe u32) { write(p); }",
        "fn write(p: &mut [u32]) {} unsafe fn run(p: *unsafe [u32]) { write(p); }",
        "fn read(p: &u64) {} unsafe fn run(p: *unsafe u32) { read(p); }",
        "fn read(p: &[u64]) {} unsafe fn run(p: *unsafe [u32]) { read(p); }",
        "fn take(p: *u32) {} unsafe fn run(p: *unsafe u32) { take(p); }",
        "fn take(p: *[u32]) {} unsafe fn run(p: *unsafe [u32]) { take(p); }",
        "fn read(p: &*u32) {} unsafe fn run(p: *unsafe *unsafe u32) { read(p); }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Implicit raw borrows retain the call's exclusive-borrow checks.
@test unsafe fn testImplicitRawBorrowConflict() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a,
        "fn useBoth(a: &mut u32, b: &u32) {} unsafe fn run(p: *unsafe mut u32) { useBoth(p, p); }");
    try expectErrorKind(&result, super::ErrorKind::BorrowConflict("p"));
}

/// Unsafe declarations can store raw pointers to stack values.
@test unsafe fn testUnsafeStackPointerAllowed() throws (testing::TestError) {
    try expectAnalyzeOk("unsafe fn run() { let mut value: u32 = 0; let pointer: *unsafe mut u32 = &mut value as *unsafe mut u32; set *pointer = 7; }");
    try expectAnalyzeOk("unsafe fn run() { let mut values: [u32; 2] = [1, 2]; let slice: *unsafe mut [u32] = &mut values[..] as *unsafe mut [u32]; set slice[0] = 7; }");
    try expectAnalyzeOk("unsafe fn run() { let value: u32 = 7; let pointer: *unsafe u32 = &value; }");
    try expectAnalyzeOk("unsafe fn run() { let values: [u32; 2] = [1, 2]; let slice: *unsafe [u32] = &values[..]; }");
}

/// Permanent storage can produce safe stored pointers and slices.
@test unsafe fn testPermanentPointerAllowed() throws (testing::TestError) {
    try expectAnalyzeOk("static VALUE: u32 = 7; fn run() -> *u32 { return &VALUE; }");
    try expectAnalyzeOk("static VALUES: [u32; 2] = [1, 2]; fn run() -> *[u32] { return &VALUES[..]; }");
    try expectAnalyzeOk("fn run() -> *[u32] { return &[1, 2]; }");
    try expectAnalyzeOk("fn run(value: *u32) -> *u32 { return &*value; }");
    try expectAnalyzeOk("fn run(values: *[u32]) -> *[u32] { return &values[..]; }");
    try expectAnalyzeOk("record Cell { value: u32 } fn run(value: *Cell) -> *u32 { return &value.value; }");
    try expectAnalyzeOk("fn run(values: *[u32]) -> *u32 { return &values[0]; }");
    try expectAnalyzeOk("unsafe fn run(values: *[u32]) -> *u32 { return values.ptr; }");
    try expectAnalyzeOk("unsafe fn run(value: *u32) -> *[u32] { return @sliceOf(value, 1); }");
}

/// References are rejected from every nested or storable type position.
@test unsafe fn testNestedRefPositionsRejected() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "record Marker: Once {} union Bad { Value(&u32) }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
    } {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn bad(value: ?&u32) {}";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
    } {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn bad(value: [&u32; 1]) {}";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
    } {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn bad(value: *&u32) {}";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
    } {
        let mut a = testResolver();
        let program = "record Marker: Once {} static BAD: &u32 = undefined;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
    } {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn bad(callback: fn() -> &u32) {}";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
    }
}

/// Function pointer parameter references remain call-scoped and valid.
@test unsafe fn testFunctionPointerRefParameterAllowed() throws (testing::TestError) {
    let program = "record Marker: Once {} fn invoke(callback: fn(&u32), value: &u32) { callback(value); }";
    try expectAnalyzeOk(program);
}

/// Pointer and slice casts cannot change reference ownership.
@test unsafe fn testRefCastClassPreserved() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn cast(value: &u32) { value as *u32; }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
    } {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn cast(values: &[u32]) { values as *[u32]; }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Every operation that interprets an unsafe address requires an unsafe declaration.
@test unsafe fn testUnsafePointerOperationsRejected() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn cast(pointer: *unsafe u32) -> u64 { return pointer as u64; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    } {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn compare(pointer: *unsafe u32) -> bool { return pointer == pointer; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    } {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn offset(pointer: *unsafe u32) -> *unsafe u32 { return pointer + 1; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    } {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn index(values: *unsafe [u32]) -> u32 { return values[0]; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    } {
        let mut a = testResolver();
        let program = "record Marker: Once {} record Cell { value: u32 } fn field(cell: *unsafe Cell) -> u32 { return cell.value; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    } {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn store(pointer: *unsafe mut u32) { set *pointer = 1; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    } {
        let mut a = testResolver();
        let program = "record Marker: Once {} fn cast() { let value: u32 = 0; let pointer = &value as *unsafe u32; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    }
}

/// Pointer offsets require an unsafe function for either operand order.
@test unsafe fn testPointerArithmeticRequiresUnsafe() throws (testing::TestError) {
    let programs = &[
        "fn run(p: *u8) -> *u8 { return p + 1; }",
        "fn run(p: *u8) -> *u8 { return 1 + p; }",
        "fn run(p: *u8) -> *u8 { return p - 1; }",
        "fn run(input: *mut u8) { let mut p = input; set p += 1; }",
        "static DATA: [u8; 1] = [42]; fn run() -> u8 { let p = &DATA[0]; return *(p + 1); }",
    ];
    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(p: *u8) -> *u8 { return p + 1; }");
    try expectAnalyzeOk("unsafe fn run(p: *u8) -> *u8 { return 1 + p; }");
    try expectAnalyzeOk("unsafe fn run(p: *mut u8) -> *mut u8 { return p - 1; }");
    try expectAnalyzeOk("fn run(value: u32) -> u32 { return value + 1; }");
}

/// Casts that reinterpret storage require an unsafe function.
@test unsafe fn testStorageCastsRequireUnsafe() throws (testing::TestError) {
    let programs = &[
        "fn run(p: *u8) -> *u64 { return p as *u64; }",
        "fn run(p: &u8) -> u64 { return *(p as &u64); }",
        "fn run(p: *mut u8) -> *mut u64 { return p as *mut u64; }",
        "fn run(p: *opaque) -> *u64 { return p as *u64; }",
        "fn run(p: **u8) -> **u64 { return p as **u64; }",
        "fn run(s: *[u8]) -> *[u64] { return s as *[u64]; }",
        "fn run(s: *[opaque]) -> *[u64] { return s as *[u64]; }",
        "fn run(s: &mut [u64]) { let _ = s as &mut [u8]; }",
        "static DATA: [u8; 1] = [42]; fn run() -> u64 { return *(&DATA[0] as *u64); }",
    ];
    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(p: *u8) -> *u64 { return p as *u64; }");
    try expectAnalyzeOk("unsafe fn run(p: &u8) -> u64 { return *(p as &u64); }");
    try expectAnalyzeOk("unsafe fn run(s: *[u8]) -> *[u64] { return s as *[u64]; }");
    try expectAnalyzeOk("fn run(p: *u8) -> *u8 { return p as *u8; }");
    try expectAnalyzeOk("fn run(p: *u8) -> *opaque { return p as *opaque; }");
    try expectAnalyzeOk("fn run(s: *[u8]) -> *[opaque] { return s as *[opaque]; }");
    try expectAnalyzeOk("fn run(p: *mut u8) -> *u8 { return p as *u8; }");
}

/// Explicit slice bounds require an unsafe function.
@test unsafe fn testSliceConstructionRequiresUnsafe() throws (testing::TestError) {
    let programs = &[
        "fn run(p: *u8) -> *[u8] { return @sliceOf(p, 100); }",
        "fn run(p: *mut u8) -> *mut [u8] { return @sliceOf(p, 0, 100); }",
        "fn run(p: &u8) -> u8 { return @sliceOf(p, 100)[99]; }",
        "fn run(p: &mut u8) { set @sliceOf(p, 100)[99] = 1; }",
        "static DATA: [u8; 1] = [42]; fn run() -> u8 { let s = @sliceOf(&DATA[0], 100); return s[99]; }",
    ];
    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(p: *u8) -> *[u8] { return @sliceOf(p, 100); }");
    try expectAnalyzeOk("unsafe fn run(p: *mut u8) -> *mut [u8] { return @sliceOf(p, 0, 100); }");
    try expectAnalyzeOk("unsafe fn run(p: &u8) -> u8 { return @sliceOf(p, 1)[0]; }");
    try expectAnalyzeOk("fn run(s: *[u8]) -> *[u8] { return &s[..]; }");
}

/// Slice header writes and mutable field borrows require an unsafe function.
@test unsafe fn testSliceHeaderMutationRequiresUnsafe() throws (testing::TestError) {
    let programs = &[
        "fn run(s: *mut [u8]) { set s.len = 100; }",
        "fn run(s: *mut [u8]) { set s.cap = 100; }",
        "fn run(s: *mut [u8], p: *mut u8) { set s.ptr = p; }",
        "fn run(s: *mut [u8]) { set s.len += 1; }",
        "fn change(n: &mut u32) { set *n = 100; } fn run(s: *mut [u8]) { change(&mut s.len); }",
        "fn change(n: &mut u32) { set *n = 100; } fn run(s: *mut [u8]) { change(&mut s.cap); }",
        "fn change(p: &mut *u8, q: *u8) { set *p = q; } fn run(q: *u8) { let mut s: *[u8] = &[]; change(&mut s.ptr, q); }",
        "fn run(s: &mut *[u8]) { set s.len = 100; }",
        "static DATA: [u8; 1] = [42]; fn run() -> u8 { let mut s = &DATA[..]; set s.len = 100; return s[99]; }",
    ];
    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(s: *mut [u8]) { set s.len = 0; set s.cap = 0; }");
    try expectAnalyzeOk("unsafe fn run(s: *mut [u8], p: *mut u8) { set s.ptr = p; }");
    try expectAnalyzeOk("fn change(n: &mut u32) { set *n = 0; } unsafe fn run(s: *mut [u8]) { change(&mut s.len); }");
    try expectAnalyzeOk("fn run(s: *mut [u8]) { set s[0] = 1; }");
    try expectAnalyzeOk("record R { len: u32 } fn run(r: &mut R) { set r.len = 1; }");
}

/// Unsafe blocks permit operations within a safe function.
@test unsafe fn testUnsafeBlocksAllowed() throws (testing::TestError) {
    try expectAnalyzeOk("fn run(p: *u8) -> *u8 { unsafe { return p + 1; } }");
    try expectAnalyzeOk("unsafe fn read(p: *unsafe u8) -> u8 { return *p; } fn run(p: *unsafe u8) -> u8 { unsafe { return read(p); } }");
    try expectAnalyzeOk("fn run(p: *u8) -> *[u8] { unsafe { { return @sliceOf(p, 1); } } }");
    try expectAnalyzeOk("fn run(p: *u8) -> *u64 { unsafe { unsafe { return p as *u64; } } }");
    try expectAnalyzeOk("unsafe fn run(p: *u8) -> *u8 { unsafe {} return p + 1; }");
}

/// Unsafe permission ends at the closing brace and at function boundaries.
@test unsafe fn testUnsafeBlockContextRestored() throws (testing::TestError) {
    let programs = &[
        "fn run(p: *u8) -> *u8 { unsafe { let q = p + 1; } return p + 1; }",
        "fn run(p: *u8) -> *u8 { unsafe { unsafe {} } return p + 1; }",
        "unsafe fn first(p: *u8) -> *u8 { return p + 1; } fn second(p: *u8) -> *u8 { return p + 1; }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    }
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "unsafe fn act() {} fn run() { unsafe { act(); } act(); }");
    try expectErrorKind(&result, super::ErrorKind::UnsafeCall);
}

/// Resolution errors do not extend an unsafe block's permission.
@test unsafe fn testUnsafeBlockErrorRestoresContext() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn run(p: *u8) { unsafe { missing; } let q = p + 1; }");
    let mut found = false;
    for err in result.diagnostics.errors {
        if let case super::ErrorKind::UnsafeOperation = err.kind {
            set found = true;
        }
    }
    try testing::expect(found);
}

/// Unsafe blocks preserve reference lifetime checks.
@test unsafe fn testUnsafeBlockPreservesReferences() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn run() { let mut n: u32 = 1; let p = &n; unsafe { set n = 2; } }");
    try expectErrorKind(&result, super::ErrorKind::BorrowConflict("n"));
}

/// Slice pointer access requires an unsafe context for every slice class.
@test unsafe fn testSlicePointerRequiresUnsafe() throws (testing::TestError) {
    let programs = &[
        "fn run(s: *[u8]) -> *u8 { return s.ptr; }",
        "fn run(s: *mut [u8]) -> *mut u8 { return s.ptr; }",
        "fn run(s: &[u8]) -> u8 { return *s.ptr; }",
        "fn run(s: &mut [u8]) { set *s.ptr = 1; }",
        "fn run(s: &*[u8]) -> *u8 { return s.ptr; }",
        "static DATA: [u8; 1] = [42]; fn run() -> u8 { let s = &DATA[1..]; return *s.ptr; }",
        "fn run(s: *[u8]) -> u64 { return s.ptr as u64; }",
    ];
    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(s: *[u8]) -> *u8 { return s.ptr; }");
    try expectAnalyzeOk("fn run(s: *[u8]) -> u64 { unsafe { return s.ptr as u64; } }");
    try expectAnalyzeOk("fn run(s: *[u8]) -> *u8 { return &s[0]; }");
    try expectAnalyzeOk("fn run(s: *[u8]) -> u32 { return s.len + s.cap; }");
    try expectAnalyzeOk("record R { ptr: u32 } fn run(r: R) -> u32 { return r.ptr; }");
}

/// Unsafe statics require unsafe permission for reads, writes, and addresses.
@test unsafe fn testUnsafeStaticAccessRejected() throws (testing::TestError) {
    let programs = &[
        "unsafe static VALUE: u32 = 7; fn run() -> u32 { return VALUE; }",
        "unsafe static VALUE: u32 = 7; fn run() { set VALUE = 8; }",
        "unsafe static VALUE: u32 = 7; fn run() -> *u32 { return &VALUE; }",
        "unsafe static VALUE: u32 = 7; fn run() -> *mut u32 { return &mut VALUE; }",
        "unsafe static DATA: [u8; 1] = [42]; fn run() -> u8 { return DATA[0]; }",
        "unsafe static DATA: [u8; 1] = [42]; fn run() -> u32 { return DATA.len; }",
        "record R { value: u32 } unsafe static DATA: R = R { value: 7 }; fn run() -> u32 { return DATA.value; }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    }
}

/// Unsafe blocks and functions can access unsafe statics.
@test unsafe fn testUnsafeStaticAccessAllowed() throws (testing::TestError) {
    try expectAnalyzeOk("unsafe static VALUE: u32 = 7; unsafe fn run() -> u32 { set VALUE = 8; return VALUE; }");
    try expectAnalyzeOk("unsafe static VALUE: u32 = 7; fn run() -> u32 { unsafe { return VALUE; } }");
    try expectAnalyzeOk("unsafe static VALUE: u32 = 7; unsafe fn run() -> *mut u32 { return &mut VALUE; }");
    try expectAnalyzeOk("static VALUE: u32 = 7; fn run() -> u32 { return VALUE; }");
    try expectAnalyzeOk("constant BYTES: *[u8] = \"x\"; unsafe static DATA: *[u64] = BYTES as *[u64];");
}

/// Imports preserve the unsafe access requirement of a static.
@test unsafe fn testUnsafeStaticImportsRejected() throws (testing::TestError) {
    let programs = &[
        "use root::storage; fn run() -> u32 { return storage::VALUE; }",
        "use root::storage::*; fn run() -> u32 { return VALUE; }",
    ];
    for program in programs {
        let mut a = testResolver();
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
        let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "export mod storage; mod app;", &mut arena);
        let _ = try registerModule(&mut MODULE_GRAPH, rootId, "storage", "export unsafe static VALUE: u32 = 7;", &mut arena);
        let _ = try registerModule(&mut MODULE_GRAPH, rootId, "app", program, &mut arena);
        let result = try resolveModuleTree(&mut a, rootId);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    }
}

/// An invalid unsafe static initializer does not grant permission to other initializers.
@test unsafe fn testUnsafeStaticInitializerRestoresContext() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "unsafe static BAD: u32 = true; static DATA: *[u64] = &[1 as u8] as *[u64];");
    let _ = try expectError(&result);
    try testing::expect(not a.inUnsafeContext);

    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);
}

/// Unsafe code may drop a checked reference to an unsafe pointer.
@test unsafe fn testUnsafePointerFromReference() throws (testing::TestError) {
    let program = "record Marker: Once {} unsafe fn store(pointer: *unsafe mut u32) { set *pointer = 42; } unsafe fn run() { let mut value: u32 = 0; store(&mut value as *unsafe mut u32); }";
    try expectAnalyzeOk(program);
}

/// Dropping a reference to an unsafe pointer cannot add mutability.
@test unsafe fn testUnsafePointerCastCannotAddMutability() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Once {} unsafe fn run(value: &u32) { value as *unsafe mut u32; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::InvalidAsCast(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Recursive cast validation cannot hide a checked-to-unsafe transition.
@test unsafe fn testNestedUnsafePointerCastRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Once {} fn run(value: **u32) { value as **unsafe u32; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::InvalidAsCast(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Unsafe code may drop a checked slice reference to an unsafe slice.
@test unsafe fn testUnsafeSliceFromReference() throws (testing::TestError) {
    let program = "record Marker: Once {} unsafe fn run(values: &[u32]) { let raw: *unsafe [u32] = values as *unsafe [u32]; }";
    try expectAnalyzeOk(program);
}

/// Slice casts cannot add mutability.
@test unsafe fn testSliceCastCannotAddMutability() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Once {} fn run(values: &[u32]) { values as &mut [u32]; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::InvalidAsCast(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Mutable unsafe receivers do not create checked exclusive loans.
@test unsafe fn testUnsafeReceiverDoesNotBorrowExclusively() throws (testing::TestError) {
    let program = "record Marker: Once {} record Value { number: u32 } unsafe fn (value: *unsafe mut Value) update(other: *unsafe mut Value) {} unsafe fn run(value: *unsafe mut Value) { value.update(value); }";
    try expectAnalyzeOk(program);
}

/// Unsafe instance-method attributes enable unsafe operations in the body.
@test unsafe fn testUnsafeInstanceMethodBody() throws (testing::TestError) {
    let program = "record Marker: Once {} record Value { number: u32 } trait Read { unsafe fn (*unsafe Read) get() -> u32; } instance Read for Value { unsafe fn (value: *unsafe Value) get() -> u32 { return value.number; } }";
    try expectAnalyzeOk(program);
}

/// Unsafe instance methods cannot implement safe trait contracts.
@test unsafe fn testUnsafeInstanceMethodSafetyMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Value {} trait Read { fn (&Read) get(); } instance Read for Value { unsafe fn (value: &Value) get() {} }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TraitMethodSafetyMismatch);
}

/// Unsafe trait methods retain their call-site requirement through dispatch.
@test unsafe fn testUnsafeTraitMethodCallRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Once {} record Value { number: u32 } trait Read { unsafe fn (&Read) get() -> u32; } instance Read for Value { unsafe fn (value: &Value) get() -> u32 { return value.number; } } fn inspect(object: &opaque Read) -> u32 { return object.get(); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnsafeCall);
}

/// An unsafe callback retains its requirement at an indirect call.
@test unsafe fn testUnsafeCallbackCallRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a,
        "fn run(callback: unsafe fn() -> u32) -> u32 { return callback(); }");
    try expectErrorKind(&result, super::ErrorKind::UnsafeCall);
}

/// An unsafe function cannot enter a safe callback slot.
@test unsafe fn testUnsafeCallbackAssignmentRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a,
        "unsafe fn load() -> u32 { return 1; } fn run() { let callback: fn() -> u32 = load; }");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// A safe function can enter an unsafe callback slot.
@test unsafe fn testSafeCallbackIntoUnsafeSlot() throws (testing::TestError) {
    try expectAnalyzeOk(
        "fn load() -> u32 { return 1; } unsafe fn run() -> u32 { let callback: unsafe fn() -> u32 = load; return callback(); }");
}

/// Borrowed callback storage must preserve its function safety type.
@test unsafe fn testBorrowedCallbackSafetyInvariant() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a,
        "fn replace(slot: &mut unsafe fn()) {} fn load() {} fn run() { let mut callback: fn() = load; replace(&mut callback); }");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Referenced storage must preserve its exact element type in every context.
@test unsafe fn testPointerStorageCoercionsRejected() throws (testing::TestError) {
    let programs = &[
        "fn replace(p: &mut ?*u8) { set *p = nil; } static DATA: u8 = 7; fn run() { let mut p = &DATA; replace(&mut p); }",
        "fn replace(p: &mut ?*u8) { set *p = nil; } static DATA: u8 = 7; unsafe fn run() { let mut p = &DATA; replace(&mut p); }",
        "fn replace(p: &mut ?*u8) { set *p = nil; } static DATA: u8 = 7; fn run() { let mut p = &DATA; unsafe { replace(&mut p); } }",
        "fn take(p: *?u32) {} fn run(p: *u32) { take(p); }",
        "unsafe fn take(p: *unsafe mut ?*u8) {} unsafe fn run(p: *unsafe mut *u8) { take(p); }",
        "fn take(p: *[?*u8]) {} fn run(p: *[*u8]) { take(p); }",
        "unsafe fn take(p: *mut [?*u8]) {} unsafe fn run(p: *mut [*u8]) { take(p); }",
        "fn take(p: &mut **u8) {} fn run(p: &mut *mut *u8) { take(p); }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
    try expectAnalyzeOk("fn take(p: &mut ?*u8) {} fn run() { let mut p: ?*u8 = nil; take(&mut p); }");
    try expectAnalyzeOk("fn run(p: *mut u8) -> *u8 { return p; }");
    try expectAnalyzeOk("fn run(p: *u8) -> *opaque { return p; }");
}

/// Casts cannot add or remove optionality in referenced storage.
@test unsafe fn testPointerOptionalStorageCastsRejected() throws (testing::TestError) {
    let programs = &[
        "fn run(p: **u8) { p as *?*u8; }",
        "unsafe fn run(p: *mut *u8) { p as *mut ?*u8; }",
        "fn run(p: *mut *u8) { unsafe { p as *mut ?*u8; } }",
        "unsafe fn run(p: *mut ?*u8) { p as *mut *u8; }",
        "unsafe fn run(p: *unsafe mut *u8) { p as *unsafe mut ?*u8; }",
        "unsafe fn run(p: *mut [*u8]) { p as *mut [?*u8]; }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Pattern references prevent replacement of their source in every context.
@test unsafe fn testPatternLoanMutationRejected() throws (testing::TestError) {
    let programs = &[
        "union U: Copy { A(u64), B(u64) } fn run() { let mut u = U::A(7); match &u { case U::A(p) => { set u = U::B(1); *p; } else => {} } }",
        "union U: Copy { A(u64), B(u64) } unsafe fn run() { let mut u = U::A(7); match &u { case U::A(p) => { set u = U::B(1); *p; } else => {} } }",
        "union U: Copy { A(u64), B(u64) } fn run() { let mut u = U::A(7); match &mut u { case U::A(p) => { unsafe { set u = U::B(1); } *p; } else => {} } }",
        "union U: Copy { A(u64), B(u64) } fn change(u: &mut U) { set *u = U::B(1); } fn run() { let mut u = U::A(7); match &u { case U::A(p) => { change(&mut u); *p; } else => {} } }",
        "union U: Copy { A(u64), B(u64) } fn run() { let mut u = U::A(7); if let case U::A(p) = &u { set u = U::B(1); *p; } }",
        "union U: Copy { A(u64), B(u64) } fn run() { let mut u = U::A(7); while let case U::A(p) = &u { set u = U::B(1); *p; } }",
        "union U: Copy { A(u64), B(u64) } fn run(u: *mut U) { match u { case U::A(p) => { let moved = u; *p; } else => {} } }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("u"));
    }
}

/// Pattern loans end at their scope and permit writes through mutable payload references.
@test unsafe fn testPatternLoanScopeAllowed() throws (testing::TestError) {
    try expectAnalyzeOk("union U: Copy { A(u64), B(u64) } fn run() { let mut u = U::A(7); match &u { case U::A(p) => { *p; } else => {} } set u = U::B(1); }");
    try expectAnalyzeOk("union U: Copy { A(u64), B(u64) } fn run() { let mut u = U::A(7); match &mut u { case U::A(p) => { set *p = 8; } else => {} } set u = U::B(1); }");
    try expectAnalyzeOk("union U: Copy { A(u64), B(u64) } fn run() { let mut u = U::A(7); if let case U::A(p) = &u { *p; } else { set u = U::A(1); } set u = U::B(1); }");
}

/// Replacing a borrowed pointer payload cannot forge an address.
@test unsafe fn testBorrowedPointerPayloadReplacementRejected() throws (testing::TestError) {
    let programs = &[
        "static DATA: u8 = 7; union U: Copy { A(*u8), B(u64) } fn run() -> u8 { let mut u = U::A(&DATA); match &u { case U::A(p) => { set u = U::B(1); return **p; } else => return 0, } }",
        "static DATA: u8 = 7; union U: Copy { A(*u8), B(u64) } unsafe fn run() -> u8 { let mut u = U::A(&DATA); match &u { case U::A(p) => { set u = U::B(1); return **p; } else => return 0, } }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("u"));
    }
}

/// Guards, nested patterns, and unsafe calls must preserve pattern source storage.
@test unsafe fn testPatternLoanIndirectMutationRejected() throws (testing::TestError) {
    let programs = &[
        "fn run() { let mut u: ?u64 = 7; match &u { p => { set u = nil; *p; } else => {} } }",
        "union U: Copy { A(u64), B(u64) } fn change(u: &mut U) -> bool { set *u = U::B(1); return true; } fn run() { let mut u = U::A(7); match &u { case U::A(p) if change(&mut u) => { *p; } else => {} } }",
        "union U: Copy { A(u64), B(u64) } unsafe fn change(u: *unsafe mut U) { set *u = U::B(1); } unsafe fn run(u: *unsafe mut U) { match u { case U::A(p) => { change(u); *p; } else => {} } }",
        "union U: Copy { A(u64), B(u64) } record R: Copy { value: U } fn run() { let mut u = R { value: U::A(7) }; match &u.value { case U::A(p) => { set u.value = U::B(1); *p; } else => {} } }",
        "union U: Copy { A(u64), B(u64) } fn run() { let mut u = [U::A(7)]; match &u[0] { case U::A(p) => { set u[0] = U::B(1); *p; } else => {} } }",
        "union U: Copy { A(u64), B(u64) } unsafe fn (u: *unsafe mut U) change() { set *u = U::B(1); } unsafe fn run(u: *unsafe mut U) { match u { case U::A(p) => { u.change(); *p; } else => {} } }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("u"));
    }
}

/// Binding mutability does not permit writes through immutable pointers.
@test unsafe fn testMutableBindingImmutableTargetRejected() throws (testing::TestError) {
    let programs = &[
        "record R: Copy { n: u8 } fn run(input: *R) { let mut p = input; set p.n = 1; }",
        "record R: Copy { n: u8 } fn run(input: *R) { let mut p = input; let q = &mut p.n; }",
        "static DATA: [u8; 1] = [0]; fn run() { let mut p = &DATA; set p[0] = 1; }",
        "static DATA: [u8; 1] = [0]; fn run() { let mut p = &DATA; set p[..] = 1; }",
        "static DATA: [u8; 1] = [0]; fn run() { let mut p = &DATA; let q = &mut p[0]; }",
        "record R: Copy { n: u8 } fn (r: &mut R) change() { set r.n = 1; } fn run(input: *R) { let mut p = input; p.change(); }",
        "fn run(p: *mut u8, q: *mut u8) { set p = q; }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
}

/// Mutable targets support access through fixed and mutable pointer bindings.
@test unsafe fn testMutablePointerTargetsAllowed() throws (testing::TestError) {
    try expectAnalyzeOk("record R: Copy { n: u8 } fn (r: &mut R) change() { set r.n = 2; } fn run(p: *mut R) { set p.n = 1; p.change(); let q = &mut p.n; set *q = 3; }");
    try expectAnalyzeOk("static DATA: [u8; 2] = [0, 0]; fn run() { let p = &mut DATA; set p[0] = 1; set p[..] = 2; let q = &mut p[0]; set *q = 3; }");
    try expectAnalyzeOk("fn run(first: *u8, second: *u8) { let mut p = first; set p = second; }");
}

/// Pattern access through raw pointers requires an unsafe context.
@test unsafe fn testRawPointerPatternRejected() throws (testing::TestError) {
    let programs = &[
        "union U: Copy { A(u8), B } fn run(p: *unsafe U) { match p { case U::A(n) => { *n; } else => {} } }",
        "union U: Copy { A(u8), B } fn run(p: *unsafe U) { if let case U::A(n) = p { *n; } }",
        "union U: Copy { A(u8), B } fn run(p: *unsafe U) { while let case U::A(n) = p { *n; break; } }",
        "record R: Copy { n: u8 } fn run(p: *unsafe R) { let case R { n } = p else return; }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    }
}

/// Unsafe contexts permit pattern access through raw pointers.
@test unsafe fn testRawPointerPatternsAllowed() throws (testing::TestError) {
    try expectAnalyzeOk("union U: Copy { A(u8), B } unsafe fn run(p: *unsafe U) { match p { case U::A(n) => { *n; } else => {} } if let case U::A(n) = p { *n; } while let case U::A(n) = p { *n; break; } }");
    try expectAnalyzeOk("record R: Copy { n: u8 } unsafe fn run(p: *unsafe R) { let case R { n } = p else return; }");
}

/// Slice append requires the allocator layout and callback signature.
@test unsafe fn testSliceAppendAllocatorRejected() throws (testing::TestError) {
    let programs = &[
        "fn run(s: *mut [u8]) { s.append(1, 0); }",
        "record A { ctx: *mut opaque, func: fn(*mut opaque, u32, u32) -> *mut opaque } fn run(s: *mut [u8], a: A) { s.append(1, a); }",
        "record A { func: u64, ctx: u64 } fn run(s: *mut [u8], a: A) { s.append(1, a); }",
        "record A { func: fn(*mut opaque, u64, u32) -> *mut opaque, ctx: *mut opaque } fn run(s: *mut [u8], a: A) { s.append(1, a); }",
        "record A { func: fn(*mut opaque, u32, u32) -> *opaque, ctx: *mut opaque } fn run(s: *mut [u8], a: A) { s.append(1, a); }",
        "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: u64 } fn run(s: *mut [u8], a: A) { s.append(1, a); }",
        "union E: Copy { Bad } record A { func: fn(*mut opaque, u32, u32) -> *mut opaque throws (E), ctx: *mut opaque } fn run(s: *mut [u8], a: A) { s.append(1, a); }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::InvalidSliceAllocator);
    }
}

/// Slice allocators can use raw context pointers.
@test unsafe fn testSliceAppendRawContextAllowed() throws (testing::TestError) {
    try expectAnalyzeOk("record A: Copy { func: unsafe fn(*unsafe mut opaque, u32, u32) -> *mut opaque, ctx: *unsafe mut opaque } fn run(s: *mut [u8], a: A) { s.append(1, a); }");
}

/// A live pattern reference protects its payload from writes through copied pointers.
@test unsafe fn testPatternPayloadPointerAliasesRejected() throws (testing::TestError) {
    let programs = &[
        "union U: Copy { A(u8), B } fn run(p: *mut U) { let q = p; match p { case U::A(n) => { set *q = U::B; *n; } else => {} } }",
        "union U: Copy { A(*u8), B(u64) } fn run(p: *mut U) -> u8 { let q = p; match p { case U::A(n) => { set *q = U::B(1); return **n; } else => return 0, } }",
        "union U: Copy { A(u8), B } fn change(p: &mut U) { set *p = U::B; } fn run(p: *mut U) { let q = p; if let case U::A(n) = p { change(q); *n; } }",
        "union U: Copy { A(u8), B } fn run(p: *mut U) { let q = p; let r = q; while let case U::A(n) = p { set *r = U::B; *n; break; } }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        let _ = try expectError(&result);
    }
}

/// Every access to a moved safe mutable pointer is rejected.
@test unsafe fn testMutablePointerMovesRejected() throws (testing::TestError) {
    let programs = &[
        "fn run(p: *mut u8) { let q = p; *p; }",
        "fn run(p: *mut u8) { let q = p; set *p = 1; }",
        "fn run(p: *mut u8) { let q = p; let r = &*p; }",
        "fn read(p: &u8) {} fn run(p: *mut u8) { let q = p; read(p); }",
        "fn run(p: &mut u8) { let q = p; *p; }",
        "fn run(p: *mut [u8]) { let q = p; p.len; }",
        "fn run(p: &mut [u8]) { let q = p; p[0]; }",
        "record R { value: u8 } fn run(p: *mut R) { let q = p; p.value; }",
        "trait T { fn (&T) read(); } fn run(p: *mut opaque T) { let q = p; p.read(); }",
        "fn run(p: *mut u8, flag: bool) { if flag { let q = p; } *p; }",
        "fn run(p: *mut u8) { loop { let q = p; } }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        let _ = try expectError(&result);
    }
}

/// Copy composites cannot contain safe mutable owners or their containers.
@test unsafe fn testCopyMutablePointerFieldsRejected() throws (testing::TestError) {
    let programs = &[
        "record R: Copy { p: *mut u8 }",
        "union U: Copy { A(*mut u8), B }",
        "record R: Copy { p: ?*mut u8 }",
        "record R: Copy { p: [*mut u8; 2] }",
        "record R: Copy { p: *mut [u8] }",
        "trait T {} record R: Copy { p: *mut opaque T }",
        "record Inner { p: *mut u8 } record Outer: Copy { inner: Inner }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::CopyContainsNonCopy);
    }
}

/// Moves transfer safe mutable pointers, and calls can borrow them temporarily.
@test unsafe fn testMutablePointerMovesAllowed() throws (testing::TestError) {
    try expectAnalyzeOk("fn run(p: *mut u8) -> u8 { let q = p; set *q = 1; return *q; }");
    try expectAnalyzeOk("fn setValue(p: &mut u8) { set *p = 1; } fn run(p: *mut u8) { setValue(p); setValue(p); *p; }");
    try expectAnalyzeOk("fn run(p: *u8) { let q = p; *p; *q; }");
    try expectAnalyzeOk("fn run(p: *mut u8, q: *mut u8) { unsafe { p == q; p as u64; } set *p = 1; set *q = 2; }");
    try expectAnalyzeOk("record R: Copy { p: *unsafe mut u8 } unsafe fn run(p: *unsafe mut u8) { let q = p; set *p = 1; set *q = 2; }");
    try expectAnalyzeOk("record R: Copy { p: *unsafe mut [u8] } unsafe fn run(p: *unsafe mut [u8]) { let q = p; set p[0] = 1; set q[0] = 2; }");
}

/// Function signature inspection uses immutable descriptors in safe code.
fn expectImmutableFunctionSignatures(res: &super::Resolver, root: *ast::Node) throws (testing::TestError) {
    let first = try typeOf(res, try getBlockStmt(root, 0));
    let equivalent = try typeOf(res, try getBlockStmt(root, 1));
    let throwing = try typeOf(res, try getBlockStmt(root, 2));
    let unsafeCall = try typeOf(res, try getBlockStmt(root, 3));
    try testing::expect(super::typesEqual(first, equivalent));
    try testing::expect(not super::typesEqual(first, throwing));
    try testing::expect(not super::typesEqual(first, unsafeCall));
}

/// Local analysis state does not change function signature identity.
@test unsafe fn testImmutableFunctionSignatures() throws (testing::TestError) {
    let mut res = testResolver();
    let result = try resolveProgramStr(&mut res,
        "fn first(x: u8) -> u32 { return 0; } fn equivalent(y: u8) -> u32 { let a: u32 = 1; return a; } fn throwing(x: u8) -> u32 throws (u8) { throw x; } unsafe fn unsafeCall(x: u8) -> u32 { return 0; }");
    try expectNoErrors(&result);
    try expectImmutableFunctionSignatures(&res, result.root);
}

/// A diagnostic snapshot keeps its contents when the resolver buffer changes.
@test unsafe fn testDiagnosticSnapshotOwnsItsErrors() throws (testing::TestError) {
    let mut res = testResolver();
    let result = try resolveProgramStr(&mut res, "fn run() { missing; }");
    let snapshot = result.diagnostics;
    let original = super::errorAt(snapshot.errors, 0) else throw testing::TestError::Failed;
    set res.errors.entries[0] = super::Error {
        kind: super::ErrorKind::Internal, node: nil, moduleId: 0,
    };
    let later = super::diagnostics(&mut res);
    try testing::expect(snapshot.errors.len == 1);
    try testing::expect(later.errors.len == 1);
    let first = super::errorAt(snapshot.errors, 0) else throw testing::TestError::Failed;
    try testing::expect(first.kind == original.kind);
    try testing::expect(later.errors[0].kind == super::ErrorKind::Internal);
    try testing::expect(super::errorAt(snapshot.errors, 1) == nil);
}

/// Prefixes, equal fields, and uncertain element locations must conflict.
@test unsafe fn testOverlappingFieldBorrows() throws (testing::TestError) {
    let programs = &[
        "record R: Copy { a: u32, b: u32 } fn take(a: &mut u32, b: &u32) {} fn run(r: &mut R) { take(&mut r.a, &r.a); }",
        "record R: Copy { a: u32, b: u32 } fn take(a: &mut R, b: &u32) {} fn run(r: &mut R) { take(r, &r.b); }",
        "record R: Copy { a: [u8; 2], b: [u8; 2] } fn take(a: &mut u8, b: &u8) {} fn run(r: &mut R) { take(&mut r.a[0], &r.a[1]); }",
        "record R: Copy { a: u32, b: u32 } fn take(a: &mut u32, b: u32) {} fn run(r: &mut R) { take(&mut r.a, r.a); }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("r"));
    }
}

/// Local loans exclude writes, competing references, and source reads.
@test unsafe fn testLocalReferenceConflicts() throws (testing::TestError) {
    let programs = &[
        "fn run() { let mut n: u32 = 4; let p = &n; set n = 1; }",
        "fn run() { let mut n: u32 = 4; let p = &mut n; n; }",
        "fn run() { let mut n: u32 = 4; let p = &mut n; let q = &n; }",
        "fn run() { let mut n: u32 = 4; let p = &n; let q = &mut n; }",
        "fn run() { let mut n: u32 = 4; let p = &mut n; let q = &mut *p; set *p = 1; }",
        "fn run() { let mut n: u32 = 4; let p = &mut n; let q = &*p; set *p = 1; }",
        "fn take(p: &mut u32) {} fn run() { let mut n: u32 = 4; let p = &n; take(&mut n); }",
        "fn run() { let mut n: u32 = 4; let p = &n; unsafe { set n = 1; } }",
        "fn run() { let mut n: u32 = 4; let p = &mut n; let q = &*p; let moved = p; }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("n"));
    }
}

/// Reference bindings cannot outlive temporary storage or change their source.
@test unsafe fn testLocalReferenceStorage() throws (testing::TestError) {
    let programs = &[
        "fn run() { let n: u32 = 4; let mut p: &u32 = &n; }",
        "record R: Copy { n: u32 } fn make() -> R { return R { n: 4 }; } fn run() { let p: &u32 = &make().n; }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::RefBinding);
    }
}

/// Stored and returned values cannot contain a local reference.
@test unsafe fn testLocalReferenceEscapeRejected() throws (testing::TestError) {
    let programs = &[
        "fn run() -> *u32 { let n: u32 = 1; let p = &n; return p; }",
        "fn run() -> *u32 { let n: u32 = 1; let p = &n; return p as *u32; }",
        "static DATA: u32 = 0; static P: *u32 = &DATA; fn run() { let n: u32 = 1; let p = &n; set P = p; }",
        "record R: Copy { p: *u32 } fn run() { let n: u32 = 1; let p = &n; let r = R { p }; }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        let _ = try expectError(&result);
    }
}

/// Pointer indirection cannot prove that sibling pointees are disjoint.
@test unsafe fn testIndirectFieldBorrowConflict() throws (testing::TestError) {
    let programs = &[
        "record R: Copy { a: *unsafe mut u32, b: *unsafe mut u32 } fn take(a: &mut u32, b: &mut u32) {} unsafe fn run(r: &mut R) { take(&mut *r.a, &mut *r.b); }",
        "record R: Copy { a: *unsafe mut u32, b: *unsafe mut u32 } unsafe fn run(r: &mut R) { let a: &mut u32 = &mut *r.a; let b: &mut u32 = &mut *r.b; }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("r"));
    }
}

/// Pattern references protect their field and permit writes to disjoint fields.
@test unsafe fn testDisjointPatternFieldBorrow() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a,
        "union U: Copy { A(u32), B } record R: Copy { u: U, n: u32 } fn run(r: &mut R) { let alias = &mut r.u; match alias { case U::A(p) => { set *alias = U::B; *p; } else => {} } }");
    try expectErrorKind(&result, super::ErrorKind::BorrowConflict("r"));
}

/// Slice mutations must preserve storage held by a local reference.
@test unsafe fn testLocalReferenceSliceMutationRejected() throws (testing::TestError) {
    let programs = &[
        "fn run(s: *mut [u8]) { let p: &u8 = &s[0]; s.delete(0); }",
        "record A: Copy { func: unsafe fn(*unsafe mut opaque, u32, u32) -> *mut opaque, ctx: *unsafe mut opaque } fn run(s: *mut [u8], a: A) { let p: &u8 = &s[0]; s.append(1, a); }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("s"));
    }
}

/// Owner moves and mutable methods cannot invalidate a local loan.
@test unsafe fn testLocalReferenceOwnerMutationRejected() throws (testing::TestError) {
    let programs = &[
        "fn run(p: *mut u32) { let r: &u32 = &*p; let moved = p; }",
        "record R: Copy { a: u32 } fn (p: &mut R) change() { set p.a = 1; } fn run(p: &mut R) { let r = &p.a; p.change(); }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("p"));
    }
}

/// Reference locals require a function scope and a reachable initializer result.
@test unsafe fn testLocalReferenceDeclarationContext() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let n: u32 = 1; let p: &u32 = &n;");
    try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
}

/// Invalid calls in function bodies retain their resolution diagnostics.
unsafe fn testInvalidBodyCalls() throws (testing::TestError) {
    for program in &[
        "fn f(x: u32) {} fn g() { f(1, 2); }",
        "fn f(x: u32) {} fn g() { if true { f(1, 2); } }",
        "fn f(x: u32) {} unsafe fn g() { f(1, 2); }",
        "fn f(x: u32) -> u32 { return x; } fn g() { f(f(1, 2)); }",
    ] {
        let mut res = testResolver();
        let result = try resolveProgramStr(&mut res, program);
        try expectErrorKind(&result, super::ErrorKind::FnArgCountMismatch(super::CountMismatch {
            expected: 1, actual: 2,
        }));
    }
}

/// Unsafe calls with excess arguments report the unsafe-call diagnostic.
unsafe fn testInvalidUnsafeBodyCall() throws (testing::TestError) {
    let mut res = testResolver();
    let result = try resolveProgramStr(&mut res,
        "unsafe fn f(x: u32) {} fn g() { f(1, 2); }");
    try expectErrorKind(&result, super::ErrorKind::UnsafeCall);
}

/// Iteration over raw slices requires permission to read their storage.
unsafe fn testRawSliceIterationRequiresUnsafe() throws (testing::TestError) {
    for program in [
        "fn f(p: *unsafe [u32]) { for item in p { assert item == 0; } }",
        "fn f(p: *unsafe mut [u32]) { for item, index in p { assert item == index; } }",
        "record R { items: *unsafe [u32] } fn f(r: &R) { for item in r.items { assert item == 0; } }",
    ] {
        let mut res = testResolver();
        let result = try resolveProgramStr(&mut res, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    }
}

/// Checked iteration is safe, and raw iteration accepts explicit permission.
unsafe fn testSliceIterationPermissions() throws (testing::TestError) {
    for program in [
        "unsafe fn f(p: *unsafe [u32]) { for item in p { assert item == 0; } }",
        "fn f(p: *unsafe [u32]) { unsafe { for item in p { assert item == 0; } } }",
        "fn f(p: &[u32]) { for item in p { assert item == 0; } }",
        "fn f(p: &mut [u32]) { for item, index in p { assert item == index; } }",
        "fn f(p: [u32; 2]) { for item in p { assert item == 0; } }",
    ] {
        let mut res = testResolver();
        let result = try resolveProgramStr(&mut res, program);
        try expectNoErrors(&result);
    }
}

/// Short-circuit paths must agree on exact-use ownership.
unsafe fn testShortCircuitOwnership() throws (testing::TestError) {
    for program in [
        "union Ticket: Once { Value(u32) } fn take(t: Ticket) -> bool { match t { case Ticket::Value(n) => return n == 1, } } fn f(t: Ticket) { let result = false and take(t); }",
        "union Ticket: Once { Value(u32) } fn take(t: Ticket) -> bool { match t { case Ticket::Value(n) => return n == 1, } } fn f(t: Ticket) { let result = true or take(t); }",
        "union Ticket: Once { Value(u32) } fn take(t: Ticket) -> bool { match t { case Ticket::Value(n) => return n == 1, } } fn f(t: Ticket, flag: bool) { let result = flag and take(t); }",
        "union Ticket: Once { Value(u32) } fn take(t: Ticket) -> bool { match t { case Ticket::Value(n) => return n == 1, } } unsafe fn f(t: Ticket, flag: bool) { let result = flag or take(t); }",
    ] {
        let mut res = testResolver();
        let result = try resolveProgramStr(&mut res, program);
        let error = try expectError(&result);
        let case super::ErrorKind::LinearBranchMismatch(_) = error.kind
            else throw testing::TestError::Failed;
    }
}

/// The left operand executes on every short-circuit path.
unsafe fn testShortCircuitLeftConsumption() throws (testing::TestError) {
    for program in [
        "union Ticket: Once { Value(u32) } fn take(t: Ticket) -> bool { match t { case Ticket::Value(n) => return n == 1, } } fn f(t: Ticket) { let result = take(t) and false; }",
        "union Ticket: Once { Value(u32) } fn take(t: Ticket) -> bool { match t { case Ticket::Value(n) => return n == 1, } } fn f(t: Ticket) { let result = take(t) or true; }",
    ] {
        let mut res = testResolver();
        let result = try resolveProgramStr(&mut res, program);
        try expectNoErrors(&result);
    }
}

/// Earlier reference arguments protect their storage during later arguments.
unsafe fn testCallArgumentLoans() throws (testing::TestError) {
    for program in [
        "fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &mut u32, n: u32) {} fn f (p: &mut u32) { outer(&mut *p, inner(p)); }",
        "fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &u32, n: u32) {} fn f (p: &mut u32) { outer(&*p, inner(p)); }",
        "fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &mut u32, n: u32) {} unsafe fn f (p: &mut u32) { outer(&mut *p, inner(p)); }",
        "record R { n: u32 } fn (r: &mut R) call(n: u32) {} fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn f (r: &mut R) { (&mut *r).call(inner(&mut r.n)); }",
    ] {
        let mut res = testResolver();
        let result = try resolveProgramStr(&mut res, program);
        let error = try expectError(&result);
        let case super::ErrorKind::BorrowConflict(_) = error.kind
            else throw testing::TestError::Failed;
    }
}

/// Conditional explicit arguments protect every possible borrowed place.
unsafe fn testConditionalCallArgumentLoans() throws (testing::TestError) {
    for program in [
        "fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &u32, n: u32) {} fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(&*p if flag else &*q, inner(p)); }",
        "fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &u32, n: u32) {} fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(&*p if flag else &*q, inner(q)); }",
        "fn outer(p: &mut u32, q: &mut u32) {} fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(&mut *p if flag else &mut *q, &mut *p); }",
        "fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &u32, n: u32) {} unsafe fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(&*p if flag else &*q, inner(q)); }",
        "fn outer(p: &mut u32, q: &mut u32) {} unsafe fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(&mut *p if flag else &mut *q, &mut *q); }",
        "fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &u32, n: u32) {} fn f (p: &mut u32, q: &mut u32, flag: bool) { outer((&*p if flag else &*q) as &u32, inner(p)); }",
        "record R { n: u32 } fn (r: &R) call(n: u32) {} fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn f (p: &mut R, q: &mut R, flag: bool) { (&*p if flag else &*q).call(inner(&mut q.n)); }",
    ] {
        let mut res = testResolver();
        let result = try resolveProgramStr(&mut res, program);
        let error = try expectError(&result);
        let case super::ErrorKind::BorrowConflict(_) = error.kind
            else throw testing::TestError::Failed;
    }
}

/// Conditional argument alternatives cannot overlap another exclusive argument.
unsafe fn testConditionalCallArgumentOverlap() throws (testing::TestError) {
    for program in [
        "fn outer(p: &mut u32, q: &mut u32) {} fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(p if flag else q, p); }",
        "fn outer(p: &mut u32, q: &mut u32) {} fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(p if flag else q, q); }",
        "fn outer(p: &mut u32, q: &mut u32) {} fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(p, p if flag else q); }",
        "fn outer(p: &mut u32, q: &mut u32) {} fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(q, p if flag else q); }",
        "fn outer(p: &mut u32, q: &mut u32) {} unsafe fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(p if flag else q, p); }",
        "fn outer(p: &u32, q: &mut u32) {} fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(p if flag else q, q); }",
        "fn outer(p: &mut u32, q: &mut u32) {} fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(p if flag else q, q if flag else p); }",
        "fn outer(p: &mut u32, q: &mut u32) {} fn f (p: &mut u32, q: &mut u32, r: &mut u32, a: bool, b: bool) { outer((p if a else q) if b else r, q); }",
        "fn outer(p: &u32, q: &mut u32) {} fn f (p: &mut u32, q: &mut u32, flag: bool) { outer((p if flag else q) as &u32, p); }",
        "record R { n: u32 } fn (r: &mut R) call(p: &R) {} fn f (p: &mut R, q: &mut R, flag: bool) { (p if flag else q).call(p); }",
        "trait R { fn (&mut R) call(p: &opaque R); } fn f (p: &mut opaque R, q: &mut opaque R, flag: bool) { (p if flag else q).call(q); }",
    ] {
        let mut res = testResolver();
        let result = try resolveProgramStr(&mut res, program);
        let error = try expectError(&result);
        let case super::ErrorKind::BorrowConflict(_) = error.kind
            else throw testing::TestError::Failed;
    }
}

/// Conditional argument alternatives permit shared access and disjoint places.
unsafe fn testConditionalCallArgumentSeparation() throws (testing::TestError) {
    for program in [
        "fn outer(p: &u32, q: &u32) {} fn f (p: &u32, q: &u32, flag: bool) { outer(p if flag else q, p); }",
        "fn outer(p: &mut u32, q: &mut u32) {} fn f (p: &mut u32, q: &mut u32, r: &mut u32, flag: bool) { outer(p if flag else q, r); }",
        "record R { a: u32, b: u32, c: u32 } fn outer(p: &mut u32, q: &mut u32) {} fn f (r: &mut R, flag: bool) { outer(&mut r.a if flag else &mut r.b, &mut r.c); }",
        "record R { n: u32 } fn (r: &mut R) call(p: &R) {} fn f (p: &mut R, q: &mut R, r: &R, flag: bool) { (p if flag else q).call(r); }",
    ] {
        let mut res = testResolver();
        let result = try resolveProgramStr(&mut res, program);
        try expectNoErrors(&result);
    }
}

/// Call loans allow shared reads, separate fields, and access after the call.
unsafe fn testCallArgumentLoanScopes() throws (testing::TestError) {
    for program in [
        "fn read(p: &u32) -> u32 { return *p; } fn outer(p: &u32, n: u32) {} fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(&*p if flag else &*q, read(p)); set *p = 3; set *q = 4; }",
        "record R { a: u32, b: u32, c: u32 } fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &mut u32, n: u32) {} fn f (r: &mut R, flag: bool) { outer(&mut r.a if flag else &mut r.b, inner(&mut r.c)); set r.a = 3; }",
        "fn outer(p: &mut u32, n: u32) {} fn f (p: &mut u32, flag: bool) { outer(&mut *p if flag else &mut *p, 0); set *p = 3; }",
        "fn read(p: &u32) -> u32 { return *p; } fn outer(p: &u32, n: u32) {} fn f (p: &mut u32) { outer(&*p, read(p)); set *p = 3; }",
        "record R { a: u32, b: u32 } fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &mut u32, n: u32) {} fn f (r: &mut R) { outer(&mut r.a, inner(&mut r.b)); set r.a = 3; }",
    ] {
        let mut res = testResolver();
        let result = try resolveProgramStr(&mut res, program);
        try expectNoErrors(&result);
    }
}

/// Verify call resolution, borrow protection, and ownership paths.
@test unsafe fn testExtractedSafetyChecks() throws (testing::TestError) {
    try testInvalidBodyCalls();
    try testInvalidUnsafeBodyCall();
    try testRawSliceIterationRequiresUnsafe();
    try testSliceIterationPermissions();
    try testShortCircuitOwnership();
    try testShortCircuitLeftConsumption();
    try testCallArgumentLoans();
    try testConditionalCallArgumentLoans();
    try testConditionalCallArgumentOverlap();
    try testConditionalCallArgumentSeparation();
    try testCallArgumentLoanScopes();
}