radiance · Radiance self-hosting compiler

compiler/ lib/ examples/ std/ arch/ collections/ lang/ alloc/ ast/ gen/ il/ module/ parser/ resolver/ printer.rad 18.2 KiB tests.rad 223.6 KiB scanner/ alloc.rad 4.2 KiB ast.rad 22.4 KiB gen.rad 489 B il.rad 15.1 KiB lower.rad 259.5 KiB module.rad 13.4 KiB package.rad 1.2 KiB parser.rad 78.5 KiB resolver.rad 244.3 KiB scanner.rad 18.1 KiB sexpr.rad 6.3 KiB strings.rad 2.2 KiB sys/ arch.rad 65 B collections.rad 36 B fmt.rad 3.8 KiB intrinsics.rad 399 B io.rad 1.2 KiB lang.rad 222 B mem.rad 2.1 KiB sys.rad 167 B testing.rad 2.3 KiB tests.rad 11.6 KiB vec.rad 3.1 KiB std.rad 231 B scripts/ seed/ test/ vim/ .gitignore 353 B .gitsigners 112 B LICENSE 1.1 KiB Makefile 3.0 KiB README 2.5 KiB std.lib 1.0 KiB std.lib.test 252 B
lib/std/lang/resolver/tests.rad 223.6 KiB raw
//! Resolver tests.

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

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

static AST_ARENA: [u8; 2097152] = undefined;
static ARENA_STORAGE: [u8; 2097152] = undefined;
static NODE_DATA_STORAGE: [super::NodeData; 256] = undefined;
static ERROR_STORAGE: [super::Error; 16] = undefined;
static PKG_SCOPE: super::Scope = undefined;
static MODULE_ENTRIES: [module::ModuleEntry; 8] = undefined;
static MODULE_GRAPH: module::ModuleGraph = undefined;
static MODULE_ARENA_STORAGE: [u8; 4096] = undefined;
static MODULE_ARENA: ast::NodeArena = undefined;
static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };

/// String literals used in tests.
const LITERALS: [*[u8]; 15] = [
    "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 {
    diagnostics: super::Diagnostics,
    root: *ast::Node,
}

/// Create isolated storage for tests to avoid conflicts with global resolver storage.
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.
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.
    MODULE_ARENA = ast::nodeArena(&mut MODULE_ARENA_STORAGE[..]);
    MODULE_GRAPH = module::moduleGraph(&mut MODULE_ENTRIES[..], &mut STRING_POOL, &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.
fn resolveStatements(
    self: *mut super::Resolver, block: ast::Block, arena: *mut ast::NodeArena
) -> TestResult throws (super::ResolveError) {
    let module = ast::synthFnModule(arena, super::ANALYZE_BLOCK_FN_NAME, block.statements);
    let diagnostics = try super::resolveModuleRoot(self, module.modBody) catch {
        return TestResult { diagnostics: super::Diagnostics { errors: self.errors }, root: module.modBody };
    };
    return TestResult { diagnostics, root: module.fnBody };
}

/// Parse and analyze an expression string for testing.
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.
fn resolveProgramStr(self: *mut super::Resolver, stmt: *[u8]) -> TestResult throws (testing::TestError) {
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let stmt = 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.
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.
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] = &[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.
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 {
        modId = try module::registerChild(graph, parent, name, filePath) catch {
            throw testing::TestError::Failed;
        };
    } else {
        modId = try module::registerRootWithName(graph, 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;
    }
    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);
}

fn expectAnalyzeOk(program: *[u8]) throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

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.
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.
fn getUnionVariantPayload(nominalTy: *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.
fn getTypeInScopeOf(a: *super::Resolver, blk: *ast::Node, name: *[u8]) -> *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;
}

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

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

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

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.
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.
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 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 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 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 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 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 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 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 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 fn testResolveConstLiteralValue() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "const 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 fn testResolveConstRequiresConstantExpr() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn value() -> i32 { return 1 } fn main() { const 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 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 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 fn testSymbolStoresFnAttributes() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "@default pub 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::Pub));
    try testing::expect(ast::hasAttribute(sym.attrs, ast::Attribute::Default));
    try testing::expectNot(ast::hasAttribute(sym.attrs, ast::Attribute::Extern));
}

@test fn testSymbolStoresRecordAttributes() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "pub 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::Pub));
    try testing::expectNot(ast::hasAttribute(sym.attrs, ast::Attribute::Default));
}

@test 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 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 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 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 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 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 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 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 fn testResolveArrayLiteralEmptyWithAnnotation() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 0] = [];");
    try expectNoErrors(&result);
}

@test 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 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 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 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 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 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 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 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 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 fn testResolveSliceIndex() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let 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 fn testResolveSliceFields() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[1..]; slice.len; 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::ExprStmt(ptrExpr) = ptrStmt.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 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 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 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 fn testResolveSliceFromArray() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let 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 = "let 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 = "let 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 = "let xs: [u8; 2] = [1, 2]; let slice = &xs[1..1];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

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

@test 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; let ptr = &mut x;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test 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]; let slice = &mut xs[..];";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test 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 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 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 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[2..];";
        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 fn testResolveArrayLenConstValue() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let xs: [i32; 3] = [1, 2, 3]; const 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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);
    }
}

@test 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 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 fn testResolveAssign() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let mut x: i32 = 0; x = 1;");
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let x: i32 = 0; x = 1;");
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let mut x: bool = false; 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, "x = 1;");
        try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("x"));
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let mut x: ?i32 = 0; x = 1;");
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, "let mut x: ?i32 = 0; x = nil;");
        try expectNoErrors(&result);
    }
}

@test fn testResolveAssignSubscript() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let mut xs: [u8; 2] = [0, 1]; xs[0] = 9;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
    {
        let mut a = testResolver();
        let program = "let mut xs: [u8; 2] = [0, 1]; let slice: *mut [u8] = &mut xs[..]; slice[0] = 1;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
    {
        let mut a = testResolver();
        let program = "let mut xs: [u8; 2] = [0, 1]; let mut slice: *[u8] = &xs[..]; 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]; xs[0] = 9;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
    {
        let mut a = testResolver();
        let program = "let mut xs: [u8; 2] = [0, 1]; let slice: *[u8] = &xs[..]; slice[0] = 1;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    }
}

@test 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("const 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("const LIMIT: u8 = 512;", super::Type::U8);
    try expectIntMismatch("const LIMIT: u8 = -5;", super::Type::U8);
}

@test 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 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 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 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 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 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 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 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 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 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 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 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 fn testResolveAnonRecordArray() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } const ARR: [Pt; 2] = [{ x: 1, y: 2 }, { x: 3, y: 4 }];";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that arrays of anonymous records with extra fields cause count mismatch.
@test fn testResolveAnonRecordArrayMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: i32 } const ARR: [Pt; 2] = [{ x: 1, y: 2 }, { x: 3, y: 4, z: 5 }];";
    let 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 fn testUndefinedCoercions() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let count: i32 = undefined;");
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "let mut value: i32 = 0; value = undefined;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "fn f(x: i32) {} fn g() { f(undefined); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "fn fetch() -> i32 { return undefined; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test 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 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 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 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 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 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 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 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 fn testResolveIfLetMut() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; if let mut v = opt { v = v + 1; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test that `if let` (without mut) rejects assignment.
@test fn testResolveIfLetImmutable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; if let v = opt { 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 fn testResolveLetMutElse() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "let opt: ?i32 = 42; let mut v = opt else panic; v = v + 1;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

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

@test 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 fn testResolveDeref() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let 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 fn testResolveAssignDeref() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "let mut x: i32 = 0; let ptr: *mut i32 = &mut x; *ptr = 42;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    } {
        let mut a = testResolver();
        let program = "let mut x: i32 = 0; let ptr: *i32 = &x; *ptr = 42;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    } {
        let mut a = testResolver();
        let program = "let mut x: i32 = 0; let mut ptr: *i32 = &x; *ptr = 42;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
    } {
        let mut a = testResolver();
        let program = "let mut x: u8 = 0; let mut ptr: *mut u8 = &mut x; *ptr = 255;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

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

@test 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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; pub 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 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", "pub fn helper() {}", &mut arena);

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

@test 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; pub 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", "pub 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 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; pub 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", "pub 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 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", "pub mod left; pub mod right;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "left", "use root::right; pub fn leftHelper() -> i32 { return right::rightHelper(); }", &mut arena);
    let utilId = try registerModule(&mut MODULE_GRAPH, rootId, "right", "use root::left; pub 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 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", "pub mod types; mod app;", &mut arena);
    let typesId = try registerModule(&mut MODULE_GRAPH, rootId, "types", "pub 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 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", "pub mod consts; mod app;", &mut arena);
    let constantsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "pub const 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 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; pub 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 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", "pub mod app; mod main;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "pub mod services;", &mut arena);
    let servicesId = try registerModule(&mut MODULE_GRAPH, appId, "services", "pub mod auth;", &mut arena);
    let authId = try registerModule(&mut MODULE_GRAPH, servicesId, "auth", "pub 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 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 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", "pub 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 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 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; pub 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 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", "pub 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 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", "pub mod types; mod app;", &mut arena);
    let typesId = try registerModule(&mut MODULE_GRAPH, rootId, "types", "pub 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 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", "pub 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 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", "pub mod statics; mod app;", &mut arena);
    let staticsId = try registerModule(&mut MODULE_GRAPH, rootId, "statics", "pub 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 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; pub 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; pub 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 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; pub 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 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; pub mod kate;", &mut arena);
    let kateId = try registerModule(&mut MODULE_GRAPH, rootId, "kate", "pub 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 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 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 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 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 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 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 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 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 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 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 that mutable bindings of immutable pointers cannot borrow mutably through the pointer.
@test fn testMutableBorrowFromMutableBindingOfPointer() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f() { let mut 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 fn testAssignThroughMutablePointerToImmutableSlice() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(slice: *[i32]) { let p: *mut *[i32] = &mut slice; 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 fn testAssignThroughMutableSliceParam() throws (testing::TestError) {
    {
        // Mutable slice param: direct assignment should work
        let mut a = testResolver();
        let program = "fn f(slice: *mut [i32]) { 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]) { 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 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 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 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 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 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 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 fn testMutableAssignToMutableRecordBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S { x: i32 } fn f() { let mut s = S { x: 1 }; 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 fn testMutableAssignToImmutableRecordBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S { x: i32 } fn f() { let s = S { x: 1 }; 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 fn testMutableAssignToMutablePointerToRecord() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S { x: i32 } fn f(p: *mut S) { 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 fn testMutableAssignToImmutablePointerToRecord() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record S { x: i32 } fn f(p: *S) { 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 fn testOpaquePointerAutoCoercion() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn f(x: i32) { let mut ptr: *i32 = &x; let o: *opaque = ptr; ptr = o as *i32; }");
    try expectNoErrors(&result);
}

/// You cannot assign an opaque pointer to a non-opaque pointer without a cast.
@test 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 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, "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 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 fn testOpaquePointerDereferenceAfterCast() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn f() { let o: *opaque = undefined; let x = *(o as *i32); }");
    try expectNoErrors(&result);
}

/// You cannot do pointer arithmetic with an opaque pointer.
@test 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 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; pub 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; pub use c::*;", &mut arena);
    let cId = try registerModule(&mut MODULE_GRAPH, bId, "c", "mod d; pub use d::*; pub fn helper() -> i32 { return 42; }", &mut arena);
    let dId = try registerModule(&mut MODULE_GRAPH, cId, "d", "pub const MAX: i32 = 100;", &mut arena);

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

/// Test that wildcard import can access public symbols.
@test 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", "pub mod b; mod a;", &mut arena);
    let bId = try registerModule(&mut MODULE_GRAPH, rootId, "b", "pub 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 public(); }", &mut arena);

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

/// Test that wildcard import cannot access private symbols.
@test 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", "pub mod b; mod a;", &mut arena);
    let bId = try registerModule(&mut MODULE_GRAPH, rootId, "b", "pub 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 fn testConstArrayWithConstLength() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "const LEN: u32 = 3; const 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 fn testRecordFieldWithConstArrayLength() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "const SIZE: u32 = 4; record Buffer { data: [i32; SIZE], }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

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

/// Test that a constant can have a union variant value (lazy union body resolution).
@test fn testConstWithUnionVariant() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Color { Red, Green, Blue } const DEFAULT: Color = Color::Red;";
    let 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 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", "pub mod types; mod scanner;", &mut arena);
    let typesId = try registerModule(&mut MODULE_GRAPH, rootId, "types", "pub 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 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", "pub mod consts; mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "pub const SIZE: u32 = 8;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; static BUFFER: [u8; consts::SIZE] = undefined;", &mut arena);

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

/// 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 fn testResolveSliceOfCorrect() throws (testing::TestError) {
    // Immutable pointer.
    {
        let mut a = testResolver();
        let program = "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 = "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 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 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 fn testResolveSliceOfWithCap() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn f(ptr: *u8, len: u32, cap: u32) -> *[u8] { return @sliceOf(ptr, len, cap); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
    // Mutable pointer produces mutable slice.
    {
        let mut a = testResolver();
        let program = "fn f(ptr: *mut u8, len: u32, cap: u32) -> *mut [u8] { return @sliceOf(ptr, len, cap); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

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

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

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

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

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

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

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

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

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

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

/// Test `match &opt` produces immutable pointer bindings.
@test fn testResolveMatchRefUnionBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some(i32), None } fn f() { let opt = Opt::Some(42); match &opt { case Opt::Some(x) => { *x; } else => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    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 target = try expectPointerType(payloadValType, false);
    try testing::expect(target == super::Type::I32);
}

/// Test `match &mut opt` produces mutable pointer bindings.
@test 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 target = try expectPointerType(payloadValType, true);
    try testing::expect(target == super::Type::I32);
}

/// Non-constant integer widening must use an explicit cast.
@test 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 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 fn testResolveMutSliceAssignableToImmutSlice() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveBlockStr(&mut a, "let mut 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 fn testResolveAsCasts() throws (testing::TestError) {
    { // Pointer to numeric.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let x: i32 = 0; let p = &x; p as u32;");
        try expectNoErrors(&result);
    } { // Function pointer to numeric.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let f: fn() = undefined; f as u32;");
        try expectNoErrors(&result);
    } { // *u8 to *i32 (u8 to i32 is valid).
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "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 resolveBlockStr(&mut a, "let p: **u8 = undefined; p as **i32;");
        try expectNoErrors(&result);
    }

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

    { // *[i32] to *[u8].
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "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 } fn f(s: *[R]) { s as *[u8]; }");
        try expectNoErrors(&result);
    }

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

    { // Identity cast: *mut [i32] to *mut [i32].
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let s: *mut [i32] = undefined; s as *mut [i32];");
        try expectNoErrors(&result);
    } { // Identity cast: *i32 to *i32.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let p: *i32 = undefined; p as *i32;");
        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 fn testResolveAsCastsInvalid() throws (testing::TestError) {
    { // Pointer to slice is invalid.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let p: *i32 = undefined; p as *[i32];");
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
    } { // Slice to pointer is invalid.
        let mut a = testResolver();
        let result = try resolveBlockStr(&mut a, "let s: *[i32] = undefined; s as *i32;");
        let 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 resolveBlockStr(&mut a, "let s: *[i32] = undefined; 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 { 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 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 { 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 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 { c.value = c.value + n; return c.value; } } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { 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 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 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 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", "pub mod defs; mod app;", &mut arena);
    let defsId = try registerModule(&mut MODULE_GRAPH, rootId, "defs", "pub record Counter { value: i32 } pub trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { 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 { let mut c = 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 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", "pub mod defs; pub mod impls; mod app;", &mut arena);
    let defsId = try registerModule(&mut MODULE_GRAPH, rootId, "defs", "pub record Counter { value: i32 } pub 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 { 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 { let mut c = 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 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 { 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 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 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() { 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 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 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 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 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 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 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 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 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 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.
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 fn testConstExprArithmetic() throws (testing::TestError) {
    try expectConstFold("const A: i32 = 10; const B: i32 = 20; const C: i32 = A + B;", 2, 30);
    try expectConstFold("const A: i32 = 50; const B: i32 = 20; const C: i32 = A - B;", 2, 30);
    try expectConstFold("const A: i32 = 6; const B: i32 = 7; const C: i32 = A * B;", 2, 42);
    try expectConstFold("const A: i32 = 100; const B: i32 = 5; const C: i32 = A / B;", 2, 20);
}

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

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

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

/// Test constant expression used as array size.
@test fn testConstExprAsArraySize() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "const A: u32 = 2; const B: u32 = 3; const SIZE: u32 = A + B; const ARR: [i32; SIZE] = [1, 2, 3, 4, 5];";
    let 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 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", "pub mod consts; mod app;", &mut arena);
    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "pub const BASE: i32 = 100;", &mut arena);
    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; const DERIVED: i32 = consts::BASE + 50;", &mut arena);

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

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

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

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

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

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

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

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

/// Test `as` cast in constant expressions used as array size.
@test fn testConstExprCastAsArraySize() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "const LEN: u64 = 4; const SIZE: u32 = LEN as u32; const ARR: [i32; SIZE] = [1, 2, 3, 4];";
    let 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 fn testConstExprUnsuffixedLiterals() throws (testing::TestError) {
    try expectConstFold("const A: u32 = 4 * 4;", 0, 16);
    try expectConstFold("const B: u32 = 10; const C: u32 = B * 2;", 1, 20);
    try expectConstFold("const D: u32 = 3 + 7;", 0, 10);
    try expectConstFold("const E: u32 = 2 * 3 + 4;", 0, 10);
    try expectConstFold("const F: i32 = -(3 + 4);", 0, 7);
}